app/kb/registry/search-inputs.mjs

Functions

Imports

It imports app/kb/registry/catalog.mjs, app/kb/registry/primer.mjs, app/kb/registry/strain.mjs. Imported by app/kb/registry/save.server.ts.

Source

1// What the site's search finds for a registry item (docs/REGISTRY.md): one record per published item, so a search for a primer's
2// sequence, its target, its reference or the paper that prints it finds the primer's own page as well as the protocols that use
3// it. The record is derived from the item and nothing else, so a save, sync_registry and sync:content write the same text, and a
4// draft has none. Like a paper's, it is one record with no deep links: an item has no sections to link to.
5
6import { itemPath, primerRow, siteText } from "./catalog.mjs";
7import { stated } from "./primer.mjs";
8import { designationOf } from "./strain.mjs";
9
10/** The item's search uid: a removal needs it to find the item's record. @param {string} kind @param {string} id */
11export function registrySearchUid(kind, id) {
12  // The registry: namespace keeps these uids separable from hand-authored pages and papers when search_docs is pruned.
13  return `registry:${kind}/${id}`;
14}
15
16/**
17 * The words a primer is searched by: what it is, its sequence and reverse complement (a sequence search finds either strand),
18 * where it binds, and the paper that prints it. Only facts the record states or computes; a fact that could not be found is
19 * not a word to find.
20 *
21 * @param {import("./kinds.mjs").RegistryItem} item
22 */
23function primerBody(item) {
24  const row = primerRow(item);
25  return [
26    row.name,
27    row.direction ? `${row.direction} primer` : "primer",
28    row.sequence,
29    row.reverseComplement,
30    row.target,
31    row.set,
32    row.length ? `${row.length} nt` : null,
33    row.placement ? `${row.placement.reference.id} ${row.placement.reference.description}` : null,
34    ...(row.placement ? row.placement.sites.map(siteText) : []),
35    row.publishedIn,
36    row.publishedDoi,
37    row.publishedName,
38    row.publishedSequence,
39  ]
40    .filter(Boolean)
41    .join(" ");
42}
43
44/**
45 * The words a strain is searched by: its organism, designation, collection and number. The phages isolated on it are the
46 * phages table's own records and are not copied into this one.
47 *
48 * @param {import("./kinds.mjs").RegistryItem} item
49 */
50function strainBody(item) {
51  const f = /** @type {Record<string, unknown>} */ (item.fields);
52  return [item.name, "strain", "host", stated(f.organism), designationOf(f), stated(f.collection), stated(f.collection_number)].filter(Boolean).join(" ");
53}
54
55/**
56 * The words a reagent is searched by: its name, what a protocol calls it or makes it of, and where it comes from. A gap is not a
57 * word to find.
58 *
59 * @param {import("./kinds.mjs").RegistryItem} item
60 */
61function reagentBody(item) {
62  const f = /** @type {Record<string, unknown>} */ (item.fields);
63  return [item.name, "reagent", stated(f.abbreviation), stated(f.contents), f.prepared_in_lab === true ? "prepared in the lab" : null, stated(f.supplier), stated(f.catalog_number)]
64    .filter(Boolean)
65    .join(" ");
66}
67
68/** The words an item of equipment is searched by: its name, who makes it and a centrifuge's rotor. @param {import("./kinds.mjs").RegistryItem} item */
69function equipmentBody(item) {
70  const f = /** @type {Record<string, unknown>} */ (item.fields);
71  return [item.name, "equipment", stated(f.manufacturer), stated(f.rotor)].filter(Boolean).join(" ");
72}
73
74/** Each kind's search words. A kind with none is not indexed, so a kind added later is not indexed by accident. */
75const BODIES = /** @type {Record<string, (item: import("./kinds.mjs").RegistryItem) => string>} */ ({
76  primer: primerBody,
77  strain: strainBody,
78  reagent: reagentBody,
79  equipment: equipmentBody,
80});
81
82/**
83 * The record input of one item, or null for a kind with no search body yet (so a kind added later is not indexed by accident).
84 *
85 * @param {import("./kinds.mjs").RegistryItem} item
86 * @returns {{ uid: string, url: string, title: string, body: string } | null}
87 */
88export function registrySearchInput(item) {
89  const body = BODIES[item.kind]?.(item) ?? null;
90  if (body === null) return null;
91  return { uid: registrySearchUid(item.kind, item.id), url: itemPath(item.kind, item.id), title: item.name, body };
92}
93
94/** The inputs of every published item that has one, for the build's search artifact. @param {import("./kinds.mjs").RegistryItem[]} items */
95export function registrySearchInputs(items) {
96  return items.flatMap((item) => {
97    if (item.status === "draft") return [];
98    const input = registrySearchInput(item);
99    return input ? [input] : [];
100  });
101}