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

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

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

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

@@ -1,155 +0,0 @@
-import { assert } from "../../../../../../shared/src/asserts.js";
-import { parse, valita_exports } from "../../../../../../shared/src/valita.js";
-import { upstreamSchema } from "../../../../types/shards.js";
-import { id } from "../../../../types/sql.js";
-import { publishedSchema } from "./published.js";
-import { getMutationsTableDefinition, legacyReplicationSlot, metadataPublicationName, setupTablesAndReplication, setupTriggers } from "./shard.js";
-import { decommissionShard } from "../decommission.js";
-import { AutoResetSignal } from "../../../change-streamer/schema/tables.js";
-import { getVersionHistory, runSchemaMigrations } from "../../../../db/migration.js";
-//#region ../zero-cache/src/services/change-source/pg/schema/init.ts
-/**
-* Ensures that a shard is set up for initial sync.
-*/
-async function ensureShardSchema(lc, db, shard) {
-	await runSchemaMigrations(lc, `upstream-shard-${shard.appID}`, upstreamSchema(shard), db, {
-		migrateSchema: (lc, tx) => setupTablesAndReplication(lc, tx, shard),
-		minSafeVersion: 1
-	}, getIncrementalMigrations(shard, "obsolete"));
-}
-/**
-* Updates the schema for an existing shard.
-*/
-async function updateShardSchema(lc, db, shard, replicaVersion) {
-	await runSchemaMigrations(lc, `upstream-shard-${shard.appID}`, upstreamSchema(shard), db, { migrateSchema: () => {
-		throw new AutoResetSignal(`upstream shard ${upstreamSchema(shard)} is not initialized`);
-	} }, getIncrementalMigrations(shard, replicaVersion));
-	await decommissionLegacyShard(lc, db, shard);
-}
-function getIncrementalMigrations(shard, replicaVersion) {
-	const shardConfigTable = `${upstreamSchema(shard)}.shardConfig`;
-	return {
-		4: {
-			migrateSchema: () => {
-				throw new AutoResetSignal("resetting to upgrade shard schema");
-			},
-			minSafeVersion: 3
-		},
-		6: { migrateSchema: async (lc, sql) => {
-			assert(replicaVersion, `replicaVersion is always passed for incremental migrations`);
-			await Promise.all([sql`
-          ALTER TABLE ${sql(shardConfigTable)} ADD "replicaVersion" TEXT`, sql`
-          UPDATE ${sql(shardConfigTable)} SET ${sql({ replicaVersion })}`]);
-			lc.info?.(`Recorded replicaVersion ${replicaVersion} in upstream shardConfig`);
-		} },
-		7: { migrateSchema: async (lc, sql) => {
-			const [{ publications }] = await sql`
-          SELECT publications FROM ${sql(shardConfigTable)}`;
-			await setupTriggers(lc, sql, {
-				...shard,
-				publications
-			});
-			lc.info?.(`Upgraded to v2 event triggers`);
-		} },
-		8: { migrateSchema: async (lc, sql) => {
-			const legacyShardConfigSchema = valita_exports.object({
-				replicaVersion: valita_exports.string().nullable(),
-				initialSchema: publishedSchema.nullable()
-			});
-			const result = await sql`
-          SELECT "replicaVersion", "initialSchema" FROM ${sql(shardConfigTable)}`;
-			assert(result.length === 1, () => `Expected exactly one shardConfig row, got ${result.length}`);
-			const { replicaVersion, initialSchema } = parse(result[0], legacyShardConfigSchema, "passthrough");
-			await Promise.all([
-				sql`
-          CREATE TABLE ${sql(upstreamSchema(shard))}.replicas (
-            "slot"          TEXT PRIMARY KEY,
-            "version"       TEXT NOT NULL,
-            "initialSchema" JSON NOT NULL
-          );
-          `,
-				sql`
-          INSERT INTO ${sql(upstreamSchema(shard))}.replicas ${sql({
-					slot: legacyReplicationSlot(shard),
-					version: replicaVersion,
-					initialSchema
-				})}
-          `,
-				sql`
-          ALTER TABLE ${sql(shardConfigTable)} DROP "replicaVersion", DROP "initialSchema"
-          `
-			]);
-			lc.info?.(`Upgraded schema to support non-disruptive resyncs`);
-		} },
-		10: { migrateSchema: async (lc, sql) => {
-			await sql.unsafe(`
-          ${getMutationsTableDefinition(upstreamSchema(shard))}
-          ALTER PUBLICATION ${id(metadataPublicationName(shard.appID, shard.shardNum))} ADD TABLE ${id(upstreamSchema(shard))}."mutations";
-        `);
-			lc.info?.("Upgraded schema with new mutations table");
-		} },
-		13: { migrateSchema: async (_, sql) => {
-			await sql`
-          CREATE TABLE IF NOT EXISTS ${sql(upstreamSchema(shard))}."schemaVersions" (
-            "minSupportedVersion" INT4,
-            "maxSupportedVersion" INT4,
-            "lock" BOOL PRIMARY KEY DEFAULT true CHECK (lock)
-        );`;
-			await sql`
-          INSERT INTO ${sql(upstreamSchema(shard))}."schemaVersions" 
-            ("lock", "minSupportedVersion", "maxSupportedVersion")
-            VALUES (true, 1, 1)
-            ON CONFLICT DO NOTHING;
-        `;
-		} },
-		15: { migrateSchema: async (_, sql) => {
-			await sql`
-          ALTER TABLE ${sql(upstreamSchema(shard))}.replicas
-            ADD COLUMN "initialSyncContext" JSON,
-            ADD COLUMN "subscriberContext" JSON
-        `;
-		} },
-		21: { migrateSchema: async (lc, sql) => {
-			const [{ publications }] = await sql`
-          SELECT publications FROM ${sql(shardConfigTable)}`;
-			await setupTriggers(lc, sql, {
-				...shard,
-				publications
-			});
-			lc.info?.(`Upgraded DDL event triggers`);
-		} },
-		22: { migrateSchema: async (_, sql) => {
-			await sql`
-          ALTER TABLE ${sql(upstreamSchema(shard))}.replicas 
-            ALTER "initialSchema" DROP NOT NULL;
-        `;
-			await sql`
-          ALTER TABLE ${sql(upstreamSchema(shard))}.replicas 
-            DROP CONSTRAINT replicas_pkey;
-        `;
-			await sql`
-          ALTER TABLE ${sql(upstreamSchema(shard))}.replicas 
-            ADD COLUMN id TEXT PRIMARY KEY DEFAULT replace(gen_random_uuid()::text, '-', '');
-        `;
-			await sql`
-          ALTER TABLE ${sql(upstreamSchema(shard))}.replicas 
-            ADD COLUMN rank BIGSERIAL;
-        `;
-		} }
-	};
-}
-Object.keys(getIncrementalMigrations({
-	appID: "unused",
-	shardNum: 0,
-	publications: ["foo"]
-})).reduce((prev, curr) => Math.max(prev, parseInt(curr)), 0);
-async function decommissionLegacyShard(lc, db, shard) {
-	if (shard.appID !== "zero") {
-		const versionHistory = await getVersionHistory(db, `zero_${shard.appID}`);
-		if (versionHistory !== null && versionHistory.schemaVersion < 5) await decommissionShard(lc, db, "zero", shard.appID);
-	}
-}
-//#endregion
-export { ensureShardSchema, updateShardSchema };
-
-//# sourceMappingURL=init.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"init.js","names":[],"sources":["../../../../../../../../zero-cache/src/services/change-source/pg/schema/init.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {assert} from '../../../../../../shared/src/asserts.ts';\nimport * as v from '../../../../../../shared/src/valita.ts';\nimport {\n  getVersionHistory,\n  runSchemaMigrations,\n  type IncrementalMigrationMap,\n  type Migration,\n} from '../../../../db/migration.ts';\nimport type {PostgresDB} from '../../../../types/pg.ts';\nimport {upstreamSchema, type ShardConfig} from '../../../../types/shards.ts';\nimport {id} from '../../../../types/sql.ts';\nimport {AutoResetSignal} from '../../../change-streamer/schema/tables.ts';\nimport {decommissionShard} from '../decommission.ts';\nimport {publishedSchema} from './published.ts';\nimport {\n  getMutationsTableDefinition,\n  legacyReplicationSlot,\n  metadataPublicationName,\n  setupTablesAndReplication,\n  setupTriggers,\n} from './shard.ts';\n\n/**\n * Ensures that a shard is set up for initial sync.\n */\nexport async function ensureShardSchema(\n  lc: LogContext,\n  db: PostgresDB,\n  shard: ShardConfig,\n): Promise<void> {\n  const initialSetup: Migration = {\n    migrateSchema: (lc, tx) => setupTablesAndReplication(lc, tx, shard),\n    minSafeVersion: 1,\n  };\n  await runSchemaMigrations(\n    lc,\n    `upstream-shard-${shard.appID}`,\n    upstreamSchema(shard),\n    db,\n    initialSetup,\n    // The incremental migration of any existing replicas will be replaced by\n    // the incoming replica being synced, so the replicaVersion here is\n    // unnecessary.\n    getIncrementalMigrations(shard, 'obsolete'),\n  );\n}\n\n/**\n * Updates the schema for an existing shard.\n */\nexport async function updateShardSchema(\n  lc: LogContext,\n  db: PostgresDB,\n  shard: ShardConfig,\n  replicaVersion: string,\n): Promise<void> {\n  await runSchemaMigrations(\n    lc,\n    `upstream-shard-${shard.appID}`,\n    upstreamSchema(shard),\n    db,\n    {\n      // If the expected existing shard is absent, throw an\n      // AutoResetSignal to backtrack and initial sync.\n      migrateSchema: () => {\n        throw new AutoResetSignal(\n          `upstream shard ${upstreamSchema(shard)} is not initialized`,\n        );\n      },\n    },\n    getIncrementalMigrations(shard, replicaVersion),\n  );\n\n  // The decommission check is run in updateShardSchema so that it happens\n  // after initial sync, and not when the shard schema is initially set up.\n  await decommissionLegacyShard(lc, db, shard);\n}\n\nfunction getIncrementalMigrations(\n  shard: ShardConfig,\n  replicaVersion?: string,\n): IncrementalMigrationMap {\n  const shardConfigTable = `${upstreamSchema(shard)}.shardConfig`;\n\n  return {\n    4: {\n      migrateSchema: () => {\n        throw new AutoResetSignal('resetting to upgrade shard schema');\n      },\n      minSafeVersion: 3,\n    },\n\n    // v5: changes the upstream schema organization from \"zero_{SHARD_ID}\" to\n    // the \"{APP_ID}_0\". An incremental migration indicates that the previous\n    // SHARD_ID was \"0\" and the new APP_ID is \"zero\" (i.e. the default values\n    // for those options). In this case, the upstream format is identical, and\n    // no migration is necessary. However, the version is bumped to v5 to\n    // indicate that it was created with the {APP_ID} configuration and should\n    // not be decommissioned as a legacy shard.\n\n    6: {\n      migrateSchema: async (lc, sql) => {\n        assert(\n          replicaVersion,\n          `replicaVersion is always passed for incremental migrations`,\n        );\n        await Promise.all([\n          sql`\n          ALTER TABLE ${sql(shardConfigTable)} ADD \"replicaVersion\" TEXT`,\n          sql`\n          UPDATE ${sql(shardConfigTable)} SET ${sql({replicaVersion})}`,\n        ]);\n        lc.info?.(\n          `Recorded replicaVersion ${replicaVersion} in upstream shardConfig`,\n        );\n      },\n    },\n\n    // Updates the DDL event trigger protocol to v2, and adds support for\n    // ALTER SCHEMA x RENAME TO y\n    7: {\n      migrateSchema: async (lc, sql) => {\n        const [{publications}] = await sql<{publications: string[]}[]>`\n          SELECT publications FROM ${sql(shardConfigTable)}`;\n        await setupTriggers(lc, sql, {...shard, publications});\n        lc.info?.(`Upgraded to v2 event triggers`);\n      },\n    },\n\n    // Adds support for non-disruptive resyncs, which tracks multiple\n    // replicas with different slot names.\n    8: {\n      migrateSchema: async (lc, sql) => {\n        const legacyShardConfigSchema = v.object({\n          replicaVersion: v.string().nullable(),\n          initialSchema: publishedSchema.nullable(),\n        });\n        const result = await sql`\n          SELECT \"replicaVersion\", \"initialSchema\" FROM ${sql(shardConfigTable)}`;\n        assert(\n          result.length === 1,\n          () => `Expected exactly one shardConfig row, got ${result.length}`,\n        );\n        const {replicaVersion, initialSchema} = v.parse(\n          result[0],\n          legacyShardConfigSchema,\n          'passthrough',\n        );\n\n        await Promise.all([\n          sql`\n          CREATE TABLE ${sql(upstreamSchema(shard))}.replicas (\n            \"slot\"          TEXT PRIMARY KEY,\n            \"version\"       TEXT NOT NULL,\n            \"initialSchema\" JSON NOT NULL\n          );\n          `,\n          sql`\n          INSERT INTO ${sql(upstreamSchema(shard))}.replicas ${sql({\n            slot: legacyReplicationSlot(shard),\n            version: replicaVersion,\n            initialSchema,\n          })}\n          `,\n          sql`\n          ALTER TABLE ${sql(shardConfigTable)} DROP \"replicaVersion\", DROP \"initialSchema\"\n          `,\n        ]);\n        lc.info?.(`Upgraded schema to support non-disruptive resyncs`);\n      },\n    },\n\n    // v9: Fixes field ordering of compound indexes. This incremental migration\n    // only fixes indexes resulting from new schema changes. A full resync is\n    // required to fix existing indexes.\n    //\n    // The migration has been subsumed by the identical logic for migrating\n    // to v12 (i.e. a trigger upgrade).\n\n    // Adds the `mutations` table used to track mutation results.\n    10: {\n      migrateSchema: async (lc, sql) => {\n        await sql.unsafe(/*sql*/ `\n          ${getMutationsTableDefinition(upstreamSchema(shard))}\n          ALTER PUBLICATION ${id(metadataPublicationName(shard.appID, shard.shardNum))} ADD TABLE ${id(upstreamSchema(shard))}.\"mutations\";\n        `);\n        lc.info?.('Upgraded schema with new mutations table');\n      },\n    },\n\n    // v11: Formerly dropped the schemaVersions table, but restored in the v13\n    // migration for rollback safety.\n\n    // v12: Upgrade DDL trigger to query schemaOID, needed information for auto-backfill.\n    // (subsumed by v14)\n\n    // Recreates the legacy schemaVersions table that was prematurely dropped\n    // in the (former) v11 migration. It needs to remain present for at least one\n    // release in order to be rollback safe.\n    //\n    // TODO: Drop the table once a release that no longer reads the table has\n    // been rolled out.\n    13: {\n      migrateSchema: async (_, sql) => {\n        await sql`\n          CREATE TABLE IF NOT EXISTS ${sql(upstreamSchema(shard))}.\"schemaVersions\" (\n            \"minSupportedVersion\" INT4,\n            \"maxSupportedVersion\" INT4,\n            \"lock\" BOOL PRIMARY KEY DEFAULT true CHECK (lock)\n        );`;\n        await sql`\n          INSERT INTO ${sql(upstreamSchema(shard))}.\"schemaVersions\" \n            (\"lock\", \"minSupportedVersion\", \"maxSupportedVersion\")\n            VALUES (true, 1, 1)\n            ON CONFLICT DO NOTHING;\n        `;\n      },\n    },\n\n    // v14: Upgrade DDL trigger to log more info to PG logs.\n    // (subsumed by v16)\n\n    // Add initialSyncContext column to replicas table.\n    15: {\n      migrateSchema: async (_, sql) => {\n        await sql`\n          ALTER TABLE ${sql(upstreamSchema(shard))}.replicas\n            ADD COLUMN \"initialSyncContext\" JSON,\n            ADD COLUMN \"subscriberContext\" JSON\n        `;\n      },\n    },\n\n    // v16: Upgrade DDL trigger to fire on all ALTER TABLE statements\n    // to catch the *removal* of a table from the published set.\n    // v17 (1.0.0): Upgrade DDL triggers to support the COMMENT ON PUBLICATION hook for\n    // working around the lack of event trigger support for PUBLICATION\n    // changes in supabase.\n    // This also adds forwards-compatible support for hierarchical logical\n    // message prefixes and unknown ddl event types.\n    // v18: Pure refactoring of event trigger code.\n    // v19 (1.4.0): Correctly handle concurrently issued DDL statements.\n    // v20 (1.4.0): Handle nested DDL triggers\n\n    // v21 (1.5.0): Handle cross-transaction DDL operations (i.e. concurrent\n    // index operations), and support manual invocation of update_schemas().\n    21: {\n      migrateSchema: async (lc, sql) => {\n        const [{publications}] = await sql<{publications: string[]}[]>`\n          SELECT publications FROM ${sql(shardConfigTable)}`;\n        await setupTriggers(lc, sql, {...shard, publications});\n        lc.info?.(`Upgraded DDL event triggers`);\n      },\n    },\n\n    22: {\n      migrateSchema: async (_, sql) => {\n        await sql`\n          ALTER TABLE ${sql(upstreamSchema(shard))}.replicas \n            ALTER \"initialSchema\" DROP NOT NULL;\n        `;\n        await sql`\n          ALTER TABLE ${sql(upstreamSchema(shard))}.replicas \n            DROP CONSTRAINT replicas_pkey;\n        `;\n        await sql`\n          ALTER TABLE ${sql(upstreamSchema(shard))}.replicas \n            ADD COLUMN id TEXT PRIMARY KEY DEFAULT replace(gen_random_uuid()::text, '-', '');\n        `;\n        await sql`\n          ALTER TABLE ${sql(upstreamSchema(shard))}.replicas \n            ADD COLUMN rank BIGSERIAL;\n        `;\n      },\n    },\n  };\n}\n\n// Referenced in tests.\nexport const CURRENT_SCHEMA_VERSION = Object.keys(\n  getIncrementalMigrations({\n    appID: 'unused',\n    shardNum: 0,\n    publications: ['foo'],\n  }),\n).reduce((prev, curr) => Math.max(prev, parseInt(curr)), 0);\n\nexport async function decommissionLegacyShard(\n  lc: LogContext,\n  db: PostgresDB,\n  shard: ShardConfig,\n) {\n  if (shard.appID !== 'zero') {\n    // When migration from non-default shard ids, e.g. \"zero_prod\" => \"prod_0\",\n    // clean up the old \"zero_prod\" shard if it is pre-v5. Note that the v5\n    // check is important to guard against cleaning up a **new** \"zero_0\" app\n    // that coexists with the current App (with app-id === \"0\").\n    const versionHistory = await getVersionHistory(db, `zero_${shard.appID}`);\n    if (versionHistory !== null && versionHistory.schemaVersion < 5) {\n      await decommissionShard(lc, db, 'zero', shard.appID);\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AA0BA,eAAsB,kBACpB,IACA,IACA,OACe;AAKf,OAAM,oBACJ,IACA,kBAAkB,MAAM,SACxB,eAAe,MAAM,EACrB,IAR8B;EAC9B,gBAAgB,IAAI,OAAO,0BAA0B,IAAI,IAAI,MAAM;EACnE,gBAAgB;EACjB,EAUC,yBAAyB,OAAO,WAAW,CAC5C;;;;;AAMH,eAAsB,kBACpB,IACA,IACA,OACA,gBACe;AACf,OAAM,oBACJ,IACA,kBAAkB,MAAM,SACxB,eAAe,MAAM,EACrB,IACA,EAGE,qBAAqB;AACnB,QAAM,IAAI,gBACR,kBAAkB,eAAe,MAAM,CAAC,qBACzC;IAEJ,EACD,yBAAyB,OAAO,eAAe,CAChD;AAID,OAAM,wBAAwB,IAAI,IAAI,MAAM;;AAG9C,SAAS,yBACP,OACA,gBACyB;CACzB,MAAM,mBAAmB,GAAG,eAAe,MAAM,CAAC;AAElD,QAAO;EACL,GAAG;GACD,qBAAqB;AACnB,UAAM,IAAI,gBAAgB,oCAAoC;;GAEhE,gBAAgB;GACjB;EAUD,GAAG,EACD,eAAe,OAAO,IAAI,QAAQ;AAChC,UACE,gBACA,6DACD;AACD,SAAM,QAAQ,IAAI,CAChB,GAAG;wBACW,IAAI,iBAAiB,CAAC,6BACpC,GAAG;mBACM,IAAI,iBAAiB,CAAC,OAAO,IAAI,EAAC,gBAAe,CAAC,GAC5D,CAAC;AACF,MAAG,OACD,2BAA2B,eAAe,0BAC3C;KAEJ;EAID,GAAG,EACD,eAAe,OAAO,IAAI,QAAQ;GAChC,MAAM,CAAC,EAAC,kBAAiB,MAAM,GAA+B;qCACjC,IAAI,iBAAiB;AAClD,SAAM,cAAc,IAAI,KAAK;IAAC,GAAG;IAAO;IAAa,CAAC;AACtD,MAAG,OAAO,gCAAgC;KAE7C;EAID,GAAG,EACD,eAAe,OAAO,IAAI,QAAQ;GAChC,MAAM,0BAA0B,eAAE,OAAO;IACvC,gBAAgB,eAAE,QAAQ,CAAC,UAAU;IACrC,eAAe,gBAAgB,UAAU;IAC1C,CAAC;GACF,MAAM,SAAS,MAAM,GAAG;0DAC0B,IAAI,iBAAiB;AACvE,UACE,OAAO,WAAW,SACZ,6CAA6C,OAAO,SAC3D;GACD,MAAM,EAAC,gBAAgB,kBAAiB,MACtC,OAAO,IACP,yBACA,cACD;AAED,SAAM,QAAQ,IAAI;IAChB,GAAG;yBACY,IAAI,eAAe,MAAM,CAAC,CAAC;;;;;;IAM1C,GAAG;wBACW,IAAI,eAAe,MAAM,CAAC,CAAC,YAAY,IAAI;KACvD,MAAM,sBAAsB,MAAM;KAClC,SAAS;KACT;KACD,CAAC,CAAC;;IAEH,GAAG;wBACW,IAAI,iBAAiB,CAAC;;IAErC,CAAC;AACF,MAAG,OAAO,oDAAoD;KAEjE;EAUD,IAAI,EACF,eAAe,OAAO,IAAI,QAAQ;AAChC,SAAM,IAAI,OAAe;YACrB,4BAA4B,eAAe,MAAM,CAAC,CAAC;8BACjC,GAAG,wBAAwB,MAAM,OAAO,MAAM,SAAS,CAAC,CAAC,aAAa,GAAG,eAAe,MAAM,CAAC,CAAC;UACpH;AACF,MAAG,OAAO,2CAA2C;KAExD;EAcD,IAAI,EACF,eAAe,OAAO,GAAG,QAAQ;AAC/B,SAAM,GAAG;uCACsB,IAAI,eAAe,MAAM,CAAC,CAAC;;;;;AAK1D,SAAM,GAAG;wBACO,IAAI,eAAe,MAAM,CAAC,CAAC;;;;;KAM9C;EAMD,IAAI,EACF,eAAe,OAAO,GAAG,QAAQ;AAC/B,SAAM,GAAG;wBACO,IAAI,eAAe,MAAM,CAAC,CAAC;;;;KAK9C;EAeD,IAAI,EACF,eAAe,OAAO,IAAI,QAAQ;GAChC,MAAM,CAAC,EAAC,kBAAiB,MAAM,GAA+B;qCACjC,IAAI,iBAAiB;AAClD,SAAM,cAAc,IAAI,KAAK;IAAC,GAAG;IAAO;IAAa,CAAC;AACtD,MAAG,OAAO,8BAA8B;KAE3C;EAED,IAAI,EACF,eAAe,OAAO,GAAG,QAAQ;AAC/B,SAAM,GAAG;wBACO,IAAI,eAAe,MAAM,CAAC,CAAC;;;AAG3C,SAAM,GAAG;wBACO,IAAI,eAAe,MAAM,CAAC,CAAC;;;AAG3C,SAAM,GAAG;wBACO,IAAI,eAAe,MAAM,CAAC,CAAC;;;AAG3C,SAAM,GAAG;wBACO,IAAI,eAAe,MAAM,CAAC,CAAC;;;KAI9C;EACF;;AAImC,OAAO,KAC3C,yBAAyB;CACvB,OAAO;CACP,UAAU;CACV,cAAc,CAAC,MAAM;CACtB,CAAC,CACH,CAAC,QAAQ,MAAM,SAAS,KAAK,IAAI,MAAM,SAAS,KAAK,CAAC,EAAE,EAAE;AAE3D,eAAsB,wBACpB,IACA,IACA,OACA;AACA,KAAI,MAAM,UAAU,QAAQ;EAK1B,MAAM,iBAAiB,MAAM,kBAAkB,IAAI,QAAQ,MAAM,QAAQ;AACzE,MAAI,mBAAmB,QAAQ,eAAe,gBAAgB,EAC5D,OAAM,kBAAkB,IAAI,IAAI,QAAQ,MAAM,MAAM"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"published.js","names":[],"sources":["../../../../../../../../zero-cache/src/services/change-source/pg/schema/published.ts"],"sourcesContent":["import {literal} from 'pg-format';\nimport type postgres from 'postgres';\nimport {assert} from '../../../../../../shared/src/asserts.ts';\nimport {BigIntJSON} from '../../../../../../shared/src/bigint-json.ts';\nimport {equals} from '../../../../../../shared/src/set-utils.ts';\nimport * as v from '../../../../../../shared/src/valita.ts';\nimport {computeZqlSpecsFromLiteSpecs} from '../../../../db/lite-tables.ts';\nimport {\n  mapPostgresToLite,\n  mapPostgresToLiteIndex,\n} from '../../../../db/pg-to-lite.ts';\nimport {publishedIndexSpec, publishedTableSpec} from '../../../../db/specs.ts';\nimport {liteTableName} from '../../../../types/names.ts';\n\nexport function publishedSchemaQuery(publications: readonly string[]) {\n  // Notes:\n  // * There's a bug in PG15 in which generated columns are incorrectly\n  //   included in pg_publication_tables.attnames, (even though the generated\n  //   column values are not be included in the replication stream).\n  //   The WHERE condition `attgenerated = ''` fixes this by explicitly excluding\n  //   generated columns from the list.\n  return (\n    /*sql*/ `\nWITH published_columns AS (SELECT \n  pc.oid::int8 AS \"oid\",\n  nspname AS \"schema\",\n  pc.relnamespace::int8 AS \"schemaOID\" ,\n  pc.relname AS \"name\", \n  pc.relreplident AS \"replicaIdentity\",\n  attnum AS \"pos\", \n  attname AS \"col\", \n  pt.typname AS \"type\", \n  atttypid::int8 AS \"typeOID\", \n  pt.typtype,\n  elem_pt.typtype AS \"elemTyptype\",\n  NULLIF(atttypmod, -1) AS \"maxLen\", \n  attndims \"arrayDims\", \n  attnotnull AS \"notNull\",\n  pg_get_expr(pd.adbin, pd.adrelid) as \"dflt\",\n  NULLIF(ARRAY_POSITION(conkey, attnum), -1) AS \"keyPos\", \n  pb.rowfilter as \"rowFilter\",\n  pb.pubname as \"publication\"\nFROM pg_attribute\nJOIN pg_class pc ON pc.oid = attrelid\nJOIN pg_namespace pns ON pns.oid = relnamespace\nJOIN pg_type pt ON atttypid = pt.oid\nLEFT JOIN pg_type elem_pt ON elem_pt.oid = pt.typelem\nJOIN pg_publication_tables as pb ON \n  pb.schemaname = nspname AND \n  pb.tablename = pc.relname AND\n  attname = ANY(pb.attnames)\nLEFT JOIN pg_constraint pk ON pk.contype = 'p' AND pk.connamespace = relnamespace AND pk.conrelid = attrelid\nLEFT JOIN pg_attrdef pd ON pd.adrelid = attrelid AND pd.adnum = attnum\nWHERE pb.pubname IN (${literal(publications)}) AND \n      (current_setting('server_version_num')::int >= 160000 OR attgenerated = '')\nORDER BY nspname, pc.relname),\n\ntables AS (SELECT json_build_object(\n  'oid', \"oid\",\n  'schema', \"schema\", \n  'schemaOID', \"schemaOID\",\n  'name', \"name\", \n  'replicaIdentity', \"replicaIdentity\",\n  'columns', json_object_agg(\n    DISTINCT\n    col,\n    jsonb_build_object(\n      'pos', \"pos\",\n      'dataType', CASE WHEN \"arrayDims\" = 0 \n                       THEN \"type\" \n                       ELSE substring(\"type\" from 2) || repeat('[]', \"arrayDims\") END,\n      'pgTypeClass', \"typtype\",\n      'elemPgTypeClass', \"elemTyptype\",\n      'typeOID', \"typeOID\",\n      -- https://stackoverflow.com/a/52376230\n      'characterMaximumLength', CASE WHEN \"typeOID\" = 1043 OR \"typeOID\" = 1042 \n                                     THEN \"maxLen\" - 4 \n                                     ELSE \"maxLen\" END,\n      'notNull', \"notNull\",\n      'dflt', \"dflt\"\n    )\n  ),\n  'primaryKey', ARRAY( SELECT json_object_keys(\n    json_strip_nulls(\n      json_object_agg(\n        DISTINCT \"col\", \"keyPos\" ORDER BY \"keyPos\"\n      )\n    )\n  )),\n  'publications', json_object_agg(\n    DISTINCT \n    \"publication\", \n    jsonb_build_object('rowFilter', \"rowFilter\")\n  )\n) AS \"table\" FROM published_columns \n  GROUP BY \"schema\", \"schemaOID\", \"name\", \"oid\", \"replicaIdentity\"),\n  ` +\n    // Note: pg_attribute contains column names for tables and for indexes.\n    // However, the latter does not get updated when a column in a table is\n    // renamed.\n    //\n    // https://www.postgresql.org/message-id/5860814f-c91d-4ab0-b771-ded90d7b9c55%40www.fastmail.com\n    //\n    // To address this, the pg_attribute rows are looked up for the index's\n    // table rather than the index itself, using the pg_index.indkey array\n    // to determine the set and order of columns to include.\n    //\n    // Notes:\n    // * The first bit of indoption is 1 for DESC and 0 for ASC:\n    //   https://github.com/postgres/postgres/blob/4e1fad37872e49a711adad5d9870516e5c71a375/src/include/catalog/pg_index.h#L89\n    // * pg_index.indkey is an int2vector which is 0-based instead of 1-based.\n    // * The additional check for attgenerated is required for the aforementioned\n    //   (in publishedTableQuery) bug in PG15 in which generated columns are\n    //   incorrectly included in pg_publication_tables.attnames\n    /*sql*/ `\n  indexed_columns AS (SELECT\n      pg_indexes.schemaname as \"schema\",\n      pg_indexes.tablename as \"tableName\",\n      pg_indexes.indexname as \"name\",\n      index_column.name as \"col\",\n      CASE WHEN pg_index.indoption[index_column.pos-1] & 1 = 1 THEN 'DESC' ELSE 'ASC' END as \"dir\",\n      pg_index.indisunique as \"unique\",\n      pg_index.indisprimary as \"isPrimaryKey\",\n      pg_index.indisreplident as \"isReplicaIdentity\",\n      pg_index.indimmediate as \"isImmediate\"\n    FROM pg_indexes\n    JOIN pg_namespace ON pg_indexes.schemaname = pg_namespace.nspname\n    JOIN pg_class pc ON\n      pc.relname = pg_indexes.indexname\n      AND pc.relnamespace = pg_namespace.oid\n    JOIN pg_publication_tables as pb ON \n      pb.schemaname = pg_indexes.schemaname AND \n      pb.tablename = pg_indexes.tablename\n    JOIN pg_index ON pg_index.indexrelid = pc.oid\n    JOIN LATERAL (\n      SELECT array_agg(attname) as attnames, array_agg(attgenerated != '') as generated FROM pg_attribute\n        WHERE attrelid = pg_index.indrelid\n          AND attnum = ANY( (pg_index.indkey::smallint[] )[:pg_index.indnkeyatts - 1] )\n    ) as indexed ON true\n    JOIN LATERAL (\n      SELECT pg_attribute.attname as name, col.index_pos as pos\n        FROM UNNEST( (pg_index.indkey::smallint[])[:pg_index.indnkeyatts - 1] ) \n          WITH ORDINALITY as col(table_pos, index_pos)\n        JOIN pg_attribute ON attrelid = pg_index.indrelid AND attnum = col.table_pos\n    ) AS index_column ON true\n    LEFT JOIN pg_constraint ON pg_constraint.conindid = pc.oid\n    WHERE pb.pubname IN (${literal(publications)})\n      AND pg_index.indexprs IS NULL\n      AND pg_index.indpred IS NULL\n      AND (pg_constraint.contype IS NULL OR pg_constraint.contype IN ('p', 'u'))\n      AND indexed.attnames <@ pb.attnames\n      AND (current_setting('server_version_num')::int >= 160000 OR false = ALL(indexed.generated))\n    ORDER BY\n      pg_indexes.schemaname,\n      pg_indexes.tablename,\n      pg_indexes.indexname,\n      index_column.pos ASC),\n  \n    indexes AS (SELECT json_build_object(\n      'schema', \"schema\",\n      'tableName', \"tableName\",\n      'name', \"name\",\n      'unique', \"unique\",\n      'isPrimaryKey', \"isPrimaryKey\",\n      'isReplicaIdentity', \"isReplicaIdentity\",\n      'isImmediate', \"isImmediate\",\n      'columns', json_object_agg(\"col\", \"dir\")\n    ) AS index FROM indexed_columns \n      GROUP BY \"schema\", \"tableName\", \"name\", \"unique\", \n         \"isPrimaryKey\", \"isReplicaIdentity\", \"isImmediate\")\n\n    SELECT json_build_object(\n      'tables', COALESCE((SELECT json_agg(\"table\") FROM tables), '[]'::json),\n      'indexes', COALESCE((SELECT json_agg(\"index\") FROM indexes), '[]'::json)\n    ) as \"publishedSchema\"\n  `\n  );\n}\n\nexport const publishedSchema = v\n  .object({\n    tables: v.array(publishedTableSpec),\n    indexes: v.array(publishedIndexSpec),\n  })\n  .map(({tables, indexes}) => {\n    const zqlSpecs = computeZqlSpecsFromLiteSpecs(\n      tables.map(t => mapPostgresToLite(t)),\n      indexes.map(mapPostgresToLiteIndex),\n      {includeBackfillingColumns: true},\n    );\n    return {\n      indexes,\n\n      // Denormalize the schema such that each `table` includes the\n      // `replicaIdentityColumns` corresponding to the table's\n      // replica identity and associated primary key or index.\n      tables: tables.map(table => {\n        const replicaIdentityColumns: string[] = [];\n        switch (table.replicaIdentity) {\n          case 'd':\n            replicaIdentityColumns.push(...(table.primaryKey ?? []));\n            break;\n          case 'i':\n            replicaIdentityColumns.push(\n              ...Object.keys(\n                indexes.find(\n                  ind =>\n                    ind.schema === table.schema &&\n                    ind.tableName === table.name &&\n                    ind.isReplicaIdentity,\n                )?.columns ?? {},\n              ),\n            );\n            break;\n          case 'f': {\n            // For the key columns of replica identity \"full\", use the columns\n            // that the replicator/change-processor will end up using\n            // (in #getKey()) as the row key.\n            const zqlTable = zqlSpecs.get(liteTableName(table));\n            // Note: There zql spec will be absent if the table is not synced,\n            //       e.g. if it has no suitable unique indexes.\n            if (zqlTable) {\n              replicaIdentityColumns.push(...zqlTable.tableSpec.primaryKey);\n            }\n            break;\n          }\n        }\n        return {\n          ...table,\n          replicaIdentityColumns,\n        };\n      }),\n    };\n  });\n\nexport type PublishedSchema = v.Infer<typeof publishedSchema>;\n\nexport type PublishedTableWithReplicaIdentity =\n  PublishedSchema['tables'][number];\n\nconst publicationSchema = v.object({\n  pubname: v.string(),\n  pubinsert: v.boolean(),\n  pubupdate: v.boolean(),\n  pubdelete: v.boolean(),\n  pubtruncate: v.boolean(),\n});\n\nconst publicationsResultSchema = v.array(publicationSchema);\n\nexport type PublicationInfo = PublishedSchema & {\n  publications: v.Infer<typeof publicationsResultSchema>;\n};\n\n/**\n * Retrieves published tables and columns.\n */\nexport async function getPublicationInfo(\n  sql: postgres.Sql,\n  publications: string[],\n): Promise<PublicationInfo> {\n  const result = await sql.unsafe(/*sql*/ `\n  SELECT \n    schemaname AS \"schema\",\n    tablename AS \"table\", \n    json_object_agg(pubname, attnames) AS \"publications\"\n    FROM pg_publication_tables pb\n    WHERE pb.pubname IN (${literal(publications)})\n    GROUP BY schemaname, tablename;\n\n  SELECT ${Object.keys(publicationSchema.shape).join(\n    ',',\n  )} FROM pg_publication pb\n    WHERE pb.pubname IN (${literal(publications)})\n    ORDER BY pubname;\n\n  ${publishedSchemaQuery(publications)};\n`);\n\n  // The first query is used to check that tables in multiple publications\n  // always publish the same set of columns.\n  const publishedColumns = result[0] as {\n    schema: string;\n    table: string;\n    publications: Record<string, string[]>;\n  }[];\n  for (const {table, publications} of publishedColumns) {\n    let expected: Set<string>;\n    Object.entries(publications).forEach(([_, columns], i) => {\n      const cols = new Set(columns);\n      if (i === 0) {\n        expected = cols;\n      } else if (!equals(expected, cols)) {\n        throw new Error(\n          `Table ${table} is exported with different columns: [${[\n            ...expected,\n          ]}] vs [${[...cols]}]`,\n        );\n      }\n    });\n  }\n\n  assert(\n    result[2][0].publishedSchema,\n    () => `Invalid publishedSchema result ${BigIntJSON.stringify(result[2])}`,\n  );\n\n  return {\n    publications: v.parse(result[1], publicationsResultSchema),\n    ...v.parse(result[2][0].publishedSchema, publishedSchema),\n  };\n}\n"],"mappings":";;;;;;;;;;AAcA,SAAgB,qBAAqB,cAAiC;AAOpE,QACU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBA+BW,QAAQ,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BA6FlB,QAAQ,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCjD,IAAa,kBAAkB,eAC5B,OAAO;CACN,QAAQ,eAAE,MAAM,mBAAmB;CACnC,SAAS,eAAE,MAAM,mBAAmB;CACrC,CAAC,CACD,KAAK,EAAC,QAAQ,cAAa;CAC1B,MAAM,WAAW,6BACf,OAAO,KAAI,MAAK,kBAAkB,EAAE,CAAC,EACrC,QAAQ,IAAI,uBAAuB,EACnC,EAAC,2BAA2B,MAAK,CAClC;AACD,QAAO;EACL;EAKA,QAAQ,OAAO,KAAI,UAAS;GAC1B,MAAM,yBAAmC,EAAE;AAC3C,WAAQ,MAAM,iBAAd;IACE,KAAK;AACH,4BAAuB,KAAK,GAAI,MAAM,cAAc,EAAE,CAAE;AACxD;IACF,KAAK;AACH,4BAAuB,KACrB,GAAG,OAAO,KACR,QAAQ,MACN,QACE,IAAI,WAAW,MAAM,UACrB,IAAI,cAAc,MAAM,QACxB,IAAI,kBACP,EAAE,WAAW,EAAE,CACjB,CACF;AACD;IACF,KAAK,KAAK;KAIR,MAAM,WAAW,SAAS,IAAI,cAAc,MAAM,CAAC;AAGnD,SAAI,SACF,wBAAuB,KAAK,GAAG,SAAS,UAAU,WAAW;AAE/D;;;AAGJ,UAAO;IACL,GAAG;IACH;IACD;IACD;EACH;EACD;AAOJ,IAAM,oBAAoB,eAAE,OAAO;CACjC,SAAS,eAAE,QAAQ;CACnB,WAAW,eAAE,SAAS;CACtB,WAAW,eAAE,SAAS;CACtB,WAAW,eAAE,SAAS;CACtB,aAAa,eAAE,SAAS;CACzB,CAAC;AAEF,IAAM,2BAA2B,eAAE,MAAM,kBAAkB;;;;AAS3D,eAAsB,mBACpB,KACA,cAC0B;CAC1B,MAAM,SAAS,MAAM,IAAI,OAAe;;;;;;2BAMf,QAAQ,aAAa,CAAC;;;WAGtC,OAAO,KAAK,kBAAkB,MAAM,CAAC,KAC5C,IACD,CAAC;2BACuB,QAAQ,aAAa,CAAC;;;IAG7C,qBAAqB,aAAa,CAAC;EACrC;CAIA,MAAM,mBAAmB,OAAO;AAKhC,MAAK,MAAM,EAAC,OAAO,kBAAiB,kBAAkB;EACpD,IAAI;AACJ,SAAO,QAAQ,aAAa,CAAC,SAAS,CAAC,GAAG,UAAU,MAAM;GACxD,MAAM,OAAO,IAAI,IAAI,QAAQ;AAC7B,OAAI,MAAM,EACR,YAAW;YACF,CAAC,OAAO,UAAU,KAAK,CAChC,OAAM,IAAI,MACR,SAAS,MAAM,wCAAwC,CACrD,GAAG,SACJ,CAAC,QAAQ,CAAC,GAAG,KAAK,CAAC,GACrB;IAEH;;AAGJ,QACE,OAAO,GAAG,GAAG,uBACP,kCAAkC,WAAW,UAAU,OAAO,GAAG,GACxE;AAED,QAAO;EACL,cAAc,MAAQ,OAAO,IAAI,yBAAyB;EAC1D,GAAG,MAAQ,OAAO,GAAG,GAAG,iBAAiB,gBAAgB;EAC1D"}

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

@@ -1,330 +0,0 @@
-import { assert } from "../../../../../../shared/src/asserts.js";
-import { parse, valita_exports } from "../../../../../../shared/src/valita.js";
-import { jsonObjectSchema, stringify } from "../../../../../../shared/src/bigint-json.js";
-import { appSchema, check, upstreamSchema } from "../../../../types/shards.js";
-import { id } from "../../../../types/sql.js";
-import { getPublicationInfo, publishedSchema } from "./published.js";
-import { createEventFunctionStatements, createEventTriggerStatements } from "./ddl.js";
-import { validate } from "./validation.js";
-import postgres from "postgres";
-import { literal } from "pg-format";
-import { PG_INSUFFICIENT_PRIVILEGE } from "@drdgvhbh/postgres-error-codes";
-//#region ../zero-cache/src/services/change-source/pg/schema/shard.ts
-/**
-* PostgreSQL unquoted identifiers must start with a letter or underscore
-* and contain only letters, digits, and underscores.
-*/
-var VALID_PUBLICATION_NAME = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
-/**
-* Validates that a publication name is a valid PostgreSQL identifier.
-* This provides defense-in-depth against SQL injection when publication
-* names are used in replication commands.
-*/
-function validatePublicationName(name) {
-	if (!VALID_PUBLICATION_NAME.test(name)) throw new Error(`Invalid publication name "${name}". Publication names must start with a letter or underscore and contain only letters, digits, and underscores.`);
-	if (name.length > 63) throw new Error(`Publication name "${name}" exceeds PostgreSQL's 63-character identifier limit.`);
-}
-function internalPublicationPrefix({ appID }) {
-	return `_${appID}_`;
-}
-function legacyReplicationSlot({ appID, shardNum }) {
-	return `${appID}_${shardNum}`;
-}
-function replicationSlotPrefix(shard) {
-	const { appID, shardNum } = check(shard);
-	return `${appID}_${shardNum}_`;
-}
-/**
-* An expression used to match replication slots in the shard
-* in a Postgres `LIKE` operator.
-*/
-function replicationSlotExpression(shard) {
-	return `${replicationSlotPrefix(shard)}%`.replaceAll("_", "\\_");
-}
-function defaultPublicationName(appID, shardID) {
-	return `_${appID}_public_${shardID}`;
-}
-function metadataPublicationName(appID, shardID) {
-	return `_${appID}_metadata_${shardID}`;
-}
-function globalSetup(appID) {
-	const app = id(appSchema(appID));
-	return `
-  CREATE SCHEMA IF NOT EXISTS ${app};
-
-  CREATE TABLE IF NOT EXISTS ${app}.permissions (
-    "permissions" JSONB,
-    "hash"        TEXT,
-
-    -- Ensure that there is only a single row in the table.
-    -- Application code can be agnostic to this column, and
-    -- simply invoke UPDATE statements on the version columns.
-    "lock" BOOL PRIMARY KEY DEFAULT true CHECK (lock)
-  );
-
-  CREATE OR REPLACE FUNCTION ${app}.set_permissions_hash()
-  RETURNS TRIGGER AS $$
-  BEGIN
-      NEW.hash = md5(NEW.permissions::text);
-      RETURN NEW;
-  END;
-  $$ LANGUAGE plpgsql;
-
-  CREATE OR REPLACE TRIGGER on_set_permissions 
-    BEFORE INSERT OR UPDATE ON ${app}.permissions
-    FOR EACH ROW
-    EXECUTE FUNCTION ${app}.set_permissions_hash();
-
-  INSERT INTO ${app}.permissions (permissions) VALUES (NULL) ON CONFLICT DO NOTHING;
-`;
-}
-async function ensureGlobalTables(db, appID) {
-	await db.unsafe(globalSetup(appID));
-}
-function getClientsTableDefinition(schema) {
-	return `
-  CREATE TABLE ${schema}."clients" (
-    "clientGroupID"  TEXT NOT NULL,
-    "clientID"       TEXT NOT NULL,
-    "lastMutationID" BIGINT NOT NULL,
-    "userID"         TEXT,
-    PRIMARY KEY("clientGroupID", "clientID")
-  );`;
-}
-/**
-* Tracks the results of mutations.
-* 1. It is an error for the same mutation ID to be used twice.
-* 2. The result is JSONB to allow for arbitrary results.
-*
-* The tables must be cleaned up as the clients
-* receive the mutation responses and as clients are removed.
-*/
-function getMutationsTableDefinition(schema) {
-	return `
-  CREATE TABLE ${schema}."mutations" (
-    "clientGroupID"  TEXT NOT NULL,
-    "clientID"       TEXT NOT NULL,
-    "mutationID"     BIGINT NOT NULL,
-    "result"         JSON NOT NULL,
-    PRIMARY KEY("clientGroupID", "clientID", "mutationID")
-  );`;
-}
-var SHARD_CONFIG_TABLE = "shardConfig";
-function shardSetup(shardConfig, metadataPublication) {
-	const app = id(appSchema(shardConfig));
-	const shard = id(upstreamSchema(shardConfig));
-	const pubs = shardConfig.publications.toSorted();
-	assert(pubs.includes(metadataPublication), () => `Publications must include ${metadataPublication}`);
-	return `
-  CREATE SCHEMA IF NOT EXISTS ${shard};
-
-  ${getClientsTableDefinition(shard)}
-  ${getMutationsTableDefinition(shard)}
-
-  DROP PUBLICATION IF EXISTS ${id(metadataPublication)};
-  CREATE PUBLICATION ${id(metadataPublication)}
-    FOR TABLE ${app}."permissions", TABLE ${shard}."clients", ${shard}."mutations";
-
-  CREATE TABLE ${shard}."${SHARD_CONFIG_TABLE}" (
-    "publications"  TEXT[] NOT NULL,
-    "ddlDetection"  BOOL NOT NULL,
-
-    -- Ensure that there is only a single row in the table.
-    "lock" BOOL PRIMARY KEY DEFAULT true CHECK (lock)
-  );
-
-  INSERT INTO ${shard}."${SHARD_CONFIG_TABLE}" (
-      "publications",
-      "ddlDetection" 
-    ) VALUES (
-      ARRAY[${literal(pubs)}], 
-      false  -- set in SAVEPOINT with triggerSetup() statements
-    );
-
-  CREATE TABLE ${shard}.replicas (
-    -- The DEFAULT exists purely for backwards compatibility support.
-    -- New code always specifies a value based on Date.now().
-    "id"                 TEXT PRIMARY KEY DEFAULT replace(gen_random_uuid()::text, '-', ''),
-    "rank"               BIGSERIAL,
-    "slot"               TEXT NOT NULL,
-    "version"            TEXT NOT NULL,
-    "initialSchema"      JSON,  -- set after initial sync
-    "initialSyncContext" JSON,
-    "subscriberContext"  JSON
-  );
-  `;
-}
-function dropShard(appID, shardID) {
-	const schema = `${appID}_${shardID}`;
-	const metadataPublication = metadataPublicationName(appID, shardID);
-	return `
-    DROP PUBLICATION IF EXISTS ${id(defaultPublicationName(appID, shardID))};
-    DROP PUBLICATION IF EXISTS ${id(metadataPublication)};
-    DROP SCHEMA IF EXISTS ${id(schema)} CASCADE;
-  `;
-}
-var internalShardConfigSchema = valita_exports.object({
-	publications: valita_exports.array(valita_exports.string()),
-	ddlDetection: valita_exports.boolean()
-});
-var replicaSchema = internalShardConfigSchema.extend({
-	id: valita_exports.string(),
-	rank: valita_exports.bigint(),
-	slot: valita_exports.string(),
-	version: valita_exports.string(),
-	initialSchema: publishedSchema,
-	initialSyncContext: jsonObjectSchema.nullable(),
-	subscriberContext: jsonObjectSchema.nullable()
-});
-function triggerSetup(shard) {
-	const schema = id(upstreamSchema(shard));
-	return createEventTriggerStatements(shard) + `UPDATE ${schema}."shardConfig" SET "ddlDetection" = true;`;
-}
-/**
-* Creates a new replica to mark it as the owner of a specified `slot`.
-* This should be done with an advisory lock for replica/slot management
-* to ensure that the slot does not get dropped by concurrent cleanup
-* logic.
-*
-* Once initial sync is complete, {@link initReplica} should be called to
-* make the replica usable for incremental sync.
-*/
-async function createReplica(sql, shard, id, slot, replicaVersion) {
-	const schema = upstreamSchema(shard);
-	const values = {
-		id,
-		slot,
-		version: replicaVersion
-	};
-	await sql`INSERT INTO ${sql(schema)}.replicas ${sql(values)}`;
-}
-async function initReplica(sql, shard, id, { tables, indexes }, initialSyncContext) {
-	const schema = upstreamSchema(shard);
-	const values = {
-		initialSchema: {
-			tables,
-			indexes
-		},
-		initialSyncContext
-	};
-	await sql`UPDATE ${sql(schema)}.replicas SET ${sql(values)} WHERE id = ${id}`;
-}
-/**
-* Gets the latest initialized replica at the specified version.
-*/
-async function getReplicaAtVersion(lc, sql, shard, replicaVersion, context) {
-	const schema = sql(upstreamSchema(shard));
-	const result = await sql`
-    SELECT
-      replicas."id",
-      replicas."rank",
-      replicas."slot",
-      replicas."version",
-      replicas."initialSchema",
-      replicas."initialSyncContext",
-      replicas."subscriberContext",
-      "shardConfig"."publications",
-      "shardConfig"."ddlDetection"
-    FROM ${schema}.replicas JOIN ${schema}."shardConfig" ON true
-      WHERE version = ${replicaVersion} AND "initialSyncContext" IS NOT NULL
-      ORDER BY rank DESC LIMIT 1;
-  `;
-	if (result.length === 0) {
-		const allReplicas = await sql`
-      SELECT id, slot, version, "initialSyncContext", "subscriberContext" 
-        FROM ${schema}.replicas`;
-		lc.info?.(`Replica ${replicaVersion} ` + (context ? `(context: ${stringify(context)}) ` : "") + `not found in: ${stringify(allReplicas)}`);
-		return null;
-	}
-	return parse(result[0], replicaSchema, "passthrough");
-}
-async function getInternalShardConfig(sql, shard) {
-	const result = await sql`
-    SELECT "publications", "ddlDetection"
-      FROM ${sql(upstreamSchema(shard))}."shardConfig";
-  `;
-	assert(result.length === 1, () => `Expected exactly one shardConfig row, got ${result.length}`);
-	return parse(result[0], internalShardConfigSchema, "passthrough");
-}
-/**
-* Sets up and returns all publications (including internal ones) for
-* the given shard.
-*/
-async function setupTablesAndReplication(lc, sql, requested) {
-	const { publications } = requested;
-	for (const pub of publications) {
-		validatePublicationName(pub);
-		if (pub.startsWith("_")) throw new Error(`Publication names starting with "_" are reserved for internal use.\nPlease use a different name for publication "${pub}".`);
-	}
-	const allPublications = [];
-	if (publications.length) {
-		const results = await sql`
-    SELECT pubname from pg_publication WHERE pubname IN ${sql(publications)}`.values();
-		if (results.length !== publications.length) throw new Error(`Unknown or invalid publications. Specified: [${publications}]. Found: [${results.flat()}]`);
-		allPublications.push(...publications);
-	} else {
-		const defaultPublication = defaultPublicationName(requested.appID, requested.shardNum);
-		await sql`
-      DROP PUBLICATION IF EXISTS ${sql(defaultPublication)}`;
-		await sql`
-      CREATE PUBLICATION ${sql(defaultPublication)} 
-        FOR TABLES IN SCHEMA public
-        WITH (publish_via_partition_root = true)`;
-		allPublications.push(defaultPublication);
-	}
-	const metadataPublication = metadataPublicationName(requested.appID, requested.shardNum);
-	allPublications.push(metadataPublication);
-	const shard = {
-		...requested,
-		publications: allPublications
-	};
-	await sql.unsafe(globalSetup(shard) + shardSetup(shard, metadataPublication));
-	await replicaIdentitiesForTablesWithoutPrimaryKeys(await getPublicationInfo(sql, allPublications))?.apply(lc, sql);
-	await setupTriggers(lc, sql, shard);
-}
-async function setupTriggers(lc, tx, shard) {
-	const [{ ddlDetection }] = await tx`
-    SELECT "ddlDetection" FROM ${tx(upstreamSchema(shard))}."shardConfig"`;
-	await tx.unsafe(createEventFunctionStatements(shard));
-	try {
-		await tx.savepoint((sub) => sub.unsafe(triggerSetup(shard)));
-	} catch (e) {
-		if (ddlDetection) throw e;
-		if (!(e instanceof postgres.PostgresError && e.code === PG_INSUFFICIENT_PRIVILEGE)) throw e;
-		lc.warn?.(`Unable to create event triggers for schema change detection:\n\n"${e.hint ?? e.message}"\n\nProceeding in degraded mode: schema changes will halt replication,\nrequiring the replica to be reset (manually or with --auto-reset).`);
-	}
-}
-function validatePublications(lc, published) {
-	published.publications.forEach((pub) => {
-		if (!pub.pubinsert || !pub.pubupdate || !pub.pubdelete || !pub.pubtruncate) throw new Error(`PUBLICATION ${pub.pubname} must publish insert, update, delete, and truncate`);
-	});
-	published.tables.forEach((table) => validate(lc, table));
-}
-function replicaIdentitiesForTablesWithoutPrimaryKeys(pubs) {
-	const replicaIdentities = [];
-	for (const table of pubs.tables) if (!table.primaryKey?.length && table.replicaIdentity === "d") {
-		const { schema, name: tableName } = table;
-		for (const { columns, name: indexName } of pubs.indexes.filter((idx) => idx.schema === schema && idx.tableName === tableName && idx.unique && idx.isImmediate)) {
-			if (Object.keys(columns).some((col) => !table.columns[col].notNull)) continue;
-			replicaIdentities.push({
-				schema,
-				tableName,
-				indexName
-			});
-			break;
-		}
-	}
-	if (replicaIdentities.length === 0) return;
-	return { apply: async (lc, sql) => {
-		for (const { schema, tableName, indexName } of replicaIdentities) {
-			lc.info?.(`setting "${indexName}" as the REPLICA IDENTITY for "${tableName}"`);
-			await sql`
-        ALTER TABLE ${sql(schema)}.${sql(tableName)} 
-          REPLICA IDENTITY USING INDEX ${sql(indexName)}`;
-		}
-	} };
-}
-//#endregion
-export { SHARD_CONFIG_TABLE, createReplica, dropShard, ensureGlobalTables, getInternalShardConfig, getMutationsTableDefinition, getReplicaAtVersion, initReplica, internalPublicationPrefix, legacyReplicationSlot, metadataPublicationName, replicaIdentitiesForTablesWithoutPrimaryKeys, replicationSlotExpression, replicationSlotPrefix, setupTablesAndReplication, setupTriggers, validatePublications };
-
-//# sourceMappingURL=shard.js.map