@rocicorp/zero 0.26.1-canary.9 → 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.d.ts

@@ -1,11 +1,30 @@
 import type { Database } from '../../../../../zqlite/src/db.ts';
 import type { Identifier, TableMetadata } from '../../change-source/protocol/current.ts';
 /**
- * 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).
+ * 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
@@ -13,11 +32,13 @@ import type { Identifier, TableMetadata } from '../../change-source/protocol/cur
  *    of ephemeral Change DBs (on SQLite) that are initialized from data
  *    in the replica.
  */
-export declare const CREATE_TABLE_METADATA_TABLE = "\n  CREATE TABLE \"_zero.tableMetadata\" (\n    \"schema\"   TEXT NOT NULL,\n    \"table\"    TEXT NOT NULL,\n    \"metadata\" TEXT NOT NULL,\n    PRIMARY KEY (\"schema\", \"table\")\n  );\n";
+export declare const CREATE_TABLE_METADATA_TABLE = "\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";
 export declare class TableMetadataTracker {
     #private;
     constructor(db: Database);
-    set({ schema, name }: Identifier, metadata: TableMetadata): void;
+    setUpstreamMetadata({ schema, name }: Identifier, metadata: TableMetadata): void;
+    setMinRowVersion({ schema, name }: Identifier, version: string): void;
+    getMinRowVersions(): Map<string, string>;
     rename(oldTable: Identifier, newTable: Identifier): void;
     drop({ schema, name }: Identifier): void;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"table-metadata.d.ts","sourceRoot":"","sources":["../../../../../../../zero-cache/src/services/replicator/schema/table-metadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,QAAQ,EAAY,MAAM,iCAAiC,CAAC;AACzE,OAAO,KAAK,EACV,UAAU,EACV,aAAa,EACd,MAAM,yCAAyC,CAAC;AAEjD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,2BAA2B,mMAOvC,CAAC;AAEF,qBAAa,oBAAoB;;gBAKnB,EAAE,EAAE,QAAQ;IAcxB,GAAG,CAAC,EAAC,MAAM,EAAE,IAAI,EAAC,EAAE,UAAU,EAAE,QAAQ,EAAE,aAAa;IAIvD,MAAM,CAAC,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,UAAU;IASjD,IAAI,CAAC,EAAC,MAAM,EAAE,IAAI,EAAC,EAAE,UAAU;CAGhC"}
+{"version":3,"file":"table-metadata.d.ts","sourceRoot":"","sources":["../../../../../../../zero-cache/src/services/replicator/schema/table-metadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,QAAQ,EAAY,MAAM,iCAAiC,CAAC;AAEzE,OAAO,KAAK,EACV,UAAU,EACV,aAAa,EACd,MAAM,yCAAyC,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,2BAA2B,yTASvC,CAAC;AAEF,qBAAa,oBAAoB;;gBAUnB,EAAE,EAAE,QAAQ;IAIxB,mBAAmB,CAAC,EAAC,MAAM,EAAE,IAAI,EAAC,EAAE,UAAU,EAAE,QAAQ,EAAE,aAAa;IAavE,gBAAgB,CAAC,EAAC,MAAM,EAAE,IAAI,EAAC,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM;IAS5D,iBAAiB,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IAYxC,MAAM,CAAC,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,UAAU;IAOjD,IAAI,CAAC,EAAC,MAAM,EAAE,IAAI,EAAC,EAAE,UAAU;CAKhC"}

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

@@ -1,57 +1,103 @@
-const CREATE_TABLE_METADATA_TABLE = (
-  /*sql*/
-  `
+import { liteTableName } from "../../../types/names.js";
+//#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,
-    "metadata" TEXT NOT NULL,
+    "schema"           TEXT NOT NULL,
+    "table"            TEXT NOT NULL,
+    "minRowVersion"    TEXT NOT NULL DEFAULT "00",
+    "upstreamMetadata" TEXT,
+    "metadata"         TEXT,  -- deprecated
     PRIMARY KEY ("schema", "table")
   );
-`
-);
-class TableMetadataTracker {
-  #set;
-  #rename;
-  #drop;
-  constructor(db) {
-    this.#set = db.prepare(
-      /*sql*/
-      `
-      INSERT OR REPLACE INTO "_zero.tableMetadata"
-        ("schema", "table", "metadata") VALUES (?, ?, ?);
-    `
-    );
-    this.#rename = 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(`
+      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(`
+      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(`
       UPDATE "_zero.tableMetadata" SET "schema" = ?, "table" = ?
         WHERE "schema" = ? AND "table" = ?
-    `
-    );
-    this.#drop = 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" = ?
-    `
-    );
-  }
-  set({ schema, name }, metadata) {
-    this.#set.run(schema, name, JSON.stringify(metadata));
-  }
-  rename(oldTable, newTable) {
-    this.#rename.run(
-      newTable.schema,
-      newTable.name,
-      oldTable.schema,
-      oldTable.name
-    );
-  }
-  drop({ schema, name }) {
-    this.#drop.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 type {\n  Identifier,\n  TableMetadata,\n} from '../../change-source/protocol/current.ts';\n\n/**\n * Replica-level analog of tableMetadata in change-streamer/schema.\n * Per the requirement of the backfill protocol, backfill metadata\n * must be tracked outside of the change source (otherwise the change\n * source would have to be able to compute the state of the metadata at\n * arbitrary points in the past).\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    \"metadata\" TEXT NOT NULL,\n    PRIMARY KEY (\"schema\", \"table\")\n  );\n`;\n\nexport class TableMetadataTracker {\n  readonly #set: Statement;\n  readonly #rename: Statement;\n  readonly #drop: Statement;\n\n  constructor(db: Database) {\n    this.#set = db.prepare(/*sql*/ `\n      INSERT OR REPLACE INTO \"_zero.tableMetadata\"\n        (\"schema\", \"table\", \"metadata\") VALUES (?, ?, ?);\n    `);\n    this.#rename = db.prepare(/*sql*/ `\n      UPDATE \"_zero.tableMetadata\" SET \"schema\" = ?, \"table\" = ?\n        WHERE \"schema\" = ? AND \"table\" = ?\n    `);\n    this.#drop = db.prepare(/*sql*/ `\n      DELETE FROM \"_zero.tableMetadata\" WHERE \"schema\" = ? AND \"table\" = ?\n    `);\n  }\n\n  set({schema, name}: Identifier, metadata: TableMetadata) {\n    this.#set.run(schema, name, JSON.stringify(metadata));\n  }\n\n  rename(oldTable: Identifier, newTable: Identifier) {\n    this.#rename.run(\n      newTable.schema,\n      newTable.name,\n      oldTable.schema,\n      oldTable.name,\n    );\n  }\n\n  drop({schema, name}: Identifier) {\n    this.#drop.run(schema, name);\n  }\n}\n"],"names":[],"mappings":"AAmBO,MAAM;AAAA;AAAA,EAAsC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAS5C,MAAM,qBAAqB;AAAA,EACvB;AAAA,EACA;AAAA,EACA;AAAA,EAET,YAAY,IAAc;AACxB,SAAK,OAAO,GAAG;AAAA;AAAA,MAAgB;AAAA;AAAA;AAAA;AAAA,IAAA;AAI/B,SAAK,UAAU,GAAG;AAAA;AAAA,MAAgB;AAAA;AAAA;AAAA;AAAA,IAAA;AAIlC,SAAK,QAAQ,GAAG;AAAA;AAAA,MAAgB;AAAA;AAAA;AAAA,IAAA;AAAA,EAGlC;AAAA,EAEA,IAAI,EAAC,QAAQ,KAAA,GAAmB,UAAyB;AACvD,SAAK,KAAK,IAAI,QAAQ,MAAM,KAAK,UAAU,QAAQ,CAAC;AAAA,EACtD;AAAA,EAEA,OAAO,UAAsB,UAAsB;AACjD,SAAK,QAAQ;AAAA,MACX,SAAS;AAAA,MACT,SAAS;AAAA,MACT,SAAS;AAAA,MACT,SAAS;AAAA,IAAA;AAAA,EAEb;AAAA,EAEA,KAAK,EAAC,QAAQ,QAAmB;AAC/B,SAAK,MAAM,IAAI,QAAQ,IAAI;AAAA,EAC7B;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":"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"}