@absolutejs/sync 0.0.1 → 0.2.0

package/dist/adapters/postgres/index.js

@@ -0,0 +1,86 @@
+// @bun
+// src/adapters/postgres/index.ts
+var DEFAULT_CHANNEL = "absolute_sync";
+var DEFAULT_FUNCTION = "absolute_sync_notify";
+var OP_BY_TG = {
+  INSERT: "insert",
+  UPDATE: "update",
+  DELETE: "delete"
+};
+var parseNotification = (payload) => {
+  let data;
+  try {
+    data = JSON.parse(payload);
+  } catch {
+    return;
+  }
+  if (typeof data !== "object" || data === null) {
+    return;
+  }
+  const { table, op, row } = data;
+  if (typeof table !== "string") {
+    return;
+  }
+  const rowOp = typeof op === "string" ? OP_BY_TG[op] : undefined;
+  if (rowOp === undefined) {
+    return;
+  }
+  if (typeof row !== "object" || row === null) {
+    return;
+  }
+  return { table, change: { op: rowOp, row } };
+};
+var postgresChangeSource = (options) => {
+  const channel = options.channel ?? DEFAULT_CHANNEL;
+  const parse = options.parse ?? parseNotification;
+  let unlisten;
+  return {
+    start: async (emit) => {
+      unlisten = await options.listen(channel, (payload) => {
+        const parsed = parse(payload);
+        if (parsed !== undefined) {
+          emit(parsed.table, parsed.change);
+        }
+      });
+    },
+    stop: async () => {
+      await unlisten?.();
+      unlisten = undefined;
+    }
+  };
+};
+var postgresNotifyTrigger = (options) => {
+  const channel = options.channel ?? DEFAULT_CHANNEL;
+  const fn = options.functionName ?? DEFAULT_FUNCTION;
+  const functionSql = [
+    `CREATE OR REPLACE FUNCTION ${fn}() RETURNS trigger AS $$`,
+    "BEGIN",
+    `  PERFORM pg_notify('${channel}', json_build_object(`,
+    `    'table', TG_TABLE_NAME,`,
+    `    'op', TG_OP,`,
+    `    'row', row_to_json(COALESCE(NEW, OLD))`,
+    "  )::text);",
+    "  RETURN COALESCE(NEW, OLD);",
+    "END;",
+    "$$ LANGUAGE plpgsql;"
+  ].join(`
+`);
+  const triggerSql = options.tables.map((table) => [
+    `DROP TRIGGER IF EXISTS ${fn}_${table} ON ${table};`,
+    `CREATE TRIGGER ${fn}_${table}`,
+    `AFTER INSERT OR UPDATE OR DELETE ON ${table}`,
+    `FOR EACH ROW EXECUTE FUNCTION ${fn}();`
+  ].join(`
+`));
+  return [functionSql, ...triggerSql].join(`
+
+`);
+};
+export {
+  postgresNotifyTrigger,
+  postgresChangeSource,
+  parseNotification
+};
+
+//# debugId=0625BCD90123273B64756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/adapters/postgres/index.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/adapters/postgres/index.ts"],
+  "sourcesContent": [
+    "import type { ChangeSource, ParsedChange, RowOp } from '../../engine/types';\n\n/**\n * Postgres CDC adapter for @absolutejs/sync (Tier 3, M5).\n *\n * Catches writes that didn't go through the mutation API by turning Postgres\n * `LISTEN/NOTIFY` into the engine's change feed. Install the triggers once with\n * {@link postgresNotifyTrigger}, then connect {@link postgresChangeSource} via\n * `engine.connectSource(...)`.\n *\n * Client-agnostic: you supply how to `listen` on a channel, so it works with\n * porsager/postgres (`sql.listen`), node-postgres, or `Bun.sql` — and the\n * adapter itself has no database dependency.\n */\n\nconst DEFAULT_CHANNEL = 'absolute_sync';\nconst DEFAULT_FUNCTION = 'absolute_sync_notify';\n\nconst OP_BY_TG: Record<string, RowOp> = {\n\tINSERT: 'insert',\n\tUPDATE: 'update',\n\tDELETE: 'delete'\n};\n\n/** A parsed change ready to feed the engine. */\nexport type ParsedNotification = ParsedChange;\n\n/**\n * Default NOTIFY-payload parser: expects the JSON the trigger from\n * {@link postgresNotifyTrigger} sends — `{ table, op, row }` where `op` is\n * `INSERT`/`UPDATE`/`DELETE`. Returns `undefined` for anything malformed so a\n * bad payload is skipped rather than throwing.\n */\nexport const parseNotification = (\n\tpayload: string\n): ParsedNotification | undefined => {\n\tlet data: unknown;\n\ttry {\n\t\tdata = JSON.parse(payload);\n\t} catch {\n\t\treturn undefined;\n\t}\n\tif (typeof data !== 'object' || data === null) {\n\t\treturn undefined;\n\t}\n\tconst { table, op, row } = data as {\n\t\ttable?: unknown;\n\t\top?: unknown;\n\t\trow?: unknown;\n\t};\n\tif (typeof table !== 'string') {\n\t\treturn undefined;\n\t}\n\tconst rowOp = typeof op === 'string' ? OP_BY_TG[op] : undefined;\n\tif (rowOp === undefined) {\n\t\treturn undefined;\n\t}\n\tif (typeof row !== 'object' || row === null) {\n\t\treturn undefined;\n\t}\n\treturn { table, change: { op: rowOp, row } };\n};\n\nexport type PostgresChangeSourceOptions = {\n\t/**\n\t * Subscribe to a Postgres NOTIFY channel; return a function that stops\n\t * listening. The wiring is yours, e.g. with porsager/postgres:\n\t * `(channel, onNotify) => { const s = await sql.listen(channel, onNotify); return s.unlisten; }`.\n\t */\n\tlisten: (\n\t\tchannel: string,\n\t\tonNotify: (payload: string) => void\n\t) => Promise<() => void | Promise<void>> | (() => void | Promise<void>);\n\t/** NOTIFY channel; must match the trigger's. Defaults to `absolute_sync`. */\n\tchannel?: string;\n\t/** Override the payload parser (defaults to {@link parseNotification}). */\n\tparse?: (payload: string) => ParsedNotification | undefined;\n};\n\n/**\n * A {@link ChangeSource} backed by Postgres `LISTEN/NOTIFY`. Each notification\n * is parsed to `(table, change)` and emitted into the engine.\n *\n * @example\n * const disconnect = await engine.connectSource(\n *   postgresChangeSource({\n *     listen: async (channel, onNotify) =>\n *       (await sql.listen(channel, onNotify)).unlisten\n *   })\n * );\n */\nexport const postgresChangeSource = (\n\toptions: PostgresChangeSourceOptions\n): ChangeSource => {\n\tconst channel = options.channel ?? DEFAULT_CHANNEL;\n\tconst parse = options.parse ?? parseNotification;\n\tlet unlisten: (() => void | Promise<void>) | undefined;\n\n\treturn {\n\t\tstart: async (emit) => {\n\t\t\tunlisten = await options.listen(channel, (payload) => {\n\t\t\t\tconst parsed = parse(payload);\n\t\t\t\tif (parsed !== undefined) {\n\t\t\t\t\tvoid emit(parsed.table, parsed.change);\n\t\t\t\t}\n\t\t\t});\n\t\t},\n\t\tstop: async () => {\n\t\t\tawait unlisten?.();\n\t\t\tunlisten = undefined;\n\t\t}\n\t};\n};\n\nexport type PostgresNotifyTriggerOptions = {\n\t/** Tables to emit changes for. */\n\ttables: string[];\n\t/** NOTIFY channel; must match the change source's. Defaults to `absolute_sync`. */\n\tchannel?: string;\n\t/** Trigger function name. Defaults to `absolute_sync_notify`. */\n\tfunctionName?: string;\n};\n\n/**\n * Generate the SQL that installs a NOTIFY trigger on each table — run it once\n * (e.g. in a migration). On every insert/update/delete it sends\n * `{ table, op, row }` JSON on the channel for {@link postgresChangeSource}.\n *\n * Note: `pg_notify` payloads are capped at 8000 bytes, so very wide rows can be\n * truncated (the parser then skips them). For large rows or high throughput,\n * prefer a logical-replication source behind the same {@link ChangeSource} seam.\n */\nexport const postgresNotifyTrigger = (\n\toptions: PostgresNotifyTriggerOptions\n): string => {\n\tconst channel = options.channel ?? DEFAULT_CHANNEL;\n\tconst fn = options.functionName ?? DEFAULT_FUNCTION;\n\n\tconst functionSql = [\n\t\t`CREATE OR REPLACE FUNCTION ${fn}() RETURNS trigger AS $$`,\n\t\t'BEGIN',\n\t\t`  PERFORM pg_notify('${channel}', json_build_object(`,\n\t\t`    'table', TG_TABLE_NAME,`,\n\t\t`    'op', TG_OP,`,\n\t\t`    'row', row_to_json(COALESCE(NEW, OLD))`,\n\t\t'  )::text);',\n\t\t'  RETURN COALESCE(NEW, OLD);',\n\t\t'END;',\n\t\t'$$ LANGUAGE plpgsql;'\n\t].join('\\n');\n\n\tconst triggerSql = options.tables.map((table) =>\n\t\t[\n\t\t\t`DROP TRIGGER IF EXISTS ${fn}_${table} ON ${table};`,\n\t\t\t`CREATE TRIGGER ${fn}_${table}`,\n\t\t\t`AFTER INSERT OR UPDATE OR DELETE ON ${table}`,\n\t\t\t`FOR EACH ROW EXECUTE FUNCTION ${fn}();`\n\t\t].join('\\n')\n\t);\n\n\treturn [functionSql, ...triggerSql].join('\\n\\n');\n};\n"
+  ],
+  "mappings": ";;AAeA,IAAM,kBAAkB;AACxB,IAAM,mBAAmB;AAEzB,IAAM,WAAkC;AAAA,EACvC,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,QAAQ;AACT;AAWO,IAAM,oBAAoB,CAChC,YACoC;AAAA,EACpC,IAAI;AAAA,EACJ,IAAI;AAAA,IACH,OAAO,KAAK,MAAM,OAAO;AAAA,IACxB,MAAM;AAAA,IACP;AAAA;AAAA,EAED,IAAI,OAAO,SAAS,YAAY,SAAS,MAAM;AAAA,IAC9C;AAAA,EACD;AAAA,EACA,QAAQ,OAAO,IAAI,QAAQ;AAAA,EAK3B,IAAI,OAAO,UAAU,UAAU;AAAA,IAC9B;AAAA,EACD;AAAA,EACA,MAAM,QAAQ,OAAO,OAAO,WAAW,SAAS,MAAM;AAAA,EACtD,IAAI,UAAU,WAAW;AAAA,IACxB;AAAA,EACD;AAAA,EACA,IAAI,OAAO,QAAQ,YAAY,QAAQ,MAAM;AAAA,IAC5C;AAAA,EACD;AAAA,EACA,OAAO,EAAE,OAAO,QAAQ,EAAE,IAAI,OAAO,IAAI,EAAE;AAAA;AA+BrC,IAAM,uBAAuB,CACnC,YACkB;AAAA,EAClB,MAAM,UAAU,QAAQ,WAAW;AAAA,EACnC,MAAM,QAAQ,QAAQ,SAAS;AAAA,EAC/B,IAAI;AAAA,EAEJ,OAAO;AAAA,IACN,OAAO,OAAO,SAAS;AAAA,MACtB,WAAW,MAAM,QAAQ,OAAO,SAAS,CAAC,YAAY;AAAA,QACrD,MAAM,SAAS,MAAM,OAAO;AAAA,QAC5B,IAAI,WAAW,WAAW;AAAA,UACpB,KAAK,OAAO,OAAO,OAAO,MAAM;AAAA,QACtC;AAAA,OACA;AAAA;AAAA,IAEF,MAAM,YAAY;AAAA,MACjB,MAAM,WAAW;AAAA,MACjB,WAAW;AAAA;AAAA,EAEb;AAAA;AAqBM,IAAM,wBAAwB,CACpC,YACY;AAAA,EACZ,MAAM,UAAU,QAAQ,WAAW;AAAA,EACnC,MAAM,KAAK,QAAQ,gBAAgB;AAAA,EAEnC,MAAM,cAAc;AAAA,IACnB,8BAA8B;AAAA,IAC9B;AAAA,IACA,wBAAwB;AAAA,IACxB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACD,EAAE,KAAK;AAAA,CAAI;AAAA,EAEX,MAAM,aAAa,QAAQ,OAAO,IAAI,CAAC,UACtC;AAAA,IACC,0BAA0B,MAAM,YAAY;AAAA,IAC5C,kBAAkB,MAAM;AAAA,IACxB,uCAAuC;AAAA,IACvC,iCAAiC;AAAA,EAClC,EAAE,KAAK;AAAA,CAAI,CACZ;AAAA,EAEA,OAAO,CAAC,aAAa,GAAG,UAAU,EAAE,KAAK;AAAA;AAAA,CAAM;AAAA;",
+  "debugId": "0625BCD90123273B64756E2164756E21",
+  "names": []
+}

package/dist/adapters/prisma/collection.d.ts

@@ -0,0 +1,39 @@
+import type { CollectionContext, CollectionDefinition } from '../../engine/collection';
+import type { RowKey } from '../../engine/types';
+import type { PrismaWhere } from './topics';
+export type PrismaCollectionOptions<T, P, Ctx> = {
+    /** Collection name (change-feed key and topic root). */
+    name: string;
+    /**
+     * The query filter, written once. Used both to hydrate from the database
+     * (passed to `find`) and, mirrored in JS, to match changed rows
+     * incrementally. Receives the subscription's params and context.
+     */
+    where: (params: P, ctx: Ctx) => PrismaWhere;
+    /**
+     * Run the database read for a given `where` — your Prisma call, e.g.
+     * `(where) => prisma.order.findMany({ where })`.
+     */
+    find: (where: PrismaWhere, params: P, ctx: Ctx) => Promise<Iterable<T>> | Iterable<T>;
+    /** Row identity. Defaults to `row.id`. */
+    key?: (row: T) => RowKey;
+    /** Access control; return false (or throw) to deny. */
+    authorize?: (params: P, ctx: Ctx) => boolean | Promise<boolean>;
+};
+/**
+ * Build a syncable {@link CollectionDefinition} for Prisma from a single filter:
+ * `where` is written once and powers both `hydrate` (via your `find`) and the
+ * incremental `match` (via {@link matchesWhere}) — no restating the WHERE.
+ *
+ * If the filter uses an operator the JS matcher can't evaluate, that change
+ * degrades to a refetch (handled by the engine), so the result stays correct.
+ *
+ * @example
+ * prismaCollection({
+ *   name: 'orders',
+ *   where: (p) => ({ userId: p.userId, status: 'open' }),
+ *   find: (where) => prisma.order.findMany({ where }),
+ *   authorize: (p, ctx) => p.userId === ctx.userId
+ * });
+ */
+export declare const prismaCollection: <T, P = void, Ctx = CollectionContext>(options: PrismaCollectionOptions<T, P, Ctx>) => CollectionDefinition<T, P, Ctx>;

package/dist/adapters/prisma/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Prisma adapter for @absolutejs/sync (Tier 2 — ORM auto-reactivity).
+ *
+ * The Prisma counterpart of the Drizzle adapter: derive the topics a query
+ * depends on ({@link deriveReadTopics}) and publish the topics a mutation
+ * invalidates ({@link publishChange} and friends). It identifies a model by name
+ * and reads Prisma's plain `where` objects and result records, so it needs no
+ * `@prisma/client` import and works on every database Prisma supports.
+ *
+ * Use the SAME model identifier on the read and write sides — the topic is the
+ * model name verbatim (e.g. `'user'` -> topic `user`, row topic `user:5`).
+ * Granularity is table-level by default, narrowing to a single row when a filter
+ * is a simple key-field equality.
+ */
+export { keyTopic, tableTopic } from './topics';
+export type { PrismaWhere, RowKey } from './topics';
+export { deriveReadTopics } from './read';
+export type { DeriveReadTopicsOptions, DerivedReadTopics } from './read';
+export { publishChange, publishRows, publishWhere } from './write';
+export type { ChangeOp, ChangePayload, PublishChangeOptions, PublishRowsOptions, PublishWhereOptions } from './write';
+export { matchesWhere, UnsupportedFilterError } from './predicate';
+export { prismaCollection } from './collection';
+export type { PrismaCollectionOptions } from './collection';

package/dist/adapters/prisma/index.js

@@ -0,0 +1,231 @@
+// @bun
+// src/adapters/prisma/topics.ts
+var tableTopic = (model) => model;
+var keyTopic = (model, key) => `${model}:${key}`;
+var isRowKey = (value) => typeof value === "string" || typeof value === "number" || typeof value === "bigint";
+var extractKeyFromWhere = (where, keyField) => {
+  const fields = Object.keys(where);
+  if (fields.length !== 1 || fields[0] !== keyField) {
+    return;
+  }
+  const condition = where[keyField];
+  if (isRowKey(condition)) {
+    return condition;
+  }
+  if (condition !== null && typeof condition === "object" && !Array.isArray(condition)) {
+    const operators = Object.keys(condition);
+    if (operators.length === 1 && operators[0] === "equals") {
+      const value = condition.equals;
+      if (isRowKey(value)) {
+        return value;
+      }
+    }
+  }
+  return;
+};
+var extractRowKeys = (rows, keyField) => {
+  const keys = [];
+  for (const row of rows) {
+    const value = row[keyField];
+    if (isRowKey(value)) {
+      keys.push(value);
+    }
+  }
+  return keys;
+};
+// src/adapters/prisma/read.ts
+var deriveReadTopics = (model, where, options = {}) => {
+  const keyField = options.keyField ?? "id";
+  const key = where === undefined ? undefined : extractKeyFromWhere(where, keyField);
+  if (key === undefined) {
+    return { topics: [tableTopic(model)], rowLevel: false };
+  }
+  return { topics: [keyTopic(model, key)], rowLevel: true };
+};
+// src/adapters/prisma/write.ts
+var publishChange = (hub, model, options = {}) => {
+  const name = tableTopic(model);
+  const keys = options.keys === undefined ? [] : [...new Set(options.keys)];
+  const payload = { table: name, op: options.op, keys };
+  const topics = [
+    ...new Set([name, ...keys.map((key) => keyTopic(model, key))])
+  ];
+  for (const topic of topics) {
+    hub.publish(topic, payload);
+  }
+  return topics;
+};
+var publishRows = (hub, model, rows, options = {}) => {
+  const list = Array.isArray(rows) ? rows : [rows];
+  return publishChange(hub, model, {
+    keys: extractRowKeys(list, options.keyField ?? "id"),
+    op: options.op
+  });
+};
+var publishWhere = (hub, model, where, options = {}) => {
+  const key = extractKeyFromWhere(where, options.keyField ?? "id");
+  return publishChange(hub, model, {
+    keys: key === undefined ? [] : [key],
+    op: options.op
+  });
+};
+// src/adapters/prisma/predicate.ts
+class UnsupportedFilterError extends Error {
+  constructor(operator) {
+    super(`Cannot evaluate Prisma filter operator "${operator}" incrementally`);
+    this.name = "UnsupportedFilterError";
+  }
+}
+var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date);
+var equals = (value, operand) => {
+  if (operand === null) {
+    return value === null || value === undefined;
+  }
+  if (value instanceof Date && operand instanceof Date) {
+    return value.getTime() === operand.getTime();
+  }
+  return value === operand;
+};
+var order = (value) => value instanceof Date ? value.getTime() : value;
+var compare = (value, operand) => {
+  const a = order(value);
+  const b = order(operand);
+  if (a < b) {
+    return -1;
+  }
+  if (a > b) {
+    return 1;
+  }
+  return 0;
+};
+var comparable = (value) => value !== null && value !== undefined;
+var FIELD_OPERATORS = new Set([
+  "equals",
+  "not",
+  "in",
+  "notIn",
+  "lt",
+  "lte",
+  "gt",
+  "gte",
+  "contains",
+  "startsWith",
+  "endsWith"
+]);
+var matchesField = (value, condition) => {
+  if (!isPlainObject(condition)) {
+    return equals(value, condition);
+  }
+  for (const operator of Object.keys(condition)) {
+    if (!FIELD_OPERATORS.has(operator)) {
+      throw new UnsupportedFilterError(operator);
+    }
+  }
+  for (const [operator, operand] of Object.entries(condition)) {
+    switch (operator) {
+      case "equals":
+        if (!equals(value, operand))
+          return false;
+        break;
+      case "not":
+        if (isPlainObject(operand)) {
+          if (matchesField(value, operand))
+            return false;
+        } else if (equals(value, operand)) {
+          return false;
+        }
+        break;
+      case "in":
+        if (!Array.isArray(operand) || !operand.some((item) => equals(value, item)))
+          return false;
+        break;
+      case "notIn":
+        if (Array.isArray(operand) && operand.some((item) => equals(value, item)))
+          return false;
+        break;
+      case "lt":
+        if (!comparable(value) || compare(value, operand) >= 0)
+          return false;
+        break;
+      case "lte":
+        if (!comparable(value) || compare(value, operand) > 0)
+          return false;
+        break;
+      case "gt":
+        if (!comparable(value) || compare(value, operand) <= 0)
+          return false;
+        break;
+      case "gte":
+        if (!comparable(value) || compare(value, operand) < 0)
+          return false;
+        break;
+      case "contains":
+        if (typeof value !== "string" || !value.includes(String(operand)))
+          return false;
+        break;
+      case "startsWith":
+        if (typeof value !== "string" || !value.startsWith(String(operand)))
+          return false;
+        break;
+      case "endsWith":
+        if (typeof value !== "string" || !value.endsWith(String(operand)))
+          return false;
+        break;
+      default:
+        throw new UnsupportedFilterError(operator);
+    }
+  }
+  return true;
+};
+var toConditions = (value) => {
+  if (Array.isArray(value)) {
+    return value.filter(isPlainObject);
+  }
+  return isPlainObject(value) ? [value] : [];
+};
+var matchesWhere = (where, row) => {
+  for (const [field, condition] of Object.entries(where)) {
+    if (field === "AND") {
+      if (!toConditions(condition).every((part) => matchesWhere(part, row)))
+        return false;
+      continue;
+    }
+    if (field === "OR") {
+      const parts = toConditions(condition);
+      if (parts.length > 0 && !parts.some((part) => matchesWhere(part, row)))
+        return false;
+      continue;
+    }
+    if (field === "NOT") {
+      if (toConditions(condition).some((part) => matchesWhere(part, row)))
+        return false;
+      continue;
+    }
+    if (!matchesField(row[field], condition)) {
+      return false;
+    }
+  }
+  return true;
+};
+// src/adapters/prisma/collection.ts
+var prismaCollection = (options) => ({
+  name: options.name,
+  hydrate: (params, ctx) => options.find(options.where(params, ctx), params, ctx),
+  match: (row, params, ctx) => matchesWhere(options.where(params, ctx), row),
+  key: options.key,
+  authorize: options.authorize
+});
+export {
+  tableTopic,
+  publishWhere,
+  publishRows,
+  publishChange,
+  prismaCollection,
+  matchesWhere,
+  keyTopic,
+  deriveReadTopics,
+  UnsupportedFilterError
+};
+
+//# debugId=96C8D5DF158A4DF864756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/adapters/prisma/index.js.map

@@ -0,0 +1,14 @@
+{
+  "version": 3,
+  "sources": ["../src/adapters/prisma/topics.ts", "../src/adapters/prisma/read.ts", "../src/adapters/prisma/write.ts", "../src/adapters/prisma/predicate.ts", "../src/adapters/prisma/collection.ts"],
+  "sourcesContent": [
+    "/**\n * Shared topic vocabulary + key extraction for the Prisma adapter. Operates on\n * Prisma's plain `where` objects and result records — there is no\n * `@prisma/client` import, so it stays generic across every database Prisma\n * supports. Both the read side (derive a query's topics) and the write side\n * (publish a mutation's topics) build on these so the two always agree.\n */\n\n/** A Prisma `where` filter object, e.g. `{ id: 5 }` or `{ id: { gt: 5 } }`. */\nexport type PrismaWhere = Record<string, unknown>;\n\n/** A scalar usable as a row key. */\nexport type RowKey = string | number | bigint;\n\n/** The coarse topic every read/write of `model` touches, e.g. `user`. */\nexport const tableTopic = (model: string): string => model;\n\n/** The row-level topic for one key of `model`, e.g. `user:5`. */\nexport const keyTopic = (model: string, key: RowKey): string =>\n\t`${model}:${key}`;\n\nconst isRowKey = (value: unknown): value is RowKey =>\n\ttypeof value === 'string' ||\n\ttypeof value === 'number' ||\n\ttypeof value === 'bigint';\n\n/**\n * Best-effort: pull a single key-field equality value out of a Prisma `where`.\n * Recognises `{ [keyField]: scalar }` and `{ [keyField]: { equals: scalar } }`\n * only — extra fields, other operators (`gt`/`in`/`not`/…), `AND`/`OR`, or a\n * compound-key object yield `undefined`, so the caller falls back to the table\n * topic (over-invalidating a little rather than missing an update).\n */\nexport const extractKeyFromWhere = (\n\twhere: PrismaWhere,\n\tkeyField: string\n): RowKey | undefined => {\n\tconst fields = Object.keys(where);\n\tif (fields.length !== 1 || fields[0] !== keyField) {\n\t\treturn undefined;\n\t}\n\tconst condition = where[keyField];\n\tif (isRowKey(condition)) {\n\t\treturn condition;\n\t}\n\tif (\n\t\tcondition !== null &&\n\t\ttypeof condition === 'object' &&\n\t\t!Array.isArray(condition)\n\t) {\n\t\tconst operators = Object.keys(condition as Record<string, unknown>);\n\t\tif (operators.length === 1 && operators[0] === 'equals') {\n\t\t\tconst value = (condition as Record<string, unknown>).equals;\n\t\t\tif (isRowKey(value)) {\n\t\t\t\treturn value;\n\t\t\t}\n\t\t}\n\t}\n\treturn undefined;\n};\n\n/**\n * Read the key value from each result record (e.g. the output of a Prisma\n * `create`/`update`/`delete`), using `keyField`. Records without a scalar key\n * are skipped.\n */\nexport const extractRowKeys = (\n\trows: ReadonlyArray<Record<string, unknown>>,\n\tkeyField: string\n): RowKey[] => {\n\tconst keys: RowKey[] = [];\n\tfor (const row of rows) {\n\t\tconst value = row[keyField];\n\t\tif (isRowKey(value)) {\n\t\t\tkeys.push(value);\n\t\t}\n\t}\n\treturn keys;\n};\n",
+    "import { extractKeyFromWhere, keyTopic, tableTopic } from './topics';\nimport type { PrismaWhere } from './topics';\n\nexport type DeriveReadTopicsOptions = {\n\t/**\n\t * Primary-key field name to narrow on. Defaults to `id` (Prisma's\n\t * convention); set it for models keyed by another field.\n\t */\n\tkeyField?: string;\n};\n\nexport type DerivedReadTopics = {\n\t/** Topics this read depends on — subscribe to all of them. */\n\ttopics: string[];\n\t/**\n\t * `true` when derivation narrowed to a specific row (`model:key`); `false`\n\t * when it fell back to the whole-model topic.\n\t */\n\trowLevel: boolean;\n};\n\n/**\n * Derive the reactive topics a read of `model` (optionally filtered by `where`)\n * depends on. A recognised key-field equality narrows to a single `model:key`\n * topic; everything else subscribes to the whole-model topic.\n *\n * @example\n * deriveReadTopics('user');                       // { topics: ['user'], rowLevel: false }\n * deriveReadTopics('user', { id: 5 });            // { topics: ['user:5'], rowLevel: true }\n * deriveReadTopics('user', { id: { gt: 5 } });    // { topics: ['user'], rowLevel: false }\n */\nexport const deriveReadTopics = (\n\tmodel: string,\n\twhere?: PrismaWhere,\n\toptions: DeriveReadTopicsOptions = {}\n): DerivedReadTopics => {\n\tconst keyField = options.keyField ?? 'id';\n\tconst key =\n\t\twhere === undefined ? undefined : extractKeyFromWhere(where, keyField);\n\n\tif (key === undefined) {\n\t\treturn { topics: [tableTopic(model)], rowLevel: false };\n\t}\n\treturn { topics: [keyTopic(model, key)], rowLevel: true };\n};\n",
+    "import type { ReactiveHub } from '../../reactiveHub';\nimport {\n\textractKeyFromWhere,\n\textractRowKeys,\n\tkeyTopic,\n\ttableTopic\n} from './topics';\nimport type { PrismaWhere, RowKey } from './topics';\n\n/**\n * Prisma write-side topic publishing (Tier 2).\n *\n * The mirror of {@link deriveReadTopics}: after a mutation commits, publish the\n * topics it invalidates so subscribed reads refetch. Every change publishes the\n * **model** topic (so list queries refresh) plus a **row** topic per affected\n * key (so row-level queries refresh) — the exact topics the read side derives.\n *\n * Use the SAME model identifier you pass on the read side; the topic is the\n * model name verbatim.\n */\n\n/** The kind of mutation, forwarded in the change-event payload. */\nexport type ChangeOp = 'insert' | 'update' | 'delete';\n\n/** Payload carried by every change event the write side publishes. */\nexport type ChangePayload = {\n\t/** Name of the model that changed. */\n\ttable: string;\n\t/** Mutation kind, when the caller provided it. */\n\top?: ChangeOp;\n\t/** Affected row keys (empty for a model-wide change). */\n\tkeys: RowKey[];\n};\n\nexport type PublishChangeOptions = {\n\t/** Row keys that changed; each emits a `model:key` topic. */\n\tkeys?: ReadonlyArray<RowKey>;\n\top?: ChangeOp;\n};\n\n/**\n * Publish the reactive topics a change to `model` invalidates: the whole-model\n * topic (always) plus a `model:key` topic per affected row. Call after the\n * mutation resolves. Returns the (de-duplicated) topics published.\n */\nexport const publishChange = (\n\thub: Pick<ReactiveHub, 'publish'>,\n\tmodel: string,\n\toptions: PublishChangeOptions = {}\n): string[] => {\n\tconst name = tableTopic(model);\n\tconst keys = options.keys === undefined ? [] : [...new Set(options.keys)];\n\tconst payload: ChangePayload = { table: name, op: options.op, keys };\n\tconst topics = [\n\t\t...new Set([name, ...keys.map((key) => keyTopic(model, key))])\n\t];\n\tfor (const topic of topics) {\n\t\thub.publish(topic, payload);\n\t}\n\treturn topics;\n};\n\nexport type PublishRowsOptions = {\n\t/** Key field (defaults to `id`). */\n\tkeyField?: string;\n\top?: ChangeOp;\n};\n\n/**\n * Publish change topics for the record(s) a mutation returned. Accepts a single\n * record (Prisma `create`/`update`/`delete`) or an array (`findMany` results),\n * reading each record's `keyField` to emit `model:key` topics.\n *\n * @example\n * const user = await prisma.user.create({ data });\n * publishRows(hub, 'user', user, { op: 'insert' });\n */\nexport const publishRows = (\n\thub: Pick<ReactiveHub, 'publish'>,\n\tmodel: string,\n\trows: Record<string, unknown> | ReadonlyArray<Record<string, unknown>>,\n\toptions: PublishRowsOptions = {}\n): string[] => {\n\tconst list = (Array.isArray(rows) ? rows : [rows]) as ReadonlyArray<\n\t\tRecord<string, unknown>\n\t>;\n\treturn publishChange(hub, model, {\n\t\tkeys: extractRowKeys(list, options.keyField ?? 'id'),\n\t\top: options.op\n\t});\n};\n\nexport type PublishWhereOptions = {\n\t/** Key field (defaults to `id`). */\n\tkeyField?: string;\n\top?: ChangeOp;\n};\n\n/**\n * Publish change topics for an `update`/`delete` identified by a `where` filter.\n * A simple key-field equality narrows to that row's topic; any other filter\n * publishes just the model topic, so every affected subscriber refetches.\n *\n * @example\n * await prisma.user.update({ where: { id }, data });\n * publishWhere(hub, 'user', { id }, { op: 'update' });\n */\nexport const publishWhere = (\n\thub: Pick<ReactiveHub, 'publish'>,\n\tmodel: string,\n\twhere: PrismaWhere,\n\toptions: PublishWhereOptions = {}\n): string[] => {\n\tconst key = extractKeyFromWhere(where, options.keyField ?? 'id');\n\treturn publishChange(hub, model, {\n\t\tkeys: key === undefined ? [] : [key],\n\t\top: options.op\n\t});\n};\n",
+    "import type { PrismaWhere } from './topics';\n\n/**\n * Thrown when a Prisma `where` uses an operator the incremental matcher can't\n * evaluate in JS. The sync engine catches it and degrades that subscription to\n * a refetch, so it never produces a wrong result — only a less efficient one.\n */\nexport class UnsupportedFilterError extends Error {\n\tconstructor(operator: string) {\n\t\tsuper(\n\t\t\t`Cannot evaluate Prisma filter operator \"${operator}\" incrementally`\n\t\t);\n\t\tthis.name = 'UnsupportedFilterError';\n\t}\n}\n\nconst isPlainObject = (value: unknown): value is Record<string, unknown> =>\n\ttypeof value === 'object' &&\n\tvalue !== null &&\n\t!Array.isArray(value) &&\n\t!(value instanceof Date);\n\n/** Prisma equality semantics (a `null` operand means IS NULL). */\nconst equals = (value: unknown, operand: unknown): boolean => {\n\tif (operand === null) {\n\t\treturn value === null || value === undefined;\n\t}\n\tif (value instanceof Date && operand instanceof Date) {\n\t\treturn value.getTime() === operand.getTime();\n\t}\n\treturn value === operand;\n};\n\nconst order = (value: unknown): number | string =>\n\tvalue instanceof Date ? value.getTime() : (value as number | string);\n\nconst compare = (value: unknown, operand: unknown): number => {\n\tconst a = order(value);\n\tconst b = order(operand);\n\tif (a < b) {\n\t\treturn -1;\n\t}\n\tif (a > b) {\n\t\treturn 1;\n\t}\n\treturn 0;\n};\n\nconst comparable = (value: unknown): boolean =>\n\tvalue !== null && value !== undefined;\n\nconst FIELD_OPERATORS = new Set([\n\t'equals',\n\t'not',\n\t'in',\n\t'notIn',\n\t'lt',\n\t'lte',\n\t'gt',\n\t'gte',\n\t'contains',\n\t'startsWith',\n\t'endsWith'\n]);\n\n/** Evaluate a single field's condition (scalar equality or an operator object). */\nconst matchesField = (value: unknown, condition: unknown): boolean => {\n\tif (!isPlainObject(condition)) {\n\t\treturn equals(value, condition);\n\t}\n\t// Validate support up front: an unsupported operator must force a refetch\n\t// even when an earlier operator would short-circuit to false.\n\tfor (const operator of Object.keys(condition)) {\n\t\tif (!FIELD_OPERATORS.has(operator)) {\n\t\t\tthrow new UnsupportedFilterError(operator);\n\t\t}\n\t}\n\tfor (const [operator, operand] of Object.entries(condition)) {\n\t\tswitch (operator) {\n\t\t\tcase 'equals':\n\t\t\t\tif (!equals(value, operand)) return false;\n\t\t\t\tbreak;\n\t\t\tcase 'not':\n\t\t\t\tif (isPlainObject(operand)) {\n\t\t\t\t\tif (matchesField(value, operand)) return false;\n\t\t\t\t} else if (equals(value, operand)) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tcase 'in':\n\t\t\t\tif (\n\t\t\t\t\t!Array.isArray(operand) ||\n\t\t\t\t\t!operand.some((item) => equals(value, item))\n\t\t\t\t)\n\t\t\t\t\treturn false;\n\t\t\t\tbreak;\n\t\t\tcase 'notIn':\n\t\t\t\tif (\n\t\t\t\t\tArray.isArray(operand) &&\n\t\t\t\t\toperand.some((item) => equals(value, item))\n\t\t\t\t)\n\t\t\t\t\treturn false;\n\t\t\t\tbreak;\n\t\t\tcase 'lt':\n\t\t\t\tif (!comparable(value) || compare(value, operand) >= 0)\n\t\t\t\t\treturn false;\n\t\t\t\tbreak;\n\t\t\tcase 'lte':\n\t\t\t\tif (!comparable(value) || compare(value, operand) > 0)\n\t\t\t\t\treturn false;\n\t\t\t\tbreak;\n\t\t\tcase 'gt':\n\t\t\t\tif (!comparable(value) || compare(value, operand) <= 0)\n\t\t\t\t\treturn false;\n\t\t\t\tbreak;\n\t\t\tcase 'gte':\n\t\t\t\tif (!comparable(value) || compare(value, operand) < 0)\n\t\t\t\t\treturn false;\n\t\t\t\tbreak;\n\t\t\tcase 'contains':\n\t\t\t\tif (\n\t\t\t\t\ttypeof value !== 'string' ||\n\t\t\t\t\t!value.includes(String(operand))\n\t\t\t\t)\n\t\t\t\t\treturn false;\n\t\t\t\tbreak;\n\t\t\tcase 'startsWith':\n\t\t\t\tif (\n\t\t\t\t\ttypeof value !== 'string' ||\n\t\t\t\t\t!value.startsWith(String(operand))\n\t\t\t\t)\n\t\t\t\t\treturn false;\n\t\t\t\tbreak;\n\t\t\tcase 'endsWith':\n\t\t\t\tif (\n\t\t\t\t\ttypeof value !== 'string' ||\n\t\t\t\t\t!value.endsWith(String(operand))\n\t\t\t\t)\n\t\t\t\t\treturn false;\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\t// `mode`, relation filters, etc. — bail so the engine refetches.\n\t\t\t\tthrow new UnsupportedFilterError(operator);\n\t\t}\n\t}\n\treturn true;\n};\n\nconst toConditions = (value: unknown): PrismaWhere[] => {\n\tif (Array.isArray(value)) {\n\t\treturn value.filter(isPlainObject);\n\t}\n\treturn isPlainObject(value) ? [value] : [];\n};\n\n/**\n * Evaluate a Prisma `where` object against an in-memory row — the JS mirror of\n * the SQL filter, used for incremental matching. Supports field equality and the\n * `equals/not/in/notIn/lt/lte/gt/gte/contains/startsWith/endsWith` operators\n * plus `AND`/`OR`/`NOT`. Anything else throws {@link UnsupportedFilterError}, so\n * the engine falls back to a refetch.\n *\n * @example\n * matchesWhere({ userId: 5, status: { not: 'archived' } }, row)\n */\nexport const matchesWhere = (\n\twhere: PrismaWhere,\n\trow: Record<string, unknown>\n): boolean => {\n\tfor (const [field, condition] of Object.entries(where)) {\n\t\tif (field === 'AND') {\n\t\t\tif (\n\t\t\t\t!toConditions(condition).every((part) =>\n\t\t\t\t\tmatchesWhere(part, row)\n\t\t\t\t)\n\t\t\t)\n\t\t\t\treturn false;\n\t\t\tcontinue;\n\t\t}\n\t\tif (field === 'OR') {\n\t\t\tconst parts = toConditions(condition);\n\t\t\tif (\n\t\t\t\tparts.length > 0 &&\n\t\t\t\t!parts.some((part) => matchesWhere(part, row))\n\t\t\t)\n\t\t\t\treturn false;\n\t\t\tcontinue;\n\t\t}\n\t\tif (field === 'NOT') {\n\t\t\tif (toConditions(condition).some((part) => matchesWhere(part, row)))\n\t\t\t\treturn false;\n\t\t\tcontinue;\n\t\t}\n\t\tif (!matchesField(row[field], condition)) {\n\t\t\treturn false;\n\t\t}\n\t}\n\treturn true;\n};\n",
+    "import type {\n\tCollectionContext,\n\tCollectionDefinition\n} from '../../engine/collection';\nimport type { RowKey } from '../../engine/types';\nimport { matchesWhere } from './predicate';\nimport type { PrismaWhere } from './topics';\n\nexport type PrismaCollectionOptions<T, P, Ctx> = {\n\t/** Collection name (change-feed key and topic root). */\n\tname: string;\n\t/**\n\t * The query filter, written once. Used both to hydrate from the database\n\t * (passed to `find`) and, mirrored in JS, to match changed rows\n\t * incrementally. Receives the subscription's params and context.\n\t */\n\twhere: (params: P, ctx: Ctx) => PrismaWhere;\n\t/**\n\t * Run the database read for a given `where` — your Prisma call, e.g.\n\t * `(where) => prisma.order.findMany({ where })`.\n\t */\n\tfind: (\n\t\twhere: PrismaWhere,\n\t\tparams: P,\n\t\tctx: Ctx\n\t) => Promise<Iterable<T>> | Iterable<T>;\n\t/** Row identity. Defaults to `row.id`. */\n\tkey?: (row: T) => RowKey;\n\t/** Access control; return false (or throw) to deny. */\n\tauthorize?: (params: P, ctx: Ctx) => boolean | Promise<boolean>;\n};\n\n/**\n * Build a syncable {@link CollectionDefinition} for Prisma from a single filter:\n * `where` is written once and powers both `hydrate` (via your `find`) and the\n * incremental `match` (via {@link matchesWhere}) — no restating the WHERE.\n *\n * If the filter uses an operator the JS matcher can't evaluate, that change\n * degrades to a refetch (handled by the engine), so the result stays correct.\n *\n * @example\n * prismaCollection({\n *   name: 'orders',\n *   where: (p) => ({ userId: p.userId, status: 'open' }),\n *   find: (where) => prisma.order.findMany({ where }),\n *   authorize: (p, ctx) => p.userId === ctx.userId\n * });\n */\nexport const prismaCollection = <T, P = void, Ctx = CollectionContext>(\n\toptions: PrismaCollectionOptions<T, P, Ctx>\n): CollectionDefinition<T, P, Ctx> => ({\n\tname: options.name,\n\thydrate: (params, ctx) =>\n\t\toptions.find(options.where(params, ctx), params, ctx),\n\tmatch: (row, params, ctx) =>\n\t\tmatchesWhere(\n\t\t\toptions.where(params, ctx),\n\t\t\trow as Record<string, unknown>\n\t\t),\n\tkey: options.key,\n\tauthorize: options.authorize\n});\n"
+  ],
+  "mappings": "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",
+  "debugId": "96C8D5DF158A4DF864756E2164756E21",
+  "names": []
+}

package/dist/adapters/prisma/predicate.d.ts

@@ -0,0 +1,20 @@
+import type { PrismaWhere } from './topics';
+/**
+ * Thrown when a Prisma `where` uses an operator the incremental matcher can't
+ * evaluate in JS. The sync engine catches it and degrades that subscription to
+ * a refetch, so it never produces a wrong result — only a less efficient one.
+ */
+export declare class UnsupportedFilterError extends Error {
+    constructor(operator: string);
+}
+/**
+ * Evaluate a Prisma `where` object against an in-memory row — the JS mirror of
+ * the SQL filter, used for incremental matching. Supports field equality and the
+ * `equals/not/in/notIn/lt/lte/gt/gte/contains/startsWith/endsWith` operators
+ * plus `AND`/`OR`/`NOT`. Anything else throws {@link UnsupportedFilterError}, so
+ * the engine falls back to a refetch.
+ *
+ * @example
+ * matchesWhere({ userId: 5, status: { not: 'archived' } }, row)
+ */
+export declare const matchesWhere: (where: PrismaWhere, row: Record<string, unknown>) => boolean;

package/dist/adapters/prisma/read.d.ts

@@ -0,0 +1,28 @@
+import type { PrismaWhere } from './topics';
+export type DeriveReadTopicsOptions = {
+    /**
+     * Primary-key field name to narrow on. Defaults to `id` (Prisma's
+     * convention); set it for models keyed by another field.
+     */
+    keyField?: string;
+};
+export type DerivedReadTopics = {
+    /** Topics this read depends on — subscribe to all of them. */
+    topics: string[];
+    /**
+     * `true` when derivation narrowed to a specific row (`model:key`); `false`
+     * when it fell back to the whole-model topic.
+     */
+    rowLevel: boolean;
+};
+/**
+ * Derive the reactive topics a read of `model` (optionally filtered by `where`)
+ * depends on. A recognised key-field equality narrows to a single `model:key`
+ * topic; everything else subscribes to the whole-model topic.
+ *
+ * @example
+ * deriveReadTopics('user');                       // { topics: ['user'], rowLevel: false }
+ * deriveReadTopics('user', { id: 5 });            // { topics: ['user:5'], rowLevel: true }
+ * deriveReadTopics('user', { id: { gt: 5 } });    // { topics: ['user'], rowLevel: false }
+ */
+export declare const deriveReadTopics: (model: string, where?: PrismaWhere, options?: DeriveReadTopicsOptions) => DerivedReadTopics;

package/dist/adapters/prisma/topics.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Shared topic vocabulary + key extraction for the Prisma adapter. Operates on
+ * Prisma's plain `where` objects and result records — there is no
+ * `@prisma/client` import, so it stays generic across every database Prisma
+ * supports. Both the read side (derive a query's topics) and the write side
+ * (publish a mutation's topics) build on these so the two always agree.
+ */
+/** A Prisma `where` filter object, e.g. `{ id: 5 }` or `{ id: { gt: 5 } }`. */
+export type PrismaWhere = Record<string, unknown>;
+/** A scalar usable as a row key. */
+export type RowKey = string | number | bigint;
+/** The coarse topic every read/write of `model` touches, e.g. `user`. */
+export declare const tableTopic: (model: string) => string;
+/** The row-level topic for one key of `model`, e.g. `user:5`. */
+export declare const keyTopic: (model: string, key: RowKey) => string;
+/**
+ * Best-effort: pull a single key-field equality value out of a Prisma `where`.
+ * Recognises `{ [keyField]: scalar }` and `{ [keyField]: { equals: scalar } }`
+ * only — extra fields, other operators (`gt`/`in`/`not`/…), `AND`/`OR`, or a
+ * compound-key object yield `undefined`, so the caller falls back to the table
+ * topic (over-invalidating a little rather than missing an update).
+ */
+export declare const extractKeyFromWhere: (where: PrismaWhere, keyField: string) => RowKey | undefined;
+/**
+ * Read the key value from each result record (e.g. the output of a Prisma
+ * `create`/`update`/`delete`), using `keyField`. Records without a scalar key
+ * are skipped.
+ */
+export declare const extractRowKeys: (rows: ReadonlyArray<Record<string, unknown>>, keyField: string) => RowKey[];

package/dist/adapters/prisma/write.d.ts

@@ -0,0 +1,65 @@
+import type { ReactiveHub } from '../../reactiveHub';
+import type { PrismaWhere, RowKey } from './topics';
+/**
+ * Prisma write-side topic publishing (Tier 2).
+ *
+ * The mirror of {@link deriveReadTopics}: after a mutation commits, publish the
+ * topics it invalidates so subscribed reads refetch. Every change publishes the
+ * **model** topic (so list queries refresh) plus a **row** topic per affected
+ * key (so row-level queries refresh) — the exact topics the read side derives.
+ *
+ * Use the SAME model identifier you pass on the read side; the topic is the
+ * model name verbatim.
+ */
+/** The kind of mutation, forwarded in the change-event payload. */
+export type ChangeOp = 'insert' | 'update' | 'delete';
+/** Payload carried by every change event the write side publishes. */
+export type ChangePayload = {
+    /** Name of the model that changed. */
+    table: string;
+    /** Mutation kind, when the caller provided it. */
+    op?: ChangeOp;
+    /** Affected row keys (empty for a model-wide change). */
+    keys: RowKey[];
+};
+export type PublishChangeOptions = {
+    /** Row keys that changed; each emits a `model:key` topic. */
+    keys?: ReadonlyArray<RowKey>;
+    op?: ChangeOp;
+};
+/**
+ * Publish the reactive topics a change to `model` invalidates: the whole-model
+ * topic (always) plus a `model:key` topic per affected row. Call after the
+ * mutation resolves. Returns the (de-duplicated) topics published.
+ */
+export declare const publishChange: (hub: Pick<ReactiveHub, "publish">, model: string, options?: PublishChangeOptions) => string[];
+export type PublishRowsOptions = {
+    /** Key field (defaults to `id`). */
+    keyField?: string;
+    op?: ChangeOp;
+};
+/**
+ * Publish change topics for the record(s) a mutation returned. Accepts a single
+ * record (Prisma `create`/`update`/`delete`) or an array (`findMany` results),
+ * reading each record's `keyField` to emit `model:key` topics.
+ *
+ * @example
+ * const user = await prisma.user.create({ data });
+ * publishRows(hub, 'user', user, { op: 'insert' });
+ */
+export declare const publishRows: (hub: Pick<ReactiveHub, "publish">, model: string, rows: Record<string, unknown> | ReadonlyArray<Record<string, unknown>>, options?: PublishRowsOptions) => string[];
+export type PublishWhereOptions = {
+    /** Key field (defaults to `id`). */
+    keyField?: string;
+    op?: ChangeOp;
+};
+/**
+ * Publish change topics for an `update`/`delete` identified by a `where` filter.
+ * A simple key-field equality narrows to that row's topic; any other filter
+ * publishes just the model topic, so every affected subscriber refetches.
+ *
+ * @example
+ * await prisma.user.update({ where: { id }, data });
+ * publishWhere(hub, 'user', { id }, { op: 'update' });
+ */
+export declare const publishWhere: (hub: Pick<ReactiveHub, "publish">, model: string, where: PrismaWhere, options?: PublishWhereOptions) => string[];

package/dist/adapters/sqlite/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * SQLite CDC adapter for @absolutejs/sync (Tier 3, M5).
+ *
+ * SQLite has no `LISTEN/NOTIFY`, and its `update_hook` isn't reachable from the
+ * JS runtimes we target, so out-of-band writes are caught with the portable
+ * changelog (outbox) pattern: install triggers that append every row change to a
+ * changelog table, then tail it with {@link createPollingChangeSource}. Polling a
+ * local SQLite table is cheap (same process, no network).
+ *
+ * Dependency-free — it only generates SQL; bring your own client (`bun:sqlite`,
+ * better-sqlite3, …) to run it and to back the poll query.
+ */
+export { createPollingChangeSource, parseOutboxRow } from '../../engine/pollingSource';
+export type { OutboxRow, PollingChangeSourceOptions } from '../../engine/pollingSource';
+export type SqliteChangelogOptions = {
+    /** Table name → the column names to capture in the change payload. */
+    tables: Record<string, string[]>;
+    /** Changelog table name. Defaults to `absolute_sync_changelog`. */
+    changelogTable?: string;
+    /** Trigger name prefix. Defaults to `absolute_sync`. */
+    prefix?: string;
+};
+/**
+ * Generate the SQL that installs the changelog table and per-table
+ * insert/update/delete triggers — run it once (e.g. in a migration). Each
+ * trigger appends `{ tbl, op, payload }` (payload built with `json_object` from
+ * the listed columns) to the changelog for {@link createPollingChangeSource}.
+ *
+ * The statements are `;`-separated; run them as a script, or split on `;` if your
+ * driver executes one statement per call.
+ */
+export declare const sqliteChangelogSchema: (options: SqliteChangelogOptions) => string;