app/kb/registry/host.server.ts

Functions

Imports

It imports app/kb/procedures/parse.mjs, app/kb/procedures/render.mjs, app/kb/registry/compile.mjs, app/kb/registry/equipment.mjs, app/kb/registry/kinds.mjs, app/kb/registry/primer.mjs, app/kb/registry/reagent.mjs, app/kb/registry/strain.mjs, app/lib/content/load-pipeline.server.ts, app/lib/editor/github.server.ts, app/lib/publications/parse.mjs. Imported by app/kb/procedures/save.server.ts, app/kb/registry/save.server.ts.

Source

1// What the Worker reads from the repository for the registry, which is what CI reads too: a field that names a paper means
2// a paper this site has a file for, and a protocol that names a primer means a primer the registry holds a file for. Asking
3// the repository rather than D1 keeps a save and a sync independent of whether the derived rows have been written yet.
4// A module of its own so the procedure save can read primers without importing the registry save, which imports it.
5
6import { loadPipeline } from "~/lib/content/load-pipeline.server";
7import { readFile } from "~/lib/editor/github.server";
8import { procedurePath } from "~/kb/procedures/parse.mjs";
9import { PUBLICATIONS_DIR } from "~/lib/publications/parse.mjs";
10import type { StoredEquipment, StoredPrimer, StoredReagent, StoredStrain } from "~/kb/procedures/render.mjs";
11
12import { compileRegistryItem, registryPath, registrySlug } from "./compile.mjs";
13import { KINDS, type KindSpec } from "./kinds.mjs";
14import { storedPrimer } from "./primer.mjs";
15import { storedEquipment } from "./equipment.mjs";
16import { storedReagent } from "./reagent.mjs";
17import { storedStrain } from "./strain.mjs";
18
19type RegistryEnv = Env & { GITHUB_TOKEN?: string };
20
21function githubHost(env: RegistryEnv) {
22  return {
23    paper: async (slug: string) => (await readFile(env, `${PUBLICATIONS_DIR}/${slug}.md`)) !== null,
24    // A recipe is a procedure file whose front matter says profile: recipe.
25    recipe: async (slug: string) => /^profile:\s*recipe\s*$/m.test(((await readFile(env, procedurePath(slug)))?.content ?? "").split(/^---\s*$/m)[1] ?? ""),
26  };
27}
28
29/** The one compile door for a registry file: the save, get_registry, sync_registry and the primer reads go through it. */
30export async function compile(env: RegistryEnv, slug: string, raw: string, kinds: Readonly<Record<string, KindSpec>> = KINDS) {
31  const { findWideDashes } = await loadPipeline();
32  return compileRegistryItem({ slug, raw, host: githubHost(env), pipeline: { findWideDashes }, kinds });
33}
34
35/**
36 * The primers a protocol names, as the repository holds them, for the procedure compile. An id with no file, or a file that
37 * does not compile, is left out of the answer, so the validator reports it as a primer the registry does not hold.
38 */
39export async function readPrimers(env: RegistryEnv, ids: string[]): Promise<Map<string, StoredPrimer>> {
40  const found = new Map<string, StoredPrimer>();
41  for (const id of ids) {
42    const slug = registrySlug("primer", id);
43    const file = await readFile(env, registryPath(slug));
44    if (!file) continue;
45    const compiled = await compile(env, slug, file.content);
46    if (compiled.ok) found.set(id, storedPrimer(compiled.item));
47  }
48  return found;
49}
50
51/** The host strains a protocol names, as the repository holds them; an id with no compiling file is left out, and the validator names it. */
52export async function readStrains(env: RegistryEnv, ids: string[]): Promise<Map<string, StoredStrain>> {
53  const found = new Map<string, StoredStrain>();
54  for (const id of ids) {
55    const slug = registrySlug("strain", id);
56    const file = await readFile(env, registryPath(slug));
57    if (!file) continue;
58    const compiled = await compile(env, slug, file.content);
59    if (compiled.ok) found.set(id, storedStrain(compiled.item));
60  }
61  return found;
62}
63
64/** The reagents a protocol's materials name, as the repository holds them; an id with no compiling file is left out, and the validator names it. */
65export async function readReagents(env: RegistryEnv, ids: string[]): Promise<Map<string, StoredReagent>> {
66  const found = new Map<string, StoredReagent>();
67  for (const id of ids) {
68    const slug = registrySlug("reagent", id);
69    const file = await readFile(env, registryPath(slug));
70    if (!file) continue;
71    const compiled = await compile(env, slug, file.content);
72    if (compiled.ok) found.set(id, storedReagent(compiled.item));
73  }
74  return found;
75}
76
77/** The equipment a protocol's list names, as the repository holds it; an id with no compiling file is left out, and the validator names it. */
78export async function readEquipment(env: RegistryEnv, ids: string[]): Promise<Map<string, StoredEquipment>> {
79  const found = new Map<string, StoredEquipment>();
80  for (const id of ids) {
81    const slug = registrySlug("equipment", id);
82    const file = await readFile(env, registryPath(slug));
83    if (!file) continue;
84    const compiled = await compile(env, slug, file.content);
85    if (compiled.ok) found.set(id, storedEquipment(compiled.item));
86  }
87  return found;
88}