app/lab/inventory.server.ts

Functions

Imports

It imports app/db/inventory.ts, app/db/registry.ts, app/db/runs.ts, app/lab/forms.mjs, app/lab/titles.mjs. Imported by app/lab/runs.server.ts, app/routes/workspace.inventory.lot.tsx, app/routes/workspace.inventory.tsx.

Source

1/**
2 * /lab/inventory: the lab's lots and where they are (docs/KNOWLEDGE-BASE.md steps 4 and 7). A lot names a registry
3 * item by its kind and id; the item's public facts stay in content/registry/, and the lot's number, amount, expiry and
4 * place live only in D1. Every write to a lot or a location writes its kb_audit row in the same batch
5 * (app/db/inventory.ts). Who may do what is a permission, never a title: `read` to see, `use_lot` to mark a lot opened
6 * or empty, `edit_inventory` to add and change lots and locations.
7 */
8
9import { can, type Actor } from "@dustinedwards/site-runtime/members";
10
11import { getLot, listLocations, listLots, lotAudit, lotChange, lotInsert, locationInsert, type LotRow } from "~/db/inventory";
12import { listRegistry } from "~/db/registry";
13import { listRunnableProcedures, runsUsingLot } from "~/db/runs";
14
15import { amountOf, field, idOf, isDate, today } from "./forms.mjs";
16import { PERMISSION } from "./titles.mjs";
17
18export type InventoryResult = { ok: boolean; text: string };
19
20export type LotView = LotRow & { item: string };
21
22const STATUSES = ["in_stock", "empty", "discarded"] as const;
23
24/** Every registry item by its address, `kind:id`, with the name the lab knows it by. */
25export async function itemNames(env: Env): Promise<Map<string, string>> {
26  const items = await listRegistry(env);
27  return new Map(items.map((i) => [`${i.kind}:${i.id}`, i.name]));
28}
29
30export function withItem(lot: LotRow, names: Map<string, string>): LotView {
31  return { ...lot, item: names.get(`${lot.item_kind}:${lot.item_id}`) ?? `${lot.item_kind} ${lot.item_id}` };
32}
33
34export async function inventoryPage(env: Env, actor: Actor) {
35  const [lots, locations, names] = await Promise.all([listLots(env), listLocations(env), itemNames(env)]);
36  const edits = can(actor, PERMISSION.editInventory);
37  return {
38    lots: lots.map((l) => withItem(l, names)),
39    locations,
40    items: edits ? [...names.entries()].map(([value, label]) => ({ value, label: `${label} (${value.split(":")[0]})` })).sort((a, b) => a.label.localeCompare(b.label)) : [],
41    canEdit: edits,
42    canUse: can(actor, PERMISSION.useLot),
43  };
44}
45
46/** One lot, its history and the runs that used it: everyone's for a reader of all runs, otherwise the person's own. */
47export async function lotPage(env: Env, actor: Actor, id: number) {
48  const lot = await getLot(env, id);
49  if (!lot) return null;
50  const allRuns = can(actor, PERMISSION.readAllRuns);
51  const [names, audit, runs, locations, procedures] = await Promise.all([
52    itemNames(env),
53    lotAudit(env, id),
54    runsUsingLot(env, id, allRuns ? null : actor.email),
55    listLocations(env),
56    listRunnableProcedures(env),
57  ]);
58  const titles = new Map(procedures.map((p) => [p.slug, p.title]));
59  return {
60    lot: withItem(lot, names),
61    // The history names who changed the lot, and a run's change names its author: someone who may see only their own
62    // runs sees only their own rows, unless they keep the inventory.
63    audit: allRuns || can(actor, PERMISSION.editInventory) ? audit : audit.filter((row) => row.actor === actor.email),
64    runs: runs.map((r) => ({ ...r, title: titles.get(r.procedure_slug) ?? r.procedure_slug })),
65    locations,
66    allRuns,
67    canEdit: can(actor, PERMISSION.editInventory),
68    canUse: can(actor, PERMISSION.useLot),
69  };
70}
71
72function refused(text: string): InventoryResult {
73  return { ok: false, text };
74}
75
76/** A D1 constraint error read as the words a person needs; anything else is thrown on. */
77function constraintText(error: unknown): string | null {
78  const message = error instanceof Error ? error.message : String(error);
79  if (/UNIQUE/.test(message)) return "That is already recorded.";
80  if (/kb_lots_amount_check/.test(message)) return "A lot's amount cannot go below zero.";
81  if (/CHECK|FOREIGN KEY/.test(message)) return "That change breaks a rule of the inventory, so nothing was saved.";
82  return null;
83}
84
85async function run(env: Env, statements: D1PreparedStatement[], done: string): Promise<InventoryResult> {
86  try {
87    await env.DB.batch(statements);
88  } catch (error) {
89    const text = constraintText(error);
90    if (text) return refused(text);
91    throw error;
92  }
93  return { ok: true, text: done };
94}
95
96function optionalDate(form: FormData, name: string): { ok: true; value: string | null } | { ok: false; reason: string } {
97  const text = field(form, name);
98  if (!text) return { ok: true, value: null };
99  return isDate(text) ? { ok: true, value: text } : { ok: false, reason: `Not a date (YYYY-MM-DD): ${text}.` };
100}
101
102async function locationId(env: Env, text: string): Promise<{ ok: true; value: number | null } | { ok: false; reason: string }> {
103  if (!text) return { ok: true, value: null };
104  const id = idOf(text);
105  const known = (await listLocations(env)).some((l) => l.id === id);
106  return known ? { ok: true, value: id } : { ok: false, reason: "That location does not exist." };
107}
108
109/** Runs one post from the inventory pages as `actor`, each intent behind its own permission. */
110export async function inventoryAction(env: Env, actor: Actor, form: FormData, nowMs: number): Promise<InventoryResult> {
111  const intent = field(form, "intent");
112
113  if (intent === "mark_opened" || intent === "mark_empty") {
114    if (!can(actor, PERMISSION.useLot)) return refused("You cannot mark lots.");
115    const lotId = idOf(field(form, "lot"));
116    const lot = lotId ? await getLot(env, lotId) : null;
117    if (!lot) return refused("That lot does not exist.");
118    if (lot.status !== "in_stock") return refused(`Lot ${lot.lot_number} is ${lot.status.replace("_", " ")}.`);
119    const update =
120      intent === "mark_opened"
121        ? env.DB.prepare("UPDATE kb_lots SET opened = coalesce(opened, ?), updated_at = unixepoch() WHERE id = ?").bind(today(nowMs), lot.id)
122        : env.DB.prepare("UPDATE kb_lots SET status = 'empty', updated_at = unixepoch() WHERE id = ?").bind(lot.id);
123    return run(env, lotChange(env, actor.email, lot.id, update), intent === "mark_opened" ? `Lot ${lot.lot_number} marked opened.` : `Lot ${lot.lot_number} marked empty.`);
124  }
125
126  if (!can(actor, PERMISSION.editInventory)) return refused("You cannot change the inventory.");
127
128  if (intent === "add_location") {
129    const name = field(form, "name");
130    if (!name) return refused("Name the location.");
131    const parent = await locationId(env, field(form, "parent"));
132    if (!parent.ok) return refused(parent.reason);
133    return run(env, locationInsert(env, actor.email, name, parent.value), `Added ${name}.`);
134  }
135
136  if (intent === "add_lot") {
137    const [kind, id] = field(form, "item").split(":");
138    if (!kind || !id || !(await itemNames(env)).has(`${kind}:${id}`)) return refused("Choose an item from the registry.");
139    const lotNumber = field(form, "lot_number");
140    if (!lotNumber) return refused("Type the lot number from the label.");
141    const expiry = optionalDate(form, "expiry");
142    const received = optionalDate(form, "received");
143    const amount = amountOf(field(form, "amount"));
144    const location = await locationId(env, field(form, "location"));
145    for (const check of [expiry, received, amount, location]) if (!check.ok) return refused(check.reason);
146    return run(
147      env,
148      lotInsert(env, actor.email, {
149        item_kind: kind,
150        item_id: id,
151        lot_number: lotNumber,
152        expiry: expiry.ok ? expiry.value : null,
153        received: received.ok ? received.value : null,
154        amount: amount.ok ? amount.value : null,
155        unit: field(form, "unit") || null,
156        location_id: location.ok ? location.value : null,
157      }),
158      `Added lot ${lotNumber}.`,
159    );
160  }
161
162  if (intent === "edit_lot") {
163    const lotId = idOf(field(form, "lot"));
164    const lot = lotId ? await getLot(env, lotId) : null;
165    if (!lot) return refused("That lot does not exist.");
166    const expiry = optionalDate(form, "expiry");
167    const amount = amountOf(field(form, "amount"));
168    const location = await locationId(env, field(form, "location"));
169    const status = field(form, "status");
170    for (const check of [expiry, amount, location]) if (!check.ok) return refused(check.reason);
171    if (!(STATUSES as readonly string[]).includes(status)) return refused(`Unknown status: ${status}.`);
172    const update = env.DB.prepare(
173      "UPDATE kb_lots SET expiry = ?, amount = ?, unit = ?, location_id = ?, status = ?, updated_at = unixepoch() WHERE id = ?",
174    ).bind(expiry.ok ? expiry.value : null, amount.ok ? amount.value : null, field(form, "unit") || null, location.ok ? location.value : null, status, lot.id);
175    return run(env, lotChange(env, actor.email, lot.id, update), `Lot ${lot.lot_number} saved.`);
176  }
177
178  return refused(`Unknown action: ${intent || "none"}.`);
179}