@lunora/do 1.0.0-alpha.2 → 1.0.0-alpha.21

package/dist/packem_shared/{ReactiveCache-ByVzgH3d.mjs → ReactiveCache-BYlSGY0N.mjs}

@@ -1,11 +1,6 @@
+import { stableStringify } from './stableStringify-MydiuScU.mjs';
 import { depKey, SCAN_DEP } from './SCAN_DEP-DLJF8dsj.mjs';
 
-const compareKeys = (a, b) => {
-  if (a < b) {
-    return -1;
-  }
-  return a > b ? 1 : 0;
-};
 const DEFAULT_MAX_ENTRIES = 1e3;
 const DEFAULT_MAX_BYTES = 4 * 1024 * 1024;
 const estimateBytes = (value) => {
@@ -232,28 +227,6 @@ class ReactiveCache {
     }
   }
 }
-const stableStringify = (value) => {
-  if (value === void 0) {
-    return "null";
-  }
-  if (value === null || typeof value !== "object") {
-    return JSON.stringify(value);
-  }
-  if (Array.isArray(value)) {
-    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
-  }
-  const record = value;
-  const keys = Object.keys(record).toSorted(compareKeys);
-  const parts = [];
-  for (const key of keys) {
-    const raw = record[key];
-    if (raw === void 0) {
-      continue;
-    }
-    parts.push(`${JSON.stringify(key)}:${stableStringify(raw)}`);
-  }
-  return `{${parts.join(",")}}`;
-};
 const reactiveCacheKey = (functionPath, args, identity) => `${identity ?? "\0anon"}\0${functionPath}:${stableStringify(args)}`;
 
 export { ReactiveCache, reactiveCacheKey, stableStringify };

package/dist/packem_shared/{applyOnDelete-CMif2RKw.mjs → applyOnDelete-BQ-8ZlZ1.mjs}

@@ -1,3 +1,15 @@
+import { applySelect } from './applySelect-BvZdFUBT.mjs';
+
+const projectChildren = (documents, nested) => nested.select ? applySelect(documents, nested.select, nested.with) : documents;
+const fanOutScalarCounts = async (counter, tableName, whereField, values, policyWhere) => {
+  const pairs = await Promise.all(
+    values.map(async (value) => {
+      const countWhere = policyWhere ? { AND: [{ [whereField]: value }, policyWhere] } : { [whereField]: value };
+      return [value, await counter(tableName, countWhere)];
+    })
+  );
+  return new Map(pairs);
+};
 const distinctValues = (rows, field) => {
   const seen = /* @__PURE__ */ new Set();
   for (const row of rows) {
@@ -9,7 +21,7 @@ const distinctValues = (rows, field) => {
   return [...seen];
 };
 const resolveWith = async (options) => {
-  const { counter, fetcher, parents, relationBaseWhere, schema, tableName, with: withInput } = options;
+  const { groupedCounter, fetcher, parents, relationBaseWhere, schema, tableName, with: withInput } = options;
   if (parents.length === 0) {
     return;
   }
@@ -44,7 +56,8 @@ const resolveWith = async (options) => {
       byReference.set(child[relation.references], child);
     }
     for (const parent of parents) {
-      parent[name] = byReference.get(parent[relation.field]) ?? null;
+      const child = byReference.get(parent[relation.field]);
+      parent[name] = child ? projectChildren([child], nested)[0] ?? null : null;
     }
   };
   const loadMany = async (name, relation, nested) => {
@@ -77,19 +90,16 @@ const resolveWith = async (options) => {
     const cap = typeof nested.limit === "number" ? Math.max(0, Math.floor(nested.limit)) : void 0;
     for (const parent of parents) {
       const group = groups.get(parent[relation.references]) ?? [];
-      parent[name] = cap === void 0 ? group : group.slice(0, cap);
+      parent[name] = projectChildren(cap === void 0 ? group : group.slice(0, cap), nested);
     }
   };
   const resolveCounts = async (countInput) => {
     for (const name of Object.keys(countInput)) {
       const relation = requireRelation(name);
       const [whereField, parentField] = relation.kind === "many" ? [relation.field, relation.references] : [relation.references, relation.field];
-      const countByValue = /* @__PURE__ */ new Map();
       const policyWhere = relationBaseWhere?.(relation.table);
-      for (const value of distinctValues(parents, parentField)) {
-        const countWhere = policyWhere ? { AND: [{ [whereField]: value }, policyWhere] } : { [whereField]: value };
-        countByValue.set(value, await counter(relation.table, countWhere));
-      }
+      const values = distinctValues(parents, parentField);
+      const countByValue = values.length === 0 ? /* @__PURE__ */ new Map() : await groupedCounter(relation.table, whereField, values, policyWhere);
       for (const parent of parents) {
         const counts = parent["_count"] ?? {};
         const parentValue = parent[parentField];
@@ -162,4 +172,4 @@ const runRowValidators = (definition, document) => {
   }
 };
 
-export { applyOnDelete, distinctValues, resolveWith, runRowValidators };
+export { applyOnDelete, distinctValues, fanOutScalarCounts, resolveWith, runRowValidators };

package/dist/packem_shared/{buildSeekWhere-lVsNXSLy.mjs → applySelect-BvZdFUBT.mjs}

@@ -80,5 +80,22 @@ const buildSeekBeforeWhere = (keys, cursorValues) => {
   }
   return { OR: branches };
 };
+const SELECT_SYSTEM_FIELDS = ["_id", "_creationTime"];
+const applySelect = (page, select, withInput) => {
+  if (!select) {
+    return page;
+  }
+  const keep = /* @__PURE__ */ new Set([...select, ...SELECT_SYSTEM_FIELDS, ...withInput ? Object.keys(withInput) : []]);
+  return page.map((document) => {
+    const projected = {};
+    for (const key of keep) {
+      if (key in document) {
+        projected[key] = document[key];
+      }
+    }
+    return projected;
+  });
+};
+const softDeleteScope = (softDeleteMode, includeDeleted) => softDeleteMode && includeDeleted !== true ? { [softDeleteMode.field]: { isNull: true } } : void 0;
 
-export { buildSeekBeforeWhere, buildSeekWhere, decodeCursor, encodeCursor, normalizeOrderKeys };
+export { applySelect, buildSeekBeforeWhere, buildSeekWhere, decodeCursor, encodeCursor, normalizeOrderKeys, softDeleteScope };

package/dist/packem_shared/{backfillAggregateIndexes-BF5eL7kW.mjs → backfillAggregateIndexes-BZsOqDXP.mjs}

@@ -1,10 +1,11 @@
 import { sql } from 'drizzle-orm';
-import { matchesStaticWhere } from './matchesStaticWhere-CFk6adSu.mjs';
+import { matchesStaticWhere } from './AGGREGATE_SQL_FUNCTION-CFk6adSu.mjs';
 import { encodeAggregateKey, foldAggregateTally, aggregateTableName } from './aggregateTableName-CxNqY1Sl.mjs';
 import { r as runDrizzle } from './do-exec-5eQy5cEi.mjs';
 import { D as DOC_COLUMN, r as rowToDocument, A as AGG_KEY, a as AGG_VALUE, b as AGG_COUNT } from './do-sql-BCHCWtrD.mjs';
 import { param } from './renderSql-D6eUcn2N.mjs';
-import { s as sortColumnName, m as matchesRankStaticWhere, e as encodePartitionKey, b as serializeSqlValue, r as rankTableName } from './rank-CrkEIpF4.mjs';
+import { sortColumnName, matchesRankStaticWhere, encodePartitionKey, rankTableName } from './RANK_TIEBREAK-CXhdcA1o.mjs';
+import { s as serializeSqlValue } from './serialize-sql-BlRUoiQe.mjs';
 
 const backfillAggregateIndex = (sql$1, tableName, index) => {
   const aggTable = aggregateTableName(tableName, index.name);

package/dist/packem_shared/{compileWhereSql-CXrhFA3G.mjs → compileWhereSql-MW_Lk8nJ.mjs}

@@ -11,9 +11,10 @@ const isOperatorObject = (value) => {
   const keys = Object.keys(value);
   return keys.length > 0 && keys.every((key) => OPERATOR_KEY_SET.has(key));
 };
+const escapeLikeTerm = (value) => typeof value === "string" ? value.replaceAll(/[\\%_]/g, (character) => `\\${character}`) : value;
 const compileContains = (reference, value, strategy) => {
-  const term = sql`${strategy.serialize(value)}`;
-  return strategy.likeContains ? strategy.likeContains(reference, term) : sql`${reference} LIKE '%' || ${term} || '%'`;
+  const term = sql`${strategy.serialize(escapeLikeTerm(value))}`;
+  return strategy.likeContains ? strategy.likeContains(reference, term) : sql`${reference} LIKE '%' || ${term} || '%' ESCAPE '\\'`;
 };
 const compileComparator = (reference, operator, comparator, value, strategy) => {
   if (value === null) {

package/dist/packem_shared/ctx-db-idempotency-BdcNpvY4.mjs

@@ -0,0 +1,108 @@
+import { sql } from 'drizzle-orm';
+import { r as runDrizzle } from './do-exec-5eQy5cEi.mjs';
+
+const CLIENT_WATERMARK_TABLE = "__client_watermark";
+const migrateClientWatermark = (sql$1) => {
+  runDrizzle(
+    sql$1,
+    sql`CREATE TABLE IF NOT EXISTS ${sql.identifier(CLIENT_WATERMARK_TABLE)} (
+            identity TEXT NOT NULL,
+            client_id TEXT NOT NULL,
+            last_mutation_id INTEGER NOT NULL,
+            PRIMARY KEY (identity, client_id)
+        )`
+  );
+};
+const readClientWatermark = (sql$1, identity, clientId) => {
+  const rows = runDrizzle(
+    sql$1,
+    sql`SELECT last_mutation_id FROM ${sql.identifier(CLIENT_WATERMARK_TABLE)} WHERE identity = ${identity} AND client_id = ${clientId} LIMIT 1`
+  ).toArray();
+  return rows[0]?.last_mutation_id ?? 0;
+};
+const advanceClientWatermark = (sql$1, identity, clientId, mutationId) => {
+  runDrizzle(
+    sql$1,
+    sql`INSERT INTO ${sql.identifier(CLIENT_WATERMARK_TABLE)} (identity, client_id, last_mutation_id) VALUES (${identity}, ${clientId}, ${mutationId})
+             ON CONFLICT(identity, client_id) DO UPDATE SET last_mutation_id = MAX(last_mutation_id, excluded.last_mutation_id)`
+  );
+};
+
+const GLOBAL_SHAPE_SNAPSHOT_TABLE = "__global_shape_snapshot";
+const migrateGlobalShapeSnapshot = (sql$1) => {
+  runDrizzle(
+    sql$1,
+    sql`CREATE TABLE IF NOT EXISTS ${sql.identifier(GLOBAL_SHAPE_SNAPSHOT_TABLE)} (
+            connection_id TEXT NOT NULL,
+            sub_id TEXT NOT NULL,
+            members TEXT NOT NULL,
+            PRIMARY KEY (connection_id, sub_id)
+        )`
+  );
+};
+const readGlobalShapeSnapshot = (sql$1, connectionId, subId) => {
+  const rows = runDrizzle(
+    sql$1,
+    sql`SELECT members FROM ${sql.identifier(GLOBAL_SHAPE_SNAPSHOT_TABLE)} WHERE connection_id = ${connectionId} AND sub_id = ${subId} LIMIT 1`
+  ).toArray();
+  const raw = rows[0]?.members;
+  if (raw === void 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object") {
+      return /* @__PURE__ */ new Map();
+    }
+    return new Map(Object.entries(parsed));
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+};
+const writeGlobalShapeSnapshot = (sql$1, connectionId, subId, snapshot) => {
+  const members = JSON.stringify(Object.fromEntries(snapshot));
+  runDrizzle(
+    sql$1,
+    sql`INSERT INTO ${sql.identifier(GLOBAL_SHAPE_SNAPSHOT_TABLE)} (connection_id, sub_id, members) VALUES (${connectionId}, ${subId}, ${members})
+             ON CONFLICT(connection_id, sub_id) DO UPDATE SET members = excluded.members`
+  );
+};
+const deleteGlobalShapeSnapshot = (sql$1, connectionId, subId) => {
+  runDrizzle(sql$1, sql`DELETE FROM ${sql.identifier(GLOBAL_SHAPE_SNAPSHOT_TABLE)} WHERE connection_id = ${connectionId} AND sub_id = ${subId}`);
+};
+const deleteGlobalShapeSnapshotsForConnection = (sql$1, connectionId) => {
+  runDrizzle(sql$1, sql`DELETE FROM ${sql.identifier(GLOBAL_SHAPE_SNAPSHOT_TABLE)} WHERE connection_id = ${connectionId}`);
+};
+
+const IDEMPOTENCY_TABLE = "__idempotency";
+const migrateIdempotency = (sql$1) => {
+  runDrizzle(
+    sql$1,
+    sql`CREATE TABLE IF NOT EXISTS ${sql.identifier(IDEMPOTENCY_TABLE)} (
+            identity TEXT NOT NULL,
+            mutation_id TEXT NOT NULL,
+            result_json TEXT NOT NULL,
+            ts REAL NOT NULL,
+            PRIMARY KEY (identity, mutation_id)
+        )`
+  );
+};
+const readIdempotent = (sql$1, identity, mutationId) => {
+  const rows = runDrizzle(
+    sql$1,
+    sql`SELECT result_json, ts FROM ${sql.identifier(IDEMPOTENCY_TABLE)} WHERE identity = ${identity} AND mutation_id = ${mutationId} LIMIT 1`
+  ).toArray();
+  const row = rows[0];
+  return row === void 0 ? void 0 : { resultJson: row.result_json, ts: row.ts };
+};
+const writeIdempotent = (sql$1, identity, mutationId, resultJson, ts) => {
+  runDrizzle(
+    sql$1,
+    sql`INSERT OR IGNORE INTO ${sql.identifier(IDEMPOTENCY_TABLE)} (identity, mutation_id, result_json, ts) VALUES (${identity}, ${mutationId}, ${resultJson}, ${ts})`
+  );
+};
+const trimIdempotent = (sql$1, olderThanTs) => {
+  runDrizzle(sql$1, sql`DELETE FROM ${sql.identifier(IDEMPOTENCY_TABLE)} WHERE ts < ${olderThanTs}`);
+};
+
+export { CLIENT_WATERMARK_TABLE as C, GLOBAL_SHAPE_SNAPSHOT_TABLE as G, IDEMPOTENCY_TABLE as I, migrateIdempotency as a, migrateGlobalShapeSnapshot as b, advanceClientWatermark as c, deleteGlobalShapeSnapshot as d, deleteGlobalShapeSnapshotsForConnection as e, readGlobalShapeSnapshot as f, readIdempotent as g, writeIdempotent as h, migrateClientWatermark as m, readClientWatermark as r, trimIdempotent as t, writeGlobalShapeSnapshot as w };

package/dist/packem_shared/ctx-db-shapes-0RaIOy7J.mjs

@@ -0,0 +1,53 @@
+import { sql } from 'drizzle-orm';
+import { r as runDrizzle } from './do-exec-5eQy5cEi.mjs';
+import { D as DOC_COLUMN, r as rowToDocument, j as jsonPathSql } from './do-sql-BCHCWtrD.mjs';
+import { compileWhereSql } from './compileWhereSql-MW_Lk8nJ.mjs';
+import { s as serializeSqlValue } from './serialize-sql-BlRUoiQe.mjs';
+
+const shapeWhereStrategy = { fieldRef: jsonPathSql, serialize: serializeSqlValue };
+const idInClause = (ids) => {
+  if (ids.length === 0) {
+    return void 0;
+  }
+  return sql`id IN (${sql.join(
+    ids.map((id) => sql`${id}`),
+    sql`, `
+  )})`;
+};
+const composeWhere = (effectiveWhere, idRestriction) => {
+  const conditions = [];
+  if (idRestriction) {
+    conditions.push(idRestriction);
+  }
+  const compiled = compileWhereSql(effectiveWhere, shapeWhereStrategy);
+  if (compiled) {
+    conditions.push(compiled);
+  }
+  if (conditions.length === 0) {
+    return sql``;
+  }
+  return sql` WHERE ${sql.join(conditions, sql` AND `)}`;
+};
+const selectShapeRows = (sql$1, table, effectiveWhere) => {
+  const whereClause = composeWhere(effectiveWhere, void 0);
+  const rows = runDrizzle(sql$1, sql`SELECT id, _creationTime, ${sql.identifier(DOC_COLUMN)} FROM ${sql.identifier(table)}${whereClause}`).toArray();
+  const result = [];
+  for (const row of rows) {
+    const doc = rowToDocument(row);
+    const { id } = row;
+    if (doc !== void 0 && typeof id === "string") {
+      result.push({ doc, id });
+    }
+  }
+  return result;
+};
+const selectShapeMemberIds = (sql$1, table, effectiveWhere, ids) => {
+  if (ids.length === 0) {
+    return /* @__PURE__ */ new Set();
+  }
+  const whereClause = composeWhere(effectiveWhere, idInClause(ids));
+  const rows = runDrizzle(sql$1, sql`SELECT id FROM ${sql.identifier(table)}${whereClause}`).toArray();
+  return new Set(rows.map((row) => row.id));
+};
+
+export { selectShapeMemberIds as a, selectShapeRows as s };

package/dist/packem_shared/diffExternalSource-Cx9HUPJj.mjs

@@ -0,0 +1,44 @@
+import { stableStringify } from './stableStringify-MydiuScU.mjs';
+
+const projectExternalSourceRow = (row, columns) => {
+  const projected = { _id: row._id };
+  if (columns) {
+    for (const key of columns) {
+      if (Object.hasOwn(row, key)) {
+        projected[key] = row[key];
+      }
+    }
+    return projected;
+  }
+  for (const [key, value] of Object.entries(row)) {
+    if (key !== "_id" && key !== "_creationTime") {
+      projected[key] = value;
+    }
+  }
+  return projected;
+};
+const diffExternalSource = (pulled, baseline, options) => {
+  const { columns, table } = options;
+  const changes = [];
+  const nextBaseline = /* @__PURE__ */ new Map();
+  for (const source of pulled) {
+    const value = projectExternalSourceRow(source, columns);
+    const id = String(value._id);
+    const json = stableStringify(value);
+    nextBaseline.set(id, json);
+    const before = baseline.get(id);
+    if (before === void 0) {
+      changes.push({ doc: value, id, op: "insert", seq: 0, table, ts: 0 });
+    } else if (before !== json) {
+      changes.push({ doc: value, id, op: "update", seq: 0, table, ts: 0 });
+    }
+  }
+  for (const id of baseline.keys()) {
+    if (!nextBaseline.has(id)) {
+      changes.push({ id, op: "delete", seq: 0, table, ts: 0 });
+    }
+  }
+  return { changes, nextBaseline };
+};
+
+export { diffExternalSource, projectExternalSourceRow };

package/dist/packem_shared/isSourceDue-9mJRJ9Ld.mjs

@@ -0,0 +1,40 @@
+import { runExternalSourceTick } from './materializeExternalRows-Bj6EXy50.mjs';
+
+const liftSourceId = (row, options = {}) => {
+  const { idColumn = "id", map } = options;
+  const idValue = row[idColumn];
+  if (idValue === void 0 || idValue === null) {
+    throw new Error(`external-source: row is missing id column "${idColumn}"`);
+  }
+  if (typeof idValue !== "string" && typeof idValue !== "number" && typeof idValue !== "bigint") {
+    throw new TypeError(`external-source: id column "${idColumn}" must be a string or number`);
+  }
+  const id = String(idValue);
+  if (map) {
+    return { ...map(row), _id: id };
+  }
+  const body = {};
+  for (const [key, value] of Object.entries(row)) {
+    if (key !== idColumn) {
+      body[key] = value;
+    }
+  }
+  return { ...body, _id: id };
+};
+const isSourceDue = (refresh, lastPolledMs, nowMs) => {
+  if (refresh === "manual") {
+    return false;
+  }
+  if (refresh === void 0 || lastPolledMs === void 0) {
+    return true;
+  }
+  return nowMs - lastPolledMs >= refresh.everyMs;
+};
+const pullExternalSourceTick = async (sql, writer, client, table, source, shardKey) => {
+  const parameters = source.tenantBy ? source.tenantBy(shardKey) : [];
+  const rows = await client.query(source.query, parameters);
+  const documents = rows.map((row) => liftSourceId(row, { idColumn: source.idColumn, map: source.map }));
+  return runExternalSourceTick(sql, writer, documents, { columns: source.columns, table });
+};
+
+export { isSourceDue, liftSourceId, pullExternalSourceTick };

package/dist/packem_shared/materializeExternalRows-Bj6EXy50.mjs

@@ -0,0 +1,23 @@
+import { applyCdcChanges } from './CDC_LOG_TABLE-DSycmnDf.mjs';
+import { s as selectShapeRows } from './ctx-db-shapes-0RaIOy7J.mjs';
+import { diffExternalSource, projectExternalSourceRow } from './diffExternalSource-Cx9HUPJj.mjs';
+import { stableStringify } from './stableStringify-MydiuScU.mjs';
+
+const materializeExternalRows = async (writer, pulled, baseline, options) => {
+  const { changes, nextBaseline } = diffExternalSource(pulled, baseline, options);
+  await applyCdcChanges(writer, changes);
+  return { applied: changes.length, nextBaseline };
+};
+const readExternalSourceBaseline = (sql, table, columns) => {
+  const baseline = /* @__PURE__ */ new Map();
+  for (const { doc, id } of selectShapeRows(sql, table, void 0)) {
+    baseline.set(id, stableStringify(projectExternalSourceRow({ ...doc, _id: id }, columns)));
+  }
+  return baseline;
+};
+const runExternalSourceTick = async (sql, writer, pulled, options) => {
+  const baseline = readExternalSourceBaseline(sql, options.table, options.columns);
+  return materializeExternalRows(writer, pulled, baseline, options);
+};
+
+export { materializeExternalRows, readExternalSourceBaseline, runExternalSourceTick };

package/dist/packem_shared/{runShardMigrations-C3bn5r93.mjs → runShardMigrations-nIwoQeOK.mjs}

@@ -1,11 +1,11 @@
 import { sql } from 'drizzle-orm';
 import { aggregateTableName } from './aggregateTableName-CxNqY1Sl.mjs';
-import { migrateCdcLog, migrateCdcMeta } from './applyCdcChanges-Ctdmxmrv.mjs';
-import { m as migrateIdempotency } from './ctx-db-idempotency-DkC9rP91.mjs';
+import { migrateCdcLog, migrateCdcMeta } from './CDC_LOG_TABLE-DSycmnDf.mjs';
+import { m as migrateClientWatermark, a as migrateIdempotency, b as migrateGlobalShapeSnapshot } from './ctx-db-idempotency-BdcNpvY4.mjs';
 import { r as runDrizzle } from './do-exec-5eQy5cEi.mjs';
 import { D as DOC_COLUMN, j as jsonPathSql, c as createIndexSql, t as tableColumns, i as isFtsAvailable, A as AGG_KEY, a as AGG_VALUE, b as AGG_COUNT } from './do-sql-BCHCWtrD.mjs';
-import { s as sortColumnName, r as rankTableName } from './rank-CrkEIpF4.mjs';
-import { ftsTableName } from './ftsTableName-BLEMawrp.mjs';
+import { sortColumnName, rankTableName } from './RANK_TIEBREAK-CXhdcA1o.mjs';
+import { ftsTableName } from './buildFtsMatch-BLEMawrp.mjs';
 
 const migrateSecondaryIndexes = (sql$1, tableName, definition) => {
   for (const index of definition.indexes) {
@@ -96,8 +96,10 @@ const runShardMigrations = (sql$1, schema, options = {}) => {
   if (options.cdc) {
     migrateCdcLog(sql$1);
     migrateCdcMeta(sql$1);
+    migrateClientWatermark(sql$1);
   }
   migrateIdempotency(sql$1);
+  migrateGlobalShapeSnapshot(sql$1);
 };
 
 export { runShardMigrations };

package/dist/packem_shared/serialize-sql-BlRUoiQe.mjs

@@ -0,0 +1,14 @@
+const serializeSqlValue = (value) => {
+  if (typeof value === "boolean") {
+    return value ? 1 : 0;
+  }
+  if (value === null || typeof value === "string" || typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  return JSON.stringify(value);
+};
+
+export { serializeSqlValue as s };

package/dist/packem_shared/{serveRelationFanout-Clr1a05L.mjs → serveRelationFanout-C5axmGDj.mjs}

@@ -1,4 +1,4 @@
-import { RELATION_FUNCTION_PREFIX } from './ADMIN_FUNCTION_PREFIX-Dzdqq5J2.mjs';
+import { RELATION_FUNCTION_PREFIX } from './ADMIN_FUNCTIONS-DSUQ5fX9.mjs';
 
 const serveRelationFanout = async (schema, database, functionPath, args) => {
   const table = typeof args["table"] === "string" ? args["table"] : "";

package/dist/packem_shared/stableStringify-MydiuScU.mjs

@@ -0,0 +1,40 @@
+const compareKeys = (a, b) => {
+  if (a < b) {
+    return -1;
+  }
+  return a > b ? 1 : 0;
+};
+const stableStringify = (value) => {
+  if (value === void 0) {
+    return "null";
+  }
+  if (typeof value === "bigint") {
+    throw new TypeError("stableStringify: cannot use a bigint in a cache key (query/subscription/shape args) — pass it as a string");
+  }
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  }
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== null && proto !== Object.prototype) {
+    const name = value.constructor?.name ?? "value";
+    throw new TypeError(
+      `stableStringify: cannot use a ${name} in a cache key (query/subscription/shape args) — only plain objects, arrays, and JSON primitives are supported`
+    );
+  }
+  const record = value;
+  const keys = Object.keys(record).toSorted(compareKeys);
+  const parts = [];
+  for (const key of keys) {
+    const raw = record[key];
+    if (raw === void 0) {
+      continue;
+    }
+    parts.push(`${JSON.stringify(key)}:${stableStringify(raw)}`);
+  }
+  return `{${parts.join(",")}}`;
+};
+
+export { stableStringify };