@ai-matrx/data 0.24.0 → 0.26.0

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## 0.26.0 — callAll: every row of a set-returning function
+
+- **`callAll(db, fn, args, { order })`** — the complete read of a set-returning database function:
+  `rpc(…, { count: "exact" })` paged by `range` over the named `order` (`"id"` or
+  `{ column, ascending, nullsFirst }`; end on a key), past the 1,000-row cap; a `DatabaseError` keeps the
+  database's own error (code kept); a short read throws `IncompleteReadError`; an empty order is refused.
+- `SupabaseLike.rpc` takes PostgREST's optional third argument (`{ count }`).
+
+Consumer action: none (additive). Packages that paged `.rpc(...).order().range()` by hand move to `callAll`.
+
+## 0.25.0 — created_by stamped; listAll keeps the database's error
+
+- **A signed-in `insert` stamps `created_by`** with the session's person when the table has a
+  `created_by` column and the row omits it (row security on `workbench.notes` / `note_folders` and
+  similar tables refuses an insert whose `created_by` is not `auth.uid()`). An explicit value is kept;
+  the service role never stamps. Descriptors carry `createdBy: boolean` (generated from the columns).
+- **`listAll` throws a `DatabaseError`** carrying the database's own error (message, code, details) —
+  it used to surface as a re-worded `readAllRows(...)` `Error` without the code.
+
+Consumer action: run `matrx-data generate` again (`pnpm db:generate`) so descriptors carry `createdBy`;
+code that matched `listAll` failures by the `readAllRows(` message should check `instanceof DatabaseError`.
+
 ## 0.24.0 — doors hardened (independent review)
 
 - **Every write on a versioned table is guarded.** `remove` (and `archive` / `restore`) take the same

package/bin/generate.mjs

@@ -94,6 +94,7 @@ function tableDescriptor(schema, name, t) {
     readOnlyColumns: reg?.clientReadOnlyColumns ?? [],
     listScope: reg?.listScope ?? null,
     realtime: (t.realtime ?? []).includes("supabase_realtime"),
+    createdBy: t.columns.some((c) => c.name === "created_by"),
   };
   return flags;
 }

package/dist/db.cjs

@@ -36,6 +36,7 @@ __export(db_exports, {
   assertDoor: () => assertDoor,
   assertWriteLanded: () => assertWriteLanded,
   call: () => call,
+  callAll: () => callAll,
   changesOf: () => changesOf,
   count: () => count,
   createActiveOrgCookie: () => createActiveOrgCookie,
@@ -1074,7 +1075,10 @@ async function listAll(db, table, where, opts = {}) {
     ({ from: lo, to: hi }) => {
       let q = live(from(db, table).select(selectOf(opts.columns), { count: "exact" }), table, opts.includeDeleted);
       if (where) q = where(q);
-      return ordered(q, table, opts.orderBy).range(lo, hi);
+      return Promise.resolve(ordered(q, table, opts.orderBy).range(lo, hi)).then((res) => {
+        if (res.error) throw new DatabaseError(`listAll ${qualified(table)}`, res.error);
+        return res;
+      });
     },
     {
       label: `listAll ${qualified(table)}`,
@@ -1120,7 +1124,12 @@ function withOrganization(db, table, values) {
 async function insert(db, table, values) {
   assertDoor(db, table, "insert");
   const many = Array.isArray(values);
-  const rows = (many ? values : [values]).map((v) => withOrganization(db, table, v));
+  let rows = (many ? values : [values]).map((v) => withOrganization(db, table, v));
+  if (table.createdBy && db.role === "user" && rows.some((r) => r.created_by == null) && db.client.auth) {
+    const { data } = await db.client.auth.getSession();
+    const person = data.session?.user?.id;
+    if (person) rows = rows.map((r) => r.created_by == null ? { ...r, created_by: person } : r);
+  }
   const res = await from(db, table).insert(rows).select("*");
   const stored = check(`insert ${qualified(table)}`, res);
   return many ? stored : stored[0];
@@ -1195,6 +1204,27 @@ async function call(db, fn, args) {
   }
   return check(door, await db.client.schema(fn.schema).rpc(fn.name, args));
 }
+async function callAll(db, fn, args, opts) {
+  const door = `callAll ${fn.schema}.${fn.name}`;
+  const role = db.role === "service" ? "service_role" : "authenticated";
+  if (!fn.roles.includes(role) && !(role === "authenticated" && fn.roles.includes("anon"))) {
+    throw new DoorRefusedError(door, `not executable by ${role} (executable by: ${fn.roles.join(", ") || "nobody"})`);
+  }
+  if (!opts.order.length) throw new DoorRefusedError(door, "a paged read needs an order (end on a key) \u2014 pages over no order can skip or repeat rows");
+  return readAllRows(
+    ({ from: lo, to: hi }) => {
+      let q = db.client.schema(fn.schema).rpc(fn.name, args, { count: "exact" });
+      for (const o of opts.order) {
+        q = typeof o === "string" ? q.order(o) : q.order(o.column, { ascending: o.ascending ?? true, ...o.nullsFirst !== void 0 ? { nullsFirst: o.nullsFirst } : {} });
+      }
+      return Promise.resolve(q.range(lo, hi)).then((res) => {
+        if (res.error) throw new DatabaseError(door, res.error);
+        return res;
+      });
+    },
+    { label: door, ...opts.pageSize !== void 0 ? { pageSize: opts.pageSize } : {}, ...opts.maxRows !== void 0 ? { maxRows: opts.maxRows } : {} }
+  );
+}
 function tableByName(index, name) {
   const t = index[name];
   if (!t) throw new DoorRefusedError(`tableByName ${name}`, "no such table in the database description (schema-qualify it: schema.table)");