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

package/out/zero-cache/src/services/change-source/pg/logical-replication/binary-reader.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"binary-reader.js","names":["#b","#p"],"sources":["../../../../../../../../zero-cache/src/services/change-source/pg/logical-replication/binary-reader.ts"],"sourcesContent":["// Forked from https://github.com/kibae/pg-logical-replication/blob/c55abddc62eadd61bd38922037ecb7a1469fa8c3/src/output-plugins/pgoutput/binary-reader.ts\n\n// should not use { fatal: true } because ErrorResponse can use invalid utf8 chars\nconst textDecoder = new TextDecoder();\n\n// https://www.postgresql.org/docs/14/protocol-message-types.html\nexport class BinaryReader {\n  #p = 0;\n  readonly #b: Uint8Array;\n\n  constructor(b: Uint8Array) {\n    this.#b = b;\n  }\n\n  readUint8() {\n    this.checkSize(1);\n\n    return this.#b[this.#p++];\n  }\n\n  readInt16() {\n    this.checkSize(2);\n\n    return (this.#b[this.#p++] << 8) | this.#b[this.#p++];\n  }\n\n  readInt32() {\n    this.checkSize(4);\n\n    return (\n      (this.#b[this.#p++] << 24) |\n      (this.#b[this.#p++] << 16) |\n      (this.#b[this.#p++] << 8) |\n      this.#b[this.#p++]\n    );\n  }\n\n  readString() {\n    const endIdx = this.#b.indexOf(0x00, this.#p);\n\n    if (endIdx < 0) {\n      // TODO PgError.protocol_violation\n      throw Error('unexpected end of message');\n    }\n\n    const strBuf = this.#b.subarray(this.#p, endIdx);\n    this.#p = endIdx + 1;\n\n    return this.decodeText(strBuf);\n  }\n\n  decodeText(strBuf: Uint8Array) {\n    return textDecoder.decode(strBuf);\n  }\n\n  read(n: number) {\n    this.checkSize(n);\n\n    return this.#b.subarray(this.#p, (this.#p += n));\n  }\n\n  checkSize(n: number) {\n    if (this.#b.length < this.#p + n) {\n      // TODO PgError.protocol_violation\n      throw Error('unexpected end of message');\n    }\n  }\n\n  array<T>(length: number, fn: () => T): T[] {\n    return Array.from({length}, fn, this);\n  }\n\n  // replication helpers\n  readLsn() {\n    const h = this.readUint32();\n    const l = this.readUint32();\n\n    if (h === 0 && l === 0) {\n      return null;\n    }\n\n    return `${h.toString(16).padStart(8, '0')}/${l\n      .toString(16)\n      .padStart(8, '0')}`.toUpperCase();\n  }\n\n  readTime() {\n    // (POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE) * USECS_PER_DAY == 946684800000000\n    return this.readUint64() + BigInt('946684800000000');\n  }\n\n  readUint64() {\n    return (\n      (BigInt(this.readUint32()) << BigInt(32)) | BigInt(this.readUint32())\n    );\n  }\n\n  readUint32() {\n    return this.readInt32() >>> 0;\n  }\n}\n"],"mappings":";AAGA,IAAM,cAAc,IAAI,aAAa;AAGrC,IAAa,eAAb,MAA0B;CACxB,KAAK;CACL;CAEA,YAAY,GAAe;AACzB,QAAA,IAAU;;CAGZ,YAAY;AACV,OAAK,UAAU,EAAE;AAEjB,SAAO,MAAA,EAAQ,MAAA;;CAGjB,YAAY;AACV,OAAK,UAAU,EAAE;AAEjB,SAAQ,MAAA,EAAQ,MAAA,QAAc,IAAK,MAAA,EAAQ,MAAA;;CAG7C,YAAY;AACV,OAAK,UAAU,EAAE;AAEjB,SACG,MAAA,EAAQ,MAAA,QAAc,KACtB,MAAA,EAAQ,MAAA,QAAc,KACtB,MAAA,EAAQ,MAAA,QAAc,IACvB,MAAA,EAAQ,MAAA;;CAIZ,aAAa;EACX,MAAM,SAAS,MAAA,EAAQ,QAAQ,GAAM,MAAA,EAAQ;AAE7C,MAAI,SAAS,EAEX,OAAM,MAAM,4BAA4B;EAG1C,MAAM,SAAS,MAAA,EAAQ,SAAS,MAAA,GAAS,OAAO;AAChD,QAAA,IAAU,SAAS;AAEnB,SAAO,KAAK,WAAW,OAAO;;CAGhC,WAAW,QAAoB;AAC7B,SAAO,YAAY,OAAO,OAAO;;CAGnC,KAAK,GAAW;AACd,OAAK,UAAU,EAAE;AAEjB,SAAO,MAAA,EAAQ,SAAS,MAAA,GAAU,MAAA,KAAW,EAAG;;CAGlD,UAAU,GAAW;AACnB,MAAI,MAAA,EAAQ,SAAS,MAAA,IAAU,EAE7B,OAAM,MAAM,4BAA4B;;CAI5C,MAAS,QAAgB,IAAkB;AACzC,SAAO,MAAM,KAAK,EAAC,QAAO,EAAE,IAAI,KAAK;;CAIvC,UAAU;EACR,MAAM,IAAI,KAAK,YAAY;EAC3B,MAAM,IAAI,KAAK,YAAY;AAE3B,MAAI,MAAM,KAAK,MAAM,EACnB,QAAO;AAGT,SAAO,GAAG,EAAE,SAAS,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC,GAAG,EAC1C,SAAS,GAAG,CACZ,SAAS,GAAG,IAAI,GAAG,aAAa;;CAGrC,WAAW;AAET,SAAO,KAAK,YAAY,GAAG,OAAO,kBAAkB;;CAGtD,aAAa;AACX,SACG,OAAO,KAAK,YAAY,CAAC,IAAI,OAAO,GAAG,GAAI,OAAO,KAAK,YAAY,CAAC;;CAIzE,aAAa;AACX,SAAO,KAAK,WAAW,KAAK"}

package/out/zero-cache/src/services/change-source/pg/logical-replication/pgoutput-parser.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"pgoutput-parser.js","names":["#typeParsers","#getTypeParser"],"sources":["../../../../../../../../zero-cache/src/services/change-source/pg/logical-replication/pgoutput-parser.ts"],"sourcesContent":["// Forked from https://github.com/kibae/pg-logical-replication/blob/c55abddc62eadd61bd38922037ecb7a1469fa8c3/src/output-plugins/pgoutput/pgoutput-parser.ts\n/* oxlint-disable */\n\n// https://www.postgresql.org/docs/current/protocol-logicalrep-message-formats.html\n\n// Replaced by TypeParsers\n// import {types} from 'pg';\n\nexport type TypeParser = (val: string) => unknown;\n\nimport type {TypeParsers} from '../../../../db/pg-type-parser.ts';\nimport {BinaryReader} from './binary-reader.ts';\nimport type {\n  Message,\n  MessageBegin,\n  MessageCommit,\n  MessageDelete,\n  MessageInsert,\n  MessageMessage,\n  MessageOrigin,\n  MessageRelation,\n  MessageTruncate,\n  MessageType,\n  MessageUpdate,\n  RelationColumn,\n} from './pgoutput.types.ts';\n\nexport class PgoutputParser {\n  _typeCache = new Map<number, {typeSchema: string; typeName: string}>();\n  _relationCache = new Map<number, MessageRelation>();\n\n  // Replaces \"pg-types\" library.\n  #typeParsers: TypeParsers;\n  constructor(typeParsers: TypeParsers) {\n    this.#typeParsers = typeParsers;\n  }\n  #getTypeParser(typeOid: number): TypeParser {\n    return this.#typeParsers.getTypeParser(typeOid);\n  }\n  // Replaced \"pg-types\" library.\n\n  public parse(buf: Buffer): Message {\n    const reader = new BinaryReader(buf);\n    const tag = reader.readUint8();\n\n    switch (tag) {\n      case 0x42 /*B*/:\n        return this.msgBegin(reader);\n      case 0x4f /*O*/:\n        return this.msgOrigin(reader);\n      case 0x59 /*Y*/:\n        return this.msgType(reader);\n      case 0x52 /*R*/:\n        return this.msgRelation(reader);\n      case 0x49 /*I*/:\n        return this.msgInsert(reader);\n      case 0x55 /*U*/:\n        return this.msgUpdate(reader);\n      case 0x44 /*D*/:\n        return this.msgDelete(reader);\n      case 0x54 /*T*/:\n        return this.msgTruncate(reader);\n      case 0x4d /*M*/:\n        return this.msgMessage(reader);\n      case 0x43 /*C*/:\n        return this.msgCommit(reader);\n      default:\n        throw Error('unknown pgoutput message');\n    }\n  }\n\n  private msgBegin(reader: BinaryReader): MessageBegin {\n    // TODO lsn can be null if origin sended\n    // https://github.com/postgres/postgres/blob/85c61ba8920ba73500e1518c63795982ee455d14/src/backend/replication/pgoutput/pgoutput.c#L409\n    // https://github.com/postgres/postgres/blob/27b77ecf9f4d5be211900eda54d8155ada50d696/src/include/replication/reorderbuffer.h#L275\n\n    return {\n      tag: 'begin',\n      commitLsn: reader.readLsn(),\n      commitTime: reader.readTime(),\n      xid: reader.readInt32(),\n    };\n  }\n\n  private msgOrigin(reader: BinaryReader): MessageOrigin {\n    return {\n      tag: 'origin',\n      originLsn: reader.readLsn(),\n      originName: reader.readString(),\n    };\n  }\n\n  private msgType(reader: BinaryReader): MessageType {\n    const typeOid = reader.readInt32();\n    const typeSchema = reader.readString();\n    const typeName = reader.readString();\n\n    // mem leak not likely to happen because amount of types is usually small\n    this._typeCache.set(typeOid, {typeSchema, typeName});\n\n    return {tag: 'type', typeOid, typeSchema, typeName};\n  }\n\n  private msgRelation(reader: BinaryReader): MessageRelation {\n    // lsn expected to be null\n    // https://github.com/postgres/postgres/blob/27b77ecf9f4d5be211900eda54d8155ada50d696/src/backend/replication/walsender.c#L1342\n    const relationOid = reader.readInt32();\n    const schema = reader.readString();\n    const name = reader.readString();\n    const replicaIdentity = this.readRelationReplicaIdentity(reader);\n    const columns = reader.array(reader.readInt16(), () =>\n      this.readRelationColumn(reader),\n    );\n    const keyColumns = columns.filter(it => it.flags & 0b1).map(it => it.name);\n\n    const msg: MessageRelation = {\n      tag: 'relation',\n      relationOid,\n      schema,\n      name,\n      replicaIdentity,\n      columns,\n      keyColumns,\n    };\n\n    // mem leak not likely to happen because amount of relations is usually small\n    this._relationCache.set(relationOid, msg);\n\n    return msg;\n  }\n\n  private readRelationReplicaIdentity(reader: BinaryReader) {\n    // https://www.postgresql.org/docs/14/catalog-pg-class.html\n    const ident = reader.readUint8();\n\n    switch (ident) {\n      case 0x64 /*d*/:\n        return 'default';\n      case 0x6e /*n*/:\n        return 'nothing';\n      case 0x66 /*f*/:\n        return 'full';\n      case 0x69 /*i*/:\n        return 'index';\n      default:\n        throw Error(`unknown replica identity ${String.fromCharCode(ident)}`);\n    }\n  }\n\n  private readRelationColumn(reader: BinaryReader): RelationColumn {\n    const flags = reader.readUint8();\n    const name = reader.readString();\n    const typeOid = reader.readInt32();\n    const typeMod = reader.readInt32();\n\n    return {\n      flags,\n      name,\n      typeOid,\n      typeMod,\n      typeSchema: null,\n      typeName: null, // TODO resolve builtin type names?\n      ...this._typeCache.get(typeOid),\n      // parser: types.getTypeParser(typeOid),\n      parser: this.#getTypeParser(typeOid),\n    };\n  }\n\n  private msgInsert(reader: BinaryReader): MessageInsert {\n    const relation = this._relationCache.get(reader.readInt32());\n\n    if (!relation) {\n      throw Error('missing relation');\n    }\n\n    reader.readUint8(); // consume the 'N' key\n\n    return {\n      tag: 'insert',\n      relation,\n      new: this.readTuple(reader, relation),\n    };\n  }\n\n  private msgUpdate(reader: BinaryReader): MessageUpdate {\n    const relation = this._relationCache.get(reader.readInt32());\n\n    if (!relation) {\n      throw Error('missing relation');\n    }\n\n    let key: Record<string, any> | null = null;\n    let old: Record<string, any> | null = null;\n    let new_: Record<string, any> | null = null;\n    const subMsgKey = reader.readUint8();\n\n    if (subMsgKey === 0x4b /*K*/) {\n      key = this.readKeyTuple(reader, relation);\n      reader.readUint8(); // consume the 'N' key\n      new_ = this.readTuple(reader, relation);\n    } else if (subMsgKey === 0x4f /*O*/) {\n      old = this.readTuple(reader, relation);\n      reader.readUint8(); // consume the 'N' key\n      new_ = this.readTuple(reader, relation, old);\n    } else if (subMsgKey === 0x4e /*N*/) {\n      new_ = this.readTuple(reader, relation);\n    } else {\n      throw Error(`unknown submessage key ${String.fromCharCode(subMsgKey)}`);\n    }\n\n    return {tag: 'update', relation, key, old, new: new_};\n  }\n\n  private msgDelete(reader: BinaryReader): MessageDelete {\n    const relation = this._relationCache.get(reader.readInt32());\n\n    if (!relation) {\n      throw Error('missing relation');\n    }\n\n    let key: Record<string, any> | null = null;\n    let old: Record<string, any> | null = null;\n    const subMsgKey = reader.readUint8();\n\n    if (subMsgKey === 0x4b /*K*/) {\n      key = this.readKeyTuple(reader, relation);\n    } else if (subMsgKey === 0x4f /*O*/) {\n      old = this.readTuple(reader, relation);\n    } else {\n      throw Error(`unknown submessage key ${String.fromCharCode(subMsgKey)}`);\n    }\n\n    return {tag: 'delete', relation, key, old};\n  }\n\n  private readKeyTuple(\n    reader: BinaryReader,\n    relation: MessageRelation,\n  ): Record<string, any> {\n    const tuple = this.readTuple(reader, relation);\n    const key = Object.create(null);\n\n    for (const k of relation.keyColumns) {\n      // If value is `null`, then it is definitely not part of key,\n      // because key cannot have nulls by documentation.\n      // And if we got `null` while reading keyOnly tuple,\n      // then it means that `null` is not actual value\n      // but placeholder of non-key column.\n      key[k] = tuple[k] === null ? undefined : tuple[k];\n    }\n\n    return key;\n  }\n\n  private readTuple(\n    reader: BinaryReader,\n    {columns}: MessageRelation,\n    unchangedToastFallback?: Record<string, any> | null,\n  ): Record<string, any> {\n    const nfields = reader.readInt16();\n    const tuple = Object.create(null);\n\n    for (let i = 0; i < nfields; i++) {\n      const {name, parser} = columns[i];\n      const kind = reader.readUint8();\n\n      switch (kind) {\n        case 0x62: // 'b' binary\n          const bsize = reader.readInt32();\n          const bval = reader.read(bsize);\n          // dont need to .slice() because new buffer\n          // is created for each replication chunk\n          tuple[name] = bval;\n          break;\n        case 0x74: // 't' text\n          const valsize = reader.readInt32();\n          const valbuf = reader.read(valsize);\n          const valtext = reader.decodeText(valbuf);\n          tuple[name] = parser(valtext);\n          break;\n        case 0x6e: // 'n' null\n          tuple[name] = null;\n          break;\n        case 0x75: // 'u' unchanged toast datum\n          tuple[name] = unchangedToastFallback?.[name];\n          break;\n        default:\n          throw Error(`unknown attribute kind ${String.fromCharCode(kind)}`);\n      }\n    }\n\n    return tuple;\n  }\n\n  private msgTruncate(reader: BinaryReader): MessageTruncate {\n    const nrels = reader.readInt32();\n    const flags = reader.readUint8();\n\n    return {\n      tag: 'truncate',\n      cascade: Boolean(flags & 0b1),\n      restartIdentity: Boolean(flags & 0b10),\n      relations: reader.array(\n        nrels,\n        () => this._relationCache.get(reader.readInt32()) as MessageRelation,\n      ),\n    };\n  }\n\n  private msgMessage(reader: BinaryReader): MessageMessage {\n    const flags = reader.readUint8();\n\n    return {\n      tag: 'message',\n      flags,\n      transactional: Boolean(flags & 0b1),\n      messageLsn: reader.readLsn(),\n      prefix: reader.readString(),\n      content: reader.read(reader.readInt32()),\n    };\n  }\n\n  private msgCommit(reader: BinaryReader): MessageCommit {\n    return {\n      tag: 'commit',\n      flags: reader.readUint8(), // reserved unused\n      commitLsn: reader.readLsn(), // should be the same as begin.commitLsn\n      commitEndLsn: reader.readLsn(),\n      commitTime: reader.readTime(),\n    };\n  }\n}\n"],"mappings":"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"}

package/out/zero-cache/src/services/change-source/pg/logical-replication/stream.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"stream.js","names":[],"sources":["../../../../../../../../zero-cache/src/services/change-source/pg/logical-replication/stream.ts"],"sourcesContent":["import {\n  PG_ADMIN_SHUTDOWN,\n  PG_OBJECT_IN_USE,\n  PG_OBJECT_NOT_IN_PREREQUISITE_STATE,\n} from '@drdgvhbh/postgres-error-codes';\nimport type {LogContext} from '@rocicorp/logger';\nimport {defu} from 'defu';\nimport postgres, {type Options, type PostgresType} from 'postgres';\nimport {sleep} from '../../../../../../shared/src/sleep.ts';\nimport {getTypeParsers} from '../../../../db/pg-type-parser.ts';\nimport {type PostgresDB} from '../../../../types/pg.ts';\nimport {id, lit} from '../../../../types/sql.ts';\nimport {pipe, type Sink, type Source} from '../../../../types/streams.ts';\nimport {Subscription} from '../../../../types/subscription.ts';\nimport {AutoResetSignal} from '../../../change-streamer/schema/tables.ts';\nimport {fromBigInt} from '../lsn.ts';\nimport {PgoutputParser} from './pgoutput-parser.ts';\nimport type {Message} from './pgoutput.types.ts';\n\nconst DEFAULT_RETRIES_IF_REPLICATION_SLOT_ACTIVE = 5;\n\nexport type StreamMessage = [\n  lsn: bigint,\n  Message | {tag: 'keepalive'; shouldRespond: boolean},\n];\n\n// Expose the `queued` variable of the Subscription to allow\n// the change-source to determine if there are more messages\n// immediately available.\ntype SourceWithPendingQueue<T> = Source<T> & {\n  queued: number;\n};\n\nexport async function subscribe(\n  lc: LogContext,\n  db: PostgresDB,\n  slot: string,\n  publications: string[],\n  lsn: bigint,\n  retriesIfReplicationSlotActive = DEFAULT_RETRIES_IF_REPLICATION_SLOT_ACTIVE,\n  applicationName = 'zero-replicator',\n): Promise<{\n  messages: SourceWithPendingQueue<StreamMessage>;\n  acks: Sink<bigint>;\n}> {\n  const session = postgres(\n    defu(\n      {\n        max: 1,\n        ['fetch_types']: false, // Necessary for the streaming protocol\n        ['idle_timeout']: null,\n        ['max_lifetime']: null as unknown as number,\n        connection: {\n          ['application_name']: applicationName,\n          replication: 'database', // https://www.postgresql.org/docs/current/protocol-replication.html\n        },\n      },\n      // ParsedOptions are technically compatible with Options, but happen\n      // to not be typed that way. The postgres.js author does an equivalent\n      // merge of ParsedOptions and Options here:\n      // https://github.com/porsager/postgres/blob/089214e85c23c90cf142d47fb30bd03f42874984/src/subscribe.js#L13\n      db.options as unknown as Options<Record<string, PostgresType>>,\n    ),\n  );\n\n  // Postgres will send keepalives before timing out a wal_sender. It is possible that\n  // these keepalives are not received if there is back-pressure in the replication\n  // stream. To keep the connection alive, explicitly send keepalives if none have been\n  // sent within the last 75% of the wal_sender_timeout.\n  //\n  // https://www.postgresql.org/docs/current/runtime-config-replication.html#GUC-WAL-SENDER-TIMEOUT\n  const [{walSenderTimeoutMs}] = await session<\n    {walSenderTimeoutMs: number}[]\n  >`SELECT EXTRACT(EPOCH FROM (setting || unit)::interval) * 1000 \n        AS \"walSenderTimeoutMs\" FROM pg_settings\n        WHERE name = 'wal_sender_timeout'`.simple();\n  const manualKeepaliveTimeout = Math.floor(walSenderTimeoutMs * 0.75);\n  lc.info?.(\n    `wal_sender_timeout: ${walSenderTimeoutMs}ms. ` +\n      `Ensuring manual keepalives at least every ${manualKeepaliveTimeout}ms`,\n  );\n\n  const [readable, writable] = await startReplicationStream(\n    lc,\n    session,\n    slot,\n    publications,\n    lsn,\n    retriesIfReplicationSlotActive + 1,\n  );\n\n  let lastAckTime = Date.now();\n  function sendAck(lsn: bigint) {\n    writable.write(makeAck(lsn));\n    lastAckTime = Date.now();\n  }\n\n  const livenessTimer = setInterval(() => {\n    const now = Date.now();\n    if (now - lastAckTime > manualKeepaliveTimeout) {\n      sendAck(0n);\n      lc.debug?.(`sent manual keepalive`);\n    }\n  }, manualKeepaliveTimeout / 5);\n\n  let destroyed = false;\n  const typeParsers = await getTypeParsers(db, {returnJsonAsString: true});\n  const parser = new PgoutputParser(typeParsers);\n  const messages = Subscription.create<StreamMessage>({\n    cleanup: () => {\n      destroyed = true;\n      readable.destroyed || readable.destroy();\n      clearInterval(livenessTimer);\n      return session.end();\n    },\n  });\n\n  readable.once(\n    'close',\n    () =>\n      // Only log a warning if the stream was not manually closed.\n      destroyed || lc.warn?.(`replication stream closed by ${db.options.host}`),\n  );\n  readable.once(\n    'error',\n    e =>\n      // Don't log the shutdown signal. This is the expected way for upstream\n      // to close the connection (and will be logged downstream).\n      (e instanceof postgres.PostgresError && e.code === PG_ADMIN_SHUTDOWN) ||\n      lc.warn?.(`error from ${db.options.host}`, e),\n  );\n\n  pipe({\n    source: readable,\n    sink: messages,\n    parse: buffer => parseStreamMessage(lc, buffer, parser),\n    // Allow a small buffer of messages to be queued in the subscription so\n    // that the change-source loop can check the queue to determine if more\n    // messages are immediately available.\n    bufferMessages: 5,\n  });\n\n  return {\n    messages,\n    acks: {push: sendAck},\n  };\n}\n\n/**\n * Formats publication names for the START_REPLICATION command.\n * The replication protocol expects format: publication_names 'pub1,pub2'\n * Each name is escaped to handle any quotes that may have passed validation.\n */\nfunction formatPublicationNames(publications: string[]): string {\n  // lit() returns 'escaped_name' with surrounding quotes\n  // We strip the quotes since the outer quotes are in the template\n  return publications.map(p => lit(p).slice(1, -1)).join(',');\n}\n\nasync function startReplicationStream(\n  lc: LogContext,\n  session: postgres.Sql,\n  slot: string,\n  publications: string[],\n  lsn: bigint,\n  maxAttempts: number,\n) {\n  for (let i = 0; i < maxAttempts; i++) {\n    try {\n      const stream = session\n        .unsafe(\n          `START_REPLICATION SLOT ${id(slot)} LOGICAL ${fromBigInt(lsn)} (\n        proto_version '1',\n        publication_names '${formatPublicationNames(publications)}',\n        messages 'true'\n      )`,\n        )\n        .execute();\n      return await Promise.all([stream.readable(), stream.writable()]);\n    } catch (e) {\n      if (e instanceof postgres.PostgresError) {\n        // error: replication slot \"zero_slot_change_source_test_id\" is active for PID 268\n        if (e.code === PG_OBJECT_IN_USE) {\n          // The freeing up of the replication slot is not transactional;\n          // sometimes it takes time for Postgres to consider the slot\n          // inactive.\n          lc.warn?.(`attempt ${i + 1}: ${String(e)}`, e);\n          await sleep(10);\n          continue;\n        }\n        // error: This slot has been invalidated because it exceeded the maximum reserved size.\n        // (This is a different manifestation of a slot being invalidated when\n        //  the wal exceeds the max_slot_wal_keep_size)\n        if (e.code === PG_OBJECT_NOT_IN_PREREQUISITE_STATE) {\n          lc.error?.(`error starting replication stream`, e);\n          throw new AutoResetSignal(`unable to start replication stream`, {\n            cause: e,\n          });\n        }\n      }\n      throw e;\n    }\n  }\n  throw new Error(\n    `exceeded max attempts (${maxAttempts}) to start the Postgres stream`,\n  );\n}\n\nfunction parseStreamMessage(\n  lc: LogContext,\n  buffer: Buffer,\n  parser: PgoutputParser,\n): StreamMessage | null {\n  // https://www.postgresql.org/docs/current/protocol-replication.html#PROTOCOL-REPLICATION-START-REPLICATION\n  if (buffer[0] !== 0x77 && buffer[0] !== 0x6b) {\n    lc.warn?.('Unknown message', buffer[0]);\n    return null;\n  }\n  const lsn = buffer.readBigUInt64BE(1);\n  if (buffer[0] === 0x77) {\n    // https://www.postgresql.org/docs/current/protocol-replication.html#PROTOCOL-REPLICATION-XLOGDATA\n    // (Byte 25 is where the WAL data begins)\n    return [lsn, parser.parse(buffer.subarray(25))];\n  }\n  // https://www.postgresql.org/docs/current/protocol-replication.html#PROTOCOL-REPLICATION-PRIMARY-KEEPALIVE-MESSAGE\n  // (Byte 17: shouldRespond)\n  const shouldRespond = buffer.readInt8(17) !== 0;\n  return [lsn, {tag: 'keepalive', shouldRespond}];\n}\n\n// https://www.postgresql.org/docs/current/protocol-replication.html#PROTOCOL-REPLICATION-STANDBY-STATUS-UPDATE\nfunction makeAck(lsn: bigint): Buffer {\n  const microNow = BigInt(Date.now() - Date.UTC(2000, 0, 1)) * BigInt(1000);\n\n  const x = Buffer.alloc(34);\n  x[0] = 'r'.charCodeAt(0);\n  x.writeBigInt64BE(lsn, 1);\n  x.writeBigInt64BE(lsn, 9);\n  x.writeBigInt64BE(lsn, 17);\n  x.writeBigInt64BE(microNow, 25);\n  return x;\n}\n"],"mappings":"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"}

package/out/zero-cache/src/services/change-source/pg/lsn.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"lsn.js","names":[],"sources":["../../../../../../../zero-cache/src/services/change-source/pg/lsn.ts"],"sourcesContent":["import {assert} from '../../../../../shared/src/asserts.ts';\nimport {\n  majorVersionToString,\n  stateVersionFromString,\n} from '../../../types/state-version.ts';\nimport type {Change} from '../protocol/current/data.ts';\n\n/**\n * Parsing and conversion utilities for the pg_lsn Type, which represents\n * the \"Log Sequence Number\" used as a monotonic progress marker for logical\n * replication from a PostgresSQL database.\n *\n * The LSN is a 64-bit integer represented in logical replication as two\n * hexadecimal numbers (up to 8 digits each) separated by a slash. This is\n * converted to a LexiVersion and used as DB-agnostic version in change log,\n * invalidation index, and row version in the tables of the sync replica.\n */\nexport type LSN = string;\n\nexport type RecordType = Change['tag'];\n\nexport function toBigInt(lsn: LSN): bigint {\n  const parts = lsn.split('/');\n  assert(parts.length === 2, `Malformed LSN: \"${lsn}\"`);\n  const high = BigInt(`0x${parts[0]}`);\n  const low = BigInt(`0x${parts[1]}`);\n  const val = (high << 32n) + low;\n  return val;\n}\n\nexport function toStateVersionString(lsn: LSN): string {\n  return majorVersionToString(toBigInt(lsn));\n}\n\n/** The LSN is tracked by the `major` component of the StateVersion. */\nexport function fromStateVersionString(ver: string): LSN {\n  const {major} = stateVersionFromString(ver);\n  return fromBigInt(major);\n}\n\nexport function fromBigInt(val: bigint): LSN {\n  const high = val >> 32n;\n  const low = val & 0xffffffffn;\n  return `${high.toString(16).toUpperCase()}/${low.toString(16).toUpperCase()}`;\n}\n"],"mappings":";;;AAqBA,SAAgB,SAAS,KAAkB;CACzC,MAAM,QAAQ,IAAI,MAAM,IAAI;AAC5B,QAAO,MAAM,WAAW,GAAG,mBAAmB,IAAI,GAAG;CACrD,MAAM,OAAO,OAAO,KAAK,MAAM,KAAK;CACpC,MAAM,MAAM,OAAO,KAAK,MAAM,KAAK;AAEnC,SADa,QAAQ,OAAO;;AAI9B,SAAgB,qBAAqB,KAAkB;AACrD,QAAO,qBAAqB,SAAS,IAAI,CAAC;;;AAI5C,SAAgB,uBAAuB,KAAkB;CACvD,MAAM,EAAC,UAAS,uBAAuB,IAAI;AAC3C,QAAO,WAAW,MAAM;;AAG1B,SAAgB,WAAW,KAAkB;CAC3C,MAAM,OAAO,OAAO;CACpB,MAAM,MAAM,MAAM;AAClB,QAAO,GAAG,KAAK,SAAS,GAAG,CAAC,aAAa,CAAC,GAAG,IAAI,SAAS,GAAG,CAAC,aAAa"}

package/out/zero-cache/src/services/change-source/pg/replication-slots.js

@@ -1,162 +0,0 @@
-import { upstreamSchema } from "../../../types/shards.js";
-import { isPostgresError } from "../../../types/pg.js";
-import { toStateVersionString } from "./lsn.js";
-import { runTx } from "../../../db/run-transaction.js";
-import { createReplica, replicationSlotExpression, replicationSlotPrefix } from "./schema/shard.js";
-import { orTimeout } from "../../../types/timeout.js";
-import postgres from "postgres";
-import { PG_CONFIGURATION_LIMIT_EXCEEDED, PG_INSUFFICIENT_PRIVILEGE } from "@drdgvhbh/postgres-error-codes";
-//#region ../zero-cache/src/services/change-source/pg/replication-slots.ts
-var CREATE_REPLICATION_SLOT_TIMEOUT_MS = 3e4;
-var SERVER_LOCK_TIMEOUT_MS = CREATE_REPLICATION_SLOT_TIMEOUT_MS - 1e3;
-async function createReplicationSlot(lc, session, { slotName, failover, lockTimeout = SERVER_LOCK_TIMEOUT_MS }) {
-	await session.unsafe(`SET lock_timeout = ${lockTimeout}`);
-	const raced = await orTimeout(failover ? session.unsafe(`CREATE_REPLICATION_SLOT "${slotName}" LOGICAL pgoutput (FAILOVER)`) : session.unsafe(`CREATE_REPLICATION_SLOT "${slotName}" LOGICAL pgoutput`), CREATE_REPLICATION_SLOT_TIMEOUT_MS);
-	if (raced === "timed-out") {
-		session.end().catch((e) => lc.warn?.(`Error closing timed out replication slot session`, e));
-		throw new Error(`Timed out after ${CREATE_REPLICATION_SLOT_TIMEOUT_MS} ms creating replication slot ${slotName}. Crashing to force a clean restart.`);
-	}
-	const [slot] = raced;
-	lc.info?.(`Created replication slot ${slotName}`, slot);
-	return slot;
-}
-/**
-* Replica and slot creation involves two sessions for proper coordination
-* with other replica management logic:
-*
-* * A normal transaction is started and acquires an advisory lock for
-*   replica slot management. This is the same lock that cleanup logic
-*   acquires before cleaning up replication slots.
-* * With the lock held, a new replication slot is created in a
-*   replication session. The API of CREATE_REPLICATION_SLOT is such
-*   that it cannot be done in a transaction, and cannot be followed by
-*   any writes, or else its snapshot (which is needed for initial sync)
-*   would be invalidated.
-* * Once the slot is created, the slot and replica information are recorded
-*   in the `replicas` table before releasing the lock.
-*
-* This locking ensures that:
-* 1. multiple replication managers attempting to create a replication slot
-*    will not use the same name for the replication slot (which is selected
-*    from a pool of reused names).
-* 2. Running replication managers (which use an earlier replica of a lower
-*    rank) will not delete the new slot during their cleanup logic, since
-*    the slot will belong to a replica of a higher rank.
-*/
-async function createReplicaAndSlot(lc, sql, replicationSession, shard, replicaID, failover) {
-	const lockName = replicationSlotManagementLock(shard);
-	const slotPoolPrefix = replicationSlotPrefix(shard);
-	for (let first = true;; first = false) try {
-		return runTx(sql, async (tx) => {
-			await tx`SELECT pg_advisory_xact_lock(hashtext(${lockName}))`;
-			let slotName;
-			const names = await tx`
-          SELECT slot_name as name FROM pg_replication_slots
-            WHERE slot_name LIKE ${slotPoolPrefix + "%"};
-        `.values();
-			const inUse = new Set(names.flat());
-			for (let next = 0;; next++) {
-				const candidateName = `${slotPoolPrefix}${slotPoolSuffix(next)}`;
-				if (!inUse.has(candidateName)) {
-					slotName = candidateName;
-					break;
-				}
-			}
-			const slot = await createReplicationSlot(lc, replicationSession, {
-				slotName,
-				failover
-			});
-			await createReplica(tx, shard, replicaID, slot.slot_name, toStateVersionString(slot.consistent_point));
-			return slot;
-		});
-	} catch (e) {
-		if (first && e instanceof postgres.PostgresError) {
-			if (isPostgresError(e, PG_INSUFFICIENT_PRIVILEGE)) {
-				await sql`ALTER ROLE current_user WITH REPLICATION`;
-				lc.info?.(`Added the REPLICATION role to database user`);
-				continue;
-			}
-			if (isPostgresError(e, PG_CONFIGURATION_LIMIT_EXCEEDED)) {
-				const dropped = await sql`
-                SELECT slot_name as slot, pg_drop_replication_slot(slot_name)
-                  FROM pg_replication_slots
-                  WHERE slot_name LIKE ${replicationSlotExpression(shard)} AND NOT active`;
-				if (dropped.length) {
-					lc.warn?.(`Dropped inactive replication slots: ${dropped.map(({ slot }) => slot)}`, e);
-					continue;
-				}
-				lc.error?.(`Unable to drop replication slots`, e);
-			}
-		}
-		throw e;
-	}
-}
-/**
-* Deletes "old" replicas (i.e. those with a lower rank than the current)
-* and attempts to drop replication slots that are not associated with any
-* replica.
-*
-* If a slot could not be dropped because there is still an active subscriber,
-* it will be reflected in the `draining` count that is returned. When there
-* are draining slots, the method should be retried until all orphaned slots
-* have been dropped.
-*/
-async function dropOldReplicasAndSlots(lc, sql, shard, beforeRank) {
-	const replicasTable = `${upstreamSchema(shard)}.replicas`;
-	const oldReplicas = await sql`
-    SELECT id, rank::float8, slot, version, "initialSyncContext", "subscriberContext"
-     FROM ${sql(replicasTable)} WHERE rank < ${beforeRank};
-  `;
-	if (oldReplicas.length) {
-		lc.info?.(`Deleting ${oldReplicas.length} old replica(s)`, { oldReplicas });
-		await sql`DELETE FROM ${sql(replicasTable)} WHERE rank < ${beforeRank}`;
-	}
-	const lockName = replicationSlotManagementLock(shard);
-	const slotExpression = replicationSlotExpression(shard);
-	return runTx(sql, async (tx) => {
-		await tx`SELECT pg_advisory_xact_lock(hashtext(${lockName}))`;
-		const dropped = await tx`
-      SELECT slot_name as slot, pg_drop_replication_slot(slot_name) 
-        FROM pg_replication_slots
-        LEFT JOIN ${tx(replicasTable)} replica on slot_name = slot
-        WHERE slot_name LIKE ${slotExpression} 
-          AND NOT active
-          AND replica.id IS NULL;
-    `;
-		if (dropped.length) lc.info?.(`dropped inactive replication slots`, { dropped });
-		const remaining = await tx`
-      SELECT slot_name as slot, active_pid as pid, replica.id as id
-        FROM pg_replication_slots
-        LEFT JOIN ${tx(replicasTable)} replica on slot_name = slot
-        WHERE slot_name LIKE ${slotExpression};
-    `;
-		if (remaining.length) lc.info?.(`remaining replication slots`, { remaining });
-		let active = 0;
-		let draining = 0;
-		for (const { id } of remaining) if (id === null) draining++;
-		else active++;
-		return {
-			dropped: dropped.length,
-			active,
-			draining
-		};
-	});
-}
-var ALPHABET = "abcdefghijklmnopqrstuvwxyz";
-function slotPoolSuffix(n) {
-	n++;
-	let suffix = "";
-	while (n > 0) {
-		n--;
-		suffix = ALPHABET[n % 26] + suffix;
-		n = Math.floor(n / 26);
-	}
-	return suffix;
-}
-function replicationSlotManagementLock(shard) {
-	return `replication-slot-management:${shard.appID}_${shard.shardNum}`;
-}
-//#endregion
-export { createReplicaAndSlot, createReplicationSlot, dropOldReplicasAndSlots };
-
-//# sourceMappingURL=replication-slots.js.map

package/out/zero-cache/src/services/change-source/pg/replication-slots.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"replication-slots.js","names":[],"sources":["../../../../../../../zero-cache/src/services/change-source/pg/replication-slots.ts"],"sourcesContent":["import {\n  PG_CONFIGURATION_LIMIT_EXCEEDED,\n  PG_INSUFFICIENT_PRIVILEGE,\n} from '@drdgvhbh/postgres-error-codes';\nimport type {LogContext} from '@rocicorp/logger';\nimport postgres from 'postgres';\nimport {runTx} from '../../../db/run-transaction';\nimport {isPostgresError, type PostgresDB} from '../../../types/pg';\nimport {upstreamSchema, type ShardID} from '../../../types/shards';\nimport {orTimeout} from '../../../types/timeout';\nimport {toStateVersionString} from './lsn';\nimport {\n  createReplica,\n  replicationSlotExpression,\n  replicationSlotPrefix,\n} from './schema/shard';\n\n// Record returned by `CREATE_REPLICATION_SLOT`\nexport type ReplicationSlot = {\n  slot_name: string;\n  consistent_point: string;\n  snapshot_name: string;\n  output_plugin: string;\n};\n\nexport type CreateSlotSpec = {\n  slotName: string;\n\n  // Note: must be false if pgVersion < PG_17. Caller must verify.\n  failover?: boolean;\n\n  // For overriding in tests.\n  lockTimeout?: number;\n};\n\n// When creating a replication slot, Postgres waits for open transactions\n// to complete before reserving a consistent_point (LSN) in the WAL and creating\n// a matching transaction snapshot. As such, it can technically take an arbitrary\n// amount of time (e.g. DDL operations, table-wide operations, etc.).\n//\n// However, to detect pathological situations, bound the amount of time that\n// the server waits for replication slot creation, so that a continual failure to\n// create a replication slot is surfaced by errors / alerts.\nconst CREATE_REPLICATION_SLOT_TIMEOUT_MS = 30_000;\n\n// The lock_timeout is set 1s before the client-side orTimeout so that\n// Postgres reliably aborts first and tears down the walsender cleanly.\n// The client-side timeout remains as a fallback for network-level failures.\nconst SERVER_LOCK_TIMEOUT_MS = CREATE_REPLICATION_SLOT_TIMEOUT_MS - 1_000;\n\n// Note: The replication connection does not support the extended query protocol,\n//       so all commands must be sent using sql.unsafe(). This is technically safe\n//       because all placeholder values are under our control (i.e. \"slotName\").\nexport async function createReplicationSlot(\n  lc: LogContext,\n  session: postgres.Sql,\n  {slotName, failover, lockTimeout = SERVER_LOCK_TIMEOUT_MS}: CreateSlotSpec,\n): Promise<ReplicationSlot> {\n  // CREATE_REPLICATION_SLOT can hang indefinitely waiting for long-running\n  // transactions to finish: internally it calls SnapBuildWaitSnapshot →\n  // XactLockTableWait → LockAcquire on each running XID. statement_timeout\n  // does NOT apply to replication commands, but lock_timeout does (it governs\n  // the heavyweight lock wait inside LockAcquire). Setting it here causes\n  // Postgres to raise ERRCODE_LOCK_NOT_AVAILABLE and cleanly tear down the\n  // walsender, rather than relying solely on the client-side orTimeout\n  // which can leave an orphaned backend.\n  //\n  // An orphaned walsender is actively harmful: by this point the replication\n  // slot has already been created and is pinning WAL retention and catalog_xmin.\n  // Worse, the slot is marked `active` (the walsender PID is still alive), so\n  // the existing cleanup code (which drops inactive slots on retry) can't\n  // reclaim it. Without lock_timeout the orphan persists until TCP keepalive\n  // fires (~2h default) or the blocking transaction finishes.\n  await session.unsafe(`SET lock_timeout = ${lockTimeout}`);\n\n  const createSlot = failover\n    ? session.unsafe<ReplicationSlot[]>(\n        /*sql*/ `CREATE_REPLICATION_SLOT \"${slotName}\" LOGICAL pgoutput (FAILOVER)`,\n      )\n    : session.unsafe<ReplicationSlot[]>(\n        /*sql*/ `CREATE_REPLICATION_SLOT \"${slotName}\" LOGICAL pgoutput`,\n      );\n  const raced = await orTimeout(createSlot, CREATE_REPLICATION_SLOT_TIMEOUT_MS);\n  if (raced === 'timed-out') {\n    // Create slot can block indefinitely waiting for old transactions. End\n    // this connection in the background and fail fast so the process restarts.\n    void session\n      .end()\n      .catch(e =>\n        lc.warn?.(`Error closing timed out replication slot session`, e),\n      );\n    throw new Error(\n      `Timed out after ${CREATE_REPLICATION_SLOT_TIMEOUT_MS} ms creating replication slot ${slotName}. ` +\n        `Crashing to force a clean restart.`,\n    );\n  }\n  const [slot] = raced;\n  lc.info?.(`Created replication slot ${slotName}`, slot);\n  return slot;\n}\n\n/**\n * Replica and slot creation involves two sessions for proper coordination\n * with other replica management logic:\n *\n * * A normal transaction is started and acquires an advisory lock for\n *   replica slot management. This is the same lock that cleanup logic\n *   acquires before cleaning up replication slots.\n * * With the lock held, a new replication slot is created in a\n *   replication session. The API of CREATE_REPLICATION_SLOT is such\n *   that it cannot be done in a transaction, and cannot be followed by\n *   any writes, or else its snapshot (which is needed for initial sync)\n *   would be invalidated.\n * * Once the slot is created, the slot and replica information are recorded\n *   in the `replicas` table before releasing the lock.\n *\n * This locking ensures that:\n * 1. multiple replication managers attempting to create a replication slot\n *    will not use the same name for the replication slot (which is selected\n *    from a pool of reused names).\n * 2. Running replication managers (which use an earlier replica of a lower\n *    rank) will not delete the new slot during their cleanup logic, since\n *    the slot will belong to a replica of a higher rank.\n */\nexport async function createReplicaAndSlot(\n  lc: LogContext,\n  sql: PostgresDB,\n  replicationSession: postgres.Sql,\n  shard: ShardID,\n  replicaID: string,\n  failover: boolean,\n): Promise<ReplicationSlot> {\n  const lockName = replicationSlotManagementLock(shard);\n  const slotPoolPrefix = replicationSlotPrefix(shard);\n  for (let first = true; ; first = false) {\n    try {\n      return runTx(sql, async tx => {\n        await tx`SELECT pg_advisory_xact_lock(hashtext(${lockName}))`;\n\n        // Pick an available slotName from the slotPoolPrefix pool.\n        let slotName: string;\n        const names = await tx<{name: string}[]> /*sql*/ `\n          SELECT slot_name as name FROM pg_replication_slots\n            WHERE slot_name LIKE ${slotPoolPrefix + '%'};\n        `.values();\n        const inUse = new Set(names.flat());\n        for (let next = 0; ; next++) {\n          const candidateName = `${slotPoolPrefix}${slotPoolSuffix(next)}`;\n          if (!inUse.has(candidateName)) {\n            slotName = candidateName;\n            break;\n          }\n        }\n\n        const slot = await createReplicationSlot(lc, replicationSession, {\n          slotName,\n          failover,\n        });\n\n        await createReplica(\n          tx,\n          shard,\n          replicaID,\n          slot.slot_name,\n          toStateVersionString(slot.consistent_point),\n        );\n\n        return slot;\n      });\n    } catch (e) {\n      if (first && e instanceof postgres.PostgresError) {\n        if (isPostgresError(e, PG_INSUFFICIENT_PRIVILEGE)) {\n          // Some Postgres variants (e.g. Google Cloud SQL) require that\n          // the user have the REPLICATION role in order to create a slot.\n          // Note that this must be done by the upstreamDB connection, and\n          // does not work in the replicationSession itself.\n          await sql`ALTER ROLE current_user WITH REPLICATION`;\n          lc.info?.(`Added the REPLICATION role to database user`);\n          continue;\n        }\n        if (isPostgresError(e, PG_CONFIGURATION_LIMIT_EXCEEDED)) {\n          const slotExpression = replicationSlotExpression(shard);\n\n          const dropped = await sql<{slot: string}[]>`\n                SELECT slot_name as slot, pg_drop_replication_slot(slot_name)\n                  FROM pg_replication_slots\n                  WHERE slot_name LIKE ${slotExpression} AND NOT active`;\n          if (dropped.length) {\n            lc.warn?.(\n              `Dropped inactive replication slots: ${dropped.map(({slot}) => slot)}`,\n              e,\n            );\n            continue;\n          }\n          lc.error?.(`Unable to drop replication slots`, e);\n        }\n      }\n      throw e;\n    }\n  }\n}\n\n/**\n * Deletes \"old\" replicas (i.e. those with a lower rank than the current)\n * and attempts to drop replication slots that are not associated with any\n * replica.\n *\n * If a slot could not be dropped because there is still an active subscriber,\n * it will be reflected in the `draining` count that is returned. When there\n * are draining slots, the method should be retried until all orphaned slots\n * have been dropped.\n */\nexport async function dropOldReplicasAndSlots(\n  lc: LogContext,\n  sql: PostgresDB,\n  shard: ShardID,\n  beforeRank: bigint,\n): Promise<{dropped: number; active: number; draining: number}> {\n  const replicasTable = `${upstreamSchema(shard)}.replicas`;\n  const oldReplicas = await sql`\n    SELECT id, rank::float8, slot, version, \"initialSyncContext\", \"subscriberContext\"\n     FROM ${sql(replicasTable)} WHERE rank < ${beforeRank};\n  `;\n  if (oldReplicas.length) {\n    lc.info?.(`Deleting ${oldReplicas.length} old replica(s)`, {oldReplicas});\n    await sql`DELETE FROM ${sql(replicasTable)} WHERE rank < ${beforeRank}`;\n  }\n\n  // The slot / replica cleanup happens within a transaction while holding\n  // the replication slot management lock for this shard, to ensure that no\n  // slot that belongs to a newer replica is dropped.\n  const lockName = replicationSlotManagementLock(shard);\n  const slotExpression = replicationSlotExpression(shard);\n  return runTx(sql, async tx => {\n    await tx`SELECT pg_advisory_xact_lock(hashtext(${lockName}))`;\n\n    const dropped = await tx /*sql*/ `\n      SELECT slot_name as slot, pg_drop_replication_slot(slot_name) \n        FROM pg_replication_slots\n        LEFT JOIN ${tx(replicasTable)} replica on slot_name = slot\n        WHERE slot_name LIKE ${slotExpression} \n          AND NOT active\n          AND replica.id IS NULL;\n    `;\n    if (dropped.length) {\n      lc.info?.(`dropped inactive replication slots`, {dropped});\n    }\n\n    const remaining = await tx<\n      {slot: string; pid: number | null; id: string | null}[]\n    > /*sql*/ `\n      SELECT slot_name as slot, active_pid as pid, replica.id as id\n        FROM pg_replication_slots\n        LEFT JOIN ${tx(replicasTable)} replica on slot_name = slot\n        WHERE slot_name LIKE ${slotExpression};\n    `;\n    if (remaining.length) {\n      lc.info?.(`remaining replication slots`, {remaining});\n    }\n\n    let active = 0;\n    let draining = 0;\n    for (const {id} of remaining) {\n      if (id === null) {\n        draining++;\n      } else {\n        active++;\n      }\n    }\n\n    return {\n      dropped: dropped.length,\n      active,\n      draining,\n    };\n  });\n}\n\nconst ALPHABET = 'abcdefghijklmnopqrstuvwxyz';\n\n// Alphabetic notation is used as the slot pool suffix to distinguish\n// it from the (numeric) shard num that's also encoded in the slot name.\nexport function slotPoolSuffix(n: number) {\n  n++; // Adjust for 0-based indexing\n\n  let suffix = '';\n  while (n > 0) {\n    n--;\n    suffix = ALPHABET[n % 26] + suffix;\n    n = Math.floor(n / 26);\n  }\n  return suffix;\n}\n\nfunction replicationSlotManagementLock(shard: ShardID) {\n  return `replication-slot-management:${shard.appID}_${shard.shardNum}`;\n}\n"],"mappings":"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"}

package/out/zero-cache/src/services/change-source/pg/schema/ddl.js

@@ -1,334 +0,0 @@
-import { assert } from "../../../../../../shared/src/asserts.js";
-import { valita_exports } from "../../../../../../shared/src/valita.js";
-import { upstreamSchema } from "../../../../types/shards.js";
-import { id } from "../../../../types/sql.js";
-import { publishedSchema, publishedSchemaQuery } from "./published.js";
-import { literal } from "pg-format";
-var ddlEventSchema = valita_exports.object({ context: valita_exports.object({ query: valita_exports.string() }).rest(valita_exports.string()) }).extend({
-	version: valita_exports.literal(1),
-	schema: publishedSchema,
-	event: valita_exports.object({ tag: valita_exports.string() })
-});
-/**
-* A {@link DdlStartEvent} message is emitted before every DDL event, containing
-* the current `schema` and the command `tag`.
-*
-* In most cases, the `DdlStartEvent` itself will not be associated with a
-* schema change, in which case `previousSchema` will be `null`. However, the
-* message is still emitted, both for backwards compatibility and to provide
-* the command `tag` context in case an immediately following `DdlStartEvent`
-* tag is emitted with a schema change (which can happen when another event
-* trigger results in a nested ddl statement).
-*
-* In such cases, the `previousSchema` and `schema` fields of the latter event
-* are used to determine the necessary schema change operations (as they are
-* with `ddlUpdate` and `schemaSnapshot` events), and the `tag` of the
-* preceding start event indicates the command that precipitated the schema
-* change (e.g. a CREATE vs ALTER) to determine whether a backfill is
-* necessary.
-*/
-var ddlStartEventSchema = ddlEventSchema.extend({
-	type: valita_exports.literal("ddlStart"),
-	previousSchema: publishedSchema.nullable().optional(),
-	event: valita_exports.object({ tag: valita_exports.string() }).optional(() => ({ tag: "UNKNOWN" }))
-});
-/**
-* A {@link DdlUpdateEvent} is emitted if there was a change in the schema.
-* It always contains `previousSchema` and (current) `schema` fields, leaving
-* it to the receiver to compute the necessary schema change operations.
-*/
-var ddlUpdateEventSchema = ddlEventSchema.extend({
-	type: valita_exports.literal("ddlUpdate"),
-	previousSchema: publishedSchema.optional()
-});
-/**
-* The `schemaSnapshot` message is a snapshot of a schema taken in response to
-* a `COMMENT ON PUBLICATION` command, which is a hook recognized by zero
-* to manually emit `previousSchema` and `schema` snapshots when a difference
-* is detected. This is a workaround provided to support detection of schema
-* changes from `ALTER PUBLICATION` commands on supabase, which does not fire
-* event triggers for them (https://github.com/supabase/supautils/issues/123).
-*
-* The hook is exercised by trailing the publication change with a
-* `COMMENT ON PUBLICATION` statement, e.g.
-*
-* ```sql
-* BEGIN;
-* ALTER PUBLICATION my_publication ...;
-* COMMENT ON PUBLICATION my_publication IS 'whatever';
-* COMMIT;
-* ```
-*
-* Note that it is fine to invoke `COMMENT ON PUBLICATION` statements
-* on a database that *does* support event triggers on
-* `ALTER PUBLICATION` statements, as it will simply be a no-op.
-*/
-var schemaSnapshotEventSchema = ddlEventSchema.extend({
-	type: valita_exports.literal("schemaSnapshot"),
-	previousSchema: publishedSchema.optional()
-});
-var replicationEventSchema = valita_exports.union(ddlStartEventSchema, ddlUpdateEventSchema, schemaSnapshotEventSchema);
-function append(shardNum) {
-	return (name) => id(name + "_" + String(shardNum));
-}
-var DDL_SERIALIZATION_LOCK = 4353719051050729648n;
-/**
-* Event trigger functions contain the core logic that are invoked by triggers.
-*
-* Note that although many of these functions can theoretically be parameterized and
-* shared across shards, it is advantageous to keep the functions in each shard
-* isolated from each other in order to avoid the complexity of shared-function
-* versioning.
-*
-* In a sense, shards (and their triggers and functions) should be thought of as
-* execution environments that can be updated at different schedules. If per-shard
-* triggers called into shared functions, we would have to consider versioning the
-* functions when changing their behavior, backwards compatibility, removal of
-* unused versions, etc. (not unlike versioning of npm packages).
-*
-* Instead, we opt for the simplicity and isolation of having each shard
-* completely own (and maintain) the entirety of its trigger/function stack.
-*/
-function createEventFunctionStatements(shard) {
-	const { appID, shardNum, publications } = shard;
-	const schema = id(upstreamSchema(shard));
-	return `
-CREATE SCHEMA IF NOT EXISTS ${schema};
-
-CREATE OR REPLACE FUNCTION ${schema}.get_trigger_context()
-RETURNS record AS $$
-DECLARE
-  result record;
-BEGIN
-  SELECT current_query() AS "query" into result;
-  RETURN result;
-END
-$$ LANGUAGE plpgsql;
-
-
-CREATE OR REPLACE FUNCTION ${schema}.notice_ignore(reason TEXT, tag TEXT, target record)
-RETURNS void AS $$
-BEGIN
-  RAISE NOTICE '${appID}_${shardNum} ignoring % % %', reason, tag, 
-    COALESCE(row_to_json(target)::text, '');
-END
-$$ LANGUAGE plpgsql;
-
-
--- Note: DROP and CREATE to upgrade from v20 to v21 because the
--- return type has changed. This can be simplified to CREATE OR REPLACE
--- once 1.5.0 is rollback safe.
-DROP FUNCTION IF EXISTS ${schema}.schema_specs();
-CREATE FUNCTION ${schema}.schema_specs()
-RETURNS JSON 
-STABLE
-AS $$
-  ${publishedSchemaQuery(publications)}
-$$ LANGUAGE sql;
-
-
--- Stores the most recent published schema
-CREATE TABLE IF NOT EXISTS ${schema}."publishedSchema" (
-  current JSON,
-  exists BOOL PRIMARY KEY DEFAULT true CHECK (exists)
-);
-
-INSERT INTO ${schema}."publishedSchema" (current) VALUES (${schema}.schema_specs())
-  ON CONFLICT (exists) DO 
-  UPDATE SET current = excluded.current;
-
-
-CREATE OR REPLACE FUNCTION ${schema}.update_schemas(event_type text, tag text, target record)
-RETURNS void AS $$
-DECLARE
-  prev_schema_specs JSON;
-  schema_specs JSON;
-  message TEXT;
-BEGIN
-  SELECT current FROM ${schema}."publishedSchema" INTO prev_schema_specs;
-  SELECT ${schema}.schema_specs() INTO schema_specs;
-  
-  IF prev_schema_specs::text != schema_specs::text THEN
-    UPDATE ${schema}."publishedSchema" SET current = schema_specs;
-  ELSIF event_type = 'ddlStart' THEN
-    -- ddlStart events are always be emitted to allow the zero-cache
-    -- to track the context of the current command tag in the face of
-    -- nested event triggers (e.g. start->start->end->end).
-    prev_schema_specs = NULL;
-  ELSIF event_type = 'ddlUpdate' THEN
-    -- TODO: fold 'schemaSnapshot' into this condition too (i.e. make it "ELSE")
-    -- when 1.5.0 is rollback safe. Until then, noop schemaSnapshots are sent
-    -- for compatibility with 1.0.0 ~ 1.4.0.
-    PERFORM ${schema}.notice_ignore('noop', tag, target);
-    RETURN;
-  END IF;
-
-  SELECT json_build_object(
-    'type', event_type,
-    'version', 1,
-    'previousSchema', prev_schema_specs,
-    'schema', schema_specs,
-    'event', json_build_object('tag', tag),
-    'context', ${schema}.get_trigger_context()
-  ) INTO message;
-
-  PERFORM pg_logical_emit_message(true, '${appID}/${shardNum}/ddl', message);
-
-  RAISE NOTICE 'Emitted ${appID}_${shardNum} % for % %', event_type, tag, 
-    COALESCE(row_to_json(target)::text, '');
-END
-$$ LANGUAGE plpgsql;
-
-
--- Hook/workaround to manually trigger replication of schema changes on DBs 
--- that do not support/allow event triggers.
-CREATE OR REPLACE FUNCTION ${schema}.update_schemas()
-RETURNS void AS $$
-BEGIN
-  PERFORM ${schema}.update_schemas('schemaSnapshot', 'MANUAL', NULL);
-END
-$$ LANGUAGE plpgsql;
-
-
-CREATE OR REPLACE FUNCTION ${schema}.emit_ddl_start()
-RETURNS event_trigger AS $$
-DECLARE
-  schema_specs JSON;
-  message TEXT;
-BEGIN
-  -- serialize DDL statements to compute correct schema change diffs
-  PERFORM pg_advisory_xact_lock(${DDL_SERIALIZATION_LOCK});
-  PERFORM ${schema}.update_schemas('ddlStart', TG_TAG, NULL);
-END
-$$ LANGUAGE plpgsql;
-
-
-CREATE OR REPLACE FUNCTION ${schema}.emit_ddl_end()
-RETURNS event_trigger AS $$
-DECLARE
-  publications TEXT[];
-  target RECORD;
-  relevant RECORD;
-  schema_specs JSON;
-  message TEXT;
-  event TEXT;
-BEGIN
-  publications := ARRAY[${literal(publications)}];
-
-  SELECT objid, object_type, object_identity 
-    FROM pg_event_trigger_ddl_commands() 
-    LIMIT 1 INTO target;
-
-  -- Filter DDL updates that are not relevant to the shard (i.e. publications) when possible.
-  SELECT true INTO relevant;
-
-  -- Note: ALTER TABLE statements may *remove* the table from the set of published
-  --       tables, and there is no way to determine if the table "used to be" in the
-  --       set. Thus, all ALTER TABLE statements must produce a ddl update, similar to
-  --       any DROP * statement.
-  IF (target.object_type = 'table' AND TG_TAG != 'ALTER TABLE') 
-     OR target.object_type = 'table column' THEN
-    SELECT ns.nspname AS "schema", c.relname AS "name" FROM pg_class AS c
-      JOIN pg_namespace AS ns ON c.relnamespace = ns.oid
-      JOIN pg_publication_tables AS pb ON pb.schemaname = ns.nspname AND pb.tablename = c.relname
-      WHERE c.oid = target.objid AND pb.pubname = ANY (publications)
-      INTO relevant;
-
-  ELSIF target.object_type = 'index' THEN
-    SELECT ns.nspname AS "schema", c.relname AS "name" FROM pg_class AS c
-      JOIN pg_namespace AS ns ON c.relnamespace = ns.oid
-      JOIN pg_indexes as ind ON ind.schemaname = ns.nspname AND ind.indexname = c.relname
-      JOIN pg_publication_tables AS pb ON pb.schemaname = ns.nspname AND pb.tablename = ind.tablename
-      WHERE c.oid = target.objid AND pb.pubname = ANY (publications)
-      INTO relevant;
-
-  ELSIF target.object_type = 'publication relation' THEN
-    SELECT pb.pubname FROM pg_publication_rel AS rel
-      JOIN pg_publication AS pb ON pb.oid = rel.prpubid
-      WHERE rel.oid = target.objid AND pb.pubname = ANY (publications) 
-      INTO relevant;
-
-  ELSIF target.object_type = 'publication namespace' THEN
-    SELECT pb.pubname FROM pg_publication_namespace AS ns
-      JOIN pg_publication AS pb ON pb.oid = ns.pnpubid
-      WHERE ns.oid = target.objid AND pb.pubname = ANY (publications) 
-      INTO relevant;
-
-  ELSIF target.object_type = 'schema' THEN
-    SELECT ns.nspname AS "schema", c.relname AS "name" FROM pg_class AS c
-      JOIN pg_namespace AS ns ON c.relnamespace = ns.oid
-      JOIN pg_publication_tables AS pb ON pb.schemaname = ns.nspname AND pb.tablename = c.relname
-      WHERE ns.oid = target.objid AND pb.pubname = ANY (publications)
-      INTO relevant;
-
-  ELSIF target.object_type = 'publication' THEN
-    SELECT 1 WHERE target.object_identity = ANY (publications)
-      INTO relevant;
-
-  -- no-op CREATE IF NOT EXIST statements
-  ELSIF TG_TAG LIKE 'CREATE %' AND target.object_type IS NULL THEN
-    relevant := NULL;
-  END IF;
-
-  IF relevant IS NULL THEN
-    PERFORM ${schema}.notice_ignore('irrelevant', TG_TAG, target);
-    RETURN;
-  END IF;
-
-  IF TG_TAG = 'COMMENT' THEN
-    -- Only make schemaSnapshots for COMMENT ON PUBLICATION
-    IF target.object_type != 'publication' THEN
-      PERFORM ${schema}.notice_ignore('irrelevant', TG_TAG, target);
-      RETURN;
-    END IF;
-    PERFORM ${schema}.update_schemas('schemaSnapshot', TG_TAG, target);
-  ELSE
-    PERFORM ${schema}.update_schemas('ddlUpdate', TG_TAG, target);
-  END IF;
-
-END
-$$ LANGUAGE plpgsql;
-`;
-}
-var TAGS = [
-	"CREATE TABLE",
-	"ALTER TABLE",
-	"CREATE INDEX",
-	"DROP TABLE",
-	"DROP INDEX",
-	"ALTER PUBLICATION",
-	"ALTER SCHEMA"
-];
-function createEventTriggerStatements(shard) {
-	assert(shard.publications.length, `shard publications must be non-empty`);
-	const { appID, shardNum } = shard;
-	const sharded = append(shardNum);
-	const schema = id(upstreamSchema(shard));
-	const triggers = [dropEventTriggerStatements(shard.appID, shard.shardNum), `
-CREATE EVENT TRIGGER ${sharded(`${appID}_ddl_start`)}
-  ON ddl_command_start
-  WHEN TAG IN (${literal(TAGS)})
-  EXECUTE PROCEDURE ${schema}.emit_ddl_start();
-
-CREATE EVENT TRIGGER ${sharded(`${appID}_ddl_end`)}
-  ON ddl_command_end
-  WHEN TAG IN (${literal([...TAGS, "COMMENT"])})
-  EXECUTE PROCEDURE ${schema}.emit_ddl_end();
-`];
-	triggers.push(`DROP FUNCTION IF EXISTS ${schema}.emit_ddl_end(text) CASCADE;`, `DROP FUNCTION IF EXISTS ${schema}.notice_ignore(text, record);`);
-	for (const tag of [...TAGS, "COMMENT"]) {
-		const tagID = tag.toLowerCase().replace(" ", "_");
-		triggers.push(`DROP FUNCTION IF EXISTS ${schema}.emit_${tagID}() CASCADE;`);
-	}
-	return triggers.join("");
-}
-function dropEventTriggerStatements(appID, shardID) {
-	return `
-    DROP EVENT TRIGGER IF EXISTS ${id(`${appID}_ddl_start_${shardID}`)};
-    DROP EVENT TRIGGER IF EXISTS ${id(`${appID}_ddl_end_${shardID}`)};
-  `;
-}
-//#endregion
-export { createEventFunctionStatements, createEventTriggerStatements, replicationEventSchema };
-
-//# sourceMappingURL=ddl.js.map