@rocicorp/zero 0.26.1-canary.9 → 0.26.2-canary.1

package/out/zero-cache/src/services/replicator/schema/change-log.js

@@ -1,36 +1,7 @@
-import { parse as parse$1, stringify, jsonObjectSchema } from "../../../../../shared/src/bigint-json.js";
-import { literalUnion, parse } from "../../../../../shared/src/valita.js";
+import { literalUnion, parse, valita_exports } from "../../../../../shared/src/valita.js";
+import { jsonObjectSchema, parse as parse$1, stringify } from "../../../../../shared/src/bigint-json.js";
 import { normalizedKeyOrder } from "../../../types/row-key.js";
-import { object, string, record } from "@badrap/valita";
-const SET_OP = "s";
-const DEL_OP = "d";
-const TRUNCATE_OP = "t";
-const RESET_OP = "r";
-const CREATE_CHANGELOG_SCHEMA = (
-  // stateVersion : a.k.a. row version
-  // pos          : order in which to process the change (within the version)
-  // table        : The table associated with the change
-  // rowKey       : JSON row key for a row change. For table-wide changes RESET
-  //                and TRUNCATE, there is no associated row; instead, `pos` is
-  //                set to -1 and the rowKey is set to the stateVersion,
-  //                guaranteeing when attempting to process the transaction,
-  //                the pipeline is reset (and the change log traversal
-  //                aborted).
-  // op           : 's' for set (insert/update)
-  //              : 'd' for delete
-  //              : 'r' for table reset (schema change)
-  //              : 't' for table truncation (which also resets the pipeline)
-  // backfillingColumnVersions
-  //              : A JSON mapping from column name to stateVersion tracked
-  //                for replicated writes of columns that are being backfilled.
-  //                This is used to prevent backfill data, which is at a
-  //                fixed snapshot/version outside of the replication stream,
-  //                from overwriting newer column values.
-  //
-  // Naming note: To maintain compatibility between a new replication-manager
-  // and old view-syncers, the previous _zero.changeLog table is preserved
-  // and its replacement given a new name "changeLog2".
-  `
+var CREATE_CHANGELOG_SCHEMA = `
   CREATE TABLE "_zero.changeLog2" (
     "stateVersion"              TEXT NOT NULL,
     "pos"                       INT  NOT NULL,
@@ -41,42 +12,41 @@ const CREATE_CHANGELOG_SCHEMA = (
     PRIMARY KEY("stateVersion", "pos"),
     UNIQUE("table", "rowKey")
   );
-  `
-);
-const changeLogEntrySchema = object({
-  stateVersion: string(),
-  table: string(),
-  rowKey: string(),
-  op: literalUnion(SET_OP, DEL_OP, TRUNCATE_OP, RESET_OP)
+  `;
+/**
+* Contains the changeLog fields relevant for computing the diff between
+* two snapshots of a replica. The `pos` and `backfillingColumnVersions`
+* fields are excluded, though the query should be ordered by
+* `<stateVersion, pos>`.
+*/
+var changeLogEntrySchema = valita_exports.object({
+	stateVersion: valita_exports.string(),
+	table: valita_exports.string(),
+	rowKey: valita_exports.string(),
+	op: literalUnion("s", "d", "t", "r")
 }).map((val) => ({
-  ...val,
-  // Note: sets the rowKey to `null` for table-wide ops / resets
-  rowKey: val.op === "t" || val.op === "r" ? null : parse(parse$1(val.rowKey), jsonObjectSchema)
+	...val,
+	rowKey: val.op === "t" || val.op === "r" ? null : parse(parse$1(val.rowKey), jsonObjectSchema)
 }));
-const rawChangeLogEntrySchema = object({
-  stateVersion: string(),
-  table: string(),
-  rowKey: string(),
-  op: literalUnion(SET_OP, DEL_OP, TRUNCATE_OP, RESET_OP),
-  backfillingColumnVersions: string().map((val) => record(string()).parse(JSON.parse(val)))
+var rawChangeLogEntrySchema = valita_exports.object({
+	stateVersion: valita_exports.string(),
+	table: valita_exports.string(),
+	rowKey: valita_exports.string(),
+	op: literalUnion("s", "d", "t", "r"),
+	backfillingColumnVersions: valita_exports.string().map((val) => valita_exports.record(valita_exports.string()).parse(JSON.parse(val)))
 });
-class ChangeLog {
-  #logRowOpStmt;
-  #logRowOpWithBackfillStmt;
-  #logTableWideOpStmt;
-  #getRowOpStmt;
-  constructor(db) {
-    this.#logRowOpStmt = db.prepare(
-      /*sql*/
-      `
+var ChangeLog = class {
+	#logRowOpStmt;
+	#logRowOpWithBackfillStmt;
+	#logTableWideOpStmt;
+	#getRowOpStmt;
+	constructor(db) {
+		this.#logRowOpStmt = db.prepare(`
       INSERT OR REPLACE INTO "_zero.changeLog2" 
         (stateVersion, pos, "table", rowKey, op)
         VALUES (@version, @pos, @table, JSON(@rowKey), @op)
-    `
-    );
-    this.#logRowOpWithBackfillStmt = db.prepare(
-      /*sql*/
-      `
+    `);
+		this.#logRowOpWithBackfillStmt = db.prepare(`
       INSERT INTO "_zero.changeLog2" 
         (stateVersion, pos, "table", rowKey, op, backfillingColumnVersions)
         VALUES (@version, @pos, @table, JSON(@rowKey), @op, 
@@ -87,79 +57,77 @@ class ChangeLog {
                                  op = excluded.op,
           backfillingColumnVersions = json_patch(
           backfillingColumnVersions, excluded.backfillingColumnVersions)
-    `
-    );
-    this.#logTableWideOpStmt = db.prepare(
-      /*sql*/
-      `
+    `);
+		this.#logTableWideOpStmt = db.prepare(`
       INSERT OR REPLACE INTO "_zero.changeLog2" 
         (stateVersion, pos, "table", rowKey, op) 
         VALUES (@version, -1, @table, @version, @op)
-    `
-    );
-    this.#getRowOpStmt = db.prepare(
-      /*sql*/
-      `
+    `);
+		this.#getRowOpStmt = db.prepare(`
       SELECT * FROM "_zero.changeLog2" WHERE "table" = ? AND "rowKey" = JSON(?)
-    `
-    );
-  }
-  /**
-   *
-   * @param backfilled The backfilling columns for which values were set. Note
-   *   that an empty list and the `undefined` value mean different things;
-   *   * An empty list indicates that a backfill is in progress but no
-   *     backfilling values were set. In this case, existing
-   *     backfillingColumnVersions are preserved.
-   *   * `undefined` indicates that there are no columns being backfilled.
-   *     In this case, any vestigial `backfillingColumnVersions` value
-   *     is cleared.
-   */
-  logSetOp(version, pos, table, row, backfilled) {
-    return this.#logRowOp(version, pos, table, row, SET_OP, backfilled);
-  }
-  logDeleteOp(version, pos, table, row) {
-    return this.#logRowOp(version, pos, table, row, DEL_OP, void 0);
-  }
-  getLatestRowOp(table, row) {
-    const rowKey = stringify(normalizedKeyOrder(row));
-    const result = this.#getRowOpStmt.get(table, rowKey);
-    return result === void 0 ? void 0 : parse(result, rawChangeLogEntrySchema, "passthrough");
-  }
-  #logRowOp(version, pos, table, row, op, backfilled) {
-    const rowKey = stringify(normalizedKeyOrder(row));
-    if (backfilled === void 0) {
-      this.#logRowOpStmt.run({ version, pos, table, rowKey, op });
-    } else {
-      const versions = {};
-      for (const col of backfilled) {
-        versions[col] = version;
-      }
-      this.#logRowOpWithBackfillStmt.run({
-        version,
-        pos,
-        table,
-        rowKey,
-        op,
-        backfillingColumnVersions: JSON.stringify(versions)
-      });
-    }
-    return rowKey;
-  }
-  logTruncateOp(version, table) {
-    this.#logTableWideOpStmt.run({ version, table, op: TRUNCATE_OP });
-  }
-  logResetOp(version, table) {
-    this.#logTableWideOpStmt.run({ version, table, op: RESET_OP });
-  }
-}
-export {
-  CREATE_CHANGELOG_SCHEMA,
-  ChangeLog,
-  DEL_OP,
-  RESET_OP,
-  SET_OP,
-  TRUNCATE_OP,
-  changeLogEntrySchema
+    `);
+	}
+	/**
+	*
+	* @param backfilled The backfilling columns for which values were set. Note
+	*   that an empty list and the `undefined` value mean different things;
+	*   * An empty list indicates that a backfill is in progress but no
+	*     backfilling values were set. In this case, existing
+	*     backfillingColumnVersions are preserved.
+	*   * `undefined` indicates that there are no columns being backfilled.
+	*     In this case, any vestigial `backfillingColumnVersions` value
+	*     is cleared.
+	*/
+	logSetOp(version, pos, table, row, backfilled) {
+		return this.#logRowOp(version, pos, table, row, "s", backfilled);
+	}
+	logDeleteOp(version, pos, table, row) {
+		return this.#logRowOp(version, pos, table, row, "d", void 0);
+	}
+	getLatestRowOp(table, row) {
+		const rowKey = stringify(normalizedKeyOrder(row));
+		const result = this.#getRowOpStmt.get(table, rowKey);
+		return result === void 0 ? void 0 : parse(result, rawChangeLogEntrySchema, "passthrough");
+	}
+	#logRowOp(version, pos, table, row, op, backfilled) {
+		const rowKey = stringify(normalizedKeyOrder(row));
+		if (backfilled === void 0) this.#logRowOpStmt.run({
+			version,
+			pos,
+			table,
+			rowKey,
+			op
+		});
+		else {
+			const versions = {};
+			for (const col of backfilled) versions[col] = version;
+			this.#logRowOpWithBackfillStmt.run({
+				version,
+				pos,
+				table,
+				rowKey,
+				op,
+				backfillingColumnVersions: JSON.stringify(versions)
+			});
+		}
+		return rowKey;
+	}
+	logTruncateOp(version, table) {
+		this.#logTableWideOpStmt.run({
+			version,
+			table,
+			op: "t"
+		});
+	}
+	logResetOp(version, table) {
+		this.#logTableWideOpStmt.run({
+			version,
+			table,
+			op: "r"
+		});
+	}
 };
-//# sourceMappingURL=change-log.js.map
+//#endregion
+export { CREATE_CHANGELOG_SCHEMA, ChangeLog, changeLogEntrySchema };
+
+//# sourceMappingURL=change-log.js.map

package/out/zero-cache/src/services/replicator/schema/change-log.js.map

@@ -1 +1 @@
-{"version":3,"file":"change-log.js","sources":["../../../../../../../zero-cache/src/services/replicator/schema/change-log.ts"],"sourcesContent":["import {\n  jsonObjectSchema,\n  parse,\n  stringify,\n} from '../../../../../shared/src/bigint-json.ts';\nimport * as v from '../../../../../shared/src/valita.ts';\nimport type {Database, Statement} from '../../../../../zqlite/src/db.ts';\nimport type {LexiVersion} from '../../../types/lexi-version.ts';\nimport type {LiteRowKey} from '../../../types/lite.ts';\nimport {normalizedKeyOrder} from '../../../types/row-key.ts';\n\n/**\n * The Change Log tracks the last operation (set or delete) for each row in the\n * data base, ordered by state version; in other words, a cross-table\n * index of row changes ordered by version. This facilitates a minimal \"diff\"\n * of row changes needed to advance a pipeline from one state version to another.\n *\n * The Change Log stores identifiers only, i.e. it does not store contents.\n * A database snapshot at the previous version can be used to query a row's\n * old contents, if any, and the current snapshot can be used to query a row's\n * new contents. (In the common case, the new contents will have just been applied\n * and thus has a high likelihood of being in the SQLite cache.)\n *\n * There are two table-wide operations:\n * - `t` corresponds to the postgres `TRUNCATE` operation\n * - `r` represents any schema (i.e. column) change\n *\n * For both operations, the corresponding row changes are not explicitly included\n * in the change log. The consumer has the option of simulating them be reading\n * from pre- and post- snapshots, or resetting their state entirely with the current\n * snapshot.\n *\n * To achieve the desired ordering semantics when processing tables that have been\n * truncated, reset, and modified, the \"rowKey\" is set to `null` for resets and\n * the empty string `\"\"` for truncates. This means that resets will be encountered\n * before truncates, which will be processed before any subsequent row changes.\n *\n * This ordering is chosen because resets are currently the more \"destructive\" op\n * and result in aborting the processing (and starting from scratch); doing this\n * earlier reduces wasted work.\n */\n\nexport const SET_OP = 's';\nexport const DEL_OP = 'd';\nexport const TRUNCATE_OP = 't';\nexport const RESET_OP = 'r';\n\n// Exported for testing (and migrations)\nexport const CREATE_CHANGELOG_SCHEMA =\n  // stateVersion : a.k.a. row version\n  // pos          : order in which to process the change (within the version)\n  // table        : The table associated with the change\n  // rowKey       : JSON row key for a row change. For table-wide changes RESET\n  //                and TRUNCATE, there is no associated row; instead, `pos` is\n  //                set to -1 and the rowKey is set to the stateVersion,\n  //                guaranteeing when attempting to process the transaction,\n  //                the pipeline is reset (and the change log traversal\n  //                aborted).\n  // op           : 's' for set (insert/update)\n  //              : 'd' for delete\n  //              : 'r' for table reset (schema change)\n  //              : 't' for table truncation (which also resets the pipeline)\n  // backfillingColumnVersions\n  //              : A JSON mapping from column name to stateVersion tracked\n  //                for replicated writes of columns that are being backfilled.\n  //                This is used to prevent backfill data, which is at a\n  //                fixed snapshot/version outside of the replication stream,\n  //                from overwriting newer column values.\n  //\n  // Naming note: To maintain compatibility between a new replication-manager\n  // and old view-syncers, the previous _zero.changeLog table is preserved\n  // and its replacement given a new name \"changeLog2\".\n  `\n  CREATE TABLE \"_zero.changeLog2\" (\n    \"stateVersion\"              TEXT NOT NULL,\n    \"pos\"                       INT  NOT NULL,\n    \"table\"                     TEXT NOT NULL,\n    \"rowKey\"                    TEXT NOT NULL,\n    \"op\"                        TEXT NOT NULL,\n    \"backfillingColumnVersions\" TEXT DEFAULT '{}',\n    PRIMARY KEY(\"stateVersion\", \"pos\"),\n    UNIQUE(\"table\", \"rowKey\")\n  );\n  `;\n\n/**\n * Contains the changeLog fields relevant for computing the diff between\n * two snapshots of a replica. The `pos` and `backfillingColumnVersions`\n * fields are excluded, though the query should be ordered by\n * `<stateVersion, pos>`.\n */\nexport const changeLogEntrySchema = v\n  .object({\n    stateVersion: v.string(),\n    table: v.string(),\n    rowKey: v.string(),\n    op: v.literalUnion(SET_OP, DEL_OP, TRUNCATE_OP, RESET_OP),\n  })\n  .map(val => ({\n    ...val,\n    // Note: sets the rowKey to `null` for table-wide ops / resets\n    rowKey:\n      val.op === 't' || val.op === 'r'\n        ? null\n        : v.parse(parse(val.rowKey), jsonObjectSchema),\n  }));\n\nexport type ChangeLogEntry = v.Infer<typeof changeLogEntrySchema>;\n\nconst rawChangeLogEntrySchema = v.object({\n  stateVersion: v.string(),\n  table: v.string(),\n  rowKey: v.string(),\n  op: v.literalUnion(SET_OP, DEL_OP, TRUNCATE_OP, RESET_OP),\n  backfillingColumnVersions: v\n    .string()\n    .map(val => v.record(v.string()).parse(JSON.parse(val))),\n});\n\nexport type RawChangeLogEntry = v.Infer<typeof rawChangeLogEntrySchema>;\n\nexport class ChangeLog {\n  readonly #logRowOpStmt: Statement;\n  readonly #logRowOpWithBackfillStmt: Statement;\n  readonly #logTableWideOpStmt;\n  readonly #getRowOpStmt: Statement;\n\n  constructor(db: Database) {\n    this.#logRowOpStmt = db.prepare(/*sql*/ `\n      INSERT OR REPLACE INTO \"_zero.changeLog2\" \n        (stateVersion, pos, \"table\", rowKey, op)\n        VALUES (@version, @pos, @table, JSON(@rowKey), @op)\n    `);\n\n    this.#logRowOpWithBackfillStmt = db.prepare(/*sql*/ `\n      INSERT INTO \"_zero.changeLog2\" \n        (stateVersion, pos, \"table\", rowKey, op, backfillingColumnVersions)\n        VALUES (@version, @pos, @table, JSON(@rowKey), @op, \n                JSON(@backfillingColumnVersions))\n        ON CONFLICT (\"table\", rowKey) DO UPDATE \n                   SET stateVersion = excluded.stateVersion,\n                                pos = excluded.pos,\n                                 op = excluded.op,\n          backfillingColumnVersions = json_patch(\n          backfillingColumnVersions, excluded.backfillingColumnVersions)\n    `);\n\n    // Because table-wide ops result in aborting an incremental update\n    // and rehydrating all queries at \"head\", they are assigned pos = -1\n    // as an optimization to abort as early as possible to skip unnecessary\n    // updates.\n    //\n    // However, changeLog entries that are destined to be \"skipped\" are\n    // nonetheless kept for the purpose of tracking backfillingColumnVersions.\n    this.#logTableWideOpStmt = db.prepare(/*sql*/ `\n      INSERT OR REPLACE INTO \"_zero.changeLog2\" \n        (stateVersion, pos, \"table\", rowKey, op) \n        VALUES (@version, -1, @table, @version, @op)\n    `);\n\n    this.#getRowOpStmt = db.prepare(/*sql*/ `\n      SELECT * FROM \"_zero.changeLog2\" WHERE \"table\" = ? AND \"rowKey\" = JSON(?)\n    `);\n  }\n\n  /**\n   *\n   * @param backfilled The backfilling columns for which values were set. Note\n   *   that an empty list and the `undefined` value mean different things;\n   *   * An empty list indicates that a backfill is in progress but no\n   *     backfilling values were set. In this case, existing\n   *     backfillingColumnVersions are preserved.\n   *   * `undefined` indicates that there are no columns being backfilled.\n   *     In this case, any vestigial `backfillingColumnVersions` value\n   *     is cleared.\n   */\n  logSetOp(\n    version: LexiVersion,\n    pos: number,\n    table: string,\n    row: LiteRowKey,\n    backfilled: string[] | undefined,\n  ): string {\n    return this.#logRowOp(version, pos, table, row, SET_OP, backfilled);\n  }\n\n  logDeleteOp(\n    version: LexiVersion,\n    pos: number,\n    table: string,\n    row: LiteRowKey,\n  ): string {\n    // Note: For delete ops, it is always safe to clear the\n    //       backfillingColumnVersions because the backfill algorithm\n    //       understands that deletes apply to the whole row.\n    return this.#logRowOp(version, pos, table, row, DEL_OP, undefined);\n  }\n\n  getLatestRowOp(table: string, row: LiteRowKey) {\n    const rowKey = stringify(normalizedKeyOrder(row));\n    const result = this.#getRowOpStmt.get(table, rowKey);\n    return result === undefined\n      ? undefined\n      : v.parse(result, rawChangeLogEntrySchema, 'passthrough');\n  }\n\n  #logRowOp(\n    version: LexiVersion,\n    pos: number,\n    table: string,\n    row: LiteRowKey,\n    op: string,\n    backfilled: string[] | undefined,\n  ): string {\n    const rowKey = stringify(normalizedKeyOrder(row));\n    if (backfilled === undefined) {\n      this.#logRowOpStmt.run({version, pos, table, rowKey, op});\n    } else {\n      const versions: Record<string, string> = {};\n      for (const col of backfilled) {\n        versions[col] = version;\n      }\n      this.#logRowOpWithBackfillStmt.run({\n        version,\n        pos,\n        table,\n        rowKey,\n        op,\n        backfillingColumnVersions: JSON.stringify(versions),\n      });\n    }\n    return rowKey;\n  }\n\n  logTruncateOp(version: LexiVersion, table: string) {\n    this.#logTableWideOpStmt.run({version, table, op: TRUNCATE_OP});\n  }\n\n  logResetOp(version: LexiVersion, table: string) {\n    this.#logTableWideOpStmt.run({version, table, op: RESET_OP});\n  }\n}\n"],"names":["v.object","v.string","v.literalUnion","v.parse","parse","v.record"],"mappings":";;;;AA0CO,MAAM,SAAS;AACf,MAAM,SAAS;AACf,MAAM,cAAc;AACpB,MAAM,WAAW;AAGjB,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAwBX;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAmBK,MAAM,uBAAuBA,OAC1B;AAAA,EACN,cAAcC,OAAE;AAAA,EAChB,OAAOA,OAAE;AAAA,EACT,QAAQA,OAAE;AAAA,EACV,IAAIC,aAAe,QAAQ,QAAQ,aAAa,QAAQ;AAC1D,CAAC,EACA,IAAI,CAAA,SAAQ;AAAA,EACX,GAAG;AAAA;AAAA,EAEH,QACE,IAAI,OAAO,OAAO,IAAI,OAAO,MACzB,OACAC,MAAQC,QAAM,IAAI,MAAM,GAAG,gBAAgB;AACnD,EAAE;AAIJ,MAAM,0BAA0BJ,OAAS;AAAA,EACvC,cAAcC,OAAE;AAAA,EAChB,OAAOA,OAAE;AAAA,EACT,QAAQA,OAAE;AAAA,EACV,IAAIC,aAAe,QAAQ,QAAQ,aAAa,QAAQ;AAAA,EACxD,2BAA2BD,OACxB,EACA,IAAI,SAAOI,OAASJ,OAAE,CAAQ,EAAE,MAAM,KAAK,MAAM,GAAG,CAAC,CAAC;AAC3D,CAAC;AAIM,MAAM,UAAU;AAAA,EACZ;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAET,YAAY,IAAc;AACxB,SAAK,gBAAgB,GAAG;AAAA;AAAA,MAAgB;AAAA;AAAA;AAAA;AAAA;AAAA,IAAA;AAMxC,SAAK,4BAA4B,GAAG;AAAA;AAAA,MAAgB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAAA;AAoBpD,SAAK,sBAAsB,GAAG;AAAA;AAAA,MAAgB;AAAA;AAAA;AAAA;AAAA;AAAA,IAAA;AAM9C,SAAK,gBAAgB,GAAG;AAAA;AAAA,MAAgB;AAAA;AAAA;AAAA,IAAA;AAAA,EAG1C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaA,SACE,SACA,KACA,OACA,KACA,YACQ;AACR,WAAO,KAAK,UAAU,SAAS,KAAK,OAAO,KAAK,QAAQ,UAAU;AAAA,EACpE;AAAA,EAEA,YACE,SACA,KACA,OACA,KACQ;AAIR,WAAO,KAAK,UAAU,SAAS,KAAK,OAAO,KAAK,QAAQ,MAAS;AAAA,EACnE;AAAA,EAEA,eAAe,OAAe,KAAiB;AAC7C,UAAM,SAAS,UAAU,mBAAmB,GAAG,CAAC;AAChD,UAAM,SAAS,KAAK,cAAc,IAAI,OAAO,MAAM;AACnD,WAAO,WAAW,SACd,SACAE,MAAQ,QAAQ,yBAAyB,aAAa;AAAA,EAC5D;AAAA,EAEA,UACE,SACA,KACA,OACA,KACA,IACA,YACQ;AACR,UAAM,SAAS,UAAU,mBAAmB,GAAG,CAAC;AAChD,QAAI,eAAe,QAAW;AAC5B,WAAK,cAAc,IAAI,EAAC,SAAS,KAAK,OAAO,QAAQ,IAAG;AAAA,IAC1D,OAAO;AACL,YAAM,WAAmC,CAAA;AACzC,iBAAW,OAAO,YAAY;AAC5B,iBAAS,GAAG,IAAI;AAAA,MAClB;AACA,WAAK,0BAA0B,IAAI;AAAA,QACjC;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA,2BAA2B,KAAK,UAAU,QAAQ;AAAA,MAAA,CACnD;AAAA,IACH;AACA,WAAO;AAAA,EACT;AAAA,EAEA,cAAc,SAAsB,OAAe;AACjD,SAAK,oBAAoB,IAAI,EAAC,SAAS,OAAO,IAAI,aAAY;AAAA,EAChE;AAAA,EAEA,WAAW,SAAsB,OAAe;AAC9C,SAAK,oBAAoB,IAAI,EAAC,SAAS,OAAO,IAAI,UAAS;AAAA,EAC7D;AACF;"}
+{"version":3,"file":"change-log.js","names":["#logRowOpStmt","#logRowOpWithBackfillStmt","#logTableWideOpStmt","#getRowOpStmt","#logRowOp"],"sources":["../../../../../../../zero-cache/src/services/replicator/schema/change-log.ts"],"sourcesContent":["import {\n  jsonObjectSchema,\n  parse,\n  stringify,\n} from '../../../../../shared/src/bigint-json.ts';\nimport * as v from '../../../../../shared/src/valita.ts';\nimport type {Database, Statement} from '../../../../../zqlite/src/db.ts';\nimport type {LexiVersion} from '../../../types/lexi-version.ts';\nimport type {LiteRowKey} from '../../../types/lite.ts';\nimport {normalizedKeyOrder} from '../../../types/row-key.ts';\n\n/**\n * The Change Log tracks the last operation (set or delete) for each row in the\n * data base, ordered by state version; in other words, a cross-table\n * index of row changes ordered by version. This facilitates a minimal \"diff\"\n * of row changes needed to advance a pipeline from one state version to another.\n *\n * The Change Log stores identifiers only, i.e. it does not store contents.\n * A database snapshot at the previous version can be used to query a row's\n * old contents, if any, and the current snapshot can be used to query a row's\n * new contents. (In the common case, the new contents will have just been applied\n * and thus has a high likelihood of being in the SQLite cache.)\n *\n * There are two table-wide operations:\n * - `t` corresponds to the postgres `TRUNCATE` operation\n * - `r` represents any schema (i.e. column) change\n *\n * For both operations, the corresponding row changes are not explicitly included\n * in the change log. The consumer has the option of simulating them be reading\n * from pre- and post- snapshots, or resetting their state entirely with the current\n * snapshot.\n *\n * To achieve the desired ordering semantics when processing tables that have been\n * truncated, reset, and modified, the \"rowKey\" is set to `null` for resets and\n * the empty string `\"\"` for truncates. This means that resets will be encountered\n * before truncates, which will be processed before any subsequent row changes.\n *\n * This ordering is chosen because resets are currently the more \"destructive\" op\n * and result in aborting the processing (and starting from scratch); doing this\n * earlier reduces wasted work.\n */\n\nexport const SET_OP = 's';\nexport const DEL_OP = 'd';\nexport const TRUNCATE_OP = 't';\nexport const RESET_OP = 'r';\n\n// Exported for testing (and migrations)\nexport const CREATE_CHANGELOG_SCHEMA =\n  // stateVersion : a.k.a. row version\n  // pos          : order in which to process the change (within the version)\n  // table        : The table associated with the change\n  // rowKey       : JSON row key for a row change. For table-wide changes RESET\n  //                and TRUNCATE, there is no associated row; instead, `pos` is\n  //                set to -1 and the rowKey is set to the stateVersion,\n  //                guaranteeing when attempting to process the transaction,\n  //                the pipeline is reset (and the change log traversal\n  //                aborted).\n  // op           : 's' for set (insert/update)\n  //              : 'd' for delete\n  //              : 'r' for table reset (schema change)\n  //              : 't' for table truncation (which also resets the pipeline)\n  // backfillingColumnVersions\n  //              : A JSON mapping from column name to stateVersion tracked\n  //                for replicated writes of columns that are being backfilled.\n  //                This is used to prevent backfill data, which is at a\n  //                fixed snapshot/version outside of the replication stream,\n  //                from overwriting newer column values.\n  //\n  // Naming note: To maintain compatibility between a new replication-manager\n  // and old view-syncers, the previous _zero.changeLog table is preserved\n  // and its replacement given a new name \"changeLog2\".\n  `\n  CREATE TABLE \"_zero.changeLog2\" (\n    \"stateVersion\"              TEXT NOT NULL,\n    \"pos\"                       INT  NOT NULL,\n    \"table\"                     TEXT NOT NULL,\n    \"rowKey\"                    TEXT NOT NULL,\n    \"op\"                        TEXT NOT NULL,\n    \"backfillingColumnVersions\" TEXT DEFAULT '{}',\n    PRIMARY KEY(\"stateVersion\", \"pos\"),\n    UNIQUE(\"table\", \"rowKey\")\n  );\n  `;\n\n/**\n * Contains the changeLog fields relevant for computing the diff between\n * two snapshots of a replica. The `pos` and `backfillingColumnVersions`\n * fields are excluded, though the query should be ordered by\n * `<stateVersion, pos>`.\n */\nexport const changeLogEntrySchema = v\n  .object({\n    stateVersion: v.string(),\n    table: v.string(),\n    rowKey: v.string(),\n    op: v.literalUnion(SET_OP, DEL_OP, TRUNCATE_OP, RESET_OP),\n  })\n  .map(val => ({\n    ...val,\n    // Note: sets the rowKey to `null` for table-wide ops / resets\n    rowKey:\n      val.op === 't' || val.op === 'r'\n        ? null\n        : v.parse(parse(val.rowKey), jsonObjectSchema),\n  }));\n\nexport type ChangeLogEntry = v.Infer<typeof changeLogEntrySchema>;\n\nconst rawChangeLogEntrySchema = v.object({\n  stateVersion: v.string(),\n  table: v.string(),\n  rowKey: v.string(),\n  op: v.literalUnion(SET_OP, DEL_OP, TRUNCATE_OP, RESET_OP),\n  backfillingColumnVersions: v\n    .string()\n    .map(val => v.record(v.string()).parse(JSON.parse(val))),\n});\n\nexport type RawChangeLogEntry = v.Infer<typeof rawChangeLogEntrySchema>;\n\nexport class ChangeLog {\n  readonly #logRowOpStmt: Statement;\n  readonly #logRowOpWithBackfillStmt: Statement;\n  readonly #logTableWideOpStmt;\n  readonly #getRowOpStmt: Statement;\n\n  constructor(db: Database) {\n    this.#logRowOpStmt = db.prepare(/*sql*/ `\n      INSERT OR REPLACE INTO \"_zero.changeLog2\" \n        (stateVersion, pos, \"table\", rowKey, op)\n        VALUES (@version, @pos, @table, JSON(@rowKey), @op)\n    `);\n\n    this.#logRowOpWithBackfillStmt = db.prepare(/*sql*/ `\n      INSERT INTO \"_zero.changeLog2\" \n        (stateVersion, pos, \"table\", rowKey, op, backfillingColumnVersions)\n        VALUES (@version, @pos, @table, JSON(@rowKey), @op, \n                JSON(@backfillingColumnVersions))\n        ON CONFLICT (\"table\", rowKey) DO UPDATE \n                   SET stateVersion = excluded.stateVersion,\n                                pos = excluded.pos,\n                                 op = excluded.op,\n          backfillingColumnVersions = json_patch(\n          backfillingColumnVersions, excluded.backfillingColumnVersions)\n    `);\n\n    // Because table-wide ops result in aborting an incremental update\n    // and rehydrating all queries at \"head\", they are assigned pos = -1\n    // as an optimization to abort as early as possible to skip unnecessary\n    // updates.\n    //\n    // However, changeLog entries that are destined to be \"skipped\" are\n    // nonetheless kept for the purpose of tracking backfillingColumnVersions.\n    this.#logTableWideOpStmt = db.prepare(/*sql*/ `\n      INSERT OR REPLACE INTO \"_zero.changeLog2\" \n        (stateVersion, pos, \"table\", rowKey, op) \n        VALUES (@version, -1, @table, @version, @op)\n    `);\n\n    this.#getRowOpStmt = db.prepare(/*sql*/ `\n      SELECT * FROM \"_zero.changeLog2\" WHERE \"table\" = ? AND \"rowKey\" = JSON(?)\n    `);\n  }\n\n  /**\n   *\n   * @param backfilled The backfilling columns for which values were set. Note\n   *   that an empty list and the `undefined` value mean different things;\n   *   * An empty list indicates that a backfill is in progress but no\n   *     backfilling values were set. In this case, existing\n   *     backfillingColumnVersions are preserved.\n   *   * `undefined` indicates that there are no columns being backfilled.\n   *     In this case, any vestigial `backfillingColumnVersions` value\n   *     is cleared.\n   */\n  logSetOp(\n    version: LexiVersion,\n    pos: number,\n    table: string,\n    row: LiteRowKey,\n    backfilled: string[] | undefined,\n  ): string {\n    return this.#logRowOp(version, pos, table, row, SET_OP, backfilled);\n  }\n\n  logDeleteOp(\n    version: LexiVersion,\n    pos: number,\n    table: string,\n    row: LiteRowKey,\n  ): string {\n    // Note: For delete ops, it is always safe to clear the\n    //       backfillingColumnVersions because the backfill algorithm\n    //       understands that deletes apply to the whole row.\n    return this.#logRowOp(version, pos, table, row, DEL_OP, undefined);\n  }\n\n  getLatestRowOp(table: string, row: LiteRowKey) {\n    const rowKey = stringify(normalizedKeyOrder(row));\n    const result = this.#getRowOpStmt.get(table, rowKey);\n    return result === undefined\n      ? undefined\n      : v.parse(result, rawChangeLogEntrySchema, 'passthrough');\n  }\n\n  #logRowOp(\n    version: LexiVersion,\n    pos: number,\n    table: string,\n    row: LiteRowKey,\n    op: string,\n    backfilled: string[] | undefined,\n  ): string {\n    const rowKey = stringify(normalizedKeyOrder(row));\n    if (backfilled === undefined) {\n      this.#logRowOpStmt.run({version, pos, table, rowKey, op});\n    } else {\n      const versions: Record<string, string> = {};\n      for (const col of backfilled) {\n        versions[col] = version;\n      }\n      this.#logRowOpWithBackfillStmt.run({\n        version,\n        pos,\n        table,\n        rowKey,\n        op,\n        backfillingColumnVersions: JSON.stringify(versions),\n      });\n    }\n    return rowKey;\n  }\n\n  logTruncateOp(version: LexiVersion, table: string) {\n    this.#logTableWideOpStmt.run({version, table, op: TRUNCATE_OP});\n  }\n\n  logResetOp(version: LexiVersion, table: string) {\n    this.#logTableWideOpStmt.run({version, table, op: RESET_OP});\n  }\n}\n"],"mappings":";;;AAgDA,IAAa,0BAwBX;;;;;;;;;;;;;;;;;;AAmBF,IAAa,uBAAuB,eACjC,OAAO;CACN,cAAc,eAAE,QAAQ;CACxB,OAAO,eAAE,QAAQ;CACjB,QAAQ,eAAE,QAAQ;CAClB,IAAI,aAAA,KAAA,KAAA,KAAA,IAAqD;CAC1D,CAAC,CACD,KAAI,SAAQ;CACX,GAAG;CAEH,QACE,IAAI,OAAO,OAAO,IAAI,OAAO,MACzB,OACA,MAAQ,QAAM,IAAI,OAAO,EAAE,iBAAiB;CACnD,EAAE;AAIL,IAAM,0BAA0B,eAAE,OAAO;CACvC,cAAc,eAAE,QAAQ;CACxB,OAAO,eAAE,QAAQ;CACjB,QAAQ,eAAE,QAAQ;CAClB,IAAI,aAAA,KAAA,KAAA,KAAA,IAAqD;CACzD,2BAA2B,eACxB,QAAQ,CACR,KAAI,QAAO,eAAE,OAAO,eAAE,QAAQ,CAAC,CAAC,MAAM,KAAK,MAAM,IAAI,CAAC,CAAC;CAC3D,CAAC;AAIF,IAAa,YAAb,MAAuB;CACrB;CACA;CACA;CACA;CAEA,YAAY,IAAc;AACxB,QAAA,eAAqB,GAAG,QAAgB;;;;MAItC;AAEF,QAAA,2BAAiC,GAAG,QAAgB;;;;;;;;;;;MAWlD;AASF,QAAA,qBAA2B,GAAG,QAAgB;;;;MAI5C;AAEF,QAAA,eAAqB,GAAG,QAAgB;;MAEtC;;;;;;;;;;;;;CAcJ,SACE,SACA,KACA,OACA,KACA,YACQ;AACR,SAAO,MAAA,SAAe,SAAS,KAAK,OAAO,KAAA,KAAa,WAAW;;CAGrE,YACE,SACA,KACA,OACA,KACQ;AAIR,SAAO,MAAA,SAAe,SAAS,KAAK,OAAO,KAAA,KAAa,KAAA,EAAU;;CAGpE,eAAe,OAAe,KAAiB;EAC7C,MAAM,SAAS,UAAU,mBAAmB,IAAI,CAAC;EACjD,MAAM,SAAS,MAAA,aAAmB,IAAI,OAAO,OAAO;AACpD,SAAO,WAAW,KAAA,IACd,KAAA,IACA,MAAQ,QAAQ,yBAAyB,cAAc;;CAG7D,UACE,SACA,KACA,OACA,KACA,IACA,YACQ;EACR,MAAM,SAAS,UAAU,mBAAmB,IAAI,CAAC;AACjD,MAAI,eAAe,KAAA,EACjB,OAAA,aAAmB,IAAI;GAAC;GAAS;GAAK;GAAO;GAAQ;GAAG,CAAC;OACpD;GACL,MAAM,WAAmC,EAAE;AAC3C,QAAK,MAAM,OAAO,WAChB,UAAS,OAAO;AAElB,SAAA,yBAA+B,IAAI;IACjC;IACA;IACA;IACA;IACA;IACA,2BAA2B,KAAK,UAAU,SAAS;IACpD,CAAC;;AAEJ,SAAO;;CAGT,cAAc,SAAsB,OAAe;AACjD,QAAA,mBAAyB,IAAI;GAAC;GAAS;GAAO,IAAA;GAAgB,CAAC;;CAGjE,WAAW,SAAsB,OAAe;AAC9C,QAAA,mBAAyB,IAAI;GAAC;GAAS;GAAO,IAAA;GAAa,CAAC"}