@flaredev/cli 0.9.1 → 0.11.0

package/templates/app/lib/resource/store.ts

@@ -8,7 +8,7 @@
 // `flare diff` shows how your copy differs from the version Flare ships, and
 // `flare update` applies the parts you choose. Neither runs unless you ask.
 
-import { columnName, ownershipFilter, storedFields, type Policy, type Resource } from "@flaredev/core";
+import { columnName, conditionHolds, fromMinorUnits, ownershipFilter, storedFields, toMinorUnits, type Policy, type Resource } from "@flaredev/core";
 import { createValidators } from "@flaredev/core";
 import { encodeCursor, isSearchable, parseListQuery, type QueryIssue } from "./query";
 import type { ResourceRows, Row } from "./rows";
@@ -46,6 +46,11 @@ export const COUNT_LIMIT = 10_000;
 function toCursorValue(value: unknown): string | number | boolean | null {
   if (value instanceof Date) return value.getTime();
   if (value === null || value === undefined) return null;
+  // A money column is BigInt on Postgres, and Prisma hands those back as a bigint.
+  // JSON.stringify throws on one — "Do not know how to serialize a BigInt" — so sorting by
+  // a money field broke the cursor on that stack and nowhere else. Minor units fit a double
+  // to about ninety trillion, which is past any amount a column like this holds.
+  if (typeof value === "bigint") return Number(value);
   if (typeof value === "object") return String(value);
   return value as string | number | boolean;
 }
@@ -195,9 +200,76 @@ export function createResourceStore(options: ResourceStoreOptions) {
 
   const notFound = () => fail(404, `${resource.label} not found.`);
 
+  /**
+   * Money fields, and the currency each one counts in.
+   *
+   * A money column holds whole minor units, because a column of doubles drifts — sum a few
+   * thousand prices and the total is a penny out. Everything above this file works in the
+   * units people write, so the conversion happens here and nowhere else: the API sends
+   * 19.99, the form shows 19.99, and only the database sees 1999.
+   */
+  const moneyFields = fields.flatMap(([key, def]) =>
+    (def.kind === "int" || def.kind === "float") && def.format === "money" ? [{ key, currency: def.currency }] : [],
+  );
+
+  /**
+   * Fields that only apply when another field says so, e.g. a billing cycle that exists
+   * on a recurring project and not on a one-off one.
+   *
+   * The validator decides whether one is *required*; this decides whether it is *kept*.
+   * Without it, changing a project from recurring to one-off leaves last month's billing
+   * cycle sitting in the row — the form stopped showing the input, so nothing ever sent a
+   * value to overwrite it, and the record quietly disagrees with itself.
+   */
+  const conditionalFields = fields.flatMap(([key, def]) => (def.showWhen ? [{ key, condition: def.showWhen }] : []));
+
+  /**
+   * Null the fields that no longer apply.
+   *
+   * `record` is what the condition is judged against: the whole record as it will be once
+   * this write lands, which on a PATCH means the stored row with the patch laid over it.
+   * Judging the patch alone would read a field it never mentioned as absent and clear a
+   * value that was meant to stay.
+   */
+  function clearInapplicable(values: Row, record: Row): Row {
+    if (conditionalFields.length === 0) return values;
+    const out = { ...values };
+    for (const { key, condition } of conditionalFields) {
+      if (!conditionHolds(condition, record)) out[key] = null;
+    }
+    return out;
+  }
+
+  /** Amounts as the database stores them: 19.99 -> 1999. */
+  function toStored(values: Row): Row {
+    if (moneyFields.length === 0) return values;
+    const out = { ...values };
+    for (const { key, currency } of moneyFields) {
+      const value = out[key];
+      if (typeof value === "number") out[key] = toMinorUnits(value, currency);
+    }
+    return out;
+  }
+
+  /** Amounts as callers read them: 1999 -> 19.99. */
+  function toAmounts(row: Row): Row {
+    if (moneyFields.length === 0) return row;
+    const out = { ...row };
+    for (const { key, currency } of moneyFields) {
+      const value = out[key];
+      // Prisma hands a BigInt column back as a bigint; D1 gives a number.
+      if (typeof value === "number") out[key] = fromMinorUnits(value, currency);
+      else if (typeof value === "bigint") out[key] = fromMinorUnits(Number(value), currency);
+    }
+    return out;
+  }
+
   const computed = Object.entries(resource.computed ?? {});
   /** Add the descriptor's computed values to a row on its way out. */
-  const withComputed = (row: Record<string, unknown>): Record<string, unknown> => {
+  const withComputed = (stored: Record<string, unknown>): Record<string, unknown> => {
+    // Amounts first: a computed value like `total` is written against the units the
+    // descriptor talks about, so it has to see 19.99 rather than 1999.
+    const row = toAmounts(stored);
     if (computed.length === 0) return row;
     const result = { ...row };
     for (const [key, compute] of computed) {
@@ -265,7 +337,10 @@ export function createResourceStore(options: ResourceStoreOptions) {
       const limit = await confine();
       if (isFailure(limit)) return limit;
       // Last, so `?filter[userId]=someone-else` cannot widen the query past the owner.
-      const filters = limit ? { ...parsed.query.filters, [limit.field]: limit.value } : parsed.query.filters;
+      const parsedFilters = limit ? { ...parsed.query.filters, [limit.field]: limit.value } : parsed.query.filters;
+      // `?filter[price]=19.99` is written in the units the caller knows; the column counts
+      // cents, so it is converted here like any other amount crossing this boundary.
+      const filters = toStored(parsedFilters) as typeof parsedFilters;
 
       /**
        * Whether a sort column holds a date, so the adapter can shape the cursor for it.
@@ -310,8 +385,16 @@ export function createResourceStore(options: ResourceStoreOptions) {
       const exactTotal = counting <= COUNT_LIMIT;
       const total = exactTotal ? counting : COUNT_LIMIT;
 
-      const first = page_[0];
-      const last = page_[page_.length - 1];
+      // Cursors are built from the rows as the database gave them, not from `page_`.
+      // A cursor is compared against the column on the next request, so sorting by a money
+      // field has to carry 1999 — the stored value — and not the 19.99 callers see. Taking
+      // it from the converted rows paged by a number the column does not contain, which
+      // silently returned the same page forever.
+      const stored = hasMore ? found.slice(0, perPage) : found;
+      if (backwards) stored.reverse();
+
+      const first = stored[0];
+      const last = stored[stored.length - 1];
       const moreAfter = backwards ? true : hasMore;
       const moreBefore = backwards ? hasMore : Boolean(cursor) || page > 1;
       const cursorFor = (row: Record<string, unknown> | undefined, direction: "after" | "before") =>
@@ -350,16 +433,19 @@ export function createResourceStore(options: ResourceStoreOptions) {
     /**
      * Title-field values for a set of ids (for showing relations). Missing ids are omitted.
      *
-     * Not confined by ownership, and `rows.titles` has no way to be: it returns an id and
-     * a title, not the owner. It is called with ids this resource's rows already point at,
-     * so in practice it shows the names of records you can already see — but if you hand a
-     * confined user a relation picker over a confined resource, the titles are not the
-     * place that restriction is enforced. Filter the ids before calling it.
+     * Confined by ownership, like every other read: a relation picker shown to a user who
+     * only sees their own rows must not name anybody else's. An id they may not see is
+     * simply absent from the result, which the caller already handles — missing ids are
+     * omitted either way, so a title they are not entitled to looks the same as one that
+     * was deleted.
      */
     async titles(ids: string[]): Promise<Record<string, string>> {
       const unique = [...new Set(ids.filter(Boolean))];
       if (unique.length === 0) return {};
-      const found = await rows.titles(unique, resource.titleField);
+      const limit = await confine();
+      // Not signed in where sign-in is required: no titles rather than everyone's.
+      if (isFailure(limit)) return {};
+      const found = await rows.titles(unique, resource.titleField, limit ?? undefined);
       return Object.fromEntries(found.map((row) => [row.id, row.title == null ? row.id : String(row.title)]));
     },
 
@@ -381,7 +467,8 @@ export function createResourceStore(options: ResourceStoreOptions) {
         if (!result.success) return invalid(result.error.issues);
         const input = result.data as Record<string, unknown>;
         const now = new Date();
-        const record = await rows.insert({ ...input, id: crypto.randomUUID(), createdAt: now, updatedAt: now });
+        const fresh = { ...input, id: crypto.randomUUID(), createdAt: now, updatedAt: now };
+        const record = await rows.insert(toStored(clearInapplicable(fresh, fresh)));
         const saved = withComputed(record);
         await hooks.afterCreate?.(saved, context);
         return { ok: true, data: saved };
@@ -397,7 +484,10 @@ export function createResourceStore(options: ResourceStoreOptions) {
 
         // A confined update has to read the row first: `rows.update(id, …)` takes an id
         // and nothing else, so this is where "is it yours" is answered.
-        const current = limit || hooks.beforeUpdate || hooks.afterUpdate ? await rows.byId(id) : null;
+        // Conditional fields join this list: deciding whether one still applies needs the
+        // whole record, and a PATCH on its own may not mention the field it depends on.
+        const needsCurrent = limit || hooks.beforeUpdate || hooks.afterUpdate || conditionalFields.length > 0;
+        const current = needsCurrent ? await rows.byId(id) : null;
         if (limit) {
           if (!current) return notFound();
           if (!owns(current, limit)) return notFound();
@@ -421,7 +511,8 @@ export function createResourceStore(options: ResourceStoreOptions) {
         const result = validators.update.safeParse(supplied);
         if (!result.success) return invalid(result.error.issues);
         const input = result.data as Record<string, unknown>;
-        const record = await rows.update(id, { ...input, updatedAt: new Date() });
+        const merged = { ...((current ?? {}) as Row), ...input };
+        const record = await rows.update(id, toStored(clearInapplicable({ ...input, updatedAt: new Date() }, merged)));
         if (!record) return notFound();
         const saved = withComputed(record);
         await hooks.afterUpdate?.(saved, { ...context, previous: current });
@@ -450,7 +541,7 @@ export function createResourceStore(options: ResourceStoreOptions) {
         // one of them, and a replace would quietly orphan the row it just saved.
         if (limit) values[limit.field] = limit.value;
 
-        const record = await rows.update(id, values);
+        const record = await rows.update(id, toStored(clearInapplicable(values, values)));
         return record ? { ok: true, data: withComputed(record) } : notFound();
       });
     },