@rocicorp/zero 0.26.1 → 0.26.2-canary.1

package/out/zero-cache/src/services/replicator/schema/replication-state.js

@@ -1,150 +1,99 @@
+import { parse, valita_exports } from "../../../../../shared/src/valita.js";
 import { jsonObjectSchema, stringify } from "../../../../../shared/src/bigint-json.js";
-import { parse } from "../../../../../shared/src/valita.js";
 import { CREATE_CHANGELOG_SCHEMA } from "./change-log.js";
+import "./constants.js";
 import { CREATE_COLUMN_METADATA_TABLE } from "./column-metadata.js";
 import { CREATE_TABLE_METADATA_TABLE } from "./table-metadata.js";
-import { array, string, object } from "@badrap/valita";
-const CREATE_RUNTIME_EVENTS_TABLE = `
+//#region ../zero-cache/src/services/replicator/schema/replication-state.ts
+/**
+* Replication metadata, used for incremental view maintenance and catchup.
+*
+* These tables are created atomically in {@link setupReplicationTables}
+* after the logical replication handoff when initial data synchronization has completed.
+*/
+var CREATE_RUNTIME_EVENTS_TABLE = `
   CREATE TABLE "_zero.runtimeEvents" (
     event TEXT PRIMARY KEY ON CONFLICT REPLACE,
     timestamp TEXT NOT NULL DEFAULT (current_timestamp)
   );
 `;
-const CREATE_REPLICATION_STATE_SCHEMA = (
-  // replicaVersion     : A value identifying the version at which the initial sync happened, i.e.
-  //                      the version at which all rows were copied, and to `_0_version` was set.
-  //                      This value is used to distinguish data from other replicas (e.g. if a
-  //                      replica is reset or if there are ever multiple replicas).
-  // publications       : JSON stringified array of publication names
-  // initialSyncContext : Metadata related to the context of when and how the replica was initially
-  //                      synced. This corresponds with the same column stored in upstream and is
-  //                      used for debugging replica version mismatches, which can arise from a number
-  //                      of misconfigurations, such as dueling replication-managers, or restores of
-  //                      stale litestream backups.
-  // lock               : Auto-magic column for enforcing single-row semantics.
-  /*sql*/
-  `
-  CREATE TABLE "_zero.replicationConfig" (
-    replicaVersion TEXT NOT NULL,
-    publications TEXT NOT NULL,
-    initialSyncContext TEXT DEFAULT '{}',
-    lock INTEGER PRIMARY KEY DEFAULT 1 CHECK (lock=1)
-  );
-  
-  CREATE TABLE "_zero.replicationState" (
-    stateVersion TEXT NOT NULL,
-    lock INTEGER PRIMARY KEY DEFAULT 1 CHECK (lock=1)
-  );
-  ` + CREATE_CHANGELOG_SCHEMA + CREATE_RUNTIME_EVENTS_TABLE + CREATE_COLUMN_METADATA_TABLE + CREATE_TABLE_METADATA_TABLE
-);
-const stringArray = array(string());
-const subscriptionStateSchema = object({
-  replicaVersion: string(),
-  publications: string(),
-  watermark: string()
+var CREATE_REPLICATION_STATE_SCHEMA = "\n  CREATE TABLE \"_zero.replicationConfig\" (\n    replicaVersion TEXT NOT NULL,\n    publications TEXT NOT NULL,\n    initialSyncContext TEXT DEFAULT '{}',\n    lock INTEGER PRIMARY KEY DEFAULT 1 CHECK (lock=1)\n  );\n  \n  CREATE TABLE \"_zero.replicationState\" (\n    stateVersion TEXT NOT NULL,\n    lock INTEGER PRIMARY KEY DEFAULT 1 CHECK (lock=1)\n  );\n  " + CREATE_CHANGELOG_SCHEMA + CREATE_RUNTIME_EVENTS_TABLE + CREATE_COLUMN_METADATA_TABLE + CREATE_TABLE_METADATA_TABLE;
+var stringArray = valita_exports.array(valita_exports.string());
+var subscriptionStateSchema = valita_exports.object({
+	replicaVersion: valita_exports.string(),
+	publications: valita_exports.string(),
+	watermark: valita_exports.string()
 }).map((s) => ({
-  ...s,
-  publications: parse(JSON.parse(s.publications), stringArray)
+	...s,
+	publications: parse(JSON.parse(s.publications), stringArray)
 }));
-const subscriptionStateAndContextSchema = object({
-  replicaVersion: string(),
-  publications: string(),
-  initialSyncContext: string(),
-  watermark: string()
+var subscriptionStateAndContextSchema = valita_exports.object({
+	replicaVersion: valita_exports.string(),
+	publications: valita_exports.string(),
+	initialSyncContext: valita_exports.string(),
+	watermark: valita_exports.string()
 }).map((s) => ({
-  ...s,
-  publications: parse(JSON.parse(s.publications), stringArray),
-  initialSyncContext: parse(
-    JSON.parse(s.initialSyncContext),
-    jsonObjectSchema
-  )
+	...s,
+	publications: parse(JSON.parse(s.publications), stringArray),
+	initialSyncContext: parse(JSON.parse(s.initialSyncContext), jsonObjectSchema)
 }));
-const replicationStateSchema = object({
-  stateVersion: string()
-});
+var replicationStateSchema = valita_exports.object({ stateVersion: valita_exports.string() });
 function initReplicationState(db, publications, watermark, initialSyncContext = {}, createTables = true) {
-  if (createTables) {
-    createReplicationStateTables(db);
-  }
-  db.prepare(
-    `
+	if (createTables) createReplicationStateTables(db);
+	db.prepare(`
     INSERT INTO "_zero.replicationConfig" 
        (replicaVersion, publications, initialSyncContext) VALUES (?, ?, ?)
-    `
-  ).run(
-    watermark,
-    JSON.stringify(publications.sort()),
-    stringify(initialSyncContext)
-  );
-  db.prepare(
-    `
+    `).run(watermark, JSON.stringify(publications.sort()), stringify(initialSyncContext));
+	db.prepare(`
     INSERT INTO "_zero.replicationState" (stateVersion) VALUES (?)
-    `
-  ).run(watermark);
-  recordEvent(db, "sync");
+    `).run(watermark);
+	recordEvent(db, "sync");
 }
+/**
+* Exposed as a separate function for the custom change source,
+* which needs the tables to be created in order to construct
+* ChangeProcessor before it knows the initial watermark.
+*/
 function createReplicationStateTables(db) {
-  db.exec(CREATE_REPLICATION_STATE_SCHEMA);
+	db.exec(CREATE_REPLICATION_STATE_SCHEMA);
 }
 function recordEvent(db, event) {
-  db.prepare(
-    `
+	db.prepare(`
     INSERT INTO "_zero.runtimeEvents" (event) VALUES (?) 
-    `
-  ).run(event);
+    `).run(event);
 }
 function getAscendingEvents(db) {
-  const result = db.prepare(
-    `SELECT event, timestamp FROM "_zero.runtimeEvents" 
+	return db.prepare(`SELECT event, timestamp FROM "_zero.runtimeEvents" 
          ORDER BY timestamp ASC
-    `
-  ).all();
-  return result.map(({ event, timestamp }) => ({
-    event,
-    timestamp: /* @__PURE__ */ new Date(timestamp + "Z")
-  }));
+    `).all().map(({ event, timestamp }) => ({
+		event,
+		timestamp: /* @__PURE__ */ new Date(timestamp + "Z")
+	}));
 }
 function getSubscriptionState(db) {
-  const result = db.get(
-    /*sql*/
-    `
+	return parse(db.get(`
       SELECT c.replicaVersion, c.publications, s.stateVersion as watermark
         FROM "_zero.replicationConfig" as c
         JOIN "_zero.replicationState" as s
         ON c.lock = s.lock
-    `
-  );
-  return parse(result, subscriptionStateSchema);
+    `), subscriptionStateSchema);
 }
 function getSubscriptionStateAndContext(db) {
-  const result = db.get(
-    /*sql*/
-    `
+	return parse(db.get(`
       SELECT c.replicaVersion, c.publications, c.initialSyncContext,
         s.stateVersion as watermark
         FROM "_zero.replicationConfig" as c
         JOIN "_zero.replicationState" as s
         ON c.lock = s.lock
-    `
-  );
-  return parse(result, subscriptionStateAndContextSchema);
+    `), subscriptionStateAndContextSchema);
 }
 function updateReplicationWatermark(db, watermark) {
-  db.run(`UPDATE "_zero.replicationState" SET stateVersion=?`, watermark);
+	db.run(`UPDATE "_zero.replicationState" SET stateVersion=?`, watermark);
 }
 function getReplicationState(db) {
-  const result = db.get(`SELECT stateVersion FROM "_zero.replicationState"`);
-  return parse(result, replicationStateSchema);
+	return parse(db.get(`SELECT stateVersion FROM "_zero.replicationState"`), replicationStateSchema);
 }
-export {
-  CREATE_RUNTIME_EVENTS_TABLE,
-  createReplicationStateTables,
-  getAscendingEvents,
-  getReplicationState,
-  getSubscriptionState,
-  getSubscriptionStateAndContext,
-  initReplicationState,
-  recordEvent,
-  updateReplicationWatermark
-};
-//# sourceMappingURL=replication-state.js.map
+//#endregion
+export { CREATE_RUNTIME_EVENTS_TABLE, createReplicationStateTables, getAscendingEvents, getReplicationState, getSubscriptionState, getSubscriptionStateAndContext, initReplicationState, recordEvent, updateReplicationWatermark };
+
+//# sourceMappingURL=replication-state.js.map

package/out/zero-cache/src/services/replicator/schema/replication-state.js.map

@@ -1 +1 @@
-{"version":3,"file":"replication-state.js","sources":["../../../../../../../zero-cache/src/services/replicator/schema/replication-state.ts"],"sourcesContent":["/**\n * Replication metadata, used for incremental view maintenance and catchup.\n *\n * These tables are created atomically in {@link setupReplicationTables}\n * after the logical replication handoff when initial data synchronization has completed.\n */\n\nimport {\n  jsonObjectSchema,\n  stringify,\n  type JSONObject,\n} from '../../../../../shared/src/bigint-json.ts';\nimport * as v from '../../../../../shared/src/valita.ts';\nimport type {Database} from '../../../../../zqlite/src/db.ts';\nimport type {StatementRunner} from '../../../db/statements.ts';\nimport {CREATE_CHANGELOG_SCHEMA} from './change-log.ts';\nimport {CREATE_COLUMN_METADATA_TABLE} from './column-metadata.ts';\nimport {ZERO_VERSION_COLUMN_NAME} from './constants.ts';\nimport {CREATE_TABLE_METADATA_TABLE} from './table-metadata.ts';\n\nexport {ZERO_VERSION_COLUMN_NAME};\n\nexport type RuntimeEvent = 'sync' | 'upgrade' | 'vacuum';\n\n// event     : The RuntimeEvent. Only one row per event is tracked.\n//             Inserting an event will REPLACE any row for the same event.\n// timestamp : SQLite timestamp string, e.g. \"2024-04-12 11:37:46\".\n//             Append a `Z` when parsing with `new Date(...)`;\nexport const CREATE_RUNTIME_EVENTS_TABLE = `\n  CREATE TABLE \"_zero.runtimeEvents\" (\n    event TEXT PRIMARY KEY ON CONFLICT REPLACE,\n    timestamp TEXT NOT NULL DEFAULT (current_timestamp)\n  );\n`;\n\nconst CREATE_REPLICATION_STATE_SCHEMA =\n  // replicaVersion     : A value identifying the version at which the initial sync happened, i.e.\n  //                      the version at which all rows were copied, and to `_0_version` was set.\n  //                      This value is used to distinguish data from other replicas (e.g. if a\n  //                      replica is reset or if there are ever multiple replicas).\n  // publications       : JSON stringified array of publication names\n  // initialSyncContext : Metadata related to the context of when and how the replica was initially\n  //                      synced. This corresponds with the same column stored in upstream and is\n  //                      used for debugging replica version mismatches, which can arise from a number\n  //                      of misconfigurations, such as dueling replication-managers, or restores of\n  //                      stale litestream backups.\n  // lock               : Auto-magic column for enforcing single-row semantics.\n  /*sql*/ `\n  CREATE TABLE \"_zero.replicationConfig\" (\n    replicaVersion TEXT NOT NULL,\n    publications TEXT NOT NULL,\n    initialSyncContext TEXT DEFAULT '{}',\n    lock INTEGER PRIMARY KEY DEFAULT 1 CHECK (lock=1)\n  );\n  ` +\n  // stateVersion     : The latest version replicated from upstream, starting with the initial\n  //                    `replicaVersion` and moving forward to each subsequent commit watermark\n  //                    (e.g. corresponding to a Postgres LSN). Versions are represented as\n  //                    lexicographically sortable watermarks (e.g. LexiVersions).\n  //\n  `\n  CREATE TABLE \"_zero.replicationState\" (\n    stateVersion TEXT NOT NULL,\n    lock INTEGER PRIMARY KEY DEFAULT 1 CHECK (lock=1)\n  );\n  ` +\n  CREATE_CHANGELOG_SCHEMA +\n  CREATE_RUNTIME_EVENTS_TABLE +\n  CREATE_COLUMN_METADATA_TABLE +\n  CREATE_TABLE_METADATA_TABLE;\n\nconst stringArray = v.array(v.string());\n\nconst subscriptionStateSchema = v\n  .object({\n    replicaVersion: v.string(),\n    publications: v.string(),\n    watermark: v.string(),\n  })\n  .map(s => ({\n    ...s,\n    publications: v.parse(JSON.parse(s.publications), stringArray),\n  }));\n\nexport type SubscriptionState = v.Infer<typeof subscriptionStateSchema>;\n\nconst subscriptionStateAndContextSchema = v\n  .object({\n    replicaVersion: v.string(),\n    publications: v.string(),\n    initialSyncContext: v.string(),\n    watermark: v.string(),\n  })\n  .map(s => ({\n    ...s,\n    publications: v.parse(JSON.parse(s.publications), stringArray),\n    initialSyncContext: v.parse(\n      JSON.parse(s.initialSyncContext),\n      jsonObjectSchema,\n    ),\n  }));\n\nexport type SubscriptionStateAndContext = v.Infer<\n  typeof subscriptionStateAndContextSchema\n>;\n\nconst replicationStateSchema = v.object({\n  stateVersion: v.string(),\n});\n\nexport type ReplicationState = v.Infer<typeof replicationStateSchema>;\n\nexport function initReplicationState(\n  db: Database,\n  publications: string[],\n  watermark: string,\n  initialSyncContext: JSONObject = {},\n  createTables = true,\n) {\n  if (createTables) {\n    createReplicationStateTables(db);\n  }\n  db.prepare(\n    `\n    INSERT INTO \"_zero.replicationConfig\" \n       (replicaVersion, publications, initialSyncContext) VALUES (?, ?, ?)\n    `,\n  ).run(\n    watermark,\n    JSON.stringify(publications.sort()),\n    stringify(initialSyncContext),\n  );\n  db.prepare(\n    `\n    INSERT INTO \"_zero.replicationState\" (stateVersion) VALUES (?)\n    `,\n  ).run(watermark);\n  recordEvent(db, 'sync');\n}\n\n/**\n * Exposed as a separate function for the custom change source,\n * which needs the tables to be created in order to construct\n * ChangeProcessor before it knows the initial watermark.\n */\nexport function createReplicationStateTables(db: Database) {\n  db.exec(CREATE_REPLICATION_STATE_SCHEMA);\n}\n\nexport function recordEvent(db: Database, event: RuntimeEvent) {\n  db.prepare(\n    `\n    INSERT INTO \"_zero.runtimeEvents\" (event) VALUES (?) \n    `,\n  ).run(event);\n}\n\nexport function getAscendingEvents(db: Database) {\n  const result = db\n    .prepare(\n      `SELECT event, timestamp FROM \"_zero.runtimeEvents\" \n         ORDER BY timestamp ASC\n    `,\n    )\n    .all<{event: string; timestamp: string}>();\n  return result.map(({event, timestamp}) => ({\n    event,\n    timestamp: new Date(timestamp + 'Z'),\n  }));\n}\n\nexport function getSubscriptionState(db: StatementRunner): SubscriptionState {\n  const result = db.get(/*sql*/ `\n      SELECT c.replicaVersion, c.publications, s.stateVersion as watermark\n        FROM \"_zero.replicationConfig\" as c\n        JOIN \"_zero.replicationState\" as s\n        ON c.lock = s.lock\n    `);\n  return v.parse(result, subscriptionStateSchema);\n}\n\nexport function getSubscriptionStateAndContext(\n  db: StatementRunner,\n): SubscriptionStateAndContext {\n  const result = db.get(/*sql*/ `\n      SELECT c.replicaVersion, c.publications, c.initialSyncContext,\n        s.stateVersion as watermark\n        FROM \"_zero.replicationConfig\" as c\n        JOIN \"_zero.replicationState\" as s\n        ON c.lock = s.lock\n    `);\n  return v.parse(result, subscriptionStateAndContextSchema);\n}\n\nexport function updateReplicationWatermark(\n  db: StatementRunner,\n  watermark: string,\n) {\n  db.run(`UPDATE \"_zero.replicationState\" SET stateVersion=?`, watermark);\n}\n\nexport function getReplicationState(db: StatementRunner): ReplicationState {\n  const result = db.get(`SELECT stateVersion FROM \"_zero.replicationState\"`);\n  return v.parse(result, replicationStateSchema);\n}\n"],"names":["v.array","v.string","v.object","v.parse"],"mappings":";;;;;;AA4BO,MAAM,8BAA8B;AAAA;AAAA;AAAA;AAAA;AAAA;AAO3C,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYI;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAmBR,0BACA,8BACA,+BACA;AAAA;AAEF,MAAM,cAAcA,MAAQC,QAAU;AAEtC,MAAM,0BAA0BC,OACtB;AAAA,EACN,gBAAgBD,OAAE;AAAA,EAClB,cAAcA,OAAE;AAAA,EAChB,WAAWA,OAAE;AACf,CAAC,EACA,IAAI,CAAA,OAAM;AAAA,EACT,GAAG;AAAA,EACH,cAAcE,MAAQ,KAAK,MAAM,EAAE,YAAY,GAAG,WAAW;AAC/D,EAAE;AAIJ,MAAM,oCAAoCD,OAChC;AAAA,EACN,gBAAgBD,OAAE;AAAA,EAClB,cAAcA,OAAE;AAAA,EAChB,oBAAoBA,OAAE;AAAA,EACtB,WAAWA,OAAE;AACf,CAAC,EACA,IAAI,CAAA,OAAM;AAAA,EACT,GAAG;AAAA,EACH,cAAcE,MAAQ,KAAK,MAAM,EAAE,YAAY,GAAG,WAAW;AAAA,EAC7D,oBAAoBA;AAAAA,IAClB,KAAK,MAAM,EAAE,kBAAkB;AAAA,IAC/B;AAAA,EAAA;AAEJ,EAAE;AAMJ,MAAM,yBAAyBD,OAAS;AAAA,EACtC,cAAcD,OAAE;AAClB,CAAC;AAIM,SAAS,qBACd,IACA,cACA,WACA,qBAAiC,CAAA,GACjC,eAAe,MACf;AACA,MAAI,cAAc;AAChB,iCAA6B,EAAE;AAAA,EACjC;AACA,KAAG;AAAA,IACD;AAAA;AAAA;AAAA;AAAA,EAAA,EAIA;AAAA,IACA;AAAA,IACA,KAAK,UAAU,aAAa,MAAM;AAAA,IAClC,UAAU,kBAAkB;AAAA,EAAA;AAE9B,KAAG;AAAA,IACD;AAAA;AAAA;AAAA,EAAA,EAGA,IAAI,SAAS;AACf,cAAY,IAAI,MAAM;AACxB;AAOO,SAAS,6BAA6B,IAAc;AACzD,KAAG,KAAK,+BAA+B;AACzC;AAEO,SAAS,YAAY,IAAc,OAAqB;AAC7D,KAAG;AAAA,IACD;AAAA;AAAA;AAAA,EAAA,EAGA,IAAI,KAAK;AACb;AAEO,SAAS,mBAAmB,IAAc;AAC/C,QAAM,SAAS,GACZ;AAAA,IACC;AAAA;AAAA;AAAA,EAAA,EAID,IAAA;AACH,SAAO,OAAO,IAAI,CAAC,EAAC,OAAO,iBAAgB;AAAA,IACzC;AAAA,IACA,WAAW,oBAAI,KAAK,YAAY,GAAG;AAAA,EAAA,EACnC;AACJ;AAEO,SAAS,qBAAqB,IAAwC;AAC3E,QAAM,SAAS,GAAG;AAAA;AAAA,IAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAAA;AAM9B,SAAOE,MAAQ,QAAQ,uBAAuB;AAChD;AAEO,SAAS,+BACd,IAC6B;AAC7B,QAAM,SAAS,GAAG;AAAA;AAAA,IAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAAA;AAO9B,SAAOA,MAAQ,QAAQ,iCAAiC;AAC1D;AAEO,SAAS,2BACd,IACA,WACA;AACA,KAAG,IAAI,sDAAsD,SAAS;AACxE;AAEO,SAAS,oBAAoB,IAAuC;AACzE,QAAM,SAAS,GAAG,IAAI,mDAAmD;AACzE,SAAOA,MAAQ,QAAQ,sBAAsB;AAC/C;"}
+{"version":3,"file":"replication-state.js","names":[],"sources":["../../../../../../../zero-cache/src/services/replicator/schema/replication-state.ts"],"sourcesContent":["/**\n * Replication metadata, used for incremental view maintenance and catchup.\n *\n * These tables are created atomically in {@link setupReplicationTables}\n * after the logical replication handoff when initial data synchronization has completed.\n */\n\nimport {\n  jsonObjectSchema,\n  stringify,\n  type JSONObject,\n} from '../../../../../shared/src/bigint-json.ts';\nimport * as v from '../../../../../shared/src/valita.ts';\nimport type {Database} from '../../../../../zqlite/src/db.ts';\nimport type {StatementRunner} from '../../../db/statements.ts';\nimport {CREATE_CHANGELOG_SCHEMA} from './change-log.ts';\nimport {CREATE_COLUMN_METADATA_TABLE} from './column-metadata.ts';\nimport {ZERO_VERSION_COLUMN_NAME} from './constants.ts';\nimport {CREATE_TABLE_METADATA_TABLE} from './table-metadata.ts';\n\nexport {ZERO_VERSION_COLUMN_NAME};\n\nexport type RuntimeEvent = 'sync' | 'upgrade' | 'vacuum';\n\n// event     : The RuntimeEvent. Only one row per event is tracked.\n//             Inserting an event will REPLACE any row for the same event.\n// timestamp : SQLite timestamp string, e.g. \"2024-04-12 11:37:46\".\n//             Append a `Z` when parsing with `new Date(...)`;\nexport const CREATE_RUNTIME_EVENTS_TABLE = `\n  CREATE TABLE \"_zero.runtimeEvents\" (\n    event TEXT PRIMARY KEY ON CONFLICT REPLACE,\n    timestamp TEXT NOT NULL DEFAULT (current_timestamp)\n  );\n`;\n\nconst CREATE_REPLICATION_STATE_SCHEMA =\n  // replicaVersion     : A value identifying the version at which the initial sync happened, i.e.\n  //                      the version at which all rows were copied, and to `_0_version` was set.\n  //                      This value is used to distinguish data from other replicas (e.g. if a\n  //                      replica is reset or if there are ever multiple replicas).\n  // publications       : JSON stringified array of publication names\n  // initialSyncContext : Metadata related to the context of when and how the replica was initially\n  //                      synced. This corresponds with the same column stored in upstream and is\n  //                      used for debugging replica version mismatches, which can arise from a number\n  //                      of misconfigurations, such as dueling replication-managers, or restores of\n  //                      stale litestream backups.\n  // lock               : Auto-magic column for enforcing single-row semantics.\n  /*sql*/ `\n  CREATE TABLE \"_zero.replicationConfig\" (\n    replicaVersion TEXT NOT NULL,\n    publications TEXT NOT NULL,\n    initialSyncContext TEXT DEFAULT '{}',\n    lock INTEGER PRIMARY KEY DEFAULT 1 CHECK (lock=1)\n  );\n  ` +\n  // stateVersion     : The latest version replicated from upstream, starting with the initial\n  //                    `replicaVersion` and moving forward to each subsequent commit watermark\n  //                    (e.g. corresponding to a Postgres LSN). Versions are represented as\n  //                    lexicographically sortable watermarks (e.g. LexiVersions).\n  //\n  `\n  CREATE TABLE \"_zero.replicationState\" (\n    stateVersion TEXT NOT NULL,\n    lock INTEGER PRIMARY KEY DEFAULT 1 CHECK (lock=1)\n  );\n  ` +\n  CREATE_CHANGELOG_SCHEMA +\n  CREATE_RUNTIME_EVENTS_TABLE +\n  CREATE_COLUMN_METADATA_TABLE +\n  CREATE_TABLE_METADATA_TABLE;\n\nconst stringArray = v.array(v.string());\n\nconst subscriptionStateSchema = v\n  .object({\n    replicaVersion: v.string(),\n    publications: v.string(),\n    watermark: v.string(),\n  })\n  .map(s => ({\n    ...s,\n    publications: v.parse(JSON.parse(s.publications), stringArray),\n  }));\n\nexport type SubscriptionState = v.Infer<typeof subscriptionStateSchema>;\n\nconst subscriptionStateAndContextSchema = v\n  .object({\n    replicaVersion: v.string(),\n    publications: v.string(),\n    initialSyncContext: v.string(),\n    watermark: v.string(),\n  })\n  .map(s => ({\n    ...s,\n    publications: v.parse(JSON.parse(s.publications), stringArray),\n    initialSyncContext: v.parse(\n      JSON.parse(s.initialSyncContext),\n      jsonObjectSchema,\n    ),\n  }));\n\nexport type SubscriptionStateAndContext = v.Infer<\n  typeof subscriptionStateAndContextSchema\n>;\n\nconst replicationStateSchema = v.object({\n  stateVersion: v.string(),\n});\n\nexport type ReplicationState = v.Infer<typeof replicationStateSchema>;\n\nexport function initReplicationState(\n  db: Database,\n  publications: string[],\n  watermark: string,\n  initialSyncContext: JSONObject = {},\n  createTables = true,\n) {\n  if (createTables) {\n    createReplicationStateTables(db);\n  }\n  db.prepare(\n    `\n    INSERT INTO \"_zero.replicationConfig\" \n       (replicaVersion, publications, initialSyncContext) VALUES (?, ?, ?)\n    `,\n  ).run(\n    watermark,\n    JSON.stringify(publications.sort()),\n    stringify(initialSyncContext),\n  );\n  db.prepare(\n    `\n    INSERT INTO \"_zero.replicationState\" (stateVersion) VALUES (?)\n    `,\n  ).run(watermark);\n  recordEvent(db, 'sync');\n}\n\n/**\n * Exposed as a separate function for the custom change source,\n * which needs the tables to be created in order to construct\n * ChangeProcessor before it knows the initial watermark.\n */\nexport function createReplicationStateTables(db: Database) {\n  db.exec(CREATE_REPLICATION_STATE_SCHEMA);\n}\n\nexport function recordEvent(db: Database, event: RuntimeEvent) {\n  db.prepare(\n    `\n    INSERT INTO \"_zero.runtimeEvents\" (event) VALUES (?) \n    `,\n  ).run(event);\n}\n\nexport function getAscendingEvents(db: Database) {\n  const result = db\n    .prepare(\n      `SELECT event, timestamp FROM \"_zero.runtimeEvents\" \n         ORDER BY timestamp ASC\n    `,\n    )\n    .all<{event: string; timestamp: string}>();\n  return result.map(({event, timestamp}) => ({\n    event,\n    timestamp: new Date(timestamp + 'Z'),\n  }));\n}\n\nexport function getSubscriptionState(db: StatementRunner): SubscriptionState {\n  const result = db.get(/*sql*/ `\n      SELECT c.replicaVersion, c.publications, s.stateVersion as watermark\n        FROM \"_zero.replicationConfig\" as c\n        JOIN \"_zero.replicationState\" as s\n        ON c.lock = s.lock\n    `);\n  return v.parse(result, subscriptionStateSchema);\n}\n\nexport function getSubscriptionStateAndContext(\n  db: StatementRunner,\n): SubscriptionStateAndContext {\n  const result = db.get(/*sql*/ `\n      SELECT c.replicaVersion, c.publications, c.initialSyncContext,\n        s.stateVersion as watermark\n        FROM \"_zero.replicationConfig\" as c\n        JOIN \"_zero.replicationState\" as s\n        ON c.lock = s.lock\n    `);\n  return v.parse(result, subscriptionStateAndContextSchema);\n}\n\nexport function updateReplicationWatermark(\n  db: StatementRunner,\n  watermark: string,\n) {\n  db.run(`UPDATE \"_zero.replicationState\" SET stateVersion=?`, watermark);\n}\n\nexport function getReplicationState(db: StatementRunner): ReplicationState {\n  const result = db.get(`SELECT stateVersion FROM \"_zero.replicationState\"`);\n  return v.parse(result, replicationStateSchema);\n}\n"],"mappings":";;;;;;;;;;;;;AA4BA,IAAa,8BAA8B;;;;;;AAO3C,IAAM,kCAYI,kXAmBR,0BACA,8BACA,+BACA;AAEF,IAAM,cAAc,eAAE,MAAM,eAAE,QAAQ,CAAC;AAEvC,IAAM,0BAA0B,eAC7B,OAAO;CACN,gBAAgB,eAAE,QAAQ;CAC1B,cAAc,eAAE,QAAQ;CACxB,WAAW,eAAE,QAAQ;CACtB,CAAC,CACD,KAAI,OAAM;CACT,GAAG;CACH,cAAc,MAAQ,KAAK,MAAM,EAAE,aAAa,EAAE,YAAY;CAC/D,EAAE;AAIL,IAAM,oCAAoC,eACvC,OAAO;CACN,gBAAgB,eAAE,QAAQ;CAC1B,cAAc,eAAE,QAAQ;CACxB,oBAAoB,eAAE,QAAQ;CAC9B,WAAW,eAAE,QAAQ;CACtB,CAAC,CACD,KAAI,OAAM;CACT,GAAG;CACH,cAAc,MAAQ,KAAK,MAAM,EAAE,aAAa,EAAE,YAAY;CAC9D,oBAAoB,MAClB,KAAK,MAAM,EAAE,mBAAmB,EAChC,iBACD;CACF,EAAE;AAML,IAAM,yBAAyB,eAAE,OAAO,EACtC,cAAc,eAAE,QAAQ,EACzB,CAAC;AAIF,SAAgB,qBACd,IACA,cACA,WACA,qBAAiC,EAAE,EACnC,eAAe,MACf;AACA,KAAI,aACF,8BAA6B,GAAG;AAElC,IAAG,QACD;;;MAID,CAAC,IACA,WACA,KAAK,UAAU,aAAa,MAAM,CAAC,EACnC,UAAU,mBAAmB,CAC9B;AACD,IAAG,QACD;;MAGD,CAAC,IAAI,UAAU;AAChB,aAAY,IAAI,OAAO;;;;;;;AAQzB,SAAgB,6BAA6B,IAAc;AACzD,IAAG,KAAK,gCAAgC;;AAG1C,SAAgB,YAAY,IAAc,OAAqB;AAC7D,IAAG,QACD;;MAGD,CAAC,IAAI,MAAM;;AAGd,SAAgB,mBAAmB,IAAc;AAQ/C,QAPe,GACZ,QACC;;MAGD,CACA,KAAyC,CAC9B,KAAK,EAAC,OAAO,iBAAgB;EACzC;EACA,2BAAW,IAAI,KAAK,YAAY,IAAI;EACrC,EAAE;;AAGL,SAAgB,qBAAqB,IAAwC;AAO3E,QAAO,MANQ,GAAG,IAAY;;;;;MAK1B,EACmB,wBAAwB;;AAGjD,SAAgB,+BACd,IAC6B;AAQ7B,QAAO,MAPQ,GAAG,IAAY;;;;;;MAM1B,EACmB,kCAAkC;;AAG3D,SAAgB,2BACd,IACA,WACA;AACA,IAAG,IAAI,sDAAsD,UAAU;;AAGzE,SAAgB,oBAAoB,IAAuC;AAEzE,QAAO,MADQ,GAAG,IAAI,oDAAoD,EACnD,uBAAuB"}

package/out/zero-cache/src/services/replicator/schema/table-metadata.js

@@ -1,7 +1,38 @@
 import { liteTableName } from "../../../types/names.js";
-const CREATE_TABLE_METADATA_TABLE = (
-  /*sql*/
-  `
+//#region ../zero-cache/src/services/replicator/schema/table-metadata.ts
+/**
+* Table-level controls for handling replicated data.
+*
+* ### Columns
+*
+* `minRowVersion`: the minimum `_0_version` value to apply to
+*   all rows in the table. This overrides any per-row
+*   `_0_version` value that is smaller (i.e. earlier).
+*   The `minRowVersion` column is used to force a re-download
+*   of all rows after a table-wide schema change (by giving
+*   each row a version that's newer than what's in any CVR).
+*   The naive, brute-force method of updating all of the rows
+*   requires re-writing the entire table into the WAL as one
+*   SQLite operation, which is too costly from both latency
+*   and storage space.
+*
+* `upstreamMetadata`: the replica-level analog of tableMetadata in
+*   change-streamer/schema. Per the requirement of the backfill
+*   protocol, backfill metadata must be tracked outside of the
+*   change source (otherwise the change source would have to be
+*   able to compute the state of the metadata at arbitrary points
+*   in the past).
+*
+* `metadata`: the previous name of the `upstreamMetadata` column,
+*   kept for backwards compatibility.
+*
+* This tracking is done:
+* 1. at the Change DB level, by the change-streamer
+* 2. at the replica level, in order to support the eventual configuration
+*    of ephemeral Change DBs (on SQLite) that are initialized from data
+*    in the replica.
+*/
+var CREATE_TABLE_METADATA_TABLE = `
   CREATE TABLE "_zero.tableMetadata" (
     "schema"           TEXT NOT NULL,
     "table"            TEXT NOT NULL,
@@ -10,79 +41,63 @@ const CREATE_TABLE_METADATA_TABLE = (
     "metadata"         TEXT,  -- deprecated
     PRIMARY KEY ("schema", "table")
   );
-`
-);
-class TableMetadataTracker {
-  #db;
-  // All statements are lazily created.
-  #setUpstreamMetadata;
-  #setMinRowVersion;
-  #getMinRowVersions;
-  #rename;
-  #drop;
-  constructor(db) {
-    this.#db = db;
-  }
-  setUpstreamMetadata({ schema, name }, metadata) {
-    (this.#setUpstreamMetadata ??= this.#db.prepare(
-      /*sql*/
-      `
+`;
+var TableMetadataTracker = class {
+	#db;
+	#setUpstreamMetadata;
+	#setMinRowVersion;
+	#getMinRowVersions;
+	#rename;
+	#drop;
+	constructor(db) {
+		this.#db = db;
+	}
+	setUpstreamMetadata({ schema, name }, metadata) {
+		(this.#setUpstreamMetadata ??= this.#db.prepare(`
       INSERT INTO "_zero.tableMetadata" ("schema", "table", "upstreamMetadata") 
         VALUES (@schema, @name, @metadata)
         ON CONFLICT ("schema", "table")
         DO UPDATE SET "upstreamMetadata" = @metadata
-    `
-    )).run({
-      schema,
-      name,
-      metadata: JSON.stringify(metadata)
-    });
-  }
-  setMinRowVersion({ schema, name }, version) {
-    (this.#setMinRowVersion ??= this.#db.prepare(
-      /*sql*/
-      `
+    `)).run({
+			schema,
+			name,
+			metadata: JSON.stringify(metadata)
+		});
+	}
+	setMinRowVersion({ schema, name }, version) {
+		(this.#setMinRowVersion ??= this.#db.prepare(`
       INSERT INTO "_zero.tableMetadata" ("schema", "table", "minRowVersion") 
         VALUES (@schema, @name, @version)
         ON CONFLICT ("schema", "table")
         DO UPDATE SET "minRowVersion" = @version;
-    `
-    )).run({ schema, name, version });
-  }
-  getMinRowVersions() {
-    const results = (this.#getMinRowVersions ??= this.#db.prepare(
-      /*sql*/
-      `
+    `)).run({
+			schema,
+			name,
+			version
+		});
+	}
+	getMinRowVersions() {
+		const results = (this.#getMinRowVersions ??= this.#db.prepare(`
       SELECT "schema", "table" as "name", "minRowVersion" FROM "_zero.tableMetadata"
-    `
-    )).all();
-    return new Map(
-      results.map(({ schema, name, minRowVersion }) => [
-        liteTableName({ schema, name }),
-        minRowVersion
-      ])
-    );
-  }
-  rename(oldTable, newTable) {
-    (this.#rename ??= this.#db.prepare(
-      /*sql*/
-      `
+    `)).all();
+		return new Map(results.map(({ schema, name, minRowVersion }) => [liteTableName({
+			schema,
+			name
+		}), minRowVersion]));
+	}
+	rename(oldTable, newTable) {
+		(this.#rename ??= this.#db.prepare(`
       UPDATE "_zero.tableMetadata" SET "schema" = ?, "table" = ?
         WHERE "schema" = ? AND "table" = ?
-    `
-    )).run(newTable.schema, newTable.name, oldTable.schema, oldTable.name);
-  }
-  drop({ schema, name }) {
-    (this.#drop ??= this.#db.prepare(
-      /*sql*/
-      `
+    `)).run(newTable.schema, newTable.name, oldTable.schema, oldTable.name);
+	}
+	drop({ schema, name }) {
+		(this.#drop ??= this.#db.prepare(`
       DELETE FROM "_zero.tableMetadata" WHERE "schema" = ? AND "table" = ?
-    `
-    )).run(schema, name);
-  }
-}
-export {
-  CREATE_TABLE_METADATA_TABLE,
-  TableMetadataTracker
+    `)).run(schema, name);
+	}
 };
-//# sourceMappingURL=table-metadata.js.map
+//#endregion
+export { CREATE_TABLE_METADATA_TABLE, TableMetadataTracker };
+
+//# sourceMappingURL=table-metadata.js.map

package/out/zero-cache/src/services/replicator/schema/table-metadata.js.map

@@ -1 +1 @@
-{"version":3,"file":"table-metadata.js","sources":["../../../../../../../zero-cache/src/services/replicator/schema/table-metadata.ts"],"sourcesContent":["import type {Database, Statement} from '../../../../../zqlite/src/db.ts';\nimport {liteTableName} from '../../../types/names.ts';\nimport type {\n  Identifier,\n  TableMetadata,\n} from '../../change-source/protocol/current.ts';\n\n/**\n * Table-level controls for handling replicated data.\n *\n * ### Columns\n *\n * `minRowVersion`: the minimum `_0_version` value to apply to\n *   all rows in the table. This overrides any per-row\n *   `_0_version` value that is smaller (i.e. earlier).\n *   The `minRowVersion` column is used to force a re-download\n *   of all rows after a table-wide schema change (by giving\n *   each row a version that's newer than what's in any CVR).\n *   The naive, brute-force method of updating all of the rows\n *   requires re-writing the entire table into the WAL as one\n *   SQLite operation, which is too costly from both latency\n *   and storage space.\n *\n * `upstreamMetadata`: the replica-level analog of tableMetadata in\n *   change-streamer/schema. Per the requirement of the backfill\n *   protocol, backfill metadata must be tracked outside of the\n *   change source (otherwise the change source would have to be\n *   able to compute the state of the metadata at arbitrary points\n *   in the past).\n *\n * `metadata`: the previous name of the `upstreamMetadata` column,\n *   kept for backwards compatibility.\n *\n * This tracking is done:\n * 1. at the Change DB level, by the change-streamer\n * 2. at the replica level, in order to support the eventual configuration\n *    of ephemeral Change DBs (on SQLite) that are initialized from data\n *    in the replica.\n */\nexport const CREATE_TABLE_METADATA_TABLE = /*sql*/ `\n  CREATE TABLE \"_zero.tableMetadata\" (\n    \"schema\"           TEXT NOT NULL,\n    \"table\"            TEXT NOT NULL,\n    \"minRowVersion\"    TEXT NOT NULL DEFAULT \"00\",\n    \"upstreamMetadata\" TEXT,\n    \"metadata\"         TEXT,  -- deprecated\n    PRIMARY KEY (\"schema\", \"table\")\n  );\n`;\n\nexport class TableMetadataTracker {\n  readonly #db: Database;\n\n  // All statements are lazily created.\n  #setUpstreamMetadata: Statement | undefined;\n  #setMinRowVersion: Statement | undefined;\n  #getMinRowVersions: Statement | undefined;\n  #rename: Statement | undefined;\n  #drop: Statement | undefined;\n\n  constructor(db: Database) {\n    this.#db = db;\n  }\n\n  setUpstreamMetadata({schema, name}: Identifier, metadata: TableMetadata) {\n    (this.#setUpstreamMetadata ??= this.#db.prepare(/*sql*/ `\n      INSERT INTO \"_zero.tableMetadata\" (\"schema\", \"table\", \"upstreamMetadata\") \n        VALUES (@schema, @name, @metadata)\n        ON CONFLICT (\"schema\", \"table\")\n        DO UPDATE SET \"upstreamMetadata\" = @metadata\n    `)).run({\n      schema,\n      name,\n      metadata: JSON.stringify(metadata),\n    });\n  }\n\n  setMinRowVersion({schema, name}: Identifier, version: string) {\n    (this.#setMinRowVersion ??= this.#db.prepare(/*sql*/ `\n      INSERT INTO \"_zero.tableMetadata\" (\"schema\", \"table\", \"minRowVersion\") \n        VALUES (@schema, @name, @version)\n        ON CONFLICT (\"schema\", \"table\")\n        DO UPDATE SET \"minRowVersion\" = @version;\n    `)).run({schema, name, version});\n  }\n\n  getMinRowVersions(): Map<string, string> {\n    const results = (this.#getMinRowVersions ??= this.#db.prepare(/*sql*/ `\n      SELECT \"schema\", \"table\" as \"name\", \"minRowVersion\" FROM \"_zero.tableMetadata\"\n    `)).all<{schema: string; name: string; minRowVersion: string}>();\n    return new Map(\n      results.map(({schema, name, minRowVersion}) => [\n        liteTableName({schema, name}),\n        minRowVersion,\n      ]),\n    );\n  }\n\n  rename(oldTable: Identifier, newTable: Identifier) {\n    (this.#rename ??= this.#db.prepare(/*sql*/ `\n      UPDATE \"_zero.tableMetadata\" SET \"schema\" = ?, \"table\" = ?\n        WHERE \"schema\" = ? AND \"table\" = ?\n    `)).run(newTable.schema, newTable.name, oldTable.schema, oldTable.name);\n  }\n\n  drop({schema, name}: Identifier) {\n    (this.#drop ??= this.#db.prepare(/*sql*/ `\n      DELETE FROM \"_zero.tableMetadata\" WHERE \"schema\" = ? AND \"table\" = ?\n    `)).run(schema, name);\n  }\n}\n"],"names":[],"mappings":";AAuCO,MAAM;AAAA;AAAA,EAAsC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAW5C,MAAM,qBAAqB;AAAA,EACvB;AAAA;AAAA,EAGT;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAEA,YAAY,IAAc;AACxB,SAAK,MAAM;AAAA,EACb;AAAA,EAEA,oBAAoB,EAAC,QAAQ,KAAA,GAAmB,UAAyB;AACvE,KAAC,KAAK,yBAAyB,KAAK,IAAI;AAAA;AAAA,MAAgB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAAA,GAKpD,IAAI;AAAA,MACN;AAAA,MACA;AAAA,MACA,UAAU,KAAK,UAAU,QAAQ;AAAA,IAAA,CAClC;AAAA,EACH;AAAA,EAEA,iBAAiB,EAAC,QAAQ,KAAA,GAAmB,SAAiB;AAC5D,KAAC,KAAK,sBAAsB,KAAK,IAAI;AAAA;AAAA,MAAgB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAAA,GAKjD,IAAI,EAAC,QAAQ,MAAM,SAAQ;AAAA,EACjC;AAAA,EAEA,oBAAyC;AACvC,UAAM,WAAW,KAAK,uBAAuB,KAAK,IAAI;AAAA;AAAA,MAAgB;AAAA;AAAA;AAAA,IAAA,GAElE,IAAA;AACJ,WAAO,IAAI;AAAA,MACT,QAAQ,IAAI,CAAC,EAAC,QAAQ,MAAM,oBAAmB;AAAA,QAC7C,cAAc,EAAC,QAAQ,MAAK;AAAA,QAC5B;AAAA,MAAA,CACD;AAAA,IAAA;AAAA,EAEL;AAAA,EAEA,OAAO,UAAsB,UAAsB;AACjD,KAAC,KAAK,YAAY,KAAK,IAAI;AAAA;AAAA,MAAgB;AAAA;AAAA;AAAA;AAAA,IAAA,GAGvC,IAAI,SAAS,QAAQ,SAAS,MAAM,SAAS,QAAQ,SAAS,IAAI;AAAA,EACxE;AAAA,EAEA,KAAK,EAAC,QAAQ,QAAmB;AAC/B,KAAC,KAAK,UAAU,KAAK,IAAI;AAAA;AAAA,MAAgB;AAAA;AAAA;AAAA,IAAA,GAErC,IAAI,QAAQ,IAAI;AAAA,EACtB;AACF;"}
+{"version":3,"file":"table-metadata.js","names":["#db","#setUpstreamMetadata","#setMinRowVersion","#getMinRowVersions","#rename","#drop"],"sources":["../../../../../../../zero-cache/src/services/replicator/schema/table-metadata.ts"],"sourcesContent":["import type {Database, Statement} from '../../../../../zqlite/src/db.ts';\nimport {liteTableName} from '../../../types/names.ts';\nimport type {\n  Identifier,\n  TableMetadata,\n} from '../../change-source/protocol/current.ts';\n\n/**\n * Table-level controls for handling replicated data.\n *\n * ### Columns\n *\n * `minRowVersion`: the minimum `_0_version` value to apply to\n *   all rows in the table. This overrides any per-row\n *   `_0_version` value that is smaller (i.e. earlier).\n *   The `minRowVersion` column is used to force a re-download\n *   of all rows after a table-wide schema change (by giving\n *   each row a version that's newer than what's in any CVR).\n *   The naive, brute-force method of updating all of the rows\n *   requires re-writing the entire table into the WAL as one\n *   SQLite operation, which is too costly from both latency\n *   and storage space.\n *\n * `upstreamMetadata`: the replica-level analog of tableMetadata in\n *   change-streamer/schema. Per the requirement of the backfill\n *   protocol, backfill metadata must be tracked outside of the\n *   change source (otherwise the change source would have to be\n *   able to compute the state of the metadata at arbitrary points\n *   in the past).\n *\n * `metadata`: the previous name of the `upstreamMetadata` column,\n *   kept for backwards compatibility.\n *\n * This tracking is done:\n * 1. at the Change DB level, by the change-streamer\n * 2. at the replica level, in order to support the eventual configuration\n *    of ephemeral Change DBs (on SQLite) that are initialized from data\n *    in the replica.\n */\nexport const CREATE_TABLE_METADATA_TABLE = /*sql*/ `\n  CREATE TABLE \"_zero.tableMetadata\" (\n    \"schema\"           TEXT NOT NULL,\n    \"table\"            TEXT NOT NULL,\n    \"minRowVersion\"    TEXT NOT NULL DEFAULT \"00\",\n    \"upstreamMetadata\" TEXT,\n    \"metadata\"         TEXT,  -- deprecated\n    PRIMARY KEY (\"schema\", \"table\")\n  );\n`;\n\nexport class TableMetadataTracker {\n  readonly #db: Database;\n\n  // All statements are lazily created.\n  #setUpstreamMetadata: Statement | undefined;\n  #setMinRowVersion: Statement | undefined;\n  #getMinRowVersions: Statement | undefined;\n  #rename: Statement | undefined;\n  #drop: Statement | undefined;\n\n  constructor(db: Database) {\n    this.#db = db;\n  }\n\n  setUpstreamMetadata({schema, name}: Identifier, metadata: TableMetadata) {\n    (this.#setUpstreamMetadata ??= this.#db.prepare(/*sql*/ `\n      INSERT INTO \"_zero.tableMetadata\" (\"schema\", \"table\", \"upstreamMetadata\") \n        VALUES (@schema, @name, @metadata)\n        ON CONFLICT (\"schema\", \"table\")\n        DO UPDATE SET \"upstreamMetadata\" = @metadata\n    `)).run({\n      schema,\n      name,\n      metadata: JSON.stringify(metadata),\n    });\n  }\n\n  setMinRowVersion({schema, name}: Identifier, version: string) {\n    (this.#setMinRowVersion ??= this.#db.prepare(/*sql*/ `\n      INSERT INTO \"_zero.tableMetadata\" (\"schema\", \"table\", \"minRowVersion\") \n        VALUES (@schema, @name, @version)\n        ON CONFLICT (\"schema\", \"table\")\n        DO UPDATE SET \"minRowVersion\" = @version;\n    `)).run({schema, name, version});\n  }\n\n  getMinRowVersions(): Map<string, string> {\n    const results = (this.#getMinRowVersions ??= this.#db.prepare(/*sql*/ `\n      SELECT \"schema\", \"table\" as \"name\", \"minRowVersion\" FROM \"_zero.tableMetadata\"\n    `)).all<{schema: string; name: string; minRowVersion: string}>();\n    return new Map(\n      results.map(({schema, name, minRowVersion}) => [\n        liteTableName({schema, name}),\n        minRowVersion,\n      ]),\n    );\n  }\n\n  rename(oldTable: Identifier, newTable: Identifier) {\n    (this.#rename ??= this.#db.prepare(/*sql*/ `\n      UPDATE \"_zero.tableMetadata\" SET \"schema\" = ?, \"table\" = ?\n        WHERE \"schema\" = ? AND \"table\" = ?\n    `)).run(newTable.schema, newTable.name, oldTable.schema, oldTable.name);\n  }\n\n  drop({schema, name}: Identifier) {\n    (this.#drop ??= this.#db.prepare(/*sql*/ `\n      DELETE FROM \"_zero.tableMetadata\" WHERE \"schema\" = ? AND \"table\" = ?\n    `)).run(schema, name);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,IAAa,8BAAsC;;;;;;;;;;AAWnD,IAAa,uBAAb,MAAkC;CAChC;CAGA;CACA;CACA;CACA;CACA;CAEA,YAAY,IAAc;AACxB,QAAA,KAAW;;CAGb,oBAAoB,EAAC,QAAQ,QAAmB,UAAyB;AACvE,GAAC,MAAA,wBAA8B,MAAA,GAAS,QAAgB;;;;;MAKtD,EAAE,IAAI;GACN;GACA;GACA,UAAU,KAAK,UAAU,SAAS;GACnC,CAAC;;CAGJ,iBAAiB,EAAC,QAAQ,QAAmB,SAAiB;AAC5D,GAAC,MAAA,qBAA2B,MAAA,GAAS,QAAgB;;;;;MAKnD,EAAE,IAAI;GAAC;GAAQ;GAAM;GAAQ,CAAC;;CAGlC,oBAAyC;EACvC,MAAM,WAAW,MAAA,sBAA4B,MAAA,GAAS,QAAgB;;MAEpE,EAAE,KAA4D;AAChE,SAAO,IAAI,IACT,QAAQ,KAAK,EAAC,QAAQ,MAAM,oBAAmB,CAC7C,cAAc;GAAC;GAAQ;GAAK,CAAC,EAC7B,cACD,CAAC,CACH;;CAGH,OAAO,UAAsB,UAAsB;AACjD,GAAC,MAAA,WAAiB,MAAA,GAAS,QAAgB;;;MAGzC,EAAE,IAAI,SAAS,QAAQ,SAAS,MAAM,SAAS,QAAQ,SAAS,KAAK;;CAGzE,KAAK,EAAC,QAAQ,QAAmB;AAC/B,GAAC,MAAA,SAAe,MAAA,GAAS,QAAgB;;MAEvC,EAAE,IAAI,QAAQ,KAAK"}

package/out/zero-cache/src/services/replicator/write-worker-client.d.ts

@@ -0,0 +1,69 @@
+import type { LogConfig } from '../../../../shared/src/logging.ts';
+import type { Database } from '../../../../zqlite/src/db.ts';
+import type { ChangeStreamData } from '../change-source/protocol/current/downstream.ts';
+import type { ChangeProcessorMode, CommitResult } from './change-processor.ts';
+import type { SubscriptionState } from './schema/replication-state.ts';
+export type PragmaConfig = {
+    busyTimeout: number;
+    analysisLimit: number;
+    walAutocheckpoint?: number | undefined;
+};
+type ErrorHandler = (err: Error) => void;
+/**
+ * Interface for a write worker that processes replication messages.
+ */
+export interface WriteWorkerClient {
+    getSubscriptionState(): Promise<SubscriptionState>;
+    processMessage(downstream: ChangeStreamData): Promise<CommitResult | null>;
+    abort(): void;
+    stop(): Promise<void>;
+    onError(handler: ErrorHandler): void;
+}
+export type ArgsMap = {
+    init: [string, ChangeProcessorMode, PragmaConfig, LogConfig];
+    getSubscriptionState: [];
+    processMessage: [ChangeStreamData];
+    abort: [];
+    stop: [];
+};
+export type Method = keyof ArgsMap;
+export type Request<M extends Method = Method> = {
+    method: M;
+    args: ArgsMap[M];
+};
+export type ResultMap = {
+    init: void;
+    getSubscriptionState: SubscriptionState;
+    processMessage: CommitResult | null;
+    abort: void;
+    stop: void;
+};
+export type Response<M extends Method = Method> = {
+    method: M;
+    result: ResultMap[M];
+    error?: undefined;
+} | {
+    method: M;
+    error: unknown;
+    result?: undefined;
+};
+export type WriteError = {
+    writeError: Error;
+};
+export declare function applyPragmas(db: Database, pragmas: PragmaConfig): void;
+/**
+ * Delegates SQLite writes to a worker_thread,
+ * keeping the main event loop free for WebSocket heartbeats and IPC.
+ */
+export declare class ThreadWriteWorkerClient implements WriteWorkerClient {
+    #private;
+    constructor();
+    init(dbPath: string, mode: ChangeProcessorMode, pragmas: PragmaConfig, logConfig: LogConfig): Promise<void>;
+    getSubscriptionState(): Promise<SubscriptionState>;
+    processMessage(downstream: ChangeStreamData): Promise<CommitResult | null>;
+    abort(): void;
+    stop(): Promise<void>;
+    onError(handler: ErrorHandler): void;
+}
+export {};
+//# sourceMappingURL=write-worker-client.d.ts.map

package/out/zero-cache/src/services/replicator/write-worker-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write-worker-client.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/replicator/write-worker-client.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,mCAAmC,CAAC;AACjE,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,8BAA8B,CAAC;AAE3D,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,iDAAiD,CAAC;AACtF,OAAO,KAAK,EAAC,mBAAmB,EAAE,YAAY,EAAC,MAAM,uBAAuB,CAAC;AAC7E,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,+BAA+B,CAAC;AAErE,MAAM,MAAM,YAAY,GAAG;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACxC,CAAC;AAEF,KAAK,YAAY,GAAG,CAAC,GAAG,EAAE,KAAK,KAAK,IAAI,CAAC;AAEzC;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,oBAAoB,IAAI,OAAO,CAAC,iBAAiB,CAAC,CAAC;IACnD,cAAc,CAAC,UAAU,EAAE,gBAAgB,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAAC;IAC3E,KAAK,IAAI,IAAI,CAAC;IACd,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB,OAAO,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI,CAAC;CACtC;AAGD,MAAM,MAAM,OAAO,GAAG;IACpB,IAAI,EAAE,CAAC,MAAM,EAAE,mBAAmB,EAAE,YAAY,EAAE,SAAS,CAAC,CAAC;IAC7D,oBAAoB,EAAE,EAAE,CAAC;IACzB,cAAc,EAAE,CAAC,gBAAgB,CAAC,CAAC;IACnC,KAAK,EAAE,EAAE,CAAC;IACV,IAAI,EAAE,EAAE,CAAC;CACV,CAAC;AAEF,MAAM,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC;AAEnC,MAAM,MAAM,OAAO,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,IAAI;IAAC,MAAM,EAAE,CAAC,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,CAAA;CAAC,CAAC;AAE/E,MAAM,MAAM,SAAS,GAAG;IACtB,IAAI,EAAE,IAAI,CAAC;IACX,oBAAoB,EAAE,iBAAiB,CAAC;IACxC,cAAc,EAAE,YAAY,GAAG,IAAI,CAAC;IACpC,KAAK,EAAE,IAAI,CAAC;IACZ,IAAI,EAAE,IAAI,CAAC;CACZ,CAAC;AAEF,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,IAC1C;IAAC,MAAM,EAAE,CAAC,CAAC;IAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IAAC,KAAK,CAAC,EAAE,SAAS,CAAA;CAAC,GACpD;IAAC,MAAM,EAAE,CAAC,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,SAAS,CAAA;CAAC,CAAC;AAEpD,MAAM,MAAM,UAAU,GAAG;IAAC,UAAU,EAAE,KAAK,CAAA;CAAC,CAAC;AAE7C,wBAAgB,YAAY,CAAC,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,YAAY,QAM/D;AAED;;;GAGG;AACH,qBAAa,uBAAwB,YAAW,iBAAiB;;;IA8D/D,IAAI,CACF,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,mBAAmB,EACzB,OAAO,EAAE,YAAY,EACrB,SAAS,EAAE,SAAS,GACnB,OAAO,CAAC,IAAI,CAAC;IAIhB,oBAAoB,IAAI,OAAO,CAAC,iBAAiB,CAAC;IAIlD,cAAc,CAAC,UAAU,EAAE,gBAAgB,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC;IAI1E,KAAK,IAAI,IAAI;IAMP,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAO3B,OAAO,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;CAGrC"}

package/out/zero-cache/src/services/replicator/write-worker-client.js

@@ -0,0 +1,96 @@
+import { assert } from "../../../../shared/src/asserts.js";
+import { WRITE_WORKER_URL } from "../../server/worker-urls.js";
+import { resolver } from "@rocicorp/resolver";
+import { Worker } from "node:worker_threads";
+//#region ../zero-cache/src/services/replicator/write-worker-client.ts
+function applyPragmas(db, pragmas) {
+	db.pragma(`busy_timeout = ${pragmas.busyTimeout}`);
+	db.pragma(`analysis_limit = ${pragmas.analysisLimit}`);
+	if (pragmas.walAutocheckpoint !== void 0) db.pragma(`wal_autocheckpoint = ${pragmas.walAutocheckpoint}`);
+}
+/**
+* Delegates SQLite writes to a worker_thread,
+* keeping the main event loop free for WebSocket heartbeats and IPC.
+*/
+var ThreadWriteWorkerClient = class {
+	#worker;
+	#pending = null;
+	#errorHandler = () => {};
+	#terminated = false;
+	constructor() {
+		this.#worker = new Worker(WRITE_WORKER_URL);
+		this.#worker.on("message", (msg) => {
+			if ("writeError" in msg) {
+				const error = msg.writeError instanceof Error ? msg.writeError : new Error(String(msg.writeError));
+				this.#rejectAll(error);
+				this.#errorHandler(error);
+				return;
+			}
+			const r = this.#pending;
+			if (!r) return;
+			this.#pending = null;
+			if (msg.error !== void 0) r.reject(msg.error instanceof Error ? msg.error : new Error(String(msg.error)));
+			else r.resolve(msg.result);
+		});
+		this.#worker.on("error", (err) => {
+			this.#rejectAll(err);
+			this.#errorHandler(err);
+		});
+		this.#worker.on("exit", (code) => {
+			this.#terminated = true;
+			if (code !== 0) {
+				const err = /* @__PURE__ */ new Error(`Worker exited with code ${code}`);
+				this.#rejectAll(err);
+				this.#errorHandler(err);
+			}
+		});
+	}
+	#rejectAll(err) {
+		const r = this.#pending;
+		if (r) {
+			this.#pending = null;
+			r.reject(err);
+		}
+	}
+	#call(method, args) {
+		assert(this.#pending === null, `concurrent call: ${method}`);
+		const r = resolver();
+		this.#pending = r;
+		this.#worker.postMessage({
+			method,
+			args
+		});
+		return r.promise;
+	}
+	init(dbPath, mode, pragmas, logConfig) {
+		return this.#call("init", [
+			dbPath,
+			mode,
+			pragmas,
+			logConfig
+		]);
+	}
+	getSubscriptionState() {
+		return this.#call("getSubscriptionState", []);
+	}
+	processMessage(downstream) {
+		return this.#call("processMessage", [downstream]);
+	}
+	abort() {
+		if (!this.#terminated) this.#worker.postMessage({
+			method: "abort",
+			args: []
+		});
+	}
+	async stop() {
+		await this.#call("stop", []);
+		if (!this.#terminated) await this.#worker.terminate();
+	}
+	onError(handler) {
+		this.#errorHandler = handler;
+	}
+};
+//#endregion
+export { ThreadWriteWorkerClient, applyPragmas };
+
+//# sourceMappingURL=write-worker-client.js.map

package/out/zero-cache/src/services/replicator/write-worker-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"write-worker-client.js","names":["#worker","#rejectAll","#errorHandler","#pending","#terminated","#call"],"sources":["../../../../../../zero-cache/src/services/replicator/write-worker-client.ts"],"sourcesContent":["import {resolver, type Resolver} from '@rocicorp/resolver';\nimport {Worker} from 'node:worker_threads';\nimport {assert} from '../../../../shared/src/asserts.ts';\nimport type {LogConfig} from '../../../../shared/src/logging.ts';\nimport type {Database} from '../../../../zqlite/src/db.ts';\nimport {WRITE_WORKER_URL} from '../../server/worker-urls.ts';\nimport type {ChangeStreamData} from '../change-source/protocol/current/downstream.ts';\nimport type {ChangeProcessorMode, CommitResult} from './change-processor.ts';\nimport type {SubscriptionState} from './schema/replication-state.ts';\n\nexport type PragmaConfig = {\n  busyTimeout: number;\n  analysisLimit: number;\n  walAutocheckpoint?: number | undefined;\n};\n\ntype ErrorHandler = (err: Error) => void;\n\n/**\n * Interface for a write worker that processes replication messages.\n */\nexport interface WriteWorkerClient {\n  getSubscriptionState(): Promise<SubscriptionState>;\n  processMessage(downstream: ChangeStreamData): Promise<CommitResult | null>;\n  abort(): void;\n  stop(): Promise<void>;\n  onError(handler: ErrorHandler): void;\n}\n\n// Wire protocol types — errors are passed directly via structured clone\nexport type ArgsMap = {\n  init: [string, ChangeProcessorMode, PragmaConfig, LogConfig];\n  getSubscriptionState: [];\n  processMessage: [ChangeStreamData];\n  abort: [];\n  stop: [];\n};\n\nexport type Method = keyof ArgsMap;\n\nexport type Request<M extends Method = Method> = {method: M; args: ArgsMap[M]};\n\nexport type ResultMap = {\n  init: void;\n  getSubscriptionState: SubscriptionState;\n  processMessage: CommitResult | null;\n  abort: void;\n  stop: void;\n};\n\nexport type Response<M extends Method = Method> =\n  | {method: M; result: ResultMap[M]; error?: undefined}\n  | {method: M; error: unknown; result?: undefined};\n\nexport type WriteError = {writeError: Error};\n\nexport function applyPragmas(db: Database, pragmas: PragmaConfig) {\n  db.pragma(`busy_timeout = ${pragmas.busyTimeout}`);\n  db.pragma(`analysis_limit = ${pragmas.analysisLimit}`);\n  if (pragmas.walAutocheckpoint !== undefined) {\n    db.pragma(`wal_autocheckpoint = ${pragmas.walAutocheckpoint}`);\n  }\n}\n\n/**\n * Delegates SQLite writes to a worker_thread,\n * keeping the main event loop free for WebSocket heartbeats and IPC.\n */\nexport class ThreadWriteWorkerClient implements WriteWorkerClient {\n  readonly #worker: Worker;\n  #pending: Resolver<unknown, Error> | null = null;\n  #errorHandler: ErrorHandler = () => {};\n  #terminated = false;\n\n  constructor() {\n    this.#worker = new Worker(WRITE_WORKER_URL);\n\n    this.#worker.on('message', (msg: Response | WriteError) => {\n      if ('writeError' in msg) {\n        const error =\n          msg.writeError instanceof Error\n            ? msg.writeError\n            : new Error(String(msg.writeError));\n        this.#rejectAll(error);\n        this.#errorHandler(error);\n        return;\n      }\n      const r = this.#pending;\n      if (!r) return; // stale abort response\n      this.#pending = null;\n      if (msg.error !== undefined) {\n        r.reject(\n          msg.error instanceof Error ? msg.error : new Error(String(msg.error)),\n        );\n      } else {\n        r.resolve(msg.result);\n      }\n    });\n\n    this.#worker.on('error', (err: Error) => {\n      this.#rejectAll(err);\n      this.#errorHandler(err);\n    });\n\n    this.#worker.on('exit', (code: number) => {\n      this.#terminated = true;\n      if (code !== 0) {\n        const err = new Error(`Worker exited with code ${code}`);\n        this.#rejectAll(err);\n        this.#errorHandler(err);\n      }\n    });\n  }\n\n  #rejectAll(err: Error) {\n    const r = this.#pending;\n    if (r) {\n      this.#pending = null;\n      r.reject(err);\n    }\n  }\n\n  #call<M extends Method>(method: M, args: ArgsMap[M]): Promise<ResultMap[M]> {\n    assert(this.#pending === null, `concurrent call: ${method}`);\n    const r = resolver<ResultMap[M]>();\n    this.#pending = r as Resolver<unknown, Error>;\n    this.#worker.postMessage({method, args} satisfies Request);\n    return r.promise;\n  }\n\n  init(\n    dbPath: string,\n    mode: ChangeProcessorMode,\n    pragmas: PragmaConfig,\n    logConfig: LogConfig,\n  ): Promise<void> {\n    return this.#call('init', [dbPath, mode, pragmas, logConfig]);\n  }\n\n  getSubscriptionState(): Promise<SubscriptionState> {\n    return this.#call('getSubscriptionState', []);\n  }\n\n  processMessage(downstream: ChangeStreamData): Promise<CommitResult | null> {\n    return this.#call('processMessage', [downstream]);\n  }\n\n  abort(): void {\n    if (!this.#terminated) {\n      this.#worker.postMessage({method: 'abort', args: []} satisfies Request);\n    }\n  }\n\n  async stop(): Promise<void> {\n    await this.#call('stop', []);\n    if (!this.#terminated) {\n      await this.#worker.terminate();\n    }\n  }\n\n  onError(handler: ErrorHandler): void {\n    this.#errorHandler = handler;\n  }\n}\n"],"mappings":";;;;;AAwDA,SAAgB,aAAa,IAAc,SAAuB;AAChE,IAAG,OAAO,kBAAkB,QAAQ,cAAc;AAClD,IAAG,OAAO,oBAAoB,QAAQ,gBAAgB;AACtD,KAAI,QAAQ,sBAAsB,KAAA,EAChC,IAAG,OAAO,wBAAwB,QAAQ,oBAAoB;;;;;;AAQlE,IAAa,0BAAb,MAAkE;CAChE;CACA,WAA4C;CAC5C,sBAAoC;CACpC,cAAc;CAEd,cAAc;AACZ,QAAA,SAAe,IAAI,OAAO,iBAAiB;AAE3C,QAAA,OAAa,GAAG,YAAY,QAA+B;AACzD,OAAI,gBAAgB,KAAK;IACvB,MAAM,QACJ,IAAI,sBAAsB,QACtB,IAAI,aACJ,IAAI,MAAM,OAAO,IAAI,WAAW,CAAC;AACvC,UAAA,UAAgB,MAAM;AACtB,UAAA,aAAmB,MAAM;AACzB;;GAEF,MAAM,IAAI,MAAA;AACV,OAAI,CAAC,EAAG;AACR,SAAA,UAAgB;AAChB,OAAI,IAAI,UAAU,KAAA,EAChB,GAAE,OACA,IAAI,iBAAiB,QAAQ,IAAI,QAAQ,IAAI,MAAM,OAAO,IAAI,MAAM,CAAC,CACtE;OAED,GAAE,QAAQ,IAAI,OAAO;IAEvB;AAEF,QAAA,OAAa,GAAG,UAAU,QAAe;AACvC,SAAA,UAAgB,IAAI;AACpB,SAAA,aAAmB,IAAI;IACvB;AAEF,QAAA,OAAa,GAAG,SAAS,SAAiB;AACxC,SAAA,aAAmB;AACnB,OAAI,SAAS,GAAG;IACd,MAAM,sBAAM,IAAI,MAAM,2BAA2B,OAAO;AACxD,UAAA,UAAgB,IAAI;AACpB,UAAA,aAAmB,IAAI;;IAEzB;;CAGJ,WAAW,KAAY;EACrB,MAAM,IAAI,MAAA;AACV,MAAI,GAAG;AACL,SAAA,UAAgB;AAChB,KAAE,OAAO,IAAI;;;CAIjB,MAAwB,QAAW,MAAyC;AAC1E,SAAO,MAAA,YAAkB,MAAM,oBAAoB,SAAS;EAC5D,MAAM,IAAI,UAAwB;AAClC,QAAA,UAAgB;AAChB,QAAA,OAAa,YAAY;GAAC;GAAQ;GAAK,CAAmB;AAC1D,SAAO,EAAE;;CAGX,KACE,QACA,MACA,SACA,WACe;AACf,SAAO,MAAA,KAAW,QAAQ;GAAC;GAAQ;GAAM;GAAS;GAAU,CAAC;;CAG/D,uBAAmD;AACjD,SAAO,MAAA,KAAW,wBAAwB,EAAE,CAAC;;CAG/C,eAAe,YAA4D;AACzE,SAAO,MAAA,KAAW,kBAAkB,CAAC,WAAW,CAAC;;CAGnD,QAAc;AACZ,MAAI,CAAC,MAAA,WACH,OAAA,OAAa,YAAY;GAAC,QAAQ;GAAS,MAAM,EAAE;GAAC,CAAmB;;CAI3E,MAAM,OAAsB;AAC1B,QAAM,MAAA,KAAW,QAAQ,EAAE,CAAC;AAC5B,MAAI,CAAC,MAAA,WACH,OAAM,MAAA,OAAa,WAAW;;CAIlC,QAAQ,SAA6B;AACnC,QAAA,eAAqB"}