@ai-matrx/records 0.81.2 → 0.82.0

package/dist/{table-kind-LodkBhCZ.d.cts → table-kind-B4vIKJVM.d.cts}

@@ -4033,8 +4033,8 @@ interface DrillFinding {
  * The records behind a DEFINER definition's numbers: a registry relation carrying the fact's column
  * names (e.g. `bucket`), read by the door definer with the SAME filter compiler and the SAME lane
  * rule as the number, for a window (required), and never past the number's `as_of` (rows created
- * after it are not listed). The number and its records are EQUAL AS OF THE COUNT; a value that
- * changes on a counted row afterwards (a cost that lands late) is SAID by the page (`settling`).
+ * after it are not listed). The number and its records are the SAME counted rows, equal as of the
+ * count (`as_of`); a value that changes afterwards reaches both at the next count.
  *
  * An INVOKER definition may declare records too (lane DRILL-GAPS): they are its own rows (`fact` is
  * the definition's own fact), read as the person through the table's row security, among the columns
@@ -4131,25 +4131,9 @@ interface DrillRowsPage {
     as_of: string | null;
     /**
      * A definer definition's records, first page only: every Measure that adds up (sum, count, ratio)
-     * summed over the SAME filter — what these records add up to NOW (the ledger as it stands).
+     * summed over the SAME filter — what these records add up to, which is the number they open.
      */
     measures?: Record<string, number | string | null>;
-    /**
-     * First page only: the NUMBER's own sums for the same filter, as counted at `as_of` (the summary).
-     * The number and its records are equal as of the count; a cost that lands on a counted row after
-     * it makes `measures` differ from `counted`, and the page then carries `settling` and says so.
-     */
-    counted?: Record<string, number | string | null>;
-    /**
-     * Present only when the records and the number differ: per Measure, what was counted, what the
-     * ledger holds now, and the difference — with `says` in words ("$1.23 more has landed since the
-     * count at 06:40 UTC. …"). The next recount (every 10 minutes) brings them back equal.
-     */
-    settling?: Record<string, {
-        counted: number | string | null;
-        now: number | string | null;
-        difference: number;
-    }>;
 }
 /**
  * A DECLARED drill definition (a `*.drill.ts` file): an override of one standard table (its key

package/dist/{table-kind-COmkYYkc.d.ts → table-kind-C5T-DOdc.d.ts}

@@ -4033,8 +4033,8 @@ interface DrillFinding {
  * The records behind a DEFINER definition's numbers: a registry relation carrying the fact's column
  * names (e.g. `bucket`), read by the door definer with the SAME filter compiler and the SAME lane
  * rule as the number, for a window (required), and never past the number's `as_of` (rows created
- * after it are not listed). The number and its records are EQUAL AS OF THE COUNT; a value that
- * changes on a counted row afterwards (a cost that lands late) is SAID by the page (`settling`).
+ * after it are not listed). The number and its records are the SAME counted rows, equal as of the
+ * count (`as_of`); a value that changes afterwards reaches both at the next count.
  *
  * An INVOKER definition may declare records too (lane DRILL-GAPS): they are its own rows (`fact` is
  * the definition's own fact), read as the person through the table's row security, among the columns
@@ -4131,25 +4131,9 @@ interface DrillRowsPage {
     as_of: string | null;
     /**
      * A definer definition's records, first page only: every Measure that adds up (sum, count, ratio)
-     * summed over the SAME filter — what these records add up to NOW (the ledger as it stands).
+     * summed over the SAME filter — what these records add up to, which is the number they open.
      */
     measures?: Record<string, number | string | null>;
-    /**
-     * First page only: the NUMBER's own sums for the same filter, as counted at `as_of` (the summary).
-     * The number and its records are equal as of the count; a cost that lands on a counted row after
-     * it makes `measures` differ from `counted`, and the page then carries `settling` and says so.
-     */
-    counted?: Record<string, number | string | null>;
-    /**
-     * Present only when the records and the number differ: per Measure, what was counted, what the
-     * ledger holds now, and the difference — with `says` in words ("$1.23 more has landed since the
-     * count at 06:40 UTC. …"). The next recount (every 10 minutes) brings them back equal.
-     */
-    settling?: Record<string, {
-        counted: number | string | null;
-        now: number | string | null;
-        difference: number;
-    }>;
 }
 /**
  * A DECLARED drill definition (a `*.drill.ts` file): an override of one standard table (its key

package/dist/templates/index.cjs

@@ -4566,8 +4566,8 @@ function validateTemplate(raw, options = {}) {
       for (const k of rule.filled ?? []) if (!filled(val(k))) say(at, `"${row.key}" is ${st}, so "${fieldOf(table, k)?.label ?? k}" is filled; it is empty.`);
       for (const [k, v] of Object.entries(rule.equals ?? {})) {
         const got = val(k) ?? null;
-        const same2 = sameJson(got, v) || typeof v === "number" && parseNumeric(storeText(got) ?? "") !== null && qCmp(parseNumeric(storeText(got) ?? ""), parseNumeric(String(v))) === 0;
-        if (!same2) say(at, `"${row.key}" is ${st}, so "${fieldOf(table, k)?.label ?? k}" is ${JSON.stringify(v)}; it is ${JSON.stringify(got)}.`);
+        const same3 = sameJson(got, v) || typeof v === "number" && parseNumeric(storeText(got) ?? "") !== null && qCmp(parseNumeric(storeText(got) ?? ""), parseNumeric(String(v))) === 0;
+        if (!same3) say(at, `"${row.key}" is ${st}, so "${fieldOf(table, k)?.label ?? k}" is ${JSON.stringify(v)}; it is ${JSON.stringify(got)}.`);
       }
     }
   };
@@ -5905,7 +5905,7 @@ ${e.body}`.matchAll(MERGE_TOKEN)].map((m) => m[1]));
       }
     }
     const rows = t.rows;
-    const same2 = (x, y) => {
+    const same3 = (x, y) => {
       const a = storeText(x);
       const b = storeText(y);
       if (a === null || b === null) return false;
@@ -5923,7 +5923,7 @@ ${e.body}`.matchAll(MERGE_TOKEN)].map((m) => m[1]));
       };
       for (const sf of t.fields.filter((ff) => !isComputed(ff) && !isRelation(ff) && ff.key !== l.key)) {
         const have = rows.filter((r) => filled(r.values?.[sf.key]));
-        if (have.length >= 3 && have.every((r) => same2(r.values?.[sf.key], far(r)))) {
+        if (have.length >= 3 && have.every((r) => same3(r.values?.[sf.key], far(r)))) {
           say(`tables (${t.token}).fields (${sf.key})`, `"${sf.label}" repeats "${l.label}" on every row; drop it and use the lookup, which follows the linked record.`);
         }
       }
@@ -6819,6 +6819,138 @@ function mergeDescribeParts(plan, tables, doors, views, existingTables = [], not
   return spec;
 }
 
+// src/templates/describe/computed-shape.ts
+var VIA_KEYS = ["via", "relation", "relationField", "relation_field", "relationKey", "through", "rollupVia", "lookupVia", "rollupRelation", "lookupRelation", "rollupThrough", "lookupThrough", "from", "link", "linkField"];
+var PICK_KEYS = ["pick", "field", "targetField", "target_field", "fieldKey", "rollupField", "lookupField", "rollupTarget", "lookupTarget", "target", "of", "column", "sourceField", "source"];
+var AGG_KEYS = ["agg", "fn", "func", "function", "operation", "aggregation", "aggregate", "op", "aggregator", "calculation", "rollupFn", "rollupFunction", "rollupAgg", "rollupAggregate", "rollupAggregation", "rollupOperation", "rollupOp"];
+var AGG_WORDS = {
+  sum: "sum",
+  total: "sum",
+  add: "sum",
+  sumof: "sum",
+  summation: "sum",
+  count: "count",
+  countall: "count",
+  countrows: "count",
+  number: "count",
+  numberof: "count",
+  n: "count",
+  tally: "count",
+  avg: "avg",
+  average: "avg",
+  mean: "avg",
+  min: "min",
+  minimum: "min",
+  lowest: "min",
+  smallest: "min",
+  earliest: "min",
+  max: "max",
+  maximum: "max",
+  highest: "max",
+  largest: "max",
+  latest: "max",
+  median: "median",
+  filled: "filled",
+  countfilled: "filled",
+  empty: "empty",
+  countempty: "empty",
+  unique: "unique",
+  distinct: "unique",
+  countunique: "unique",
+  countdistinct: "unique"
+};
+var squash = (s) => String(s ?? "").toLowerCase().replace(/[^a-z0-9]/g, "");
+var singular = (s) => s.replace(/ies$/, "y").replace(/s$/, "");
+var same2 = (a, b) => squash(a) === squash(b) || singular(squash(a)) === singular(squash(b));
+function aggWord(v) {
+  return typeof v === "string" ? AGG_WORDS[squash(v)] : void 0;
+}
+function take(f, nested, keys) {
+  for (const k of keys) if (nested && nested[k] !== void 0 && nested[k] !== null && nested[k] !== "") return { value: nested[k], key: k, from: "nested" };
+  for (const k of keys) if (f[k] !== void 0 && f[k] !== null && f[k] !== "") return { value: f[k], key: k, from: "field" };
+  return void 0;
+}
+function normalizeComputedFields(spec, fixes) {
+  const every = allTables(spec);
+  const byToken = new Map(every.map((t) => [t.token, t]));
+  for (const t of spec.tables) {
+    for (const f of t.fields) {
+      const raw = f;
+      const nestedKind = ["rollup", "lookup"].find((k) => raw[k] && typeof raw[k] === "object");
+      const kind = f.parityType === "rollup" || f.parityType === "lookup" ? f.parityType : !f.parityType && nestedKind ? nestedKind : void 0;
+      if (!kind) continue;
+      const nested = nestedKind ? raw[nestedKind] : void 0;
+      const at = `tables.${t.token}.fields.${f.key}`;
+      const consumed = [];
+      let changed = false;
+      const hasVia = typeof f.via === "string" && t.fields.some((x) => x.key === f.via);
+      let via = hasVia ? t.fields.find((x) => x.key === f.via) : void 0;
+      if (!via) {
+        const got = take(raw, nested, VIA_KEYS);
+        if (got && typeof got.value === "string") {
+          const rels = t.fields.filter((x) => x.parityType === "relation" && x.relationTarget && x.key !== f.key);
+          const hits = [
+            rels.filter((x) => x.key === got.value),
+            rels.filter((x) => same2(x.key, got.value)),
+            rels.filter((x) => same2(x.label, got.value)),
+            rels.filter((x) => same2(x.relationTarget, got.value))
+          ].find((h) => h.length === 1);
+          if (hits) {
+            via = hits[0];
+            f.via = via.key;
+            consumed.push([got.from, got.key]);
+            changed = true;
+          }
+        }
+      }
+      if (!via || !via.relationTarget) {
+        if (changed) fixes.push(`${at}: ${kind} written as ${nestedKind ? `{${nestedKind}:\u2026}` : "loose keys"}, read into via/pick${kind === "rollup" ? "/agg" : ""} where unambiguous`);
+        continue;
+      }
+      const far = byToken.get(via.relationTarget);
+      if (kind === "rollup" && !f.agg) {
+        const got = take(raw, nested, AGG_KEYS);
+        const word = got ? aggWord(got.value) : void 0;
+        if (got && word) {
+          f.agg = word;
+          consumed.push([got.from, got.key]);
+          changed = true;
+        }
+      }
+      if (!f.pick || !far?.fields.some((x) => x.key === f.pick)) {
+        const got = take(raw, nested, PICK_KEYS);
+        const named = got && typeof got.value === "string" ? got.value : void 0;
+        const farField = named ? far?.fields.find((x) => x.key === named) ?? far?.fields.find((x) => same2(x.key, named)) ?? far?.fields.find((x) => same2(x.label, named)) : void 0;
+        if (farField) {
+          f.pick = farField.key;
+          if (got) consumed.push([got.from, got.key]);
+          changed = true;
+        } else if (kind === "rollup" && (f.agg === "count" || !f.agg && !named) && far) {
+          const title = far.titleField;
+          const stand = far.fields.find((x) => x.key === title) ?? far.fields.find((x) => !["relation", "formula", "lookup", "rollup", "autonumber"].includes(x.parityType));
+          if (stand) {
+            f.pick = stand.key;
+            if (got) consumed.push([got.from, got.key]);
+            changed = true;
+          }
+        }
+      }
+      if (kind === "rollup" && changed && via && !via.multi && (via.relationMax ?? 1) <= 1) {
+        via.multi = true;
+        delete via.relationMax;
+        for (const r of spec.relationships ?? []) if (r.fromTable === t.token && r.fromField === via.key) r.cardinality = "many";
+        fixes.push(`${at}.via: "${via.key}" made a list (a rollup adds up many linked records)`);
+      }
+      if (!changed) continue;
+      f.parityType = kind;
+      if (kind === "lookup") delete raw["agg"];
+      for (const [from, k] of consumed) if (from === "field") delete raw[k];
+      if (nestedKind) delete raw[nestedKind];
+      fixes.push(`${at}: ${kind} written in a shape the check does not read, rewritten as via "${f.via}", pick "${f.pick ?? "(none)"}"${kind === "rollup" ? `, agg "${f.agg ?? "(none)"}"` : ""}`);
+    }
+  }
+}
+
 // src/templates/describe/autofix.ts
 var clone2 = (v) => JSON.parse(JSON.stringify(v));
 var SENSITIVITY_RANK2 = ["public", "internal", "confidential", "restricted"];
@@ -7140,6 +7272,7 @@ function switchJob(spec, fixes) {
 function autofixDescribeSpec(input, ctx = {}) {
   const spec = describeSpec(clone2(input));
   const autoFixes = [];
+  normalizeComputedFields(spec, autoFixes);
   fixMissingQuestionFields(spec, autoFixes);
   raiseSensitivity(spec, autoFixes);
   flagAskedOfSubject(spec, ctx, autoFixes);
@@ -7363,6 +7496,14 @@ var VIEW_SHAPE_FACTS = {
   startField_endField: "timeline only, required: keys of two datetime fields",
   coverField: "gallery only, required: the key of a file field"
 };
+var ROLLUP_SHAPE_FACTS = {
+  rule: 'a rollup is a field of the PARENT table that adds up the records linked to it: parityType "rollup", via = the key of a relation field of THIS table (that link must be a list: multi true), pick = the key of a field on the far table, agg = sum | count | avg | min | max; an optional filter picks which linked records. Write exactly these keys on the field itself \u2014 never a nested {rollup:{\u2026}} object, never relation/field/fn.',
+  example: { key: "total_paid", label: "Total paid", parityType: "rollup", via: "payments", pick: "amount", agg: "sum" }
+};
+var LOOKUP_SHAPE_FACTS = {
+  rule: 'a lookup is a field that shows one value of the record a relation field points at: parityType "lookup", via = the key of a relation field of THIS table, pick = the key of a field on the far table. Write exactly these keys on the field itself \u2014 never a nested {lookup:{\u2026}} object.',
+  example: { key: "client_phone", label: "Client phone", parityType: "lookup", via: "client", pick: "phone" }
+};
 function describeVocabulary() {
   return {
     field_kinds: RESOLVABLE_FIELD_TYPE_WORDS,
@@ -7386,6 +7527,8 @@ function describeVocabulary() {
     booking_window: { weekday: "0 = Sunday \u2026 6 = Saturday", from: "HH:MM", to: "HH:MM later than from" },
     booking_availability: BOOKING_AVAILABILITY_FACTS,
     view_shape: VIEW_SHAPE_FACTS,
+    rollup_shape: ROLLUP_SHAPE_FACTS,
+    lookup_shape: LOOKUP_SHAPE_FACTS,
     title_field: "a table's titleField is the key of a plain text-like field of that same table (a name, a title) \u2014 never a link to another table, a formula or a timed date"
   };
 }