@rocicorp/zero 1.6.0-canary.0 → 1.6.0-canary.10

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

@@ -1 +0,0 @@
-{"version":3,"file":"change-processor.js","names":["#db","#changeLog","#tableMetadata","#mode","#failService","#tableSpecs","#failure","#currentTx","#fail","#processMessage","#beginTransaction","#lc","#startMs","#version","#jsonFormat","#columnMetadata","#reloadTableSpecs","#tableSpec","#upsert","#getKey","#logSetOp","#logDeleteOp","#delete","#logTruncateOp","#logResetOp","#bumpVersions","#pos","#numChangeLogEntries","#schemaChanged","#completedBackfill"],"sources":["../../../../../../zero-cache/src/services/replicator/change-processor.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {SqliteError} from '@rocicorp/zero-sqlite3';\nimport {AbortError} from '../../../../shared/src/abort-error.ts';\nimport {assert, unreachable} from '../../../../shared/src/asserts.ts';\nimport {stringify} from '../../../../shared/src/bigint-json.ts';\nimport {must} from '../../../../shared/src/must.ts';\nimport type {DownloadStatus} from '../../../../zero-events/src/status.ts';\nimport {\n  createLiteIndexStatement,\n  createLiteTableStatement,\n  liteColumnDef,\n} from '../../db/create.ts';\nimport {\n  computeZqlSpecs,\n  listIndexes,\n  listTables,\n  type LiteTableSpecWithReplicationStatus,\n} from '../../db/lite-tables.ts';\nimport {\n  mapPostgresToLite,\n  mapPostgresToLiteColumn,\n  mapPostgresToLiteIndex,\n} from '../../db/pg-to-lite.ts';\nimport type {StatementRunner} from '../../db/statements.ts';\nimport type {LexiVersion} from '../../types/lexi-version.ts';\nimport {\n  JSON_PARSED,\n  liteRow,\n  type JSONFormat,\n  type LiteRow,\n  type LiteRowKey,\n  type LiteValueType,\n} from '../../types/lite.ts';\nimport {liteTableName} from '../../types/names.ts';\nimport {id} from '../../types/sql.ts';\nimport type {\n  BackfillCompleted,\n  Change,\n  ColumnAdd,\n  ColumnDrop,\n  ColumnUpdate,\n  Identifier,\n  IndexCreate,\n  IndexDrop,\n  MessageBackfill,\n  MessageCommit,\n  MessageDelete,\n  MessageInsert,\n  MessageRelation,\n  MessageTruncate,\n  MessageUpdate,\n  TableCreate,\n  TableDrop,\n  TableRename,\n  TableUpdateMetadata,\n} from '../change-source/protocol/current/data.ts';\nimport type {ChangeStreamData} from '../change-source/protocol/current/downstream.ts';\nimport type {ReplicatorMode} from './replicator.ts';\nimport {ChangeLog, DEL_OP, SET_OP} from './schema/change-log.ts';\nimport {ColumnMetadataStore} from './schema/column-metadata.ts';\nimport {\n  ZERO_VERSION_COLUMN_NAME,\n  updateReplicationWatermark,\n} from './schema/replication-state.ts';\nimport {TableMetadataTracker} from './schema/table-metadata.ts';\n\nexport type ChangeProcessorMode = ReplicatorMode | 'initial-sync';\n\nexport type CommitResult = {\n  watermark: string;\n  completedBackfill: DownloadStatus | undefined;\n  schemaUpdated: boolean;\n  changeLogUpdated: boolean;\n};\n\n/**\n * The ChangeProcessor partitions the stream of messages into transactions\n * by creating a {@link TransactionProcessor} when a transaction begins, and dispatching\n * messages to it until the commit is received.\n *\n * From https://www.postgresql.org/docs/current/protocol-logical-replication.html#PROTOCOL-LOGICAL-MESSAGES-FLOW :\n *\n * \"The logical replication protocol sends individual transactions one by one.\n *  This means that all messages between a pair of Begin and Commit messages\n *  belong to the same transaction.\"\n */\nexport class ChangeProcessor {\n  readonly #db: StatementRunner;\n  readonly #changeLog: ChangeLog;\n  readonly #tableMetadata: TableMetadataTracker;\n  readonly #mode: ChangeProcessorMode;\n  readonly #failService: (lc: LogContext, err: unknown) => void;\n\n  // The TransactionProcessor lazily loads table specs into this Map,\n  // and reloads them after a schema change. It is cached here to avoid\n  // reading them from the DB on every transaction.\n  readonly #tableSpecs = new Map<string, LiteTableSpecWithReplicationStatus>();\n\n  #currentTx: TransactionProcessor | null = null;\n\n  #failure: Error | undefined;\n\n  constructor(\n    db: StatementRunner,\n    mode: ChangeProcessorMode,\n    failService: (lc: LogContext, err: unknown) => void,\n  ) {\n    this.#db = db;\n    this.#changeLog = new ChangeLog(db.db);\n    this.#tableMetadata = new TableMetadataTracker(db.db);\n    this.#mode = mode;\n    this.#failService = failService;\n  }\n\n  #fail(lc: LogContext, err: unknown) {\n    if (!this.#failure) {\n      let failureError = err;\n      try {\n        this.#currentTx?.abort(lc); // roll back any pending transaction.\n      } catch (rollbackError) {\n        const combinedError = new Error(\n          `Message processing failed and rollback also failed: operation error = ${String(err)}; rollback error = ${String(rollbackError)}`,\n        );\n        combinedError.cause = err;\n        failureError = combinedError;\n      }\n\n      this.#failure = ensureError(failureError);\n\n      if (!(this.#failure instanceof AbortError)) {\n        // Propagate the failure up to the service.\n        lc.error?.('Message Processing failed:', this.#failure);\n        this.#failService(lc, this.#failure);\n      }\n    }\n  }\n\n  abort(lc: LogContext) {\n    this.#fail(lc, new AbortError());\n  }\n\n  /** @return If a transaction was committed. */\n  processMessage(\n    lc: LogContext,\n    downstream: ChangeStreamData,\n  ): CommitResult | null {\n    const [type, message] = downstream;\n    if (this.#failure) {\n      lc.debug?.(`Dropping ${message.tag}`);\n      return null;\n    }\n    try {\n      const watermark =\n        type === 'begin'\n          ? downstream[2].commitWatermark\n          : type === 'commit'\n            ? downstream[2].watermark\n            : undefined;\n      return this.#processMessage(lc, message, watermark);\n    } catch (e) {\n      this.#fail(lc, e);\n    }\n    return null;\n  }\n\n  #beginTransaction(\n    lc: LogContext,\n    commitVersion: string,\n    jsonFormat: JSONFormat,\n  ): TransactionProcessor {\n    const start = Date.now();\n\n    // litestream can technically hold the lock for an arbitrary amount of time\n    // when checkpointing a large commit. Crashing on the busy-timeout in this\n    // scenario will either produce a corrupt backup or otherwise prevent\n    // replication from proceeding.\n    //\n    // Instead, retry the lock acquisition indefinitely. If this masks\n    // an unknown deadlock situation, manual intervention will be necessary.\n    for (let i = 0; ; i++) {\n      try {\n        return new TransactionProcessor(\n          lc,\n          this.#db,\n          this.#mode,\n          this.#changeLog,\n          this.#tableMetadata,\n          this.#tableSpecs,\n          commitVersion,\n          jsonFormat,\n        );\n      } catch (e) {\n        if (e instanceof SqliteError && e.code === 'SQLITE_BUSY') {\n          lc.warn?.(\n            `SQLITE_BUSY for ${Date.now() - start} ms (attempt ${i + 1}). ` +\n              `This is only expected if litestream is performing a large ` +\n              `checkpoint.`,\n            e,\n          );\n          continue;\n        }\n        throw e;\n      }\n    }\n  }\n\n  /** @return If a transaction was committed. */\n  #processMessage(\n    lc: LogContext,\n    msg: Change,\n    watermark: string | undefined,\n  ): CommitResult | null {\n    if (msg.tag === 'begin') {\n      if (this.#currentTx) {\n        throw new Error(`Already in a transaction ${stringify(msg)}`);\n      }\n      this.#currentTx = this.#beginTransaction(\n        lc,\n        must(watermark),\n        msg.json ?? JSON_PARSED,\n      );\n      return null;\n    }\n\n    // For non-begin messages, there should be a #currentTx set.\n    const tx = this.#currentTx;\n    if (!tx) {\n      throw new Error(\n        `Received message outside of transaction: ${stringify(msg)}`,\n      );\n    }\n\n    if (msg.tag === 'commit') {\n      // Undef this.#currentTx to allow the assembly of the next transaction.\n      this.#currentTx = null;\n\n      assert(watermark, 'watermark is required for commit messages');\n      return tx.processCommit(msg, watermark);\n    }\n\n    if (msg.tag === 'rollback') {\n      this.#currentTx?.abort(lc);\n      this.#currentTx = null;\n      return null;\n    }\n\n    switch (msg.tag) {\n      case 'insert':\n        tx.processInsert(msg);\n        break;\n      case 'update':\n        tx.processUpdate(msg);\n        break;\n      case 'delete':\n        tx.processDelete(msg);\n        break;\n      case 'truncate':\n        tx.processTruncate(msg);\n        break;\n      case 'create-table':\n        tx.processCreateTable(msg);\n        break;\n      case 'rename-table':\n        tx.processRenameTable(msg);\n        break;\n      case 'update-table-metadata':\n        tx.processTableMetadata(msg);\n        break;\n      case 'add-column':\n        tx.processAddColumn(msg);\n        break;\n      case 'update-column':\n        tx.processUpdateColumn(msg);\n        break;\n      case 'drop-column':\n        tx.processDropColumn(msg);\n        break;\n      case 'drop-table':\n        tx.processDropTable(msg);\n        break;\n      case 'create-index':\n        tx.processCreateIndex(msg);\n        break;\n      case 'drop-index':\n        tx.processDropIndex(msg);\n        break;\n      case 'backfill':\n        tx.processBackfill(msg);\n        break;\n      case 'backfill-completed':\n        tx.processBackfillCompleted(msg);\n        break;\n      default:\n        unreachable(msg);\n    }\n\n    return null;\n  }\n}\n\n/**\n * The {@link TransactionProcessor} handles the sequence of messages from\n * upstream, from `BEGIN` to `COMMIT` and executes the corresponding mutations\n * on the {@link postgres.TransactionSql} on the replica.\n *\n * When applying row contents to the replica, the `_0_version` column is added / updated,\n * and a corresponding entry in the `ChangeLog` is added. The version value is derived\n * from the watermark of the preceding transaction (stored as the `nextStateVersion` in the\n * `ReplicationState` table).\n *\n *   Side note: For non-streaming Postgres transactions, the commitEndLsn (and thus\n *   commit watermark) is available in the `begin` message, so it could theoretically\n *   be used for the row version of changes within the transaction. However, the\n *   commitEndLsn is not available in the streaming (in-progress) transaction\n *   protocol, and may not be available for CDC streams of other upstream types.\n *   Therefore, the zero replication protocol is designed to not require the commit\n *   watermark when a transaction begins.\n *\n * Also of interest is the fact that all INSERT Messages are logically applied as\n * UPSERTs. See {@link processInsert} for the underlying motivation.\n */\nclass TransactionProcessor {\n  readonly #lc: LogContext;\n  readonly #startMs: number;\n  readonly #db: StatementRunner;\n  readonly #mode: ChangeProcessorMode;\n  readonly #version: LexiVersion;\n  readonly #changeLog: ChangeLog;\n  readonly #tableMetadata: TableMetadataTracker;\n  readonly #tableSpecs: Map<string, LiteTableSpecWithReplicationStatus>;\n  readonly #jsonFormat: JSONFormat;\n  readonly #columnMetadata: ColumnMetadataStore;\n\n  #pos = 0;\n  #schemaChanged = false;\n  #numChangeLogEntries = 0;\n\n  constructor(\n    lc: LogContext,\n    db: StatementRunner,\n    mode: ChangeProcessorMode,\n    changeLog: ChangeLog,\n    tableMetadata: TableMetadataTracker,\n    tableSpecs: Map<string, LiteTableSpecWithReplicationStatus>,\n    commitVersion: LexiVersion,\n    jsonFormat: JSONFormat,\n  ) {\n    this.#startMs = Date.now();\n    this.#mode = mode;\n    this.#jsonFormat = jsonFormat;\n\n    switch (mode) {\n      case 'serving':\n        // Although the Replicator / Incremental Syncer is the only writer of the replica,\n        // a `BEGIN CONCURRENT` transaction is used to allow View Syncers to simulate\n        // (i.e. and `ROLLBACK`) changes on historic snapshots of the database for the\n        // purpose of IVM).\n        //\n        // This TransactionProcessor is the only logic that will actually\n        // `COMMIT` any transactions to the replica.\n        db.beginConcurrent();\n        break;\n      case 'backup':\n        // For the backup-replicator (i.e. replication-manager), there are no View Syncers\n        // and thus BEGIN CONCURRENT is not necessary. In fact, BEGIN CONCURRENT can cause\n        // deadlocks with forced wal-checkpoints (which `litestream replicate` performs),\n        // so it is important to use vanilla transactions in this configuration.\n        db.beginImmediate();\n        break;\n      case 'initial-sync':\n        // When the ChangeProcessor is used for initial-sync, the calling code\n        // handles the transaction boundaries.\n        break;\n      default:\n        unreachable();\n    }\n    this.#db = db;\n    this.#version = commitVersion;\n    this.#lc = lc.withContext('version', commitVersion);\n    this.#changeLog = changeLog;\n    this.#tableMetadata = tableMetadata;\n    this.#tableSpecs = tableSpecs;\n    // The column_metadata table is guaranteed to exist since the\n    // replica-schema.ts migration to v8.\n    this.#columnMetadata = must(ColumnMetadataStore.getInstance(db.db));\n\n    if (this.#tableSpecs.size === 0) {\n      this.#reloadTableSpecs();\n    }\n  }\n\n  #reloadTableSpecs() {\n    this.#tableSpecs.clear();\n    // zqlSpecs include the primary key derived from unique indexes\n    const zqlSpecs = computeZqlSpecs(this.#lc, this.#db.db, {\n      includeBackfillingColumns: true,\n    });\n    for (let spec of listTables(this.#db.db)) {\n      if (!spec.primaryKey) {\n        spec = {\n          ...spec,\n          primaryKey: [\n            ...(zqlSpecs.get(spec.name)?.tableSpec.primaryKey ?? []),\n          ],\n        };\n      }\n      this.#tableSpecs.set(spec.name, spec);\n    }\n  }\n\n  #tableSpec(name: string) {\n    return must(this.#tableSpecs.get(name), `Unknown table ${name}`);\n  }\n\n  #getKey(\n    {row, numCols}: {row: LiteRow; numCols: number},\n    {relation}: {relation: MessageRelation},\n  ): LiteRowKey {\n    const keyColumns =\n      relation.rowKey.type !== 'full'\n        ? relation.rowKey.columns // already a suitable key\n        : this.#tableSpec(liteTableName(relation)).primaryKey;\n    if (!keyColumns?.length) {\n      throw new Error(\n        `Cannot replicate table \"${relation.name}\" without a PRIMARY KEY or UNIQUE INDEX`,\n      );\n    }\n    // For the common case (replica identity default), the row is already the\n    // key for deletes and updates, in which case a new object can be avoided.\n    if (numCols === keyColumns.length) {\n      return row;\n    }\n    const key: Record<string, LiteValueType> = {};\n    for (const col of keyColumns) {\n      key[col] = row[col];\n    }\n    return key;\n  }\n\n  processInsert(insert: MessageInsert) {\n    const table = liteTableName(insert.relation);\n    const tableSpec = this.#tableSpec(table);\n    const newRow = liteRow(insert.new, tableSpec, this.#jsonFormat);\n\n    this.#upsert(table, {\n      ...newRow.row,\n      [ZERO_VERSION_COLUMN_NAME]: this.#version,\n    });\n\n    if (insert.relation.rowKey.columns.length === 0) {\n      // INSERTs can be replicated for rows without a PRIMARY KEY or a\n      // UNIQUE INDEX. These are written to the replica but not recorded\n      // in the changeLog, because these rows cannot participate in IVM.\n      //\n      // (Once the table schema has been corrected to include a key, the\n      //  associated schema change will reset pipelines and data can be\n      //  loaded via hydration.)\n      return;\n    }\n    const key = this.#getKey(newRow, insert);\n    this.#logSetOp(table, key, getBackfilledColumns(newRow.row, tableSpec));\n  }\n\n  #upsert(table: string, row: LiteRow) {\n    const columns = Object.keys(row).map(c => id(c));\n    this.#db.run(\n      `\n      INSERT OR REPLACE INTO ${id(table)} (${columns.join(',')})\n        VALUES (${Array.from({length: columns.length}).fill('?').join(',')})\n      `,\n      Object.values(row),\n    );\n  }\n\n  // Updates by default are applied as UPDATE commands to support partial\n  // row specifications from the change source. In particular, this is needed\n  // to handle updates for which unchanged TOASTed values are not sent:\n  //\n  // https://www.postgresql.org/docs/current/protocol-logicalrep-message-formats.html#PROTOCOL-LOGICALREP-MESSAGE-FORMATS-TUPLEDATA\n  //\n  // However, in certain cases an UPDATE may be received for a row that\n  // was not initially synced, such as when, an existing table is added\n  // to the app's publication.\n  //\n  // In order to facilitate \"resumptive\" replication, the logic falls back to\n  // an INSERT if the update did not change any rows.\n  processUpdate(update: MessageUpdate) {\n    const table = liteTableName(update.relation);\n    const tableSpec = this.#tableSpec(table);\n    const newRow = liteRow(update.new, tableSpec, this.#jsonFormat);\n    const row = {...newRow.row, [ZERO_VERSION_COLUMN_NAME]: this.#version};\n\n    // update.key is set with the old values if the key has changed.\n    const oldKey = update.key\n      ? this.#getKey(\n          liteRow(update.key, this.#tableSpec(table), this.#jsonFormat),\n          update,\n        )\n      : null;\n    const newKey = this.#getKey(newRow, update);\n\n    if (oldKey) {\n      this.#logDeleteOp(table, oldKey, tableSpec.backfilling);\n    }\n    this.#logSetOp(table, newKey, getBackfilledColumns(newRow.row, tableSpec));\n\n    const currKey = oldKey ?? newKey;\n    const conds = Object.keys(currKey).map(col => `${id(col)}=?`);\n    const setExprs = Object.keys(row).map(col => `${id(col)}=?`);\n\n    const {changes} = this.#db.run(\n      `\n      UPDATE ${id(table)}\n        SET ${setExprs.join(',')}\n        WHERE ${conds.join(' AND ')}\n      `,\n      [...Object.values(row), ...Object.values(currKey)],\n    );\n\n    // If the UPDATE did not affect any rows, perform an UPSERT of the\n    // new row for resumptive replication.\n    if (changes === 0) {\n      this.#upsert(table, row);\n    }\n  }\n\n  processDelete(del: MessageDelete) {\n    const table = liteTableName(del.relation);\n    const tableSpec = this.#tableSpec(table);\n    const rowKey = this.#getKey(\n      liteRow(del.key, tableSpec, this.#jsonFormat),\n      del,\n    );\n\n    this.#delete(table, rowKey);\n    this.#logDeleteOp(table, rowKey, tableSpec.backfilling);\n  }\n\n  #delete(table: string, rowKey: LiteRowKey) {\n    const conds = Object.keys(rowKey).map(col => `${id(col)}=?`);\n    this.#db.run(\n      `DELETE FROM ${id(table)} WHERE ${conds.join(' AND ')}`,\n      Object.values(rowKey),\n    );\n  }\n\n  processTruncate(truncate: MessageTruncate) {\n    for (const relation of truncate.relations) {\n      const table = liteTableName(relation);\n      // Update replica data.\n      this.#db.run(`DELETE FROM ${id(table)}`);\n\n      // Update change log.\n      this.#logTruncateOp(table);\n    }\n  }\n\n  processCreateTable(create: TableCreate) {\n    if (create.metadata) {\n      this.#tableMetadata.setUpstreamMetadata(create.spec, create.metadata);\n    }\n    const table = mapPostgresToLite(create.spec);\n    this.#db.db.exec(createLiteTableStatement(table));\n\n    // Write to metadata table\n    for (const [colName, colSpec] of Object.entries(create.spec.columns)) {\n      this.#columnMetadata.insert(\n        table.name,\n        colName,\n        colSpec,\n        create.backfill?.[colName],\n      );\n    }\n\n    if (\n      Object.keys(create.backfill ?? {}).length ===\n      Object.keys(create.spec.columns).length\n    ) {\n      this.#reloadTableSpecs();\n    } else {\n      // Make the table visible immediately unless all of the columns are\n      // being backfilled. In the backfill case, the version bump will happen\n      // with the backfill is complete.\n      this.#logResetOp(table.name);\n    }\n    this.#lc.info?.(create.tag, table.name);\n  }\n\n  processTableMetadata(msg: TableUpdateMetadata) {\n    this.#tableMetadata.setUpstreamMetadata(msg.table, msg.new);\n  }\n\n  processRenameTable(rename: TableRename) {\n    this.#tableMetadata.rename(rename.old, rename.new);\n\n    const oldName = liteTableName(rename.old);\n    const newName = liteTableName(rename.new);\n    this.#db.db.exec(`ALTER TABLE ${id(oldName)} RENAME TO ${id(newName)}`);\n\n    // Rename in metadata table\n    this.#columnMetadata.renameTable(oldName, newName);\n\n    this.#bumpVersions(rename.new);\n    this.#logResetOp(oldName);\n    this.#lc.info?.(rename.tag, oldName, newName);\n  }\n\n  processAddColumn(msg: ColumnAdd) {\n    if (msg.tableMetadata) {\n      this.#tableMetadata.setUpstreamMetadata(msg.table, msg.tableMetadata);\n    }\n    const table = liteTableName(msg.table);\n    const {name} = msg.column;\n    const spec = mapPostgresToLiteColumn(table, msg.column);\n    this.#db.db.exec(\n      `ALTER TABLE ${id(table)} ADD ${id(name)} ${liteColumnDef(spec)}`,\n    );\n\n    // Write to metadata table\n    this.#columnMetadata.insert(table, name, msg.column.spec, msg.backfill);\n\n    if (msg.backfill) {\n      this.#reloadTableSpecs();\n    } else {\n      // Make the new column visible immediately if it's not being backfilled.\n      // Otherwise, the version bump will happen with the backfill is complete.\n      this.#bumpVersions(msg.table);\n    }\n    this.#lc.info?.(msg.tag, table, msg.column);\n  }\n\n  processUpdateColumn(msg: ColumnUpdate) {\n    const table = liteTableName(msg.table);\n    let oldName = msg.old.name;\n    const newName = msg.new.name;\n\n    // update-column can ignore defaults because it does not change the values\n    // in existing rows.\n    //\n    // https://www.postgresql.org/docs/current/sql-altertable.html#SQL-ALTERTABLE-DESC-SET-DROP-DEFAULT\n    //\n    // \"The new default value will only apply in subsequent INSERT or UPDATE\n    //  commands; it does not cause rows already in the table to change.\"\n    //\n    // This allows support for _changing_ column defaults to any expression,\n    // since it does not affect what the replica needs to do.\n    const oldSpec = mapPostgresToLiteColumn(table, msg.old, 'ignore-default');\n    const newSpec = mapPostgresToLiteColumn(table, msg.new, 'ignore-default');\n\n    // The only updates that are relevant are the column name and the data type.\n    if (oldName === newName && oldSpec.dataType === newSpec.dataType) {\n      this.#lc.info?.(msg.tag, 'no thing to update', oldSpec, newSpec);\n      return;\n    }\n    // If the data type changes, we have to make a new column with the new data type\n    // and copy the values over.\n    if (oldSpec.dataType !== newSpec.dataType) {\n      // Remember (and drop) the indexes that reference the column.\n      const indexes = listIndexes(this.#db.db).filter(\n        idx => idx.tableName === table && oldName in idx.columns,\n      );\n      const stmts = indexes.map(idx => `DROP INDEX IF EXISTS ${id(idx.name)};`);\n      const tmpName = `tmp.${newName}`;\n      stmts.push(`\n        ALTER TABLE ${id(table)} ADD ${id(tmpName)} ${liteColumnDef(newSpec)};\n        UPDATE ${id(table)} SET ${id(tmpName)} = ${id(oldName)};\n        ALTER TABLE ${id(table)} DROP ${id(oldName)};\n        `);\n      for (const idx of indexes) {\n        // Re-create the indexes to reference the new column.\n        idx.columns[tmpName] = idx.columns[oldName];\n        delete idx.columns[oldName];\n        stmts.push(createLiteIndexStatement(idx));\n      }\n      this.#db.db.exec(stmts.join(''));\n      oldName = tmpName;\n    }\n    if (oldName !== newName) {\n      this.#db.db.exec(\n        `ALTER TABLE ${id(table)} RENAME ${id(oldName)} TO ${id(newName)}`,\n      );\n    }\n\n    // Update metadata table\n    this.#columnMetadata.update(\n      table,\n      msg.old.name,\n      msg.new.name,\n      msg.new.spec,\n    );\n\n    this.#bumpVersions(msg.table);\n    this.#lc.info?.(msg.tag, table, msg.new);\n  }\n\n  processDropColumn(msg: ColumnDrop) {\n    const table = liteTableName(msg.table);\n    const {column} = msg;\n    this.#db.db.exec(`ALTER TABLE ${id(table)} DROP ${id(column)}`);\n\n    // Delete from metadata table\n    this.#columnMetadata.deleteColumn(table, column);\n\n    this.#bumpVersions(msg.table);\n    this.#lc.info?.(msg.tag, table, column);\n  }\n\n  processDropTable(drop: TableDrop) {\n    this.#tableMetadata.drop(drop.id);\n\n    const name = liteTableName(drop.id);\n    this.#db.db.exec(`DROP TABLE IF EXISTS ${id(name)}`);\n\n    // Delete from metadata table\n    this.#columnMetadata.deleteTable(name);\n\n    this.#logResetOp(name);\n    this.#lc.info?.(drop.tag, name);\n  }\n\n  processCreateIndex(create: IndexCreate) {\n    const index = mapPostgresToLiteIndex(create.spec);\n    this.#db.db.exec(createLiteIndexStatement(index));\n\n    // indexes affect tables visibility (e.g. sync-ability is gated on\n    // having a unique index), so reset pipelines to refresh table schemas.\n    // However, the reset is not necessary if the index is for a table\n    // that is not yet visible due to backfilling.\n    const tableSpec = must(this.#tableSpecs.get(index.tableName));\n    if (\n      (tableSpec.backfilling ?? []).length ===\n      Object.entries(tableSpec.columns).length - 1 // don't count _0_version\n    ) {\n      this.#reloadTableSpecs();\n    } else {\n      this.#logResetOp(index.tableName);\n    }\n    this.#lc.info?.(create.tag, index.name);\n  }\n\n  processDropIndex(drop: IndexDrop) {\n    const name = liteTableName(drop.id);\n    this.#db.db.exec(`DROP INDEX IF EXISTS ${id(name)}`);\n    this.#lc.info?.(drop.tag, name);\n  }\n\n  #bumpVersions(table: Identifier) {\n    this.#tableMetadata.setMinRowVersion(table, this.#version);\n    this.#logResetOp(liteTableName(table));\n  }\n\n  /**\n   * @param backfilledColumns `backfilling` columns for which values were set\n   */\n  #logSetOp(\n    table: string,\n    key: LiteRowKey,\n    backfilledColumns: string[] | undefined,\n  ) {\n    // The \"serving\" replicator always writes to the change-log (for IVM).\n    // The \"backup\" replicator only needs to write to the change log\n    // when writing columns that are being backfilled.\n    if (this.#mode === 'serving' || backfilledColumns !== undefined) {\n      this.#changeLog.logSetOp(\n        this.#version,\n        this.#pos++,\n        table,\n        key,\n        backfilledColumns,\n      );\n      this.#numChangeLogEntries++;\n    }\n  }\n\n  #logDeleteOp(table: string, key: LiteRowKey, backfilling?: string[]) {\n    // The \"serving\" replicator always writes to the change-log (for IVM).\n    // The \"backup\" replicator only needs to write to the change log\n    // when writing columns that are being backfilled.\n    if (this.#mode === 'serving' || backfilling?.length) {\n      this.#changeLog.logDeleteOp(this.#version, this.#pos++, table, key);\n      this.#numChangeLogEntries++;\n    }\n  }\n\n  #logTruncateOp(table: string) {\n    if (this.#mode === 'serving') {\n      this.#changeLog.logTruncateOp(this.#version, table);\n      this.#numChangeLogEntries++;\n    }\n  }\n\n  #logResetOp(table: string) {\n    this.#schemaChanged = true;\n    if (this.#mode === 'serving') {\n      this.#changeLog.logResetOp(this.#version, table);\n      this.#numChangeLogEntries++;\n    }\n    this.#reloadTableSpecs();\n  }\n\n  processBackfill({relation, watermark, columns, rowValues}: MessageBackfill) {\n    const tableName = liteTableName(relation);\n    const tableSpec = must(this.#tableSpecs.get(tableName));\n    const rowKeyCols = relation.rowKey.columns;\n    const cols = [...rowKeyCols, ...columns];\n\n    // Common parts of the INSERT sql statement.\n    const insertColsStr = [...cols, ZERO_VERSION_COLUMN_NAME].map(id).join(',');\n    const qMarks = Array.from({length: cols.length + 1})\n      .fill('?')\n      .join(',');\n    const rowKeyColsStr = rowKeyCols.map(id).join(',');\n\n    let backfilled = 0;\n    let skipped = 0;\n    for (const v of rowValues) {\n      const row = liteRow(\n        Object.fromEntries(cols.map((c, i) => [c, v[i]])),\n        tableSpec,\n        this.#jsonFormat,\n      );\n      const rowKey = this.#getKey(row, {relation});\n      const rowOp = this.#changeLog.getLatestRowOp(tableName, rowKey);\n      if (rowOp?.op === DEL_OP && rowOp.stateVersion > watermark) {\n        skipped++;\n        continue; // the row was deleted after the backfill snapshot\n      }\n      const updates =\n        rowOp?.op === SET_OP\n          ? cols.filter(\n              c => (rowOp.backfillingColumnVersions[c] ?? '') <= watermark,\n            )\n          : cols;\n      if (updates.length === 0) {\n        // row already has newer values for all backfilling columns.\n        skipped++;\n        continue;\n      }\n      const updateStmts = updates.map(col => `${id(col)}=excluded.${id(col)}`);\n      this.#db.run(\n        /*sql*/ `\n        INSERT INTO ${id(tableName)} (${insertColsStr}) VALUES (${qMarks})\n          ON CONFLICT (${rowKeyColsStr})\n          DO UPDATE SET ${updateStmts.join(',')};\n      `,\n        ...Object.values(row.row),\n        watermark, // the _0_version for new rows (i.e. table backfill)\n      );\n      backfilled++;\n    }\n\n    this.#lc.debug?.(\n      `backfilled ${backfilled} rows (skipped ${skipped}) into ${tableName}`,\n    );\n  }\n\n  #completedBackfill: DownloadStatus | undefined;\n\n  processBackfillCompleted({relation, columns, status}: BackfillCompleted) {\n    const tableName = liteTableName(relation);\n    const rowKeyCols = relation.rowKey.columns;\n    const cols = [...rowKeyCols, ...columns];\n\n    const columnMetadata = must(ColumnMetadataStore.getInstance(this.#db.db));\n    for (const col of cols) {\n      columnMetadata.clearBackfilling(tableName, col);\n    }\n    // Given that new columns are being exposed for every row in the table, bump the\n    // row version for all rows.\n    this.#bumpVersions(relation);\n    if (status) {\n      this.#completedBackfill = {table: tableName, columns: cols, ...status};\n    }\n    this.#lc.info?.(`finished backfilling ${tableName}`);\n\n    // Note that there is no need to clear the backfillingColumnVersions values\n    // in the changeLog. It could theoretically be done for clarity but:\n    // (1) it could be non-trivial in terms of latency introduced and\n    // (2) the data must be preserved if _other_ columns are in the process\n    //     of being backfilled\n    //\n    // Thus, for speed and simplicity, the values are left as is. (Note that\n    // subsequent replicated changes to those rows will clear the values if\n    // no backfills are in progress).\n  }\n\n  processCommit(commit: MessageCommit, watermark: string): CommitResult {\n    if (watermark !== this.#version) {\n      throw new Error(\n        `'commit' version ${watermark} does not match 'begin' version ${\n          this.#version\n        }: ${stringify(commit)}`,\n      );\n    }\n    updateReplicationWatermark(this.#db, watermark);\n\n    if (this.#schemaChanged) {\n      const start = Date.now();\n      this.#db.db.pragma('optimize');\n      this.#lc.info?.(\n        `PRAGMA optimized after schema change (${Date.now() - start} ms)`,\n      );\n    }\n\n    if (this.#mode !== 'initial-sync') {\n      this.#db.commit();\n    }\n\n    const elapsedMs = Date.now() - this.#startMs;\n    this.#lc.debug?.(`Committed tx@${this.#version} (${elapsedMs} ms)`);\n\n    return {\n      watermark,\n      completedBackfill: this.#completedBackfill,\n      schemaUpdated: this.#schemaChanged,\n      changeLogUpdated: this.#numChangeLogEntries > 0,\n    };\n  }\n\n  abort(lc: LogContext) {\n    lc.info?.(`aborting transaction ${this.#version}`);\n    this.#db.rollback();\n  }\n}\n\nfunction getBackfilledColumns(\n  row: LiteRow,\n  {backfilling}: LiteTableSpecWithReplicationStatus,\n): string[] | undefined {\n  if (!backfilling?.length) {\n    return undefined; // common case\n  }\n  return backfilling.filter(col => col in row);\n}\n\nfunction ensureError(err: unknown): Error {\n  if (err instanceof Error) {\n    return err;\n  }\n  const error = new Error();\n  error.cause = err;\n  return error;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsFA,IAAa,kBAAb,MAA6B;CAC3B;CACA;CACA;CACA;CACA;CAKA,8BAAuB,IAAI,KAAiD;CAE5E,aAA0C;CAE1C;CAEA,YACE,IACA,MACA,aACA;AACA,QAAA,KAAW;AACX,QAAA,YAAkB,IAAI,UAAU,GAAG,GAAG;AACtC,QAAA,gBAAsB,IAAI,qBAAqB,GAAG,GAAG;AACrD,QAAA,OAAa;AACb,QAAA,cAAoB;;CAGtB,MAAM,IAAgB,KAAc;AAClC,MAAI,CAAC,MAAA,SAAe;GAClB,IAAI,eAAe;AACnB,OAAI;AACF,UAAA,WAAiB,MAAM,GAAG;YACnB,eAAe;IACtB,MAAM,gCAAgB,IAAI,MACxB,yEAAyE,OAAO,IAAI,CAAC,qBAAqB,OAAO,cAAc,GAChI;AACD,kBAAc,QAAQ;AACtB,mBAAe;;AAGjB,SAAA,UAAgB,YAAY,aAAa;AAEzC,OAAI,EAAE,MAAA,mBAAyB,aAAa;AAE1C,OAAG,QAAQ,8BAA8B,MAAA,QAAc;AACvD,UAAA,YAAkB,IAAI,MAAA,QAAc;;;;CAK1C,MAAM,IAAgB;AACpB,QAAA,KAAW,IAAI,IAAI,YAAY,CAAC;;;CAIlC,eACE,IACA,YACqB;EACrB,MAAM,CAAC,MAAM,WAAW;AACxB,MAAI,MAAA,SAAe;AACjB,MAAG,QAAQ,YAAY,QAAQ,MAAM;AACrC,UAAO;;AAET,MAAI;GACF,MAAM,YACJ,SAAS,UACL,WAAW,GAAG,kBACd,SAAS,WACP,WAAW,GAAG,YACd,KAAA;AACR,UAAO,MAAA,eAAqB,IAAI,SAAS,UAAU;WAC5C,GAAG;AACV,SAAA,KAAW,IAAI,EAAE;;AAEnB,SAAO;;CAGT,kBACE,IACA,eACA,YACsB;EACtB,MAAM,QAAQ,KAAK,KAAK;AASxB,OAAK,IAAI,IAAI,IAAK,IAChB,KAAI;AACF,UAAO,IAAI,qBACT,IACA,MAAA,IACA,MAAA,MACA,MAAA,WACA,MAAA,eACA,MAAA,YACA,eACA,WACD;WACM,GAAG;AACV,OAAI,aAAa,eAAe,EAAE,SAAS,eAAe;AACxD,OAAG,OACD,mBAAmB,KAAK,KAAK,GAAG,MAAM,eAAe,IAAI,EAAE,2EAG3D,EACD;AACD;;AAEF,SAAM;;;;CAMZ,gBACE,IACA,KACA,WACqB;AACrB,MAAI,IAAI,QAAQ,SAAS;AACvB,OAAI,MAAA,UACF,OAAM,IAAI,MAAM,4BAA4B,UAAU,IAAI,GAAG;AAE/D,SAAA,YAAkB,MAAA,iBAChB,IACA,KAAK,UAAU,EACf,IAAI,QAAA,IACL;AACD,UAAO;;EAIT,MAAM,KAAK,MAAA;AACX,MAAI,CAAC,GACH,OAAM,IAAI,MACR,4CAA4C,UAAU,IAAI,GAC3D;AAGH,MAAI,IAAI,QAAQ,UAAU;AAExB,SAAA,YAAkB;AAElB,UAAO,WAAW,4CAA4C;AAC9D,UAAO,GAAG,cAAc,KAAK,UAAU;;AAGzC,MAAI,IAAI,QAAQ,YAAY;AAC1B,SAAA,WAAiB,MAAM,GAAG;AAC1B,SAAA,YAAkB;AAClB,UAAO;;AAGT,UAAQ,IAAI,KAAZ;GACE,KAAK;AACH,OAAG,cAAc,IAAI;AACrB;GACF,KAAK;AACH,OAAG,cAAc,IAAI;AACrB;GACF,KAAK;AACH,OAAG,cAAc,IAAI;AACrB;GACF,KAAK;AACH,OAAG,gBAAgB,IAAI;AACvB;GACF,KAAK;AACH,OAAG,mBAAmB,IAAI;AAC1B;GACF,KAAK;AACH,OAAG,mBAAmB,IAAI;AAC1B;GACF,KAAK;AACH,OAAG,qBAAqB,IAAI;AAC5B;GACF,KAAK;AACH,OAAG,iBAAiB,IAAI;AACxB;GACF,KAAK;AACH,OAAG,oBAAoB,IAAI;AAC3B;GACF,KAAK;AACH,OAAG,kBAAkB,IAAI;AACzB;GACF,KAAK;AACH,OAAG,iBAAiB,IAAI;AACxB;GACF,KAAK;AACH,OAAG,mBAAmB,IAAI;AAC1B;GACF,KAAK;AACH,OAAG,iBAAiB,IAAI;AACxB;GACF,KAAK;AACH,OAAG,gBAAgB,IAAI;AACvB;GACF,KAAK;AACH,OAAG,yBAAyB,IAAI;AAChC;GACF,QACE,aAAY,IAAI;;AAGpB,SAAO;;;;;;;;;;;;;;;;;;;;;;;;AAyBX,IAAM,uBAAN,MAA2B;CACzB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAEA,OAAO;CACP,iBAAiB;CACjB,uBAAuB;CAEvB,YACE,IACA,IACA,MACA,WACA,eACA,YACA,eACA,YACA;AACA,QAAA,UAAgB,KAAK,KAAK;AAC1B,QAAA,OAAa;AACb,QAAA,aAAmB;AAEnB,UAAQ,MAAR;GACE,KAAK;AAQH,OAAG,iBAAiB;AACpB;GACF,KAAK;AAKH,OAAG,gBAAgB;AACnB;GACF,KAAK,eAGH;GACF,QACE,cAAa;;AAEjB,QAAA,KAAW;AACX,QAAA,UAAgB;AAChB,QAAA,KAAW,GAAG,YAAY,WAAW,cAAc;AACnD,QAAA,YAAkB;AAClB,QAAA,gBAAsB;AACtB,QAAA,aAAmB;AAGnB,QAAA,iBAAuB,KAAK,oBAAoB,YAAY,GAAG,GAAG,CAAC;AAEnE,MAAI,MAAA,WAAiB,SAAS,EAC5B,OAAA,kBAAwB;;CAI5B,oBAAoB;AAClB,QAAA,WAAiB,OAAO;EAExB,MAAM,WAAW,gBAAgB,MAAA,IAAU,MAAA,GAAS,IAAI,EACtD,2BAA2B,MAC5B,CAAC;AACF,OAAK,IAAI,QAAQ,WAAW,MAAA,GAAS,GAAG,EAAE;AACxC,OAAI,CAAC,KAAK,WACR,QAAO;IACL,GAAG;IACH,YAAY,CACV,GAAI,SAAS,IAAI,KAAK,KAAK,EAAE,UAAU,cAAc,EAAE,CACxD;IACF;AAEH,SAAA,WAAiB,IAAI,KAAK,MAAM,KAAK;;;CAIzC,WAAW,MAAc;AACvB,SAAO,KAAK,MAAA,WAAiB,IAAI,KAAK,EAAE,iBAAiB,OAAO;;CAGlE,QACE,EAAC,KAAK,WACN,EAAC,YACW;EACZ,MAAM,aACJ,SAAS,OAAO,SAAS,SACrB,SAAS,OAAO,UAChB,MAAA,UAAgB,cAAc,SAAS,CAAC,CAAC;AAC/C,MAAI,CAAC,YAAY,OACf,OAAM,IAAI,MACR,2BAA2B,SAAS,KAAK,yCAC1C;AAIH,MAAI,YAAY,WAAW,OACzB,QAAO;EAET,MAAM,MAAqC,EAAE;AAC7C,OAAK,MAAM,OAAO,WAChB,KAAI,OAAO,IAAI;AAEjB,SAAO;;CAGT,cAAc,QAAuB;EACnC,MAAM,QAAQ,cAAc,OAAO,SAAS;EAC5C,MAAM,YAAY,MAAA,UAAgB,MAAM;EACxC,MAAM,SAAS,QAAQ,OAAO,KAAK,WAAW,MAAA,WAAiB;AAE/D,QAAA,OAAa,OAAO;GAClB,GAAG,OAAO;IACT,2BAA2B,MAAA;GAC7B,CAAC;AAEF,MAAI,OAAO,SAAS,OAAO,QAAQ,WAAW,EAQ5C;EAEF,MAAM,MAAM,MAAA,OAAa,QAAQ,OAAO;AACxC,QAAA,SAAe,OAAO,KAAK,qBAAqB,OAAO,KAAK,UAAU,CAAC;;CAGzE,QAAQ,OAAe,KAAc;EACnC,MAAM,UAAU,OAAO,KAAK,IAAI,CAAC,KAAI,MAAK,GAAG,EAAE,CAAC;AAChD,QAAA,GAAS,IACP;+BACyB,GAAG,MAAM,CAAC,IAAI,QAAQ,KAAK,IAAI,CAAC;kBAC7C,MAAM,KAAK,EAAC,QAAQ,QAAQ,QAAO,CAAC,CAAC,KAAK,IAAI,CAAC,KAAK,IAAI,CAAC;SAErE,OAAO,OAAO,IAAI,CACnB;;CAeH,cAAc,QAAuB;EACnC,MAAM,QAAQ,cAAc,OAAO,SAAS;EAC5C,MAAM,YAAY,MAAA,UAAgB,MAAM;EACxC,MAAM,SAAS,QAAQ,OAAO,KAAK,WAAW,MAAA,WAAiB;EAC/D,MAAM,MAAM;GAAC,GAAG,OAAO;IAAM,2BAA2B,MAAA;GAAc;EAGtE,MAAM,SAAS,OAAO,MAClB,MAAA,OACE,QAAQ,OAAO,KAAK,MAAA,UAAgB,MAAM,EAAE,MAAA,WAAiB,EAC7D,OACD,GACD;EACJ,MAAM,SAAS,MAAA,OAAa,QAAQ,OAAO;AAE3C,MAAI,OACF,OAAA,YAAkB,OAAO,QAAQ,UAAU,YAAY;AAEzD,QAAA,SAAe,OAAO,QAAQ,qBAAqB,OAAO,KAAK,UAAU,CAAC;EAE1E,MAAM,UAAU,UAAU;EAC1B,MAAM,QAAQ,OAAO,KAAK,QAAQ,CAAC,KAAI,QAAO,GAAG,GAAG,IAAI,CAAC,IAAI;EAC7D,MAAM,WAAW,OAAO,KAAK,IAAI,CAAC,KAAI,QAAO,GAAG,GAAG,IAAI,CAAC,IAAI;EAE5D,MAAM,EAAC,YAAW,MAAA,GAAS,IACzB;eACS,GAAG,MAAM,CAAC;cACX,SAAS,KAAK,IAAI,CAAC;gBACjB,MAAM,KAAK,QAAQ,CAAC;SAE9B,CAAC,GAAG,OAAO,OAAO,IAAI,EAAE,GAAG,OAAO,OAAO,QAAQ,CAAC,CACnD;AAID,MAAI,YAAY,EACd,OAAA,OAAa,OAAO,IAAI;;CAI5B,cAAc,KAAoB;EAChC,MAAM,QAAQ,cAAc,IAAI,SAAS;EACzC,MAAM,YAAY,MAAA,UAAgB,MAAM;EACxC,MAAM,SAAS,MAAA,OACb,QAAQ,IAAI,KAAK,WAAW,MAAA,WAAiB,EAC7C,IACD;AAED,QAAA,OAAa,OAAO,OAAO;AAC3B,QAAA,YAAkB,OAAO,QAAQ,UAAU,YAAY;;CAGzD,QAAQ,OAAe,QAAoB;EACzC,MAAM,QAAQ,OAAO,KAAK,OAAO,CAAC,KAAI,QAAO,GAAG,GAAG,IAAI,CAAC,IAAI;AAC5D,QAAA,GAAS,IACP,eAAe,GAAG,MAAM,CAAC,SAAS,MAAM,KAAK,QAAQ,IACrD,OAAO,OAAO,OAAO,CACtB;;CAGH,gBAAgB,UAA2B;AACzC,OAAK,MAAM,YAAY,SAAS,WAAW;GACzC,MAAM,QAAQ,cAAc,SAAS;AAErC,SAAA,GAAS,IAAI,eAAe,GAAG,MAAM,GAAG;AAGxC,SAAA,cAAoB,MAAM;;;CAI9B,mBAAmB,QAAqB;AACtC,MAAI,OAAO,SACT,OAAA,cAAoB,oBAAoB,OAAO,MAAM,OAAO,SAAS;EAEvE,MAAM,QAAQ,kBAAkB,OAAO,KAAK;AAC5C,QAAA,GAAS,GAAG,KAAK,yBAAyB,MAAM,CAAC;AAGjD,OAAK,MAAM,CAAC,SAAS,YAAY,OAAO,QAAQ,OAAO,KAAK,QAAQ,CAClE,OAAA,eAAqB,OACnB,MAAM,MACN,SACA,SACA,OAAO,WAAW,SACnB;AAGH,MACE,OAAO,KAAK,OAAO,YAAY,EAAE,CAAC,CAAC,WACnC,OAAO,KAAK,OAAO,KAAK,QAAQ,CAAC,OAEjC,OAAA,kBAAwB;MAKxB,OAAA,WAAiB,MAAM,KAAK;AAE9B,QAAA,GAAS,OAAO,OAAO,KAAK,MAAM,KAAK;;CAGzC,qBAAqB,KAA0B;AAC7C,QAAA,cAAoB,oBAAoB,IAAI,OAAO,IAAI,IAAI;;CAG7D,mBAAmB,QAAqB;AACtC,QAAA,cAAoB,OAAO,OAAO,KAAK,OAAO,IAAI;EAElD,MAAM,UAAU,cAAc,OAAO,IAAI;EACzC,MAAM,UAAU,cAAc,OAAO,IAAI;AACzC,QAAA,GAAS,GAAG,KAAK,eAAe,GAAG,QAAQ,CAAC,aAAa,GAAG,QAAQ,GAAG;AAGvE,QAAA,eAAqB,YAAY,SAAS,QAAQ;AAElD,QAAA,aAAmB,OAAO,IAAI;AAC9B,QAAA,WAAiB,QAAQ;AACzB,QAAA,GAAS,OAAO,OAAO,KAAK,SAAS,QAAQ;;CAG/C,iBAAiB,KAAgB;AAC/B,MAAI,IAAI,cACN,OAAA,cAAoB,oBAAoB,IAAI,OAAO,IAAI,cAAc;EAEvE,MAAM,QAAQ,cAAc,IAAI,MAAM;EACtC,MAAM,EAAC,SAAQ,IAAI;EACnB,MAAM,OAAO,wBAAwB,OAAO,IAAI,OAAO;AACvD,QAAA,GAAS,GAAG,KACV,eAAe,GAAG,MAAM,CAAC,OAAO,GAAG,KAAK,CAAC,GAAG,cAAc,KAAK,GAChE;AAGD,QAAA,eAAqB,OAAO,OAAO,MAAM,IAAI,OAAO,MAAM,IAAI,SAAS;AAEvE,MAAI,IAAI,SACN,OAAA,kBAAwB;MAIxB,OAAA,aAAmB,IAAI,MAAM;AAE/B,QAAA,GAAS,OAAO,IAAI,KAAK,OAAO,IAAI,OAAO;;CAG7C,oBAAoB,KAAmB;EACrC,MAAM,QAAQ,cAAc,IAAI,MAAM;EACtC,IAAI,UAAU,IAAI,IAAI;EACtB,MAAM,UAAU,IAAI,IAAI;EAYxB,MAAM,UAAU,wBAAwB,OAAO,IAAI,KAAK,iBAAiB;EACzE,MAAM,UAAU,wBAAwB,OAAO,IAAI,KAAK,iBAAiB;AAGzE,MAAI,YAAY,WAAW,QAAQ,aAAa,QAAQ,UAAU;AAChE,SAAA,GAAS,OAAO,IAAI,KAAK,sBAAsB,SAAS,QAAQ;AAChE;;AAIF,MAAI,QAAQ,aAAa,QAAQ,UAAU;GAEzC,MAAM,UAAU,YAAY,MAAA,GAAS,GAAG,CAAC,QACvC,QAAO,IAAI,cAAc,SAAS,WAAW,IAAI,QAClD;GACD,MAAM,QAAQ,QAAQ,KAAI,QAAO,wBAAwB,GAAG,IAAI,KAAK,CAAC,GAAG;GACzE,MAAM,UAAU,OAAO;AACvB,SAAM,KAAK;sBACK,GAAG,MAAM,CAAC,OAAO,GAAG,QAAQ,CAAC,GAAG,cAAc,QAAQ,CAAC;iBAC5D,GAAG,MAAM,CAAC,OAAO,GAAG,QAAQ,CAAC,KAAK,GAAG,QAAQ,CAAC;sBACzC,GAAG,MAAM,CAAC,QAAQ,GAAG,QAAQ,CAAC;UAC1C;AACJ,QAAK,MAAM,OAAO,SAAS;AAEzB,QAAI,QAAQ,WAAW,IAAI,QAAQ;AACnC,WAAO,IAAI,QAAQ;AACnB,UAAM,KAAK,yBAAyB,IAAI,CAAC;;AAE3C,SAAA,GAAS,GAAG,KAAK,MAAM,KAAK,GAAG,CAAC;AAChC,aAAU;;AAEZ,MAAI,YAAY,QACd,OAAA,GAAS,GAAG,KACV,eAAe,GAAG,MAAM,CAAC,UAAU,GAAG,QAAQ,CAAC,MAAM,GAAG,QAAQ,GACjE;AAIH,QAAA,eAAqB,OACnB,OACA,IAAI,IAAI,MACR,IAAI,IAAI,MACR,IAAI,IAAI,KACT;AAED,QAAA,aAAmB,IAAI,MAAM;AAC7B,QAAA,GAAS,OAAO,IAAI,KAAK,OAAO,IAAI,IAAI;;CAG1C,kBAAkB,KAAiB;EACjC,MAAM,QAAQ,cAAc,IAAI,MAAM;EACtC,MAAM,EAAC,WAAU;AACjB,QAAA,GAAS,GAAG,KAAK,eAAe,GAAG,MAAM,CAAC,QAAQ,GAAG,OAAO,GAAG;AAG/D,QAAA,eAAqB,aAAa,OAAO,OAAO;AAEhD,QAAA,aAAmB,IAAI,MAAM;AAC7B,QAAA,GAAS,OAAO,IAAI,KAAK,OAAO,OAAO;;CAGzC,iBAAiB,MAAiB;AAChC,QAAA,cAAoB,KAAK,KAAK,GAAG;EAEjC,MAAM,OAAO,cAAc,KAAK,GAAG;AACnC,QAAA,GAAS,GAAG,KAAK,wBAAwB,GAAG,KAAK,GAAG;AAGpD,QAAA,eAAqB,YAAY,KAAK;AAEtC,QAAA,WAAiB,KAAK;AACtB,QAAA,GAAS,OAAO,KAAK,KAAK,KAAK;;CAGjC,mBAAmB,QAAqB;EACtC,MAAM,QAAQ,uBAAuB,OAAO,KAAK;AACjD,QAAA,GAAS,GAAG,KAAK,yBAAyB,MAAM,CAAC;EAMjD,MAAM,YAAY,KAAK,MAAA,WAAiB,IAAI,MAAM,UAAU,CAAC;AAC7D,OACG,UAAU,eAAe,EAAE,EAAE,WAC9B,OAAO,QAAQ,UAAU,QAAQ,CAAC,SAAS,EAE3C,OAAA,kBAAwB;MAExB,OAAA,WAAiB,MAAM,UAAU;AAEnC,QAAA,GAAS,OAAO,OAAO,KAAK,MAAM,KAAK;;CAGzC,iBAAiB,MAAiB;EAChC,MAAM,OAAO,cAAc,KAAK,GAAG;AACnC,QAAA,GAAS,GAAG,KAAK,wBAAwB,GAAG,KAAK,GAAG;AACpD,QAAA,GAAS,OAAO,KAAK,KAAK,KAAK;;CAGjC,cAAc,OAAmB;AAC/B,QAAA,cAAoB,iBAAiB,OAAO,MAAA,QAAc;AAC1D,QAAA,WAAiB,cAAc,MAAM,CAAC;;;;;CAMxC,UACE,OACA,KACA,mBACA;AAIA,MAAI,MAAA,SAAe,aAAa,sBAAsB,KAAA,GAAW;AAC/D,SAAA,UAAgB,SACd,MAAA,SACA,MAAA,OACA,OACA,KACA,kBACD;AACD,SAAA;;;CAIJ,aAAa,OAAe,KAAiB,aAAwB;AAInE,MAAI,MAAA,SAAe,aAAa,aAAa,QAAQ;AACnD,SAAA,UAAgB,YAAY,MAAA,SAAe,MAAA,OAAa,OAAO,IAAI;AACnE,SAAA;;;CAIJ,eAAe,OAAe;AAC5B,MAAI,MAAA,SAAe,WAAW;AAC5B,SAAA,UAAgB,cAAc,MAAA,SAAe,MAAM;AACnD,SAAA;;;CAIJ,YAAY,OAAe;AACzB,QAAA,gBAAsB;AACtB,MAAI,MAAA,SAAe,WAAW;AAC5B,SAAA,UAAgB,WAAW,MAAA,SAAe,MAAM;AAChD,SAAA;;AAEF,QAAA,kBAAwB;;CAG1B,gBAAgB,EAAC,UAAU,WAAW,SAAS,aAA6B;EAC1E,MAAM,YAAY,cAAc,SAAS;EACzC,MAAM,YAAY,KAAK,MAAA,WAAiB,IAAI,UAAU,CAAC;EACvD,MAAM,aAAa,SAAS,OAAO;EACnC,MAAM,OAAO,CAAC,GAAG,YAAY,GAAG,QAAQ;EAGxC,MAAM,gBAAgB,CAAC,GAAG,MAAM,yBAAyB,CAAC,IAAI,GAAG,CAAC,KAAK,IAAI;EAC3E,MAAM,SAAS,MAAM,KAAK,EAAC,QAAQ,KAAK,SAAS,GAAE,CAAC,CACjD,KAAK,IAAI,CACT,KAAK,IAAI;EACZ,MAAM,gBAAgB,WAAW,IAAI,GAAG,CAAC,KAAK,IAAI;EAElD,IAAI,aAAa;EACjB,IAAI,UAAU;AACd,OAAK,MAAM,KAAK,WAAW;GACzB,MAAM,MAAM,QACV,OAAO,YAAY,KAAK,KAAK,GAAG,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,EACjD,WACA,MAAA,WACD;GACD,MAAM,SAAS,MAAA,OAAa,KAAK,EAAC,UAAS,CAAC;GAC5C,MAAM,QAAQ,MAAA,UAAgB,eAAe,WAAW,OAAO;AAC/D,OAAI,OAAO,OAAA,OAAiB,MAAM,eAAe,WAAW;AAC1D;AACA;;GAEF,MAAM,UACJ,OAAO,OAAA,MACH,KAAK,QACH,OAAM,MAAM,0BAA0B,MAAM,OAAO,UACpD,GACD;AACN,OAAI,QAAQ,WAAW,GAAG;AAExB;AACA;;GAEF,MAAM,cAAc,QAAQ,KAAI,QAAO,GAAG,GAAG,IAAI,CAAC,YAAY,GAAG,IAAI,GAAG;AACxE,SAAA,GAAS,IACC;sBACM,GAAG,UAAU,CAAC,IAAI,cAAc,YAAY,OAAO;yBAChD,cAAc;0BACb,YAAY,KAAK,IAAI,CAAC;SAExC,GAAG,OAAO,OAAO,IAAI,IAAI,EACzB,UACD;AACD;;AAGF,QAAA,GAAS,QACP,cAAc,WAAW,iBAAiB,QAAQ,SAAS,YAC5D;;CAGH;CAEA,yBAAyB,EAAC,UAAU,SAAS,UAA4B;EACvE,MAAM,YAAY,cAAc,SAAS;EAEzC,MAAM,OAAO,CAAC,GADK,SAAS,OAAO,SACN,GAAG,QAAQ;EAExC,MAAM,iBAAiB,KAAK,oBAAoB,YAAY,MAAA,GAAS,GAAG,CAAC;AACzE,OAAK,MAAM,OAAO,KAChB,gBAAe,iBAAiB,WAAW,IAAI;AAIjD,QAAA,aAAmB,SAAS;AAC5B,MAAI,OACF,OAAA,oBAA0B;GAAC,OAAO;GAAW,SAAS;GAAM,GAAG;GAAO;AAExE,QAAA,GAAS,OAAO,wBAAwB,YAAY;;CAatD,cAAc,QAAuB,WAAiC;AACpE,MAAI,cAAc,MAAA,QAChB,OAAM,IAAI,MACR,oBAAoB,UAAU,kCAC5B,MAAA,QACD,IAAI,UAAU,OAAO,GACvB;AAEH,6BAA2B,MAAA,IAAU,UAAU;AAE/C,MAAI,MAAA,eAAqB;GACvB,MAAM,QAAQ,KAAK,KAAK;AACxB,SAAA,GAAS,GAAG,OAAO,WAAW;AAC9B,SAAA,GAAS,OACP,yCAAyC,KAAK,KAAK,GAAG,MAAM,MAC7D;;AAGH,MAAI,MAAA,SAAe,eACjB,OAAA,GAAS,QAAQ;EAGnB,MAAM,YAAY,KAAK,KAAK,GAAG,MAAA;AAC/B,QAAA,GAAS,QAAQ,gBAAgB,MAAA,QAAc,IAAI,UAAU,MAAM;AAEnE,SAAO;GACL;GACA,mBAAmB,MAAA;GACnB,eAAe,MAAA;GACf,kBAAkB,MAAA,sBAA4B;GAC/C;;CAGH,MAAM,IAAgB;AACpB,KAAG,OAAO,wBAAwB,MAAA,UAAgB;AAClD,QAAA,GAAS,UAAU;;;AAIvB,SAAS,qBACP,KACA,EAAC,eACqB;AACtB,KAAI,CAAC,aAAa,OAChB;AAEF,QAAO,YAAY,QAAO,QAAO,OAAO,IAAI;;AAG9C,SAAS,YAAY,KAAqB;AACxC,KAAI,eAAe,MACjB,QAAO;CAET,MAAM,wBAAQ,IAAI,OAAO;AACzB,OAAM,QAAQ;AACd,QAAO"}

package/out/zero-cache/src/services/replicator/incremental-sync.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"incremental-sync.js","names":["#lc","#taskID","#id","#changeStreamer","#worker","#mode","#statusPublisher","#notifier","#reporter","#state","#replicationEvents","#handleResult"],"sources":["../../../../../../zero-cache/src/services/replicator/incremental-sync.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {AbortError} from '../../../../shared/src/abort-error.ts';\nimport type {Enum} from '../../../../shared/src/enum.ts';\nimport {getOrCreateCounter} from '../../observability/metrics.ts';\nimport type {Source} from '../../types/streams.ts';\nimport type {DownloadStatus} from '../change-source/protocol/current.ts';\nimport type {ChangeStreamData} from '../change-source/protocol/current/downstream.ts';\nimport {\n  errorTypeToReadableName,\n  PROTOCOL_VERSION,\n  type ChangeStreamer,\n  type Downstream,\n} from '../change-streamer/change-streamer.ts';\nimport type * as ErrorType from '../change-streamer/error-type-enum.ts';\nimport {RunningState} from '../running-state.ts';\nimport type {CommitResult} from './change-processor.ts';\nimport {Notifier} from './notifier.ts';\nimport type {ReplicationStatusPublisher} from './replication-status.ts';\nimport type {ReplicaState, ReplicatorMode} from './replicator.ts';\nimport {ReplicationReportRecorder} from './reporter/recorder.ts';\nimport type {ReplicationReport} from './reporter/report-schema.ts';\nimport type {WriteWorkerClient} from './write-worker-client.ts';\n\ntype ErrorType = Enum<typeof ErrorType>;\n\n/**\n * The {@link IncrementalSyncer} manages a logical replication stream from upstream,\n * handling application lifecycle events (start, stop) and retrying the\n * connection with exponential backoff. The actual handling of the logical\n * replication messages is done by the {@link ChangeProcessor}, which runs\n * in a worker thread via the {@link WriteWorkerClient}.\n */\nexport class IncrementalSyncer {\n  readonly #lc: LogContext;\n  readonly #taskID: string;\n  readonly #id: string;\n  readonly #changeStreamer: ChangeStreamer;\n  readonly #worker: WriteWorkerClient;\n  readonly #mode: ReplicatorMode;\n  readonly #statusPublisher: ReplicationStatusPublisher | null;\n  readonly #notifier: Notifier;\n  readonly #reporter: ReplicationReportRecorder;\n\n  readonly #state = new RunningState('IncrementalSyncer');\n\n  readonly #replicationEvents = getOrCreateCounter(\n    'replication',\n    'events',\n    'Number of replication events processed',\n  );\n\n  constructor(\n    lc: LogContext,\n    taskID: string,\n    id: string,\n    changeStreamer: ChangeStreamer,\n    worker: WriteWorkerClient,\n    mode: ReplicatorMode,\n    statusPublisher: ReplicationStatusPublisher | null,\n  ) {\n    this.#lc = lc;\n    this.#taskID = taskID;\n    this.#id = id;\n    this.#changeStreamer = changeStreamer;\n    this.#worker = worker;\n    this.#mode = mode;\n    this.#statusPublisher = statusPublisher;\n    this.#notifier = new Notifier();\n    this.#reporter = new ReplicationReportRecorder(lc);\n  }\n\n  async run() {\n    const lc = this.#lc;\n    this.#worker.onError(err => this.#state.stop(lc, err));\n    lc.info?.(`Starting IncrementalSyncer`);\n    const {watermark: initialWatermark} =\n      await this.#worker.getSubscriptionState();\n\n    // Notify any waiting subscribers that the replica is ready to be read.\n    void this.#notifier.notifySubscribers();\n\n    while (this.#state.shouldRun()) {\n      const {replicaVersion, watermark} =\n        await this.#worker.getSubscriptionState();\n\n      let downstream: Source<Downstream> | undefined;\n      let unregister = () => {};\n      let err: unknown | undefined;\n\n      try {\n        downstream = await this.#changeStreamer.subscribe({\n          protocolVersion: PROTOCOL_VERSION,\n          taskID: this.#taskID,\n          id: this.#id,\n          mode: this.#mode,\n          watermark,\n          replicaVersion,\n          initial: watermark === initialWatermark,\n        });\n        this.#state.resetBackoff();\n        unregister = this.#state.cancelOnStop(downstream);\n        this.#statusPublisher?.publish(\n          lc,\n          'Replicating',\n          `Replicating from ${watermark}`,\n        );\n\n        let backfillStatus: DownloadStatus | undefined;\n\n        for await (const message of downstream) {\n          this.#replicationEvents.add(1);\n          switch (message[0]) {\n            case 'status': {\n              const {lagReport} = message[1];\n              if (lagReport) {\n                const report: ReplicationReport = {\n                  nextSendTimeMs: lagReport.nextSendTimeMs,\n                };\n                if (lagReport.lastTimings) {\n                  report.lastTimings = {\n                    ...lagReport.lastTimings,\n                    replicateTimeMs: Date.now(),\n                  };\n                }\n                this.#reporter.record(report);\n              }\n              break;\n            }\n            case 'error': {\n              // Signal from the replication-manager that the view-syncer must\n              // shut down and restore a new backup from litestream.\n              const {type, message: msg} = message[1];\n              this.stop(\n                lc,\n                // Note: The AbortError indicates a clean / intentional shutdown.\n                new AbortError(\n                  `${errorTypeToReadableName(type as ErrorType)}: ${msg}`,\n                ),\n              );\n              break;\n            }\n            default: {\n              const msg = message[1];\n              if (msg.tag === 'backfill' && msg.status) {\n                const {status} = msg;\n                if (!backfillStatus) {\n                  // Start publishing the status every 3 seconds.\n                  backfillStatus = status;\n                  this.#statusPublisher?.publish(\n                    lc,\n                    'Replicating',\n                    `Backfilling ${msg.relation.name} table`,\n                    3000,\n                    () =>\n                      backfillStatus\n                        ? {\n                            downloadStatus: [\n                              {\n                                ...backfillStatus,\n                                table: msg.relation.name,\n                                columns: [\n                                  ...msg.relation.rowKey.columns,\n                                  ...msg.columns,\n                                ],\n                              },\n                            ],\n                          }\n                        : {},\n                  );\n                }\n                backfillStatus = status; // Update the current status\n              }\n\n              const result = await this.#worker.processMessage(\n                message as ChangeStreamData,\n              );\n\n              this.#handleResult(lc, result);\n              if (result?.completedBackfill) {\n                backfillStatus = undefined;\n              }\n              break;\n            }\n          }\n        }\n        this.#worker.abort();\n      } catch (e) {\n        err = e;\n        this.#worker.abort();\n      } finally {\n        downstream?.cancel();\n        unregister();\n        this.#statusPublisher?.stop();\n      }\n      await this.#state.backoff(lc, err);\n    }\n    lc.info?.('IncrementalSyncer stopped');\n  }\n\n  #handleResult(lc: LogContext, result: CommitResult | null) {\n    if (!result) {\n      return;\n    }\n    if (result.completedBackfill) {\n      // Publish the final status\n      const status = result.completedBackfill;\n      this.#statusPublisher?.publish(\n        lc,\n        'Replicating',\n        `Backfilled ${status.table} table`,\n        0,\n        () => ({downloadStatus: [status]}),\n      );\n    } else if (result.schemaUpdated) {\n      this.#statusPublisher?.publish(lc, 'Replicating', 'Schema updated');\n    }\n    if (result.watermark && result.changeLogUpdated) {\n      void this.#notifier.notifySubscribers({state: 'version-ready'});\n    }\n  }\n\n  subscribe(): Source<ReplicaState> {\n    return this.#notifier.subscribe();\n  }\n\n  stop(lc: LogContext, err?: unknown) {\n    this.#state.stop(lc, err);\n  }\n}\n"],"mappings":"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"}

package/out/zero-cache/src/services/replicator/notifier.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"notifier.js","names":["#eventEmitter","#newSubscription","#lastStateReceived"],"sources":["../../../../../../zero-cache/src/services/replicator/notifier.ts"],"sourcesContent":["import {EventEmitter} from 'eventemitter3';\nimport {\n  type PendingResult,\n  type Result,\n  Subscription,\n} from '../../types/subscription.ts';\nimport type {ReplicaState, ReplicaStateNotifier} from './replicator.ts';\n\n/**\n * Handles the semantics of {@link ReplicatorVersionNotifier.subscribe()}\n * notifications, namely:\n *\n * * New subscribers are notified immediately with the latest received\n *   ReplicaState.\n *\n * * Non-latest notifications are discarded if the subscriber is too\n *   busy to consume them.\n *\n * By encapsulating the state for the first behavior (essentially, whether\n * the first notification has been sent by the Replicator), Notifier objects\n * can be chained to simplify fanout from Replicator to View Syncers.\n *\n * In particular, each Syncer Thread can manage a single Subscription to\n * the Replicator across a MessageChannel, which it uses for its own Notifier\n * instance to manage subscriptions from View Syncers within its thread. This\n * way a Replicator only deals with sending notifications to a bounded set\n * of MessageChannel-based subscribers (Syncer Threads), while the dynamic\n * subscribe and unsubscribe traffic from View Syncers remains within each\n * Syncer Thread.\n */\nexport class Notifier implements ReplicaStateNotifier {\n  readonly #eventEmitter = new EventEmitter();\n  #lastStateReceived: ReplicaState | undefined;\n\n  #newSubscription() {\n    const notify = (state: ReplicaState) => subscription.push(state);\n    const subscription = Subscription.create<ReplicaState>({\n      coalesce: curr => curr,\n      cleanup: () => this.#eventEmitter.off('version', notify),\n    });\n    return {notify, subscription};\n  }\n\n  subscribe(): Subscription<ReplicaState> {\n    const {notify, subscription} = this.#newSubscription();\n    this.#eventEmitter.on('version', notify);\n    if (this.#lastStateReceived) {\n      // Per Replicator.subscribe() semantics, the current state of the\n      // replica, if known, is immediately sent on subscribe.\n      notify(this.#lastStateReceived);\n    }\n    return subscription;\n  }\n\n  notifySubscribers(\n    state: ReplicaState = {state: 'version-ready'},\n  ): Promise<Result>[] {\n    this.#lastStateReceived = state;\n    return this.#eventEmitter\n      .listeners('version')\n      .map(notify => notify(state) as unknown as PendingResult)\n      .map(pending => pending.result);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,IAAa,WAAb,MAAsD;CACpD,gBAAyB,IAAI,cAAc;CAC3C;CAEA,mBAAmB;EACjB,MAAM,UAAU,UAAwB,aAAa,KAAK,MAAM;EAChE,MAAM,eAAe,aAAa,OAAqB;GACrD,WAAU,SAAQ;GAClB,eAAe,MAAA,aAAmB,IAAI,WAAW,OAAO;GACzD,CAAC;AACF,SAAO;GAAC;GAAQ;GAAa;;CAG/B,YAAwC;EACtC,MAAM,EAAC,QAAQ,iBAAgB,MAAA,iBAAuB;AACtD,QAAA,aAAmB,GAAG,WAAW,OAAO;AACxC,MAAI,MAAA,kBAGF,QAAO,MAAA,kBAAwB;AAEjC,SAAO;;CAGT,kBACE,QAAsB,EAAC,OAAO,iBAAgB,EAC3B;AACnB,QAAA,oBAA0B;AAC1B,SAAO,MAAA,aACJ,UAAU,UAAU,CACpB,KAAI,WAAU,OAAO,MAAM,CAA6B,CACxD,KAAI,YAAW,QAAQ,OAAO"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"replication-status.js","names":["#dbRunner","#publish","#timer"],"sources":["../../../../../../zero-cache/src/services/replicator/replication-status.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {createSilentLogContext} from '../../../../shared/src/logging-test-utils.ts';\nimport type {JSONObject} from '../../../../zero-events/src/json.ts';\nimport type {\n  ReplicatedIndex,\n  ReplicatedTable,\n  ReplicationStage,\n  ReplicationState,\n  ReplicationStatusEvent,\n  Status,\n} from '../../../../zero-events/src/status.ts';\nimport {Database} from '../../../../zqlite/src/db.ts';\nimport {computeZqlSpecs, listIndexes} from '../../db/lite-tables.ts';\nimport type {LiteTableSpec} from '../../db/specs.ts';\nimport {\n  makeErrorDetails,\n  publishCriticalEvent,\n} from '../../observability/events.ts';\n\nconst byKeys = (a: [string, unknown], b: [string, unknown]) =>\n  a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0;\n\nexport class ReplicationStatusPublisher {\n  readonly #dbRunner: <T>(lc: LogContext, fn: (db: Database) => T) => T;\n  readonly #publish: typeof publishCriticalEvent;\n  #timer: NodeJS.Timeout | undefined;\n\n  static forTesting() {\n    return ReplicationStatusPublisher.forReplicaFile(':memory:');\n  }\n\n  static forRunningTransaction(tx: Database, publishFn = publishCriticalEvent) {\n    return new ReplicationStatusPublisher((_lc, fn) => fn(tx), publishFn);\n  }\n\n  static forReplicaFile(file: string, publishFn = publishCriticalEvent) {\n    return new ReplicationStatusPublisher((lc, fn) => {\n      const db = new Database(lc, file, {readonly: true});\n      try {\n        return fn(db);\n      } finally {\n        db.close();\n      }\n    }, publishFn);\n  }\n\n  constructor(\n    dbRunner: <T>(lc: LogContext, fn: (db: Database) => T) => T,\n    publishFn = publishCriticalEvent,\n  ) {\n    this.#dbRunner = dbRunner;\n    this.#publish = publishFn;\n  }\n\n  publish(\n    lc: LogContext,\n    stage: ReplicationStage,\n    description?: string,\n    interval = 0,\n    extraState?: () => Partial<ReplicationState>,\n    now = new Date(),\n  ): this {\n    this.stop();\n\n    const event = this.#dbRunner(lc, db =>\n      replicationStatusEvent(lc, db, stage, 'OK', description, now),\n    );\n    if (event.state) {\n      event.state = {\n        ...event.state,\n        ...extraState?.(),\n      };\n    }\n    void this.#publish(lc, event);\n\n    if (interval) {\n      this.#timer = setInterval(\n        () => this.publish(lc, stage, description, interval, extraState),\n        interval,\n      );\n    }\n    return this;\n  }\n\n  async publishAndThrowError(\n    lc: LogContext,\n    stage: ReplicationStage,\n    e: unknown,\n  ): Promise<never> {\n    this.stop();\n    const event = this.#dbRunner(lc, db =>\n      replicationStatusError(lc, stage, e, db),\n    );\n    await this.#publish(lc, event);\n    throw e;\n  }\n\n  stop(): this {\n    clearInterval(this.#timer);\n    return this;\n  }\n}\n\nexport async function publishReplicationError(\n  lc: LogContext,\n  stage: ReplicationStage,\n  description: string,\n  errorDetails?: JSONObject,\n  now = new Date(),\n) {\n  const event: ReplicationStatusEvent = {\n    type: 'zero/events/status/replication/v1',\n    component: 'replication',\n    status: 'ERROR',\n    stage,\n    description,\n    errorDetails,\n    time: now.toISOString(),\n  };\n  await publishCriticalEvent(lc, event);\n}\n\nexport function replicationStatusError(\n  lc: LogContext,\n  stage: ReplicationStage,\n  e: unknown,\n  db?: Database,\n  now = new Date(),\n) {\n  const event = replicationStatusEvent(lc, db, stage, 'ERROR', String(e), now);\n  event.errorDetails = makeErrorDetails(e);\n  return event;\n}\n\n// Exported for testing.\nexport function replicationStatusEvent(\n  lc: LogContext,\n  db: Database | undefined,\n  stage: ReplicationStage,\n  status: Status,\n  description?: string,\n  now = new Date(),\n): ReplicationStatusEvent {\n  const start = performance.now();\n  try {\n    return {\n      type: 'zero/events/status/replication/v1',\n      component: 'replication',\n      status,\n      stage,\n      description,\n      time: now.toISOString(),\n      state: {\n        tables: db ? getReplicatedTables(db) : [],\n        indexes: db ? getReplicatedIndexes(db) : [],\n        replicaSize: db ? getReplicaSize(db) : undefined,\n      },\n    };\n  } catch (e) {\n    lc.warn?.(`Unable to create full ReplicationStatusEvent`, e);\n    return {\n      type: 'zero/events/status/replication/v1',\n      component: 'replication',\n      status,\n      stage,\n      description,\n      time: now.toISOString(),\n      state: {\n        tables: [],\n        indexes: [],\n        replicaSize: 0,\n      },\n    };\n  } finally {\n    const elapsed = (performance.now() - start).toFixed(3);\n    lc.debug?.(`computed schema for replication event (${elapsed} ms)`);\n  }\n}\n\nfunction getReplicatedTables(db: Database): ReplicatedTable[] {\n  const fullTables = new Map<string, LiteTableSpec>();\n  const clientSchema = computeZqlSpecs(\n    createSilentLogContext(), // avoid logging warnings about indexes\n    db,\n    {includeBackfillingColumns: false},\n    new Map(),\n    fullTables,\n  );\n\n  // oxlint-disable-next-line e18e/prefer-array-to-sorted\n  return [...fullTables.entries()].sort(byKeys).map(([table, spec]) => ({\n    table,\n    columns: Object.entries(spec.columns)\n      .sort(byKeys)\n      .map(([column, spec]) => ({\n        column,\n        upstreamType: spec.dataType.split('|')[0],\n        clientType: clientSchema.get(table)?.zqlSpec[column]?.type ?? null,\n      })),\n  }));\n}\n\nfunction getReplicatedIndexes(db: Database): ReplicatedIndex[] {\n  return listIndexes(db).map(({tableName: table, columns, unique}) => ({\n    table,\n    unique,\n    columns: Object.entries(columns)\n      .sort(byKeys)\n      .map(([column, dir]) => ({column, dir})),\n  }));\n}\n\nfunction getReplicaSize(db: Database) {\n  const [{page_count: pageCount}] = db.pragma<{page_count: number}>(\n    'page_count',\n  );\n  const [{page_size: pageSize}] = db.pragma<{page_size: number}>('page_size');\n  return pageCount * pageSize;\n}\n"],"mappings":"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"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"replicator.js","names":["#lc","#incrementalSyncer","#worker","#runPromise"],"sources":["../../../../../../zero-cache/src/services/replicator/replicator.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport type {ReadonlyJSONObject} from '../../../../shared/src/json.ts';\nimport type {Source} from '../../types/streams.ts';\nimport type {ChangeStreamer} from '../change-streamer/change-streamer.ts';\nimport type {Service} from '../service.ts';\nimport {IncrementalSyncer} from './incremental-sync.ts';\nimport type {ReplicationStatusPublisher} from './replication-status.ts';\nimport type {WriteWorkerClient} from './write-worker-client.ts';\n\n/** See {@link ReplicaStateNotifier.subscribe()}. */\nexport type ReplicaState = {\n  readonly state: 'version-ready';\n\n  // Used in tests to verify behavior when additional information\n  // is ferried in the future. Not set in production.\n  readonly testSeqNum?: number;\n};\n\nexport interface ReplicaStateNotifier {\n  /**\n   * Creates a cancelable subscription of changes in the replica state.\n   *\n   * A `version-ready` message indicates that the replica is ready to be\n   * read, and henceforth that a _new_ version is ready, i.e. whenever a\n   * change is committed to the replica. The `version-ready` message itself\n   * otherwise contains no other information; the subscriber queries the\n   * replica for the current data.\n   *\n   * A `maintenance` state indicates that the replica should not be read from.\n   * If a subscriber is holding any transaction locks, it should release them\n   * until the next `version-ready` signal.\n   *\n   * Upon subscription, the current state of the replica is sent immediately\n   * if known. If multiple notifications occur before the subscriber\n   * can consume them, all but the last notification are discarded by the\n   * Subscription object (i.e. not buffered). Thus, a subscriber only\n   * ever consumes the current (i.e. known) state of the replica. This avoids\n   * a buildup of \"work\" if a subscriber is too busy to consume all\n   * notifications.\n   */\n  subscribe(): Source<ReplicaState>;\n}\n\nexport interface Replicator extends ReplicaStateNotifier {\n  /**\n   * Returns an opaque message for human-readable consumption. This is\n   * purely for ensuring that the Replicator has started at least once to\n   * bootstrap a new replica.\n   */\n  status(): Promise<ReadonlyJSONObject>;\n}\n\nexport type ReplicatorMode = 'backup' | 'serving';\n\nexport class ReplicatorService implements Replicator, Service {\n  readonly id: string;\n  readonly #lc: LogContext;\n  readonly #incrementalSyncer: IncrementalSyncer;\n  readonly #worker: WriteWorkerClient;\n  #runPromise: Promise<void> | undefined;\n\n  constructor(\n    lc: LogContext,\n    taskID: string,\n    id: string,\n    mode: ReplicatorMode,\n    changeStreamer: ChangeStreamer,\n    worker: WriteWorkerClient,\n    statusPublisher: ReplicationStatusPublisher | null,\n  ) {\n    this.id = id;\n    this.#lc = lc\n      .withContext('component', 'replicator')\n      .withContext('serviceID', this.id);\n    this.#worker = worker;\n\n    this.#incrementalSyncer = new IncrementalSyncer(\n      this.#lc,\n      taskID,\n      `${taskID}/${id}`,\n      changeStreamer,\n      worker,\n      mode,\n      statusPublisher,\n    );\n  }\n\n  status() {\n    return Promise.resolve({status: 'ok'});\n  }\n\n  run() {\n    this.#runPromise = this.#incrementalSyncer.run();\n    return this.#runPromise;\n  }\n\n  subscribe(): Source<ReplicaState> {\n    return this.#incrementalSyncer.subscribe();\n  }\n\n  async stop() {\n    this.#incrementalSyncer.stop(this.#lc);\n    // Wait for the syncer's run loop to finish so that any in-flight\n    // worker.processMessage() call completes and clears #pending\n    // before we send the 'stop' message to the worker.\n    await this.#runPromise;\n    await this.#worker.stop();\n  }\n}\n"],"mappings":";;AAsDA,IAAa,oBAAb,MAA8D;CAC5D;CACA;CACA;CACA;CACA;CAEA,YACE,IACA,QACA,IACA,MACA,gBACA,QACA,iBACA;AACA,OAAK,KAAK;AACV,QAAA,KAAW,GACR,YAAY,aAAa,aAAa,CACtC,YAAY,aAAa,KAAK,GAAG;AACpC,QAAA,SAAe;AAEf,QAAA,oBAA0B,IAAI,kBAC5B,MAAA,IACA,QACA,GAAG,OAAO,GAAG,MACb,gBACA,QACA,MACA,gBACD;;CAGH,SAAS;AACP,SAAO,QAAQ,QAAQ,EAAC,QAAQ,MAAK,CAAC;;CAGxC,MAAM;AACJ,QAAA,aAAmB,MAAA,kBAAwB,KAAK;AAChD,SAAO,MAAA;;CAGT,YAAkC;AAChC,SAAO,MAAA,kBAAwB,WAAW;;CAG5C,MAAM,OAAO;AACX,QAAA,kBAAwB,KAAK,MAAA,GAAS;AAItC,QAAM,MAAA;AACN,QAAM,MAAA,OAAa,MAAM"}

package/out/zero-cache/src/services/replicator/reporter/recorder.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"recorder.js","names":["#lc","#now","#last"],"sources":["../../../../../../../zero-cache/src/services/replicator/reporter/recorder.ts"],"sourcesContent":["import type {ObservableResult} from '@opentelemetry/api';\nimport type {LogContext} from '@rocicorp/logger';\nimport {getOrCreateGauge} from '../../../observability/metrics.ts';\nimport type {ReplicationReport} from './report-schema.ts';\n\n// Hook for sanity checking lag reports in development.\nconst LOG_ALL_REPLICATION_REPORTS_AT_DEBUG =\n  process.env.ZERO_LOG_ALL_REPLICATION_REPORTS_AT_DEBUG === '1';\n\nexport class ReplicationReportRecorder {\n  readonly #lc: LogContext;\n  readonly #now: () => number;\n  #last: ReplicationReport | null = null;\n\n  constructor(lc: LogContext, now = Date.now) {\n    this.#lc = lc;\n    this.#now = now;\n  }\n\n  record(report: ReplicationReport) {\n    const first = this.#last === null;\n    this.#last = report;\n\n    const {lastTimings} = report;\n    if (lastTimings) {\n      const total = lastTimings.replicateTimeMs - lastTimings.sendTimeMs;\n      if (total > 10_000) {\n        this.#lc.warn?.(`high replication lag: ${total} ms`, report);\n      } else if (total > 1_000) {\n        this.#lc.info?.(`replication lag: ${total} ms`, report);\n      }\n      if (LOG_ALL_REPLICATION_REPORTS_AT_DEBUG) {\n        this.#lc.debug?.(`replication lag ${total} ms`, report);\n      }\n    }\n\n    if (first) {\n      getOrCreateGauge('replication', 'upstream_lag', {\n        description:\n          'Latency from sending an upstream replication report ' +\n          'to receiving it in the replication stream',\n        unit: 'millisecond',\n      }).addCallback(this.reportUpstreamLag);\n\n      getOrCreateGauge('replication', 'replica_lag', {\n        description:\n          'Latency from receiving an upstream replication report ' +\n          'to its reaching the replica',\n        unit: 'millisecond',\n      }).addCallback(this.reportReplicaLag);\n\n      getOrCreateGauge('replication', 'total_lag', {\n        description:\n          'Latency from sending an upstream replication report to its ' +\n          'reaching the replica. This will be a (growing) estimate if the ' +\n          'next expected report has yet to be received and the elapsed ' +\n          `time has exceeded the previous report's total lag.`,\n        unit: 'millisecond',\n      }).addCallback(this.reportTotalLag);\n    }\n  }\n\n  readonly reportUpstreamLag = (o: ObservableResult) => {\n    const last = this.#last?.lastTimings;\n    if (last) {\n      o.observe(last.receiveTimeMs - last.sendTimeMs);\n    }\n  };\n\n  readonly reportReplicaLag = (o: ObservableResult) => {\n    const last = this.#last?.lastTimings;\n    if (last) {\n      o.observe(last.replicateTimeMs - last.receiveTimeMs);\n    }\n  };\n\n  readonly reportTotalLag = (o: ObservableResult) => {\n    const last = this.#last;\n    if (last) {\n      const nextLagEstimate = this.#now() - last.nextSendTimeMs;\n      const timings = last.lastTimings;\n      const lastLag = timings\n        ? timings.replicateTimeMs - timings.sendTimeMs\n        : 0;\n      o.observe(Math.max(lastLag, nextLagEstimate));\n    }\n  };\n}\n"],"mappings":";;AAMA,IAAM,uCACJ,QAAQ,IAAI,8CAA8C;AAE5D,IAAa,4BAAb,MAAuC;CACrC;CACA;CACA,QAAkC;CAElC,YAAY,IAAgB,MAAM,KAAK,KAAK;AAC1C,QAAA,KAAW;AACX,QAAA,MAAY;;CAGd,OAAO,QAA2B;EAChC,MAAM,QAAQ,MAAA,SAAe;AAC7B,QAAA,OAAa;EAEb,MAAM,EAAC,gBAAe;AACtB,MAAI,aAAa;GACf,MAAM,QAAQ,YAAY,kBAAkB,YAAY;AACxD,OAAI,QAAQ,IACV,OAAA,GAAS,OAAO,yBAAyB,MAAM,MAAM,OAAO;YACnD,QAAQ,IACjB,OAAA,GAAS,OAAO,oBAAoB,MAAM,MAAM,OAAO;AAEzD,OAAI,qCACF,OAAA,GAAS,QAAQ,mBAAmB,MAAM,MAAM,OAAO;;AAI3D,MAAI,OAAO;AACT,oBAAiB,eAAe,gBAAgB;IAC9C,aACE;IAEF,MAAM;IACP,CAAC,CAAC,YAAY,KAAK,kBAAkB;AAEtC,oBAAiB,eAAe,eAAe;IAC7C,aACE;IAEF,MAAM;IACP,CAAC,CAAC,YAAY,KAAK,iBAAiB;AAErC,oBAAiB,eAAe,aAAa;IAC3C,aACE;IAIF,MAAM;IACP,CAAC,CAAC,YAAY,KAAK,eAAe;;;CAIvC,qBAA8B,MAAwB;EACpD,MAAM,OAAO,MAAA,MAAY;AACzB,MAAI,KACF,GAAE,QAAQ,KAAK,gBAAgB,KAAK,WAAW;;CAInD,oBAA6B,MAAwB;EACnD,MAAM,OAAO,MAAA,MAAY;AACzB,MAAI,KACF,GAAE,QAAQ,KAAK,kBAAkB,KAAK,cAAc;;CAIxD,kBAA2B,MAAwB;EACjD,MAAM,OAAO,MAAA;AACb,MAAI,MAAM;GACR,MAAM,kBAAkB,MAAA,KAAW,GAAG,KAAK;GAC3C,MAAM,UAAU,KAAK;GACrB,MAAM,UAAU,UACZ,QAAQ,kBAAkB,QAAQ,aAClC;AACJ,KAAE,QAAQ,KAAK,IAAI,SAAS,gBAAgB,CAAC"}

package/out/zero-cache/src/services/replicator/reporter/report-schema.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"report-schema.js","names":[],"sources":["../../../../../../../zero-cache/src/services/replicator/reporter/report-schema.ts"],"sourcesContent":["import * as v from '../../../../../shared/src/valita.ts';\n\nexport const changeSourceTimingsSchema = v.object({\n  sendTimeMs: v.number(),\n  commitTimeMs: v.number(),\n  receiveTimeMs: v.number(),\n});\n\nexport const changeSourceReportSchema = v.object({\n  lastTimings: changeSourceTimingsSchema,\n  nextSendTimeMs: v.number(),\n});\n\nexport const replicationTimingsSchema = changeSourceTimingsSchema.extend({\n  replicateTimeMs: v.number(),\n});\n\nexport const replicationReportSchema = v.object({\n  lastTimings: replicationTimingsSchema.optional(),\n  nextSendTimeMs: v.number(),\n});\n\nexport type ChangeSourceTimings = v.Infer<typeof changeSourceTimingsSchema>;\nexport type ChangeSourceReport = v.Infer<typeof changeSourceReportSchema>;\n\nexport type ReplicationTimings = v.Infer<typeof replicationTimingsSchema>;\nexport type ReplicationReport = v.Infer<typeof replicationReportSchema>;\n"],"mappings":";;AAEA,IAAa,4BAA4B,eAAE,OAAO;CAChD,YAAY,eAAE,QAAQ;CACtB,cAAc,eAAE,QAAQ;CACxB,eAAe,eAAE,QAAQ;CAC1B,CAAC;AAEF,IAAa,2BAA2B,eAAE,OAAO;CAC/C,aAAa;CACb,gBAAgB,eAAE,QAAQ;CAC3B,CAAC;AAEF,IAAa,2BAA2B,0BAA0B,OAAO,EACvE,iBAAiB,eAAE,QAAQ,EAC5B,CAAC;AAEqC,eAAE,OAAO;CAC9C,aAAa,yBAAyB,UAAU;CAChD,gBAAgB,eAAE,QAAQ;CAC3B,CAAC"}

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

@@ -1 +0,0 @@
-{"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    // oxlint-disable-next-line zero/no-select-star -- Local SQLite replica query; not run through pg prepared statements.\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;AAGF,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"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"column-metadata.js","names":["#instances","#insertStmt","#updateStmt","#clearBackfillStmt","#deleteColumnStmt","#deleteTableStmt","#renameTableStmt","#getColumnStmt","#getTableStmt","#hasTableStmt","#insertMetadata"],"sources":["../../../../../../../zero-cache/src/services/replicator/schema/column-metadata.ts"],"sourcesContent":["/**\n * Column metadata table for storing upstream PostgreSQL schema information.\n *\n * Previously, upstream type metadata was embedded in SQLite column type strings\n * using pipe-delimited notation (e.g., \"int8|NOT_NULL|TEXT_ENUM\"). This caused\n * issues with SQLite type affinity and made schema inspection difficult.\n *\n * This table stores that metadata separately, allowing SQLite columns to use\n * plain type names while preserving all necessary upstream type information.\n */\n\nimport type {Database, Statement} from '../../../../../zqlite/src/db.ts';\nimport {isArrayColumn, isEnumColumn} from '../../../db/pg-to-lite.ts';\nimport type {ColumnSpec, LiteTableSpec} from '../../../db/specs.ts';\nimport {\n  isArray as checkIsArray,\n  isEnum as checkIsEnum,\n  liteTypeString,\n  nullableUpstream,\n  upstreamDataType,\n} from '../../../types/lite.ts';\nimport type {BackfillID} from '../../change-source/protocol/current.ts';\n\n/**\n * Structured column metadata, replacing the old pipe-delimited string format.\n */\nexport interface ColumnMetadata {\n  /** PostgreSQL type name, e.g., 'int8', 'varchar', 'text[]', 'user_role' */\n  upstreamType: string;\n  isNotNull: boolean;\n  isEnum: boolean;\n  isArray: boolean;\n  /** Maximum character length for varchar/char types */\n  characterMaxLength?: number | null;\n  isBackfilling: boolean;\n}\n\ntype ColumnMetadataRow = {\n  upstream_type: string;\n  is_not_null: number;\n  is_enum: number;\n  is_array: number;\n  character_max_length: number | null;\n  backfill: string | null;\n};\n\nexport const CREATE_COLUMN_METADATA_TABLE = `\n  CREATE TABLE \"_zero.column_metadata\" (\n    table_name TEXT NOT NULL,\n    column_name TEXT NOT NULL,\n    upstream_type TEXT NOT NULL,\n    is_not_null INTEGER NOT NULL,\n    is_enum INTEGER NOT NULL,\n    is_array INTEGER NOT NULL,\n    character_max_length INTEGER,\n    backfill TEXT,\n    PRIMARY KEY (table_name, column_name)\n  );\n`;\n\n/**\n * Efficient column metadata store that prepares all statements upfront.\n * Use this class to avoid re-preparing statements on every operation.\n *\n * Access via `ColumnMetadataStore.getInstance(db)`, which returns `undefined`\n * if the metadata table doesn't exist yet.\n */\nexport class ColumnMetadataStore {\n  static #instances = new WeakMap<Database, ColumnMetadataStore>();\n\n  readonly #insertStmt: Statement;\n  readonly #updateStmt: Statement;\n  readonly #clearBackfillStmt: Statement;\n  readonly #deleteColumnStmt: Statement;\n  readonly #deleteTableStmt: Statement;\n  readonly #renameTableStmt: Statement;\n  readonly #getColumnStmt: Statement;\n  readonly #getTableStmt: Statement;\n  readonly #hasTableStmt: Statement;\n\n  private constructor(db: Database) {\n    this.#insertStmt = db.prepare(`\n      INSERT INTO \"_zero.column_metadata\"\n        (table_name, column_name, upstream_type, is_not_null, is_enum, is_array, character_max_length, backfill)\n      VALUES (?, ?, ?, ?, ?, ?, ?, ?)\n    `);\n\n    this.#updateStmt = db.prepare(`\n      UPDATE \"_zero.column_metadata\"\n      SET column_name = ?,\n          upstream_type = ?,\n          is_not_null = ?,\n          is_enum = ?,\n          is_array = ?,\n          character_max_length = ?\n      WHERE table_name = ? AND column_name = ?\n    `);\n\n    this.#clearBackfillStmt = db.prepare(/*sql*/ `\n      UPDATE \"_zero.column_metadata\"\n      SET backfill = NULL\n      WHERE table_name = ? AND column_name = ?\n    `);\n\n    this.#deleteColumnStmt = db.prepare(`\n      DELETE FROM \"_zero.column_metadata\"\n      WHERE table_name = ? AND column_name = ?\n    `);\n\n    this.#deleteTableStmt = db.prepare(`\n      DELETE FROM \"_zero.column_metadata\"\n      WHERE table_name = ?\n    `);\n\n    this.#renameTableStmt = db.prepare(`\n      UPDATE \"_zero.column_metadata\"\n      SET table_name = ?\n      WHERE table_name = ?\n    `);\n\n    this.#getColumnStmt = db.prepare(`\n      SELECT upstream_type, is_not_null, is_enum, is_array, character_max_length, backfill\n      FROM \"_zero.column_metadata\"\n      WHERE table_name = ? AND column_name = ?\n    `);\n\n    this.#getTableStmt = db.prepare(`\n      SELECT column_name, upstream_type, is_not_null, is_enum, is_array, character_max_length, backfill\n      FROM \"_zero.column_metadata\"\n      WHERE table_name = ?\n      ORDER BY column_name\n    `);\n\n    this.#hasTableStmt = db.prepare(`\n      SELECT 1 FROM sqlite_master\n      WHERE type = 'table' AND name = '_zero.column_metadata'\n    `);\n  }\n\n  /**\n   * Gets the singleton instance of ColumnMetadataStore for the given database.\n   * Returns `undefined` if the metadata table doesn't exist yet.\n   */\n  static getInstance(db: Database): ColumnMetadataStore | undefined {\n    // Check if table exists\n    const tableExists = db\n      .prepare(\n        `SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = '_zero.column_metadata'`,\n      )\n      .get();\n\n    if (!tableExists) {\n      return undefined;\n    }\n\n    let instance = ColumnMetadataStore.#instances.get(db);\n    if (!instance) {\n      instance = new ColumnMetadataStore(db);\n      ColumnMetadataStore.#instances.set(db, instance);\n    }\n    return instance;\n  }\n\n  insert(\n    tableName: string,\n    columnName: string,\n    spec: ColumnSpec,\n    backfill?: BackfillID,\n  ): void {\n    const metadata = pgColumnSpecToMetadata(spec);\n    this.#insertMetadata(tableName, columnName, metadata, backfill);\n  }\n\n  #insertMetadata(\n    tableName: string,\n    columnName: string,\n    metadata: Omit<ColumnMetadata, 'isBackfilling'>,\n    backfill?: BackfillID,\n  ): void {\n    this.#insertStmt.run(\n      tableName,\n      columnName,\n      metadata.upstreamType,\n      metadata.isNotNull ? 1 : 0,\n      metadata.isEnum ? 1 : 0,\n      metadata.isArray ? 1 : 0,\n      metadata.characterMaxLength ?? null,\n      backfill ? JSON.stringify(backfill) : null,\n    );\n  }\n\n  update(\n    tableName: string,\n    oldColumnName: string,\n    newColumnName: string,\n    spec: ColumnSpec,\n  ): void {\n    const metadata = pgColumnSpecToMetadata(spec);\n    this.#updateStmt.run(\n      newColumnName,\n      metadata.upstreamType,\n      metadata.isNotNull ? 1 : 0,\n      metadata.isEnum ? 1 : 0,\n      metadata.isArray ? 1 : 0,\n      metadata.characterMaxLength ?? null,\n      tableName,\n      oldColumnName,\n    );\n  }\n\n  clearBackfilling(tableName: string, columnName: string): void {\n    this.#clearBackfillStmt.run(tableName, columnName);\n  }\n\n  deleteColumn(tableName: string, columnName: string): void {\n    this.#deleteColumnStmt.run(tableName, columnName);\n  }\n\n  deleteTable(tableName: string): void {\n    this.#deleteTableStmt.run(tableName);\n  }\n\n  renameTable(oldTableName: string, newTableName: string): void {\n    this.#renameTableStmt.run(newTableName, oldTableName);\n  }\n\n  getColumn(tableName: string, columnName: string): ColumnMetadata | undefined {\n    const row = this.#getColumnStmt.get(tableName, columnName) as\n      | ColumnMetadataRow\n      | undefined;\n\n    if (!row) {\n      return undefined;\n    }\n\n    return {\n      upstreamType: row.upstream_type,\n      isNotNull: row.is_not_null !== 0,\n      isEnum: row.is_enum !== 0,\n      isArray: row.is_array !== 0,\n      characterMaxLength: row.character_max_length,\n      isBackfilling: row.backfill !== null,\n    };\n  }\n\n  getTable(tableName: string): Map<string, ColumnMetadata> {\n    const rows = this.#getTableStmt.all(tableName) as Array<\n      ColumnMetadataRow & {column_name: string}\n    >;\n\n    const metadata = new Map<string, ColumnMetadata>();\n    for (const row of rows) {\n      metadata.set(row.column_name, {\n        upstreamType: row.upstream_type,\n        isNotNull: row.is_not_null !== 0,\n        isEnum: row.is_enum !== 0,\n        isArray: row.is_array !== 0,\n        characterMaxLength: row.character_max_length,\n        isBackfilling: row.backfill !== null,\n      });\n    }\n\n    return metadata;\n  }\n\n  hasTable(): boolean {\n    const result = this.#hasTableStmt.get();\n    return result !== undefined;\n  }\n}\n\n/**\n * Populates metadata table from existing tables that use pipe notation.\n * This is used during migration v8 to backfill the metadata table.\n */\nexport function populateFromExistingTables(\n  db: Database,\n  tables: LiteTableSpec[],\n): void {\n  // The backfill column is not relevant here, and does not exist on\n  // older versions of the replica.\n  const legacyInsertStmt = db.prepare(`\n      INSERT INTO \"_zero.column_metadata\"\n        (table_name, column_name, upstream_type, is_not_null, is_enum, is_array, character_max_length)\n      VALUES (?, ?, ?, ?, ?, ?, ?)\n    `);\n\n  for (const table of tables) {\n    for (const [columnName, columnSpec] of Object.entries(table.columns)) {\n      const metadata = liteTypeStringToMetadata(\n        columnSpec.dataType,\n        columnSpec.characterMaximumLength,\n      );\n      legacyInsertStmt.run(\n        table.name,\n        columnName,\n        metadata.upstreamType,\n        metadata.isNotNull ? 1 : 0,\n        metadata.isEnum ? 1 : 0,\n        metadata.isArray ? 1 : 0,\n        metadata.characterMaxLength ?? null,\n      );\n    }\n  }\n}\n\n/**\n * Converts pipe-delimited LiteTypeString to structured ColumnMetadata.\n * This is a compatibility helper for the migration period.\n */\nexport function liteTypeStringToMetadata(\n  liteTypeString: string,\n  characterMaxLength?: number | null,\n): ColumnMetadata {\n  const baseType = upstreamDataType(liteTypeString);\n  const isArrayType = checkIsArray(liteTypeString);\n\n  // Reconstruct the full upstream type including array notation\n  // For new-style arrays like 'text[]', upstreamDataType returns 'text[]'\n  // For old-style arrays like 'int4|NOT_NULL[]', upstreamDataType returns 'int4', so we append '[]'\n  const fullUpstreamType =\n    isArrayType && !baseType.includes('[]') ? `${baseType}[]` : baseType;\n\n  return {\n    upstreamType: fullUpstreamType,\n    isNotNull: !nullableUpstream(liteTypeString),\n    isEnum: checkIsEnum(liteTypeString),\n    isArray: isArrayType,\n    characterMaxLength: characterMaxLength ?? null,\n    isBackfilling: false,\n  };\n}\n\n/**\n * Converts structured ColumnMetadata back to pipe-delimited LiteTypeString.\n * This is a compatibility helper for the migration period.\n */\nexport function metadataToLiteTypeString(metadata: ColumnMetadata): string {\n  return liteTypeString(\n    metadata.upstreamType,\n    metadata.isNotNull,\n    metadata.isEnum,\n    metadata.isArray,\n  );\n}\n\n/**\n * Converts PostgreSQL ColumnSpec to structured ColumnMetadata.\n * Used during replication to populate the metadata table from upstream schema.\n *\n * Uses the same logic as liteTypeString() and mapPostgresToLiteColumn() via shared helpers.\n */\nexport function pgColumnSpecToMetadata(spec: ColumnSpec): ColumnMetadata {\n  return {\n    upstreamType: spec.dataType,\n    isNotNull: spec.notNull ?? false,\n    isEnum: isEnumColumn(spec),\n    isArray: isArrayColumn(spec),\n    characterMaxLength: spec.characterMaximumLength ?? null,\n    isBackfilling: false,\n  };\n}\n"],"mappings":"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"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"constants.js","names":[],"sources":["../../../../../../../zero-cache/src/services/replicator/schema/constants.ts"],"sourcesContent":["/**\n * Constants for replication metadata.\n *\n * Extracted to avoid loading SQLite when only needing constant values.\n */\n\nexport const ZERO_VERSION_COLUMN_NAME = '_0_version';\n"],"mappings":";;;;;;AAMA,IAAa,2BAA2B"}

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

@@ -1 +0,0 @@
-{"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  // writeTimeMs      : The millisecond epoch at which this version was written to the replica.\n  //\n  /*sql*/ `\n  CREATE TABLE \"_zero.replicationState\" (\n    stateVersion TEXT NOT NULL,\n    writeTimeMs INTEGER,\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(/*sql*/ `\n    INSERT INTO \"_zero.replicationState\" (stateVersion, writeTimeMs) \n      VALUES (?, unixepoch('subsec') * 1000)\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(\n    /*sql*/ `\n    UPDATE \"_zero.replicationState\" \n      SET stateVersion=?, writeTimeMs=unixepoch('subsec') * 1000`,\n    watermark,\n  );\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,4YAqBR,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,QAAgB;;;MAGf,CAAC,IAAI,UAAU;AACnB,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,IACO;;mEAGR,UACD;;AAGH,SAAgB,oBAAoB,IAAuC;AAEzE,QAAO,MADQ,GAAG,IAAI,oDAAoD,EACnD,uBAAuB"}

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

@@ -1 +0,0 @@
-{"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.js.map

@@ -1 +0,0 @@
-{"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 {Worker} from 'node:worker_threads';\nimport {resolver, type Resolver} from '@rocicorp/resolver';\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"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"write-worker.js","names":[],"sources":["../../../../../../zero-cache/src/services/replicator/write-worker.ts"],"sourcesContent":["import {parentPort} from 'node:worker_threads';\nimport type {LogContext} from '@rocicorp/logger';\nimport type {LogConfig} from '../../../../shared/src/logging.ts';\nimport {must} from '../../../../shared/src/must.ts';\nimport {Database} from '../../../../zqlite/src/db.ts';\nimport {StatementRunner} from '../../db/statements.ts';\nimport {createLogContext} from '../../server/logging.ts';\nimport type {ChangeStreamData} from '../change-source/protocol/current/downstream.ts';\nimport {ChangeProcessor, type ChangeProcessorMode} from './change-processor.ts';\nimport {getSubscriptionState} from './schema/replication-state.ts';\nimport {\n  applyPragmas,\n  type ArgsMap,\n  type Method,\n  type PragmaConfig,\n  type Request,\n  type Response,\n  type ResultMap,\n  type WriteError,\n} from './write-worker-client.ts';\n\nif (!parentPort) {\n  throw new Error('write-worker must be run as a worker thread');\n}\n\nconst port = parentPort;\n\ntype API = {[M in Method]: (...args: ArgsMap[M]) => ResultMap[M]};\n\nfunction createAPI(): API {\n  let db: Database | undefined;\n  let runner: StatementRunner | undefined;\n  let processor: ChangeProcessor | undefined;\n  let mode: ChangeProcessorMode | undefined;\n  let lc: LogContext | undefined;\n\n  function createProcessor() {\n    processor = new ChangeProcessor(must(runner), must(mode), (_lc, err) => {\n      port.postMessage({\n        writeError: err instanceof Error ? err : new Error(String(err)),\n      } satisfies WriteError);\n    });\n  }\n\n  return {\n    init(\n      dbPath: string,\n      cpMode: ChangeProcessorMode,\n      pragmas: PragmaConfig,\n      logConfig: LogConfig,\n    ) {\n      lc = createLogContext({log: logConfig}, 'write-worker');\n      db = new Database(lc, dbPath);\n      applyPragmas(db, pragmas);\n      runner = new StatementRunner(db);\n      mode = cpMode;\n      createProcessor();\n    },\n\n    getSubscriptionState() {\n      return getSubscriptionState(must(runner));\n    },\n\n    processMessage(downstream: ChangeStreamData) {\n      return must(processor).processMessage(must(lc), downstream);\n    },\n\n    abort() {\n      must(processor).abort(must(lc));\n      createProcessor();\n    },\n\n    stop() {\n      db?.close();\n      db = undefined;\n      runner = undefined;\n      processor = undefined;\n    },\n  };\n}\n\nconst api = createAPI();\n\nport.on('message', (msg: Request) => {\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- TS can't narrow msg.method + msg.args together\n    const result = (api[msg.method] as (...args: any[]) => unknown)(\n      ...msg.args,\n    );\n    // abort is fire-and-forget — no pending slot on the client side.\n    if (msg.method !== 'abort') {\n      port.postMessage({method: msg.method, result} as Response);\n    }\n  } catch (e) {\n    if (msg.method !== 'abort') {\n      port.postMessage({method: msg.method, error: e} as Response);\n    }\n  }\n});\n"],"mappings":";;;;;;;;;AAqBA,IAAI,CAAC,WACH,OAAM,IAAI,MAAM,8CAA8C;AAGhE,IAAM,OAAO;AAIb,SAAS,YAAiB;CACxB,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,IAAI;CAEJ,SAAS,kBAAkB;AACzB,cAAY,IAAI,gBAAgB,KAAK,OAAO,EAAE,KAAK,KAAK,GAAG,KAAK,QAAQ;AACtE,QAAK,YAAY,EACf,YAAY,eAAe,QAAQ,MAAM,IAAI,MAAM,OAAO,IAAI,CAAC,EAChE,CAAsB;IACvB;;AAGJ,QAAO;EACL,KACE,QACA,QACA,SACA,WACA;AACA,QAAK,iBAAiB,EAAC,KAAK,WAAU,EAAE,eAAe;AACvD,QAAK,IAAI,SAAS,IAAI,OAAO;AAC7B,gBAAa,IAAI,QAAQ;AACzB,YAAS,IAAI,gBAAgB,GAAG;AAChC,UAAO;AACP,oBAAiB;;EAGnB,uBAAuB;AACrB,UAAO,qBAAqB,KAAK,OAAO,CAAC;;EAG3C,eAAe,YAA8B;AAC3C,UAAO,KAAK,UAAU,CAAC,eAAe,KAAK,GAAG,EAAE,WAAW;;EAG7D,QAAQ;AACN,QAAK,UAAU,CAAC,MAAM,KAAK,GAAG,CAAC;AAC/B,oBAAiB;;EAGnB,OAAO;AACL,OAAI,OAAO;AACX,QAAK,KAAA;AACL,YAAS,KAAA;AACT,eAAY,KAAA;;EAEf;;AAGH,IAAM,MAAM,WAAW;AAEvB,KAAK,GAAG,YAAY,QAAiB;AACnC,KAAI;EAEF,MAAM,SAAU,IAAI,IAAI,QACtB,GAAG,IAAI,KACR;AAED,MAAI,IAAI,WAAW,QACjB,MAAK,YAAY;GAAC,QAAQ,IAAI;GAAQ;GAAO,CAAa;UAErD,GAAG;AACV,MAAI,IAAI,WAAW,QACjB,MAAK,YAAY;GAAC,QAAQ,IAAI;GAAQ,OAAO;GAAE,CAAa;;EAGhE"}

package/out/zero-cache/src/services/run-ast.js

@@ -1,87 +0,0 @@
-import { assert } from "../../../shared/src/asserts.js";
-import { sleep } from "../../../shared/src/sleep.js";
-import { must } from "../../../shared/src/must.js";
-import { mapAST } from "../../../zero-protocol/src/ast.js";
-import { hashOfAST } from "../../../zero-protocol/src/query-hash.js";
-import { skipYields } from "../../../zql/src/ivm/skip-yields.js";
-import { buildPipeline } from "../../../zql/src/builder/builder.js";
-import { astToZQL } from "../../../ast-to-zql/src/ast-to-zql.js";
-import { formatOutput } from "../../../ast-to-zql/src/format.js";
-import { computeZqlSpecs } from "../db/lite-tables.js";
-import { resolveSimpleScalarSubqueries } from "../../../zqlite/src/resolve-scalar-subqueries.js";
-import { transformAndHashQuery } from "../auth/read-authorizer.js";
-import { hydrate } from "./view-syncer/pipeline-driver.js";
-//#region ../zero-cache/src/services/run-ast.ts
-async function runAst(lc, clientSchema, ast, isTransformed, options, yieldProcess) {
-	const { clientToServerMapper, permissions, host, db } = options;
-	const result = {
-		warnings: [],
-		syncedRows: void 0,
-		syncedRowCount: 0,
-		start: 0,
-		end: 0,
-		elapsed: 0,
-		afterPermissions: void 0,
-		readRows: void 0,
-		readRowCountsByQuery: {},
-		readRowCount: void 0
-	};
-	if (!isTransformed) ast = mapAST(ast, must(clientToServerMapper));
-	if (options.applyPermissions) {
-		const auth = options.auth;
-		if (!auth) result.warnings.push("No auth data provided. Permission rules will compare to `NULL` wherever an auth data field is referenced.");
-		ast = transformAndHashQuery(lc, "clientGroupIDForAnalyze", ast, must(permissions), auth, false).transformedAst;
-		result.afterPermissions = await formatOutput(ast.table + astToZQL(ast));
-	}
-	const executor = (subqueryAST, childField) => {
-		const input = buildPipeline(subqueryAST, host, "scalar-subquery");
-		let node;
-		for (const n of skipYields(input.fetch({}))) node ??= n;
-		input.destroy();
-		return node ? node.row[childField] ?? null : void 0;
-	};
-	const { ast: resolvedAst } = resolveSimpleScalarSubqueries(ast, options.tableSpecs, executor);
-	const pipeline = buildPipeline(resolvedAst, host, "query-id", options.costModel, lc, options.planDebugger);
-	const start = performance.now();
-	let syncedRowCount = 0;
-	const rowsByTable = {};
-	const seenByTable = /* @__PURE__ */ new Set();
-	for (const rowChange of hydrate(pipeline, hashOfAST(resolvedAst), clientSchema, computeZqlSpecs(lc, db, { includeBackfillingColumns: false }))) {
-		if (rowChange === "yield") {
-			await yieldProcess();
-			continue;
-		}
-		assert(rowChange.type === 0, "Hydration only handles add row changes");
-		if (syncedRowCount % 10 === 0) await Promise.resolve();
-		if (syncedRowCount % 100 === 0) await sleep(1);
-		let rows = rowsByTable[rowChange.table];
-		const s = rowChange.table + "." + JSON.stringify(rowChange.row);
-		if (seenByTable.has(s)) continue;
-		syncedRowCount++;
-		seenByTable.add(s);
-		if (options.syncedRows) {
-			if (!rows) {
-				rows = [];
-				rowsByTable[rowChange.table] = rows;
-			}
-			rows.push(rowChange.row);
-		}
-	}
-	const end = performance.now();
-	if (options.syncedRows) result.syncedRows = rowsByTable;
-	result.start = start;
-	result.end = end;
-	result.elapsed = end - start;
-	result.syncedRowCount = syncedRowCount;
-	result.readRowCountsByQuery = host.debug?.getVendedRowCounts() ?? {};
-	let readRowCount = 0;
-	for (const c of Object.values(result.readRowCountsByQuery)) for (const v of Object.values(c)) readRowCount += v;
-	result.readRowCount = readRowCount;
-	result.dbScansByQuery = host.debug?.getNVisitCounts() ?? {};
-	if (options.vendedRows) result.readRows = host.debug?.getVendedRows();
-	return result;
-}
-//#endregion
-export { runAst };
-
-//# sourceMappingURL=run-ast.js.map

package/out/zero-cache/src/services/run-ast.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"run-ast.js","names":[],"sources":["../../../../../zero-cache/src/services/run-ast.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\n// @circular-dep-ignore\nimport {astToZQL} from '../../../ast-to-zql/src/ast-to-zql.ts';\n// @circular-dep-ignore\nimport {formatOutput} from '../../../ast-to-zql/src/format.ts';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport {must} from '../../../shared/src/must.ts';\nimport {sleep} from '../../../shared/src/sleep.ts';\nimport type {AnalyzeQueryResult} from '../../../zero-protocol/src/analyze-query-result.ts';\nimport type {AST, LiteralValue} from '../../../zero-protocol/src/ast.ts';\nimport {mapAST} from '../../../zero-protocol/src/ast.ts';\nimport type {ClientSchema} from '../../../zero-protocol/src/client-schema.ts';\nimport type {Row} from '../../../zero-protocol/src/data.ts';\nimport {hashOfAST} from '../../../zero-protocol/src/query-hash.ts';\nimport type {PermissionsConfig} from '../../../zero-schema/src/compiled-permissions.ts';\nimport type {NameMapper} from '../../../zero-schema/src/name-mapper.ts';\nimport {\n  buildPipeline,\n  type BuilderDelegate,\n} from '../../../zql/src/builder/builder.ts';\nimport {ChangeType} from '../../../zql/src/ivm/change-type.ts';\nimport type {Node} from '../../../zql/src/ivm/data.ts';\nimport {skipYields} from '../../../zql/src/ivm/operator.ts';\nimport type {ConnectionCostModel} from '../../../zql/src/planner/planner-connection.ts';\nimport type {PlanDebugger} from '../../../zql/src/planner/planner-debug.ts';\nimport type {Database} from '../../../zqlite/src/db.ts';\nimport {resolveSimpleScalarSubqueries} from '../../../zqlite/src/resolve-scalar-subqueries.ts';\nimport type {JWTAuth} from '../auth/auth.ts';\nimport {transformAndHashQuery} from '../auth/read-authorizer.ts';\nimport {computeZqlSpecs} from '../db/lite-tables.ts';\nimport type {LiteAndZqlSpec} from '../db/specs.ts';\nimport {hydrate} from './view-syncer/pipeline-driver.ts';\n\nexport type RunAstOptions = {\n  applyPermissions?: boolean | undefined;\n  auth?: JWTAuth | undefined;\n  clientToServerMapper?: NameMapper | undefined;\n  costModel?: ConnectionCostModel | undefined;\n  db: Database;\n  host: BuilderDelegate;\n  permissions?: PermissionsConfig | undefined;\n  planDebugger?: PlanDebugger | undefined;\n  syncedRows?: boolean | undefined;\n  tableSpecs: Map<string, LiteAndZqlSpec>;\n  vendedRows?: boolean | undefined;\n};\n\nexport async function runAst(\n  lc: LogContext,\n  clientSchema: ClientSchema,\n  ast: AST,\n  isTransformed: boolean,\n  options: RunAstOptions,\n  yieldProcess: () => Promise<void>,\n): Promise<AnalyzeQueryResult> {\n  const {clientToServerMapper, permissions, host, db} = options;\n  const result: AnalyzeQueryResult = {\n    warnings: [],\n    syncedRows: undefined,\n    syncedRowCount: 0,\n    start: 0,\n    end: 0,\n    elapsed: 0,\n    afterPermissions: undefined,\n    readRows: undefined,\n    readRowCountsByQuery: {},\n    readRowCount: undefined,\n  };\n\n  if (!isTransformed) {\n    // map the AST to server names if not already transformed\n    ast = mapAST(ast, must(clientToServerMapper));\n  }\n  if (options.applyPermissions) {\n    const auth = options.auth;\n    if (!auth) {\n      result.warnings.push(\n        'No auth data provided. Permission rules will compare to `NULL` wherever an auth data field is referenced.',\n      );\n    }\n    ast = transformAndHashQuery(\n      lc,\n      'clientGroupIDForAnalyze',\n      ast,\n      must(permissions),\n      auth,\n      false,\n    ).transformedAst;\n    result.afterPermissions = await formatOutput(ast.table + astToZQL(ast));\n  }\n\n  // Resolve scalar subqueries (e.g. whereExists with {scalar: true}) to\n  // literal equality conditions so that SQLite can use indexes effectively.\n  // Without this, correlated subqueries get stripped from SQL filters and\n  // queries on large tables fall back to full table scans.\n  const executor = (\n    subqueryAST: AST,\n    childField: string,\n  ): LiteralValue | null | undefined => {\n    const input = buildPipeline(subqueryAST, host, 'scalar-subquery');\n    // Consume the full stream rather than using first() to avoid\n    // triggering early return on Take's #initialFetch assertion.\n    // The subquery AST already has limit: 1, so at most one row is produced.\n    let node: Node | undefined;\n    for (const n of skipYields(input.fetch({}))) {\n      node ??= n;\n    }\n    input.destroy();\n    return node ? ((node.row[childField] as LiteralValue) ?? null) : undefined;\n  };\n\n  const {ast: resolvedAst} = resolveSimpleScalarSubqueries(\n    ast,\n    options.tableSpecs,\n    executor,\n  );\n\n  const pipeline = buildPipeline(\n    resolvedAst,\n    host,\n    'query-id',\n    options.costModel,\n    lc,\n    options.planDebugger,\n  );\n\n  const start = performance.now();\n\n  let syncedRowCount = 0;\n  const rowsByTable: Record<string, Row[]> = {};\n  const seenByTable: Set<string> = new Set();\n  for (const rowChange of hydrate(\n    pipeline,\n    hashOfAST(resolvedAst),\n    clientSchema,\n    computeZqlSpecs(lc, db, {includeBackfillingColumns: false}),\n  )) {\n    if (rowChange === 'yield') {\n      await yieldProcess();\n      continue;\n    }\n    assert(\n      rowChange.type === ChangeType.ADD,\n      'Hydration only handles add row changes',\n    );\n\n    // yield to other tasks to avoid blocking for too long\n    if (syncedRowCount % 10 === 0) {\n      await Promise.resolve();\n    }\n    if (syncedRowCount % 100 === 0) {\n      await sleep(1);\n    }\n\n    let rows: Row[] = rowsByTable[rowChange.table];\n    const s = rowChange.table + '.' + JSON.stringify(rowChange.row);\n    if (seenByTable.has(s)) {\n      continue; // skip duplicates\n    }\n    syncedRowCount++;\n    seenByTable.add(s);\n    if (options.syncedRows) {\n      if (!rows) {\n        rows = [];\n        rowsByTable[rowChange.table] = rows;\n      }\n      rows.push(rowChange.row);\n    }\n  }\n\n  const end = performance.now();\n  if (options.syncedRows) {\n    result.syncedRows = rowsByTable;\n  }\n  result.start = start;\n  result.end = end;\n  result.elapsed = end - start;\n\n  // Always include the count of synced and vended rows.\n  result.syncedRowCount = syncedRowCount;\n  result.readRowCountsByQuery = host.debug?.getVendedRowCounts() ?? {};\n  let readRowCount = 0;\n  for (const c of Object.values(result.readRowCountsByQuery)) {\n    for (const v of Object.values(c)) {\n      readRowCount += v;\n    }\n  }\n  result.readRowCount = readRowCount;\n  result.dbScansByQuery = host.debug?.getNVisitCounts() ?? {};\n\n  if (options.vendedRows) {\n    result.readRows = host.debug?.getVendedRows();\n  }\n  return result;\n}\n"],"mappings":";;;;;;;;;;;;;;AA+CA,eAAsB,OACpB,IACA,cACA,KACA,eACA,SACA,cAC6B;CAC7B,MAAM,EAAC,sBAAsB,aAAa,MAAM,OAAM;CACtD,MAAM,SAA6B;EACjC,UAAU,EAAE;EACZ,YAAY,KAAA;EACZ,gBAAgB;EAChB,OAAO;EACP,KAAK;EACL,SAAS;EACT,kBAAkB,KAAA;EAClB,UAAU,KAAA;EACV,sBAAsB,EAAE;EACxB,cAAc,KAAA;EACf;AAED,KAAI,CAAC,cAEH,OAAM,OAAO,KAAK,KAAK,qBAAqB,CAAC;AAE/C,KAAI,QAAQ,kBAAkB;EAC5B,MAAM,OAAO,QAAQ;AACrB,MAAI,CAAC,KACH,QAAO,SAAS,KACd,4GACD;AAEH,QAAM,sBACJ,IACA,2BACA,KACA,KAAK,YAAY,EACjB,MACA,MACD,CAAC;AACF,SAAO,mBAAmB,MAAM,aAAa,IAAI,QAAQ,SAAS,IAAI,CAAC;;CAOzE,MAAM,YACJ,aACA,eACoC;EACpC,MAAM,QAAQ,cAAc,aAAa,MAAM,kBAAkB;EAIjE,IAAI;AACJ,OAAK,MAAM,KAAK,WAAW,MAAM,MAAM,EAAE,CAAC,CAAC,CACzC,UAAS;AAEX,QAAM,SAAS;AACf,SAAO,OAAS,KAAK,IAAI,eAAgC,OAAQ,KAAA;;CAGnE,MAAM,EAAC,KAAK,gBAAe,8BACzB,KACA,QAAQ,YACR,SACD;CAED,MAAM,WAAW,cACf,aACA,MACA,YACA,QAAQ,WACR,IACA,QAAQ,aACT;CAED,MAAM,QAAQ,YAAY,KAAK;CAE/B,IAAI,iBAAiB;CACrB,MAAM,cAAqC,EAAE;CAC7C,MAAM,8BAA2B,IAAI,KAAK;AAC1C,MAAK,MAAM,aAAa,QACtB,UACA,UAAU,YAAY,EACtB,cACA,gBAAgB,IAAI,IAAI,EAAC,2BAA2B,OAAM,CAAC,CAC5D,EAAE;AACD,MAAI,cAAc,SAAS;AACzB,SAAM,cAAc;AACpB;;AAEF,SACE,UAAU,SAAS,GACnB,yCACD;AAGD,MAAI,iBAAiB,OAAO,EAC1B,OAAM,QAAQ,SAAS;AAEzB,MAAI,iBAAiB,QAAQ,EAC3B,OAAM,MAAM,EAAE;EAGhB,IAAI,OAAc,YAAY,UAAU;EACxC,MAAM,IAAI,UAAU,QAAQ,MAAM,KAAK,UAAU,UAAU,IAAI;AAC/D,MAAI,YAAY,IAAI,EAAE,CACpB;AAEF;AACA,cAAY,IAAI,EAAE;AAClB,MAAI,QAAQ,YAAY;AACtB,OAAI,CAAC,MAAM;AACT,WAAO,EAAE;AACT,gBAAY,UAAU,SAAS;;AAEjC,QAAK,KAAK,UAAU,IAAI;;;CAI5B,MAAM,MAAM,YAAY,KAAK;AAC7B,KAAI,QAAQ,WACV,QAAO,aAAa;AAEtB,QAAO,QAAQ;AACf,QAAO,MAAM;AACb,QAAO,UAAU,MAAM;AAGvB,QAAO,iBAAiB;AACxB,QAAO,uBAAuB,KAAK,OAAO,oBAAoB,IAAI,EAAE;CACpE,IAAI,eAAe;AACnB,MAAK,MAAM,KAAK,OAAO,OAAO,OAAO,qBAAqB,CACxD,MAAK,MAAM,KAAK,OAAO,OAAO,EAAE,CAC9B,iBAAgB;AAGpB,QAAO,eAAe;AACtB,QAAO,iBAAiB,KAAK,OAAO,iBAAiB,IAAI,EAAE;AAE3D,KAAI,QAAQ,WACV,QAAO,WAAW,KAAK,OAAO,eAAe;AAE/C,QAAO"}

package/out/zero-cache/src/services/runner.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"runner.js","names":["#lc","#instances","#create","#isValid"],"sources":["../../../../../zero-cache/src/services/runner.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport type {Service} from './service.ts';\n\n/**\n * Manages the creation and lifecycle of objects that implement\n * {@link Service}.\n */\nexport class ServiceRunner<S extends Service> {\n  readonly #lc: LogContext;\n  readonly #instances = new Map<string, S>();\n  readonly #create: (id: string) => S;\n  readonly #isValid: (existing: S) => boolean;\n\n  constructor(\n    lc: LogContext,\n    factory: (id: string) => S,\n    isValid: (existing: S) => boolean = () => true,\n  ) {\n    this.#lc = lc;\n    this.#create = factory;\n    this.#isValid = isValid;\n  }\n\n  /**\n   * Creates and runs the Service with the given `id`, returning\n   * an existing one if it is still running a valid.\n   */\n  getService(id: string): S {\n    const existing = this.#instances.get(id);\n    if (existing && this.#isValid(existing)) {\n      return existing;\n    }\n    const service = this.#create(id);\n    this.#instances.set(id, service);\n    void service\n      .run()\n      .catch(e =>\n        this.#lc.error?.(\n          `Error running ${service.constructor?.name} ${service.id}`,\n          e,\n        ),\n      )\n      .finally(() => {\n        this.#instances.delete(id);\n      });\n    return service;\n  }\n\n  get size() {\n    return this.#instances.size;\n  }\n\n  getServices(): Iterable<S> {\n    return this.#instances.values();\n  }\n}\n"],"mappings":";;;;;AAOA,IAAa,gBAAb,MAA8C;CAC5C;CACA,6BAAsB,IAAI,KAAgB;CAC1C;CACA;CAEA,YACE,IACA,SACA,gBAA0C,MAC1C;AACA,QAAA,KAAW;AACX,QAAA,SAAe;AACf,QAAA,UAAgB;;;;;;CAOlB,WAAW,IAAe;EACxB,MAAM,WAAW,MAAA,UAAgB,IAAI,GAAG;AACxC,MAAI,YAAY,MAAA,QAAc,SAAS,CACrC,QAAO;EAET,MAAM,UAAU,MAAA,OAAa,GAAG;AAChC,QAAA,UAAgB,IAAI,IAAI,QAAQ;AAC3B,UACF,KAAK,CACL,OAAM,MACL,MAAA,GAAS,QACP,iBAAiB,QAAQ,aAAa,KAAK,GAAG,QAAQ,MACtD,EACD,CACF,CACA,cAAc;AACb,SAAA,UAAgB,OAAO,GAAG;IAC1B;AACJ,SAAO;;CAGT,IAAI,OAAO;AACT,SAAO,MAAA,UAAgB;;CAGzB,cAA2B;AACzB,SAAO,MAAA,UAAgB,QAAQ"}

package/out/zero-cache/src/services/running-state.js

@@ -1,136 +0,0 @@
-import { AbortError } from "../../../shared/src/abort-error.js";
-import { sleepWithAbort } from "../../../shared/src/sleep.js";
-import { resolver } from "@rocicorp/resolver";
-//#region ../zero-cache/src/services/running-state.ts
-var DEFAULT_INITIAL_RETRY_DELAY_MS = 25;
-var DEFAULT_MAX_RETRY_DELAY_MS = 1e4;
-/**
-* Facilitates lifecycle control with exponential backoff.
-*/
-var RunningState = class {
-	#serviceName;
-	#controller;
-	#sleep;
-	#setTimeout;
-	#stopped;
-	#initialRetryDelay;
-	#maxRetryDelay;
-	#pendingTimeouts = /* @__PURE__ */ new Set();
-	#retryDelay;
-	constructor(serviceName, retryConfig, setTimeoutFn = setTimeout, sleeper = sleepWithAbort) {
-		const { initialRetryDelay = DEFAULT_INITIAL_RETRY_DELAY_MS, maxRetryDelay = DEFAULT_MAX_RETRY_DELAY_MS } = retryConfig ?? {};
-		this.#serviceName = serviceName;
-		this.#initialRetryDelay = initialRetryDelay;
-		this.#maxRetryDelay = maxRetryDelay;
-		this.#retryDelay = initialRetryDelay;
-		this.#controller = new AbortController();
-		this.#sleep = sleeper;
-		this.#setTimeout = setTimeoutFn;
-		const { promise, resolve } = resolver();
-		this.#stopped = promise;
-		this.#controller.signal.addEventListener("abort", () => {
-			resolve();
-			for (const timeout of this.#pendingTimeouts) clearTimeout(timeout);
-			this.#pendingTimeouts.clear();
-		}, { once: true });
-	}
-	get signal() {
-		return this.#controller.signal;
-	}
-	get retryDelay() {
-		return this.#retryDelay;
-	}
-	/**
-	* Returns `true` until {@link stop()} has been called.
-	*
-	* This is usually called as part of the service's main loop
-	* conditional to determine if the next iteration should execute.
-	*/
-	shouldRun() {
-		return !this.#controller.signal.aborted;
-	}
-	/**
-	* Registers a Cancelable object to be invoked when {@link stop()} is called.
-	* Returns a method to unregister the object.
-	*/
-	cancelOnStop(c) {
-		const onStop = () => c.cancel();
-		this.#controller.signal.addEventListener("abort", onStop, { once: true });
-		return () => this.#controller.signal.removeEventListener("abort", onStop);
-	}
-	/**
-	* Sets a Timeout that is automatically cancelled if the service is cancelled.
-	*/
-	setTimeout(fn, timeoutMs, ...args) {
-		const timeout = this.#setTimeout(() => {
-			clearTimeout(timeout);
-			this.#pendingTimeouts.delete(timeout);
-			return fn(...args);
-		}, timeoutMs);
-		this.#pendingTimeouts.add(timeout);
-	}
-	/**
-	* Returns a promise that resolves after `ms` milliseconds or when
-	* the service is stopped.
-	*/
-	async sleep(ms) {
-		await Promise.race(this.#sleep(ms, this.#controller.signal));
-	}
-	/**
-	* Called to stop the service. After this is called, {@link shouldRun()}
-	* will return `false` and the {@link stopped()} Promise will be resolved.
-	*/
-	stop(lc, err) {
-		if (this.shouldRun()) {
-			lc[!err || err instanceof AbortError ? "info" : "error"]?.(`stopping ${this.#serviceName}`, err ?? "");
-			this.#controller.abort();
-		}
-	}
-	/**
-	* Returns a Promise that resolves when {@link stop()} is called.
-	*/
-	stopped() {
-		return this.#stopped;
-	}
-	/**
-	* Call in response to an error or unexpected termination in the main
-	* loop of the service. The returned Promise will resolve after an
-	* exponential delay, or once {@link stop()} is called.
-	*
-	* If the supplied `err` is an `AbortError`, the service will shut down.
-	*/
-	async backoff(lc, err) {
-		const delay = this.#retryDelay;
-		this.#retryDelay = Math.min(delay * 2, this.#maxRetryDelay);
-		if (err instanceof AbortError || err instanceof UnrecoverableError) {
-			this.resetBackoff();
-			this.stop(lc, err);
-		} else if (this.shouldRun()) {
-			lc[delay < 1e3 ? "info" : delay < 6500 ? "warn" : "error"]?.(`retrying ${this.#serviceName} in ${delay} ms`, err);
-			await this.sleep(delay);
-		}
-	}
-	/**
-	* When using {@link backoff()}, this method should be called when the
-	* implementation receives a healthy signal (e.g. a successful
-	* response). This resets the delay used in {@link backoff()}.
-	*
-	* @returns The previous backoff delay
-	*/
-	resetBackoff() {
-		const prevDelay = this.#retryDelay;
-		this.#retryDelay = this.#initialRetryDelay;
-		return prevDelay;
-	}
-};
-/**
-* Superclass for Errors that should bypass exponential backoff
-* and immediately shut down the server.
-*/
-var UnrecoverableError = class extends Error {
-	name = "UnrecoverableError";
-};
-//#endregion
-export { DEFAULT_MAX_RETRY_DELAY_MS, RunningState, UnrecoverableError };
-
-//# sourceMappingURL=running-state.js.map