@ai-matrx/data 0.22.33 → 0.24.0

package/dist/db.cjs

@@ -7,11 +7,11 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
+var __copyProps = (to, from2, except, desc) => {
+  if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+    for (let key of __getOwnPropNames(from2))
       if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+        __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
   }
   return to;
 };
@@ -24,35 +24,53 @@ __export(db_exports, {
   DEFAULT_ACTIVE_ORG_COOKIE_MAX_AGE: () => DEFAULT_ACTIVE_ORG_COOKIE_MAX_AGE,
   DEFAULT_ACTIVE_ORG_COOKIE_NAME: () => DEFAULT_ACTIVE_ORG_COOKIE_NAME,
   DEFAULT_AUTH_COOKIE_NAME: () => DEFAULT_AUTH_COOKIE_NAME,
+  DatabaseError: () => DatabaseError,
+  DoorRefusedError: () => DoorRefusedError,
   IncompleteReadError: () => IncompleteReadError,
   RecordUnavailableError: () => RecordUnavailableError,
   SessionUnavailableError: () => SessionUnavailableError,
   WriteDidNotLandError: () => WriteDidNotLandError,
   WriteRefusedError: () => WriteRefusedError,
+  archive: () => archive,
   asJsonObject: () => asJsonObject,
+  assertDoor: () => assertDoor,
   assertWriteLanded: () => assertWriteLanded,
+  call: () => call,
+  changesOf: () => changesOf,
+  count: () => count,
   createActiveOrgCookie: () => createActiveOrgCookie,
   createAuthCookie: () => createAuthCookie,
+  createDb: () => createDb,
   createOAuthRefreshFetch: () => createOAuthRefreshFetch,
+  createServiceDb: () => createServiceDb,
   createSessionRetry: () => createSessionRetry,
   decodeActiveOrgSelection: () => decodeActiveOrgSelection,
   decodeOAuthRefreshClaims: () => decodeOAuthRefreshClaims,
   describeWriteFailure: () => describeWriteFailure,
   encodeActiveOrgSelection: () => encodeActiveOrgSelection,
   guardedUpdate: () => guardedUpdate,
+  insert: () => insert,
   isMissingSessionError: () => isMissingSessionError,
   isRecordUnavailableError: () => isRecordUnavailableError,
+  listAll: () => listAll,
+  loadTableByName: () => loadTableByName,
   mergeJsonColumn: () => mergeJsonColumn,
+  page: () => page,
   parseCookieHeader: () => parseCookieHeader,
   personSentence: () => personSentence,
+  read: () => read,
   readAllRows: () => readAllRows,
   readAllRowsRest: () => readAllRowsRest,
   recordUnavailableMessage: () => recordUnavailableMessage,
+  remove: () => remove,
+  restore: () => restore,
   serverMessageFromBody: () => serverMessageFromBody,
+  tableByName: () => tableByName,
   tryReadAllRows: () => tryReadAllRows,
   tryReadAllRowsRest: () => tryReadAllRowsRest,
   tryWriteOne: () => tryWriteOne,
   uniqueChannelTopic: () => import_realtime.uniqueChannelTopic,
+  update: () => update,
   writeFailureStatus: () => writeFailureStatus,
   writeOne: () => writeOne,
   writeOneRow: () => writeOneRow
@@ -127,18 +145,18 @@ async function readAllRows(query, opts) {
   const maxRows = opts.maxRows ?? DEFAULT_MAX_ROWS;
   const rows = [];
   let total = null;
-  for (let from = 0; ; from += pageSize) {
-    const res = await query({ from, to: from + pageSize - 1 });
+  for (let from2 = 0; ; from2 += pageSize) {
+    const res = await query({ from: from2, to: from2 + pageSize - 1 });
     if (res.error) {
       throw new Error(
         `readAllRows(${opts.label}): query failed \u2014 ${res.error.message}`
       );
     }
-    const page = res.data ?? [];
-    rows.push(...page);
+    const page2 = res.data ?? [];
+    rows.push(...page2);
     if (typeof res.count === "number") total = res.count;
     if (total === null) {
-      if (page.length < pageSize) return rows;
+      if (page2.length < pageSize) return rows;
       throw new IncompleteReadError(
         opts.label,
         rows.length,
@@ -147,7 +165,7 @@ async function readAllRows(query, opts) {
       );
     }
     if (rows.length >= total) break;
-    if (page.length === 0) {
+    if (page2.length === 0) {
       throw new IncompleteReadError(
         opts.label,
         rows.length,
@@ -190,7 +208,7 @@ async function readAllRowsRest(opts) {
   const endpoint = `${opts.url.replace(/\/$/, "")}/rest/v1/${opts.path}`;
   const rows = [];
   let total = null;
-  for (let from = 0; ; from += pageSize) {
+  for (let from2 = 0; ; from2 += pageSize) {
     const res = await fetch(endpoint, {
       headers: {
         apikey: opts.key,
@@ -201,7 +219,7 @@ async function readAllRowsRest(opts) {
         // no total, which is unverifiable and therefore refused below. This is
         // the REST twin of supabase-js's `{ count: "exact" }`.
         Prefer: "count=exact",
-        Range: `${from}-${from + pageSize - 1}`,
+        Range: `${from2}-${from2 + pageSize - 1}`,
         "Range-Unit": "items"
       }
     });
@@ -210,12 +228,12 @@ async function readAllRowsRest(opts) {
         `readAllRowsRest(${opts.label}): HTTP ${res.status} \u2014 ${await res.text()}`
       );
     }
-    const page = await res.json();
-    rows.push(...page);
+    const page2 = await res.json();
+    rows.push(...page2);
     const totalPart = res.headers.get("content-range")?.split("/")[1];
     if (totalPart && totalPart !== "*") total = Number(totalPart);
     if (total === null) {
-      if (page.length < pageSize) return rows;
+      if (page2.length < pageSize) return rows;
       throw new IncompleteReadError(
         opts.label,
         rows.length,
@@ -224,7 +242,7 @@ async function readAllRowsRest(opts) {
       );
     }
     if (rows.length >= total) break;
-    if (page.length === 0) {
+    if (page2.length === 0) {
       throw new IncompleteReadError(
         opts.label,
         rows.length,
@@ -360,9 +378,9 @@ function belongsToStorageKey(name, storageKey) {
   if (!name.startsWith(`${storageKey}.`)) return false;
   return /^(0|[1-9][0-9]*)$/.test(name.slice(storageKey.length + 1));
 }
-function renamedCookie(cookie, from, to) {
-  if (cookie.name === from) return { ...cookie, name: to };
-  const prefix = `${from}.`;
+function renamedCookie(cookie, from2, to) {
+  if (cookie.name === from2) return { ...cookie, name: to };
+  const prefix = `${from2}.`;
   if (!cookie.name.startsWith(prefix)) return null;
   const chunk = cookie.name.slice(prefix.length);
   if (!/^(0|[1-9][0-9]*)$/.test(chunk)) return null;
@@ -955,4 +973,241 @@ function recordUnavailableMessage(entity, reason) {
 function isRecordUnavailableError(value) {
   return value instanceof RecordUnavailableError;
 }
+
+// src/db/doors.ts
+function credentialsOf(client) {
+  return {
+    async get() {
+      if (!client.auth) return null;
+      const { data } = await client.auth.getSession();
+      return data.session ? { kind: "user", accessToken: data.session.access_token } : null;
+    },
+    onChange(cb) {
+      if (!client.auth) return () => {
+      };
+      const { data } = client.auth.onAuthStateChange(() => cb());
+      return () => data.subscription.unsubscribe();
+    }
+  };
+}
+function createDb(options) {
+  const { client, organization } = options;
+  return {
+    client,
+    role: "user",
+    activeOrganization: () => organization?.() ?? null,
+    credentials: credentialsOf(client)
+  };
+}
+function createServiceDb(options) {
+  if (typeof globalThis.window !== "undefined") {
+    throw new DoorRefusedError("createServiceDb", "the service role never runs in a browser");
+  }
+  return { client: options.client, role: "service", activeOrganization: () => null, credentials: credentialsOf(options.client) };
+}
+var DoorRefusedError = class extends Error {
+  constructor(door, reason) {
+    super(`${door}: ${reason}`);
+    this.door = door;
+    this.reason = reason;
+    this.name = "DoorRefusedError";
+  }
+  door;
+  reason;
+};
+var DatabaseError = class extends Error {
+  constructor(door, cause) {
+    super(`${door}: ${cause.message}${cause.code ? ` (${cause.code})` : ""}`);
+    this.door = door;
+    this.cause = cause;
+    this.name = "DatabaseError";
+  }
+  door;
+  cause;
+};
+var CLIENT_DOORS = {
+  entity: ["read", "insert", "update", "remove", "archive"],
+  detail: ["read", "insert", "update", "remove", "archive"],
+  ledger: ["read", "insert"],
+  reference: ["read"],
+  system: ["read"],
+  restricted: [],
+  deprecated: []
+};
+var qualified = (t) => `${t.schema}.${t.name}`;
+function assertDoor(db, table, op) {
+  const door = `${op} ${qualified(table)}`;
+  if (table.type === "deprecated") throw new DoorRefusedError(door, "the table is deprecated \u2014 no door opens on it");
+  if (table.kind !== "table" && op !== "read") throw new DoorRefusedError(door, `a ${table.kind.replace("_", " ")} is read-only`);
+  if (db.role === "service") return;
+  if (table.type && !CLIENT_DOORS[table.type].includes(op))
+    throw new DoorRefusedError(door, `a ${table.type} table opens only ${CLIENT_DOORS[table.type].join(", ") || "service"} doors to a client`);
+  if (op !== "read" && table.readOnly) throw new DoorRefusedError(door, "the table is read-only to clients (client_read_only)");
+  if (op === "remove" && table.deletesRefused) throw new DoorRefusedError(door, "clients may not delete from this table (client_deletes_refused)");
+}
+function check(door, res) {
+  if (res.error) throw new DatabaseError(door, res.error);
+  return res.data;
+}
+var from = (db, t) => db.client.schema(t.schema).from(t.name);
+function byPk(q, t, id) {
+  if (t.pk.length === 1) return q.eq(t.pk[0], id);
+  const key = id;
+  return t.pk.reduce((acc, col) => acc.eq(col, key[col]), q);
+}
+var selectOf = (columns) => columns && columns.length ? columns.join(",") : "*";
+function live(q, table, includeDeleted) {
+  return table.softDelete && !includeDeleted ? q.is("deleted_at", null) : q;
+}
+function ordered(q, table, orderBy, ascending = true) {
+  const cols = orderBy ? [orderBy, ...table.pk.filter((c) => c !== orderBy)] : table.pk.length ? table.pk : ["id"];
+  return cols.reduce((acc, c) => acc.order(c, { ascending }), q);
+}
+async function read(db, table, id, opts = {}) {
+  assertDoor(db, table, "read");
+  const q = live(byPk(from(db, table).select(selectOf(opts.columns)), table, id), table, opts.includeDeleted);
+  return check(`read ${qualified(table)}`, await q.maybeSingle());
+}
+async function listAll(db, table, where, opts = {}) {
+  assertDoor(db, table, "read");
+  return readAllRows(
+    ({ 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);
+    },
+    {
+      label: `listAll ${qualified(table)}`,
+      ...opts.pageSize !== void 0 ? { pageSize: opts.pageSize } : {},
+      ...opts.maxRows !== void 0 ? { maxRows: opts.maxRows } : {}
+    }
+  );
+}
+async function page(db, table, window2) {
+  assertDoor(db, table, "read");
+  let q = live(from(db, table).select(selectOf(window2.columns), { count: "exact" }), table, window2.includeDeleted);
+  if (window2.where) q = window2.where(q);
+  const res = await ordered(q, table, window2.orderBy, window2.ascending ?? true).range(window2.from, window2.to);
+  return { rows: check(`page ${qualified(table)}`, res) ?? [], total: res.count ?? null };
+}
+async function count(db, table, where, opts = {}) {
+  assertDoor(db, table, "read");
+  let q = live(from(db, table).select("*", { count: "exact", head: true }), table, opts.includeDeleted);
+  if (where) q = where(q);
+  const res = await q;
+  check(`count ${qualified(table)}`, res);
+  return res.count ?? 0;
+}
+function withOrganization(db, table, values) {
+  const door = `insert ${qualified(table)}`;
+  const org = table.org;
+  if (org.rule === "parent" && values[org.via] != null) {
+    return values;
+  }
+  if (org.rule === "binding" || org.rule === "parent") {
+    if (values.organization_id != null) return values;
+    const active = db.activeOrganization();
+    if (!active) {
+      throw new DoorRefusedError(
+        door,
+        db.role === "service" ? "a service insert names its organization_id" : "no organization: pass organization_id or bind createDb({ organization })"
+      );
+    }
+    return { ...values, organization_id: active };
+  }
+  return 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));
+  const res = await from(db, table).insert(rows).select("*");
+  const stored = check(`insert ${qualified(table)}`, res);
+  return many ? stored : stored[0];
+}
+async function writeRow(db, table, id, values, door, guard) {
+  const expected = guard && "expectedVersion" in guard ? guard.expectedVersion : void 0;
+  if (expected !== void 0 && !table.versioned) {
+    throw new DoorRefusedError(door, "expectedVersion on a table that is not versioned \u2014 nothing would guard it; pass no guard");
+  }
+  if (table.versioned && expected === void 0 && !(guard && "overwrite" in guard && guard.overwrite)) {
+    throw new DoorRefusedError(door, "a versioned table takes { expectedVersion } or { overwrite: true }");
+  }
+  if (expected !== void 0) {
+    return await guardedUpdate({
+      expectedVersion: expected,
+      applyUpdate: ({ expectedVersion, nextVersion }) => byPk(from(db, table).update({ ...values, version: nextVersion }), table, id).eq("version", expectedVersion).select("*").maybeSingle(),
+      fetchCurrent: () => byPk(from(db, table).select("*"), table, id).maybeSingle()
+    });
+  }
+  const row = check(door, await byPk(from(db, table).update(values), table, id).select("*").maybeSingle());
+  return row ? { status: "saved", row } : { status: "not_found" };
+}
+async function update(db, table, id, patch, guard) {
+  assertDoor(db, table, "update");
+  const door = `update ${qualified(table)}`;
+  const values = patch;
+  if (db.role === "user") {
+    const blocked = table.readOnlyColumns.filter((c) => c in values);
+    if (blocked.length) throw new DoorRefusedError(door, `read-only to clients: ${blocked.join(", ")}`);
+  }
+  return writeRow(db, table, id, values, door, guard);
+}
+async function remove(db, table, id, guard) {
+  assertDoor(db, table, "remove");
+  const door = `remove ${qualified(table)}`;
+  if (table.softDelete) {
+    const res = await writeRow(db, table, id, { deleted_at: (/* @__PURE__ */ new Date()).toISOString() }, door, guard);
+    return res.status === "saved" ? { status: "soft_deleted" } : res.status === "conflict" ? { status: "conflict", currentVersion: res.currentVersion } : res;
+  }
+  if (table.archive) throw new DoorRefusedError(door, "this table archives instead of deleting \u2014 use archive()");
+  const expected = guard && "expectedVersion" in guard ? guard.expectedVersion : void 0;
+  if (expected !== void 0 && !table.versioned) throw new DoorRefusedError(door, "expectedVersion on a table that is not versioned");
+  if (table.versioned && expected === void 0 && !(guard && "overwrite" in guard)) {
+    throw new DoorRefusedError(door, "a versioned table takes { expectedVersion } or { overwrite: true }");
+  }
+  let q = byPk(from(db, table).delete(), table, id);
+  if (expected !== void 0) q = q.eq("version", expected);
+  const rows = check(door, await q.select("*"));
+  if (rows && rows.length) return { status: "deleted" };
+  if (expected !== void 0) {
+    const current = check(door, await byPk(from(db, table).select("version"), table, id).maybeSingle());
+    if (current) return { status: "conflict", currentVersion: current.version };
+  }
+  return { status: "not_found" };
+}
+async function archive(db, table, id, opts = {}) {
+  assertDoor(db, table, "archive");
+  const door = `${opts.restore ? "restore" : "archive"} ${qualified(table)}`;
+  let values;
+  if (table.archive === "archived_at") values = { archived_at: opts.restore ? null : (/* @__PURE__ */ new Date()).toISOString() };
+  else if (table.archive === "is_archived") values = { is_archived: !opts.restore };
+  else if (table.softDelete && opts.restore) values = { deleted_at: null };
+  else throw new DoorRefusedError(door, "the table has no archive column");
+  return writeRow(db, table, id, values, door, opts.guard);
+}
+var restore = (db, table, id, guard) => archive(db, table, id, guard ? { restore: true, guard } : { restore: true });
+async function call(db, fn, args) {
+  const door = `call ${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"})`);
+  }
+  return check(door, await db.client.schema(fn.schema).rpc(fn.name, args));
+}
+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)");
+  return t;
+}
+async function loadTableByName(loaders, name) {
+  const schema = name.slice(0, name.indexOf("."));
+  const load = schema ? loaders[schema] : void 0;
+  if (!load) throw new DoorRefusedError(`tableByName ${name}`, "no such schema in the database description (schema-qualify it: schema.table)");
+  return tableByName(await load(), name);
+}
+function changesOf(table) {
+  if (!table.realtime) throw new DoorRefusedError(`changesOf ${qualified(table)}`, "the table is not in the supabase_realtime publication");
+  return { schema: table.schema, table: table.name };
+}
 //# sourceMappingURL=db.cjs.map