@rocicorp/zero 1.11.0-canary.4 → 1.11.0-canary.41

package/out/zero-cache/src/services/change-source/pg/replication-slot-cleanup-monitor.js

@@ -0,0 +1,113 @@
+import { replicationSlotPrefix } from "./schema/shard.js";
+import "../../../types/pg-versions.js";
+import { dropInactiveSlotsAndReplicas } from "./replication-slots.js";
+//#region ../zero-cache/src/services/change-source/pg/replication-slot-cleanup-monitor.ts
+var DEFAULT_INACTIVE_SLOT_CLEANUP_TIMEOUT_MS = 300 * 1e3;
+var DEFAULT_POLL_INTERVAL_MS = 60 * 1e3;
+var ReplicationSlotCleanupMonitor = class {
+	#lc;
+	/** The shard constrains which slots are monitored (e.g. zero_0_*). */
+	#shard;
+	#upstream;
+	/**
+	* This slot that this task is using. Cleanup of slots is predicated on
+	* this slot remaining active, in order to guarantee at least one healthy
+	* slot in the shard.
+	*/
+	#currentSlot;
+	/**
+	* How long a slot is inactive (while the currentSlot is active) before it
+	* is eligible to be cleaned up. Because new slots are immediately connected
+	* to, even while an initial-sync or replica-restore is in progress, slots
+	* should only be inactive if no server is using it, or if a server was
+	* disconnected (e.g. a pg restart) and is in the process of reconnecting
+	* to it (see `keepSlotActiveUntilTakenOver`).
+	*
+	* As such, this timeout should be long enough to account for a server
+	* reconnecting to upstream. Note again that the cleanup monitor only runs
+	* while at least one replication slot is active, guaranteeing that upstream
+	* replication is working.
+	*/
+	#inactiveSlotCleanupTimeoutMs;
+	#pollIntervalMs;
+	/** Manually tracked inactive times for PG < 17. null for PG 17+ */
+	#firstInactiveTimes;
+	#pollTimer;
+	constructor(lc, shard, upstream, upstreamPgServerVersionNum, currentSlot, { inactiveSlotCleanupTimeoutMs, pollIntervalMs } = {}) {
+		this.#lc = lc.withContext("component", "replication-slot-cleanup-monitor");
+		this.#shard = shard;
+		this.#upstream = upstream;
+		this.#currentSlot = currentSlot;
+		this.#inactiveSlotCleanupTimeoutMs = inactiveSlotCleanupTimeoutMs ?? DEFAULT_INACTIVE_SLOT_CLEANUP_TIMEOUT_MS;
+		this.#pollIntervalMs = pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+		this.#firstInactiveTimes = upstreamPgServerVersionNum >= 17e4 ? null : /* @__PURE__ */ new Map();
+	}
+	start() {
+		if (this.#pollTimer) {
+			this.#lc.warn?.(`monitor already started`);
+			return;
+		}
+		this.#pollTimer = setInterval(() => this.#poll(/* @__PURE__ */ new Date()).catch((e) => this.#lc.warn?.(`error checking replication slots`, e)), this.#pollIntervalMs);
+	}
+	stop() {
+		clearInterval(this.#pollTimer);
+		this.#pollTimer = void 0;
+		this.#firstInactiveTimes?.clear();
+	}
+	async #poll(now) {
+		if (!this.#pollTimer) return;
+		const slots = await this.getSlotsToCleanup(now);
+		if (slots.length) await dropInactiveSlotsAndReplicas(this.#lc, this.#upstream, this.#shard, slots);
+	}
+	async getSlotsToCleanup(now) {
+		const slotPoolPrefix = replicationSlotPrefix(this.#shard);
+		const slotsToCleanUp = [];
+		const trackedInactiveTimes = this.#firstInactiveTimes;
+		if (trackedInactiveTimes) {
+			const shardSlots = await this.#upstream`
+        SELECT slot_name AS slot, active FROM pg_replication_slots
+          WHERE slot_name LIKE ${slotPoolPrefix + "%"};
+      `;
+			for (const { slot, active } of shardSlots) {
+				if (slot === this.#currentSlot && !active) {
+					this.#lc.warn?.(`current slot ${this.#currentSlot} is not active. disabling cleanup.`);
+					this.stop();
+					return [];
+				}
+				if (active) trackedInactiveTimes.delete(slot);
+				else {
+					const inactiveSince = trackedInactiveTimes.get(slot);
+					if (!inactiveSince) trackedInactiveTimes.set(slot, now);
+					else if (now.getTime() - inactiveSince.getTime() >= this.#inactiveSlotCleanupTimeoutMs) {
+						this.#lc.info?.(`slot ${slot} has been inactive since ${inactiveSince.toISOString()} and is eligible for cleanup`);
+						slotsToCleanUp.push(slot);
+					}
+				}
+			}
+		} else {
+			const expiration = now.getTime() - this.#inactiveSlotCleanupTimeoutMs;
+			const inactiveSlots = await this.#upstream`
+        SELECT slot_name AS slot, inactive_since AS "inactiveSince" FROM pg_replication_slots
+          WHERE slot_name LIKE ${slotPoolPrefix + "%"}
+            AND active = false
+            AND inactive_since IS NOT NULL;
+      `;
+			for (const { slot, inactiveSince } of inactiveSlots) {
+				if (slot === this.#currentSlot) {
+					this.#lc.warn?.(`current slot ${this.#currentSlot} is not active. disabling cleanup.`);
+					this.stop();
+					return [];
+				}
+				if (inactiveSince <= expiration) {
+					this.#lc.info?.(`slot ${slot} has been inactive since ${new Date(inactiveSince).toISOString()} and is eligible for cleanup`);
+					slotsToCleanUp.push(slot);
+				}
+			}
+		}
+		return slotsToCleanUp;
+	}
+};
+//#endregion
+export { ReplicationSlotCleanupMonitor };
+
+//# sourceMappingURL=replication-slot-cleanup-monitor.js.map

package/out/zero-cache/src/services/change-source/pg/replication-slot-cleanup-monitor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"replication-slot-cleanup-monitor.js","names":["#lc","#shard","#upstream","#currentSlot","#inactiveSlotCleanupTimeoutMs","#pollIntervalMs","#firstInactiveTimes","#pollTimer","#poll"],"sources":["../../../../../../../zero-cache/src/services/change-source/pg/replication-slot-cleanup-monitor.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {PG_17} from '../../../types/pg-versions.ts';\nimport type {PostgresDB} from '../../../types/pg.ts';\nimport type {ShardID} from '../../../types/shards.ts';\nimport {dropInactiveSlotsAndReplicas} from './replication-slots.ts';\nimport {replicationSlotPrefix} from './schema/shard.ts';\n\ntype Options = {\n  inactiveSlotCleanupTimeoutMs?: number | undefined;\n  pollIntervalMs?: number | undefined;\n};\n\nconst DEFAULT_INACTIVE_SLOT_CLEANUP_TIMEOUT_MS = 5 * 60 * 1000;\nconst DEFAULT_POLL_INTERVAL_MS = 60 * 1000;\n\nexport class ReplicationSlotCleanupMonitor {\n  readonly #lc: LogContext;\n\n  /** The shard constrains which slots are monitored (e.g. zero_0_*). */\n  readonly #shard: ShardID;\n  readonly #upstream: PostgresDB;\n  /**\n   * This slot that this task is using. Cleanup of slots is predicated on\n   * this slot remaining active, in order to guarantee at least one healthy\n   * slot in the shard.\n   */\n  readonly #currentSlot: string;\n\n  /**\n   * How long a slot is inactive (while the currentSlot is active) before it\n   * is eligible to be cleaned up. Because new slots are immediately connected\n   * to, even while an initial-sync or replica-restore is in progress, slots\n   * should only be inactive if no server is using it, or if a server was\n   * disconnected (e.g. a pg restart) and is in the process of reconnecting\n   * to it (see `keepSlotActiveUntilTakenOver`).\n   *\n   * As such, this timeout should be long enough to account for a server\n   * reconnecting to upstream. Note again that the cleanup monitor only runs\n   * while at least one replication slot is active, guaranteeing that upstream\n   * replication is working.\n   */\n  readonly #inactiveSlotCleanupTimeoutMs: number;\n  readonly #pollIntervalMs: number;\n\n  /** Manually tracked inactive times for PG < 17. null for PG 17+ */\n  readonly #firstInactiveTimes: Map<string, Date> | null;\n\n  #pollTimer: NodeJS.Timeout | undefined;\n\n  constructor(\n    lc: LogContext,\n    shard: ShardID,\n    upstream: PostgresDB,\n    upstreamPgServerVersionNum: number,\n    currentSlot: string,\n    {inactiveSlotCleanupTimeoutMs, pollIntervalMs}: Options = {},\n  ) {\n    this.#lc = lc.withContext('component', 'replication-slot-cleanup-monitor');\n    this.#shard = shard;\n    this.#upstream = upstream;\n    this.#currentSlot = currentSlot;\n    this.#inactiveSlotCleanupTimeoutMs =\n      inactiveSlotCleanupTimeoutMs ?? DEFAULT_INACTIVE_SLOT_CLEANUP_TIMEOUT_MS;\n    this.#pollIntervalMs = pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;\n    this.#firstInactiveTimes =\n      upstreamPgServerVersionNum >= PG_17 ? null : new Map();\n  }\n\n  start() {\n    if (this.#pollTimer) {\n      this.#lc.warn?.(`monitor already started`);\n      return;\n    }\n    this.#pollTimer = setInterval(\n      () =>\n        this.#poll(new Date()).catch(e =>\n          this.#lc.warn?.(`error checking replication slots`, e),\n        ),\n      this.#pollIntervalMs,\n    );\n  }\n\n  stop() {\n    clearInterval(this.#pollTimer);\n    this.#pollTimer = undefined;\n    this.#firstInactiveTimes?.clear();\n  }\n\n  async #poll(now: Date) {\n    if (!this.#pollTimer) {\n      return; // concurrently stopped\n    }\n    const slots = await this.getSlotsToCleanup(now);\n    if (slots.length) {\n      await dropInactiveSlotsAndReplicas(\n        this.#lc,\n        this.#upstream,\n        this.#shard,\n        slots,\n      );\n    }\n  }\n\n  async getSlotsToCleanup(now: Date): Promise<string[]> {\n    const slotPoolPrefix = replicationSlotPrefix(this.#shard);\n\n    const slotsToCleanUp: string[] = [];\n    const trackedInactiveTimes = this.#firstInactiveTimes;\n\n    if (trackedInactiveTimes) {\n      // For PG <17, each poll tracks and updates earliest time the slot was\n      // observed to be inactive.\n      const shardSlots = await this.#upstream<{slot: string; active: boolean}[]>\n      /*sql*/ `\n        SELECT slot_name AS slot, active FROM pg_replication_slots\n          WHERE slot_name LIKE ${slotPoolPrefix + '%'};\n      `;\n      for (const {slot, active} of shardSlots) {\n        if (slot === this.#currentSlot && !active) {\n          this.#lc.warn?.(\n            `current slot ${this.#currentSlot} is not active. disabling cleanup.`,\n          );\n          this.stop();\n          return [];\n        }\n        if (active) {\n          trackedInactiveTimes.delete(slot);\n        } else {\n          const inactiveSince = trackedInactiveTimes.get(slot);\n          if (!inactiveSince) {\n            trackedInactiveTimes.set(slot, now);\n          } else if (\n            now.getTime() - inactiveSince.getTime() >=\n            this.#inactiveSlotCleanupTimeoutMs\n          ) {\n            this.#lc.info?.(\n              `slot ${slot} has been inactive since ${inactiveSince.toISOString()} and is eligible for cleanup`,\n            );\n            slotsToCleanUp.push(slot);\n          }\n        }\n      }\n    } else {\n      // PG 17+ is simpler as inactivity time is tracked in the table.\n      const expiration = now.getTime() - this.#inactiveSlotCleanupTimeoutMs;\n      const inactiveSlots = await this.#upstream<\n        {slot: string; inactiveSince: number}[]\n      > /*sql*/ `\n        SELECT slot_name AS slot, inactive_since AS \"inactiveSince\" FROM pg_replication_slots\n          WHERE slot_name LIKE ${slotPoolPrefix + '%'}\n            AND active = false\n            AND inactive_since IS NOT NULL;\n      `;\n      for (const {slot, inactiveSince} of inactiveSlots) {\n        if (slot === this.#currentSlot) {\n          this.#lc.warn?.(\n            `current slot ${this.#currentSlot} is not active. disabling cleanup.`,\n          );\n          this.stop();\n          return [];\n        }\n        // The slot has been inactive since at or before the expiration cutoff\n        // (now - timeout), i.e. inactive for at least the timeout duration.\n        if (inactiveSince <= expiration) {\n          this.#lc.info?.(\n            `slot ${slot} has been inactive since ${new Date(inactiveSince).toISOString()} and is eligible for cleanup`,\n          );\n          slotsToCleanUp.push(slot);\n        }\n      }\n    }\n    return slotsToCleanUp;\n  }\n}\n"],"mappings":";;;;AAYA,IAAM,2CAA2C,MAAS;AAC1D,IAAM,2BAA2B,KAAK;AAEtC,IAAa,gCAAb,MAA2C;CACzC;;CAGA;CACA;;;;;;CAMA;;;;;;;;;;;;;;CAeA;CACA;;CAGA;CAEA;CAEA,YACE,IACA,OACA,UACA,4BACA,aACA,EAAC,8BAA8B,mBAA2B,CAAC,GAC3D;EACA,KAAKA,MAAM,GAAG,YAAY,aAAa,kCAAkC;EACzE,KAAKC,SAAS;EACd,KAAKC,YAAY;EACjB,KAAKC,eAAe;EACpB,KAAKC,gCACH,gCAAgC;EAClC,KAAKC,kBAAkB,kBAAkB;EACzC,KAAKC,sBACH,8BAAA,OAAsC,uBAAO,IAAI,IAAI;CACzD;CAEA,QAAQ;EACN,IAAI,KAAKC,YAAY;GACnB,KAAKP,IAAI,OAAO,yBAAyB;GACzC;EACF;EACA,KAAKO,aAAa,kBAEd,KAAKC,sBAAM,IAAI,KAAK,CAAC,EAAE,OAAM,MAC3B,KAAKR,IAAI,OAAO,oCAAoC,CAAC,CACvD,GACF,KAAKK,eACP;CACF;CAEA,OAAO;EACL,cAAc,KAAKE,UAAU;EAC7B,KAAKA,aAAa,KAAA;EAClB,KAAKD,qBAAqB,MAAM;CAClC;CAEA,MAAME,MAAM,KAAW;EACrB,IAAI,CAAC,KAAKD,YACR;EAEF,MAAM,QAAQ,MAAM,KAAK,kBAAkB,GAAG;EAC9C,IAAI,MAAM,QACR,MAAM,6BACJ,KAAKP,KACL,KAAKE,WACL,KAAKD,QACL,KACF;CAEJ;CAEA,MAAM,kBAAkB,KAA8B;EACpD,MAAM,iBAAiB,sBAAsB,KAAKA,MAAM;EAExD,MAAM,iBAA2B,CAAC;EAClC,MAAM,uBAAuB,KAAKK;EAElC,IAAI,sBAAsB;GAGxB,MAAM,aAAa,MAAM,KAAKJ,SACtB;;iCAEmB,iBAAiB,IAAI;;GAEhD,KAAK,MAAM,EAAC,MAAM,YAAW,YAAY;IACvC,IAAI,SAAS,KAAKC,gBAAgB,CAAC,QAAQ;KACzC,KAAKH,IAAI,OACP,gBAAgB,KAAKG,aAAa,mCACpC;KACA,KAAK,KAAK;KACV,OAAO,CAAC;IACV;IACA,IAAI,QACF,qBAAqB,OAAO,IAAI;SAC3B;KACL,MAAM,gBAAgB,qBAAqB,IAAI,IAAI;KACnD,IAAI,CAAC,eACH,qBAAqB,IAAI,MAAM,GAAG;UAC7B,IACL,IAAI,QAAQ,IAAI,cAAc,QAAQ,KACtC,KAAKC,+BACL;MACA,KAAKJ,IAAI,OACP,QAAQ,KAAK,2BAA2B,cAAc,YAAY,EAAE,6BACtE;MACA,eAAe,KAAK,IAAI;KAC1B;IACF;GACF;EACF,OAAO;GAEL,MAAM,aAAa,IAAI,QAAQ,IAAI,KAAKI;GACxC,MAAM,gBAAgB,MAAM,KAAKF,SAEvB;;iCAEiB,iBAAiB,IAAI;;;;GAIhD,KAAK,MAAM,EAAC,MAAM,mBAAkB,eAAe;IACjD,IAAI,SAAS,KAAKC,cAAc;KAC9B,KAAKH,IAAI,OACP,gBAAgB,KAAKG,aAAa,mCACpC;KACA,KAAK,KAAK;KACV,OAAO,CAAC;IACV;IAGA,IAAI,iBAAiB,YAAY;KAC/B,KAAKH,IAAI,OACP,QAAQ,KAAK,2BAA2B,IAAI,KAAK,aAAa,EAAE,YAAY,EAAE,6BAChF;KACA,eAAe,KAAK,IAAI;IAC1B;GACF;EACF;EACA,OAAO;CACT;AACF"}

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

@@ -1,9 +1,10 @@
 import type { Readable } from 'node:stream';
 import type { LogContext } from '@rocicorp/logger';
-import type postgres from 'postgres';
+import postgres from 'postgres';
 import { type PostgresDB } from '../../../types/pg.ts';
 import { type ShardID } from '../../../types/shards.ts';
-import { type BackupOptions } from './schema/shard.ts';
+import { type ReplicaStage } from './schema/replica-stage-enum.ts';
+import { type BackupOptions, type ReplicaState } from './schema/shard.ts';
 export type ReplicationSlot = {
     slot_name: string;
     consistent_point: string;
@@ -14,21 +15,54 @@ export type ReplicationSlotResult<T> = {
     slot: ReplicationSlot;
     capturedSnapshot: T;
     initialSession: Readable;
+    replica: ReplicaState;
+};
+export type ReservedSlot = {
+    slot: string;
+    reservation: Readable;
+    replica: ReplicaState;
 };
 export type CreateSlotSpec = {
     slotName: string;
     failover?: boolean;
     temporary?: boolean;
-    lockTimeout?: number;
+    lockTimeout?: number | undefined;
+    diagnosticsDB?: PostgresDB | undefined;
+};
+export declare const CREATE_REPLICATION_SLOT_TIMEOUT_MS = 60000;
+/** Thrown when the client-side timeout for creating a slot is reached. */
+export declare class SlotCreationTimeoutError extends Error {
+    readonly name = "SlotCreationTimeoutError";
+}
+export declare function createReplicationSlot(lc: LogContext, session: postgres.Sql, { slotName, failover, temporary, lockTimeout, diagnosticsDB, }: CreateSlotSpec): Promise<ReplicationSlot>;
+/**
+ * Best-effort logging of what a timed out CREATE_REPLICATION_SLOT was waiting
+ * on: the walsender's wait event and blocking pids, and the oldest
+ * transactions holding an xid. Slot creation waits for every such transaction
+ * on the instance (in all databases), each with its own lock_timeout, so a
+ * chain of overlapping transactions can exceed the client-side timeout
+ * without the lock_timeout ever firing.
+ *
+ * Query text is deliberately omitted since it can contain row values.
+ *
+ * Exported for testing.
+ */
+export declare function logSlotCreationBlockers(lc: LogContext, sql: PostgresDB, walsenderPID: number, slotName: string): Promise<void>;
+export type CreateReplicaAndSlotOptions = {
+    lockTimeout?: number | undefined;
+    maxBlockedMs?: number | undefined;
+    retryDelayMs?: number | undefined;
 };
-export declare function createReplicationSlot(lc: LogContext, session: postgres.Sql, { slotName, failover, temporary, lockTimeout, }: CreateSlotSpec): Promise<ReplicationSlot>;
 /**
- * Replica and slot creation involves two sessions for proper coordination
- * with other replica management logic:
+ * Replica and slot creation involves several sessions for proper
+ * coordination with other replica management logic:
  *
- * * A normal transaction is started and acquires an advisory lock for
+ * * A dedicated session acquires a (session-level) advisory lock for
  *   replica slot management. This is the same lock that cleanup logic
- *   acquires before cleaning up replication slots.
+ *   acquires before cleaning up replication slots. The lock is held
+ *   outside of a transaction so that the session is not "idle in
+ *   transaction" while slot creation waits on upstream transactions,
+ *   which some upstreams terminate (e.g. idle_in_transaction_session_timeout).
  * * 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
@@ -37,6 +71,14 @@ export declare function createReplicationSlot(lc: LogContext, session: postgres.
  * * Once the slot is created, the slot and replica information are recorded
  *   in the `replicas` table before releasing the lock.
  *
+ * Slot creation waits for all transactions on the upstream instance that
+ * hold an xid, so it can be blocked by long-running transactions. A blocked
+ * attempt is abandoned (see {@link CREATE_REPLICATION_SLOT_TIMEOUT_MS}) and
+ * retried in-process, as it leaves no durable state: the `replicas` row is
+ * only inserted after the slot has been created. Retries continue until the
+ * slot is created or until `maxBlockedMs` has elapsed, after which the error
+ * is thrown.
+ *
  * 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
@@ -61,22 +103,25 @@ export declare function createReplicationSlot(lc: LogContext, session: postgres.
  * PostgresChangeSource takes over the slot to process the stream in earnest.
  * It is also returned for cleanup in the case of failures (and for control
  * in unit tests).
+ *
+ * For replica's created in the `Restore` stage, the `generation` is
+ * initialized to an empty string instead of the slot's consistent point,
+ * since the slot is not being used for initial sync. It is the
+ * responsibiliy of the caller to call {@link initRestoreReplica} when
+ * the source replica has been selected for restoring, which will carry
+ * over the `generation` and other relevant values from the source.
  */
-export declare function createReplicaAndSlot<T>(lc: LogContext, sql: PostgresDB, sessionName: string, shard: ShardID, replicaID: string, failover: boolean, backupOptions: BackupOptions, captureSnapshot: (snapshot: string) => Promise<T>): Promise<ReplicationSlotResult<T>>;
+export declare function createReplicaAndSlot<T>(lc: LogContext, sql: PostgresDB, sessionName: string, shard: ShardID, epoch: number, replicaID: string, failover: boolean, backupOptions: BackupOptions, captureSnapshot: (snapshot: string) => Promise<T>, stage: ReplicaStage, { lockTimeout, maxBlockedMs, retryDelayMs, }?: CreateReplicaAndSlotOptions): Promise<ReplicationSlotResult<T>>;
 /**
- * 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.
+ * Claims the inactive slot of the given replica for use by this task, opening
+ * a replication session to mark it as active. The process should follow up by
+ * taking over the slot via the PostgresChangeSource.
  *
- * 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.
+ * The replica is identified by its ID (and not just its slot) because rows of
+ * replicas whose slots were dropped outside of zero-cache's control may share
+ * the slot name.
  */
-export declare function dropOldReplicasAndSlots(lc: LogContext, sql: PostgresDB, shard: ShardID, beforeRank: bigint): Promise<{
-    dropped: number;
-    active: number;
-    draining: number;
-}>;
+export declare function claimSlotForResumption(lc: LogContext, sql: PostgresDB, shard: ShardID, _sessionName: string, { id: replicaID, slot }: Pick<ReplicaState, 'id' | 'slot'>): Promise<ReservedSlot | null>;
+export declare function dropInactiveSlotsAndReplicas(lc: LogContext, sql: PostgresDB, shard: ShardID, slots: string[]): Promise<void>;
 export declare function slotPoolSuffix(n: number): string;
 //# sourceMappingURL=replication-slots.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"replication-slots.d.ts","sourceRoot":"","sources":["../../../../../../../zero-cache/src/services/change-source/pg/replication-slots.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,aAAa,CAAC;AAK1C,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AAErC,OAAO,EAAkB,KAAK,UAAU,EAAC,MAAM,sBAAsB,CAAC;AACtE,OAAO,EAAiB,KAAK,OAAO,EAAC,MAAM,0BAA0B,CAAC;AAOtE,OAAO,EAKL,KAAK,aAAa,EACnB,MAAM,mBAAmB,CAAC;AAG3B,MAAM,MAAM,eAAe,GAAG;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,qBAAqB,CAAC,CAAC,IAAI;IACrC,IAAI,EAAE,eAAe,CAAC;IACtB,gBAAgB,EAAE,CAAC,CAAC;IACpB,cAAc,EAAE,QAAQ,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,EAAE,MAAM,CAAC;IAGjB,QAAQ,CAAC,EAAE,OAAO,CAAC;IAInB,SAAS,CAAC,EAAE,OAAO,CAAC;IAGpB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAoBF,wBAAsB,qBAAqB,CACzC,EAAE,EAAE,UAAU,EACd,OAAO,EAAE,QAAQ,CAAC,GAAG,EACrB,EACE,QAAQ,EACR,QAAQ,EACR,SAAS,EACT,WAAoC,GACrC,EAAE,cAAc,GAChB,OAAO,CAAC,eAAe,CAAC,CAwC1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAsB,oBAAoB,CAAC,CAAC,EAC1C,EAAE,EAAE,UAAU,EACd,GAAG,EAAE,UAAU,EACf,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,OAAO,EACd,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,OAAO,EACjB,aAAa,EAAE,aAAa,EAC5B,eAAe,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,GAChD,OAAO,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC,CAuFnC;AAED;;;;;;;;;GASG;AACH,wBAAsB,uBAAuB,CAC3C,EAAE,EAAE,UAAU,EACd,GAAG,EAAE,UAAU,EACf,KAAK,EAAE,OAAO,EACd,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAAC,CAY9D;AA+DD,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,UAUvC"}
+{"version":3,"file":"replication-slots.d.ts","sourceRoot":"","sources":["../../../../../../../zero-cache/src/services/change-source/pg/replication-slots.ts"],"names":[],"mappings":"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"}