@rocicorp/zero 1.12.0-canary.2 → 1.12.0-canary.4

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

@@ -1 +1 @@
-{"version":3,"file":"published.js","names":[],"sources":["../../../../../../../../zero-cache/src/services/change-source/pg/schema/published.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {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 {\n  publishedColumnSpec,\n  publishedIndexSpec,\n  publishedTableSpec,\n  type PublishedIndexSpec,\n} from '../../../../db/specs.ts';\nimport {getOrCreateCounter} from '../../../../observability/metrics.ts';\nimport {liteTableName} from '../../../../types/names.ts';\nimport {\n  translatePostgresIndexPredicate,\n  type UnsupportedPredicateReason,\n} from './index-predicate.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  coll.collisdeterministic AS \"collationIsDeterministic\",\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\nLEFT JOIN pg_collation coll ON coll.oid = pg_attribute.attcollation\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      'collationIsDeterministic', \"collationIsDeterministic\",\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      -- Partial indexes are always reported as non-unique. Nothing on the\n      -- replica relies on the uniqueness of a partial index (it cannot serve\n      -- as a row key), and reporting it as non-unique keeps the ddl event\n      -- format compatible with older versions of the zero-cache, which\n      -- ignore \"predicateSQL\" and would otherwise create a full UNIQUE index\n      -- on the replica.\n      (pg_index.indisunique AND pg_index.indpred IS NULL) as \"unique\",\n      pg_index.indisprimary as \"isPrimaryKey\",\n      pg_index.indisreplident as \"isReplicaIdentity\",\n      pg_index.indimmediate as \"isImmediate\",\n      pg_get_expr(pg_index.indpred, pg_index.indrelid, false) as \"predicateSQL\"\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_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      'predicateSQL', \"predicateSQL\",\n      'columns', json_object_agg(\"col\", \"dir\")\n    ) AS index FROM indexed_columns \n      GROUP BY \"schema\", \"tableName\", \"name\", \"unique\", \n         \"isPrimaryKey\", \"isReplicaIdentity\", \"isImmediate\", \"predicateSQL\")\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\nconst rawPublishedColumnSpec = publishedColumnSpec.extend({\n  collationIsDeterministic: v.boolean().nullable().optional(),\n});\n\nconst rawPublishedTableSpec = publishedTableSpec.extend({\n  columns: v.record(rawPublishedColumnSpec),\n});\n\nconst rawPublishedIndexSpec = publishedIndexSpec.extend({\n  predicateSQL: v.string().nullable().optional(),\n});\n\nexport type SkippedIndexDiagnostic = {\n  readonly schema: string;\n  readonly index: string;\n  readonly predicate: string;\n  readonly reason: UnsupportedPredicateReason;\n};\n\nconst skippedIndexDiagnostics = new WeakMap<\n  object,\n  readonly SkippedIndexDiagnostic[]\n>();\nexport function getSkippedIndexDiagnostics(\n  schema: PublishedSchema,\n): readonly SkippedIndexDiagnostic[] {\n  return skippedIndexDiagnostics.get(schema) ?? [];\n}\n\nexport function warnForSkippedIndexes(\n  lc: LogContext,\n  schema: PublishedSchema,\n  warned: Set<string> = new Set(),\n): void {\n  for (const diagnostic of getSkippedIndexDiagnostics(schema)) {\n    const key = JSON.stringify(diagnostic);\n    if (warned.has(key)) continue;\n    warned.add(key);\n    lc.warn?.('Skipping unsupported PostgreSQL partial index', diagnostic);\n    getOrCreateCounter('replication', 'skipped_index', {\n      description: 'Number of PostgreSQL indexes skipped during replication.',\n      unit: '{index}',\n    }).add(1, {reason: diagnostic.reason, partial: true});\n  }\n}\n\nexport const publishedSchema = v\n  .object({\n    tables: v.array(rawPublishedTableSpec),\n    indexes: v.array(rawPublishedIndexSpec),\n  })\n  .map(({tables: rawTables, indexes: rawIndexes}) => {\n    const diagnostics: SkippedIndexDiagnostic[] = [];\n    const indexes: PublishedIndexSpec[] = [];\n    for (const rawIndex of rawIndexes) {\n      const {predicateSQL, ...index} = rawIndex;\n      if (predicateSQL !== null && predicateSQL !== undefined) {\n        const table = rawTables.find(\n          candidate =>\n            candidate.schema === index.schema &&\n            candidate.name === index.tableName,\n        );\n        const translation = table\n          ? translatePostgresIndexPredicate(predicateSQL, table)\n          : {supported: false as const, reason: 'unpublished-column' as const};\n        if (!translation.supported) {\n          diagnostics.push({\n            schema: index.schema,\n            index: index.name,\n            predicate: predicateSQL,\n            reason: translation.reason,\n          });\n          continue;\n        }\n        indexes.push({...index, predicate: translation.predicate});\n      } else {\n        indexes.push(index);\n      }\n    }\n\n    const tables = rawTables.map(table => ({\n      ...table,\n      columns: Object.fromEntries(\n        Object.entries(table.columns).map(\n          ([name, {collationIsDeterministic: _, ...column}]) => [name, column],\n        ),\n      ),\n    }));\n    const zqlSpecs = computeZqlSpecsFromLiteSpecs(\n      tables.map(t => mapPostgresToLite(t)),\n      indexes.map(mapPostgresToLiteIndex),\n      {includeBackfillingColumns: true},\n    );\n    const result = {\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    skippedIndexDiagnostics.set(result, diagnostics);\n    return result;\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  const schema = v.parse(result[2][0].publishedSchema, publishedSchema);\n  const info = {\n    publications: v.parse(result[1], publicationsResultSchema),\n    ...schema,\n  };\n  skippedIndexDiagnostics.set(info, getSkippedIndexDiagnostics(schema));\n  return info;\n}\n"],"mappings":"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"}
+{"version":3,"file":"published.js","names":["v","v.parse"],"sources":["../../../../../../../../zero-cache/src/services/change-source/pg/schema/published.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {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 {\n  publishedColumnSpec,\n  publishedIndexSpec,\n  publishedTableSpec,\n  type PublishedIndexSpec,\n} from '../../../../db/specs.ts';\nimport {getOrCreateCounter} from '../../../../observability/metrics.ts';\nimport {liteTableName} from '../../../../types/names.ts';\nimport {\n  translatePostgresIndexPredicate,\n  type UnsupportedPredicateReason,\n} from './index-predicate.ts';\n\nexport function publishedSchemaQuery(\n  publications: readonly string[],\n  includePartialIndexes = true,\n) {\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  coll.collisdeterministic AS \"collationIsDeterministic\",\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\nLEFT JOIN pg_collation coll ON coll.oid = pg_attribute.attcollation\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      'collationIsDeterministic', \"collationIsDeterministic\",\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      -- Partial indexes are always reported as non-unique. Nothing on the\n      -- replica relies on the uniqueness of a partial index (it cannot serve\n      -- as a row key), and reporting it as non-unique keeps the ddl event\n      -- format compatible with older versions of the zero-cache, which\n      -- ignore \"predicateSQL\" and would otherwise create a full UNIQUE index\n      -- on the replica.\n      (pg_index.indisunique AND pg_index.indpred IS NULL) as \"unique\",\n      pg_index.indisprimary as \"isPrimaryKey\",\n      pg_index.indisreplident as \"isReplicaIdentity\",\n      pg_index.indimmediate as \"isImmediate\",\n      pg_get_expr(pg_index.indpred, pg_index.indrelid, false) as \"predicateSQL\"\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 (${includePartialIndexes} OR 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      'predicateSQL', \"predicateSQL\",\n      'columns', json_object_agg(\"col\", \"dir\")\n    ) AS index FROM indexed_columns \n      GROUP BY \"schema\", \"tableName\", \"name\", \"unique\", \n         \"isPrimaryKey\", \"isReplicaIdentity\", \"isImmediate\", \"predicateSQL\")\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\nconst rawPublishedColumnSpec = publishedColumnSpec.extend({\n  collationIsDeterministic: v.boolean().nullable().optional(),\n});\n\nconst rawPublishedTableSpec = publishedTableSpec.extend({\n  columns: v.record(rawPublishedColumnSpec),\n});\n\nconst rawPublishedIndexSpec = publishedIndexSpec.extend({\n  predicateSQL: v.string().nullable().optional(),\n});\n\nexport type SkippedIndexDiagnostic = {\n  readonly schema: string;\n  readonly index: string;\n  readonly predicate: string;\n  readonly reason: UnsupportedPredicateReason;\n};\n\nconst skippedIndexDiagnostics = new WeakMap<\n  object,\n  readonly SkippedIndexDiagnostic[]\n>();\nexport function getSkippedIndexDiagnostics(\n  schema: PublishedSchema,\n): readonly SkippedIndexDiagnostic[] {\n  return skippedIndexDiagnostics.get(schema) ?? [];\n}\n\nexport function warnForSkippedIndexes(\n  lc: LogContext,\n  schema: PublishedSchema,\n  warned: Set<string> = new Set(),\n): void {\n  for (const diagnostic of getSkippedIndexDiagnostics(schema)) {\n    const key = JSON.stringify(diagnostic);\n    if (warned.has(key)) continue;\n    warned.add(key);\n    lc.warn?.('Skipping unsupported PostgreSQL partial index', diagnostic);\n    getOrCreateCounter('replication', 'skipped_index', {\n      description: 'Number of PostgreSQL indexes skipped during replication.',\n      unit: '{index}',\n    }).add(1, {reason: diagnostic.reason, partial: true});\n  }\n}\n\nexport const publishedSchema = v\n  .object({\n    tables: v.array(rawPublishedTableSpec),\n    indexes: v.array(rawPublishedIndexSpec),\n  })\n  .map(({tables: rawTables, indexes: rawIndexes}) => {\n    const diagnostics: SkippedIndexDiagnostic[] = [];\n    const indexes: PublishedIndexSpec[] = [];\n    for (const rawIndex of rawIndexes) {\n      const {predicateSQL, ...index} = rawIndex;\n      if (predicateSQL !== null && predicateSQL !== undefined) {\n        const table = rawTables.find(\n          candidate =>\n            candidate.schema === index.schema &&\n            candidate.name === index.tableName,\n        );\n        const translation = table\n          ? translatePostgresIndexPredicate(predicateSQL, table)\n          : {supported: false as const, reason: 'unpublished-column' as const};\n        if (!translation.supported) {\n          diagnostics.push({\n            schema: index.schema,\n            index: index.name,\n            predicate: predicateSQL,\n            reason: translation.reason,\n          });\n          continue;\n        }\n        indexes.push({...index, predicate: translation.predicate});\n      } else {\n        indexes.push(index);\n      }\n    }\n\n    const tables = rawTables.map(table => ({\n      ...table,\n      columns: Object.fromEntries(\n        Object.entries(table.columns).map(\n          ([name, {collationIsDeterministic: _, ...column}]) => [name, column],\n        ),\n      ),\n    }));\n    const zqlSpecs = computeZqlSpecsFromLiteSpecs(\n      tables.map(t => mapPostgresToLite(t)),\n      indexes.map(mapPostgresToLiteIndex),\n      {includeBackfillingColumns: true},\n    );\n    const result = {\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    skippedIndexDiagnostics.set(result, diagnostics);\n    return result;\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  const schema = v.parse(result[2][0].publishedSchema, publishedSchema);\n  const info = {\n    publications: v.parse(result[1], publicationsResultSchema),\n    ...schema,\n  };\n  skippedIndexDiagnostics.set(info, getSkippedIndexDiagnostics(schema));\n  return info;\n}\n"],"mappings":"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"}

package/out/zero-cache/src/services/change-source/pg/schema/replica-stage-enum.js.map

@@ -1 +1 @@
-{"version":3,"file":"replica-stage-enum.js","names":[],"sources":["../../../../../../../../zero-cache/src/services/change-source/pg/schema/replica-stage-enum.ts"],"sourcesContent":["import * as v from '../../../../../../shared/src/valita.ts';\n\n// Note: The stages are ordered by restore availability:\n// * InitialSync is the first to create the generation, by definition.\n// * Replicate has already restored and thus can be restored from\n// * Restore is in the process of awaiting the backup\nexport const InitialSync = 0;\nexport const Replicate = 1;\nexport const Restore = 2;\n\nexport type InitialSync = typeof InitialSync;\nexport type Replicate = typeof Replicate;\nexport type Restore = typeof Restore;\n\nexport const replicaStageSchema = v.literalUnion(\n  InitialSync,\n  Replicate,\n  Restore,\n);\n\nexport type ReplicaStage = v.Infer<typeof replicaStageSchema>;\n"],"mappings":";AAcA,IAAa,qBAAqB,aAAA,GAAA,GAAA,CAIlC"}
+{"version":3,"file":"replica-stage-enum.js","names":["v.literalUnion"],"sources":["../../../../../../../../zero-cache/src/services/change-source/pg/schema/replica-stage-enum.ts"],"sourcesContent":["import * as v from '../../../../../../shared/src/valita.ts';\n\n// Note: The stages are ordered by restore availability:\n// * InitialSync is the first to create the generation, by definition.\n// * Replicate has already restored and thus can be restored from\n// * Restore is in the process of awaiting the backup\nexport const InitialSync = 0;\nexport const Replicate = 1;\nexport const Restore = 2;\n\nexport type InitialSync = typeof InitialSync;\nexport type Replicate = typeof Replicate;\nexport type Restore = typeof Restore;\n\nexport const replicaStageSchema = v.literalUnion(\n  InitialSync,\n  Replicate,\n  Restore,\n);\n\nexport type ReplicaStage = v.Infer<typeof replicaStageSchema>;\n"],"mappings":";AAcA,IAAa,qBAAqBA,aAAAA,GAAAA,GAAAA,CAIlC"}

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

@@ -196,8 +196,8 @@ export declare function getInternalShardConfig(sql: PostgresDB, shard: ShardID):
  * Sets up and returns all publications (including internal ones) for
  * the given shard.
  */
-export declare function setupTablesAndReplication(lc: LogContext, sql: PostgresTransaction, requested: ShardConfig): Promise<void>;
-export declare function setupTriggers(lc: LogContext, tx: PostgresTransaction, shard: ShardConfig): Promise<void>;
+export declare function setupTablesAndReplication(lc: LogContext, sql: PostgresTransaction, requested: ShardConfig, includePartialIndexes?: boolean): Promise<void>;
+export declare function setupTriggers(lc: LogContext, tx: PostgresTransaction, shard: ShardConfig, includePartialIndexes?: boolean): Promise<void>;
 export declare function validatePublications(lc: LogContext, published: PublicationInfo): void;
 type ReplicaIdentities = {
     apply(lc: LogContext, db: PostgresDB): Promise<void>;

package/out/zero-cache/src/services/change-source/pg/schema/shard.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shard.d.ts","sourceRoot":"","sources":["../../../../../../../../zero-cache/src/services/change-source/pg/schema/shard.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"shard.d.ts","sourceRoot":"","sources":["../../../../../../../../zero-cache/src/services/change-source/pg/schema/shard.ts"],"names":[],"mappings":"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"}

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

@@ -168,8 +168,9 @@ function shardSetup(shardConfig, metadataPublication) {
 function dropShard(appID, shardID) {
 	const schema = `${appID}_${shardID}`;
 	const metadataPublication = metadataPublicationName(appID, shardID);
+	const defaultPublication = defaultPublicationName(appID, shardID);
 	return `
-    DROP PUBLICATION IF EXISTS ${id(defaultPublicationName(appID, shardID))};
+    DROP PUBLICATION IF EXISTS ${id(defaultPublication)};
     DROP PUBLICATION IF EXISTS ${id(metadataPublication)};
     DROP SCHEMA IF EXISTS ${id(schema)} CASCADE;
   `;
@@ -296,7 +297,7 @@ async function getReplicaAtVersion(lc, sql, shard, replicaVersion, id = null, co
 	return parse(result[0], replicaSchema, "passthrough");
 }
 async function getActiveReplicas(lc, sql, shard) {
-	const replicas = parse(await sql`
+	const results = await sql`
     SELECT
       replicas."id",
       replicas."rank",
@@ -317,7 +318,8 @@ async function getActiveReplicas(lc, sql, shard) {
         AND slots.restart_lsn IS NOT NULL
         AND slots.wal_status IS DISTINCT FROM 'lost'
       ORDER BY generation DESC, confirmed_flush_lsn DESC;
-  `, valita_exports.array(replicaStateSchema), "passthrough");
+  `;
+	const replicas = parse(results, valita_exports.array(replicaStateSchema), "passthrough");
 	lc.info?.(`current replicas`, { replicas });
 	return replicas;
 }
@@ -333,7 +335,7 @@ async function getActiveReplicas(lc, sql, shard) {
 */
 async function getRestoreCandidates(sql, shard, epoch) {
 	const schema = sql(upstreamSchema(shard));
-	return parse(await sql`
+	const results = await sql`
     SELECT
       replicas."id",
       replicas."rank",
@@ -368,7 +370,8 @@ async function getRestoreCandidates(sql, shard, epoch) {
         stage ASC,                 -- ordered by backup availalibility
         active DESC,               -- prefer active slots (fork over resume)
         confirmed_flush_lsn DESC;  -- prefer replicas further ahead
-  `, valita_exports.array(replicaStateSchema), "passthrough");
+  `;
+	return parse(results, valita_exports.array(replicaStateSchema), "passthrough");
 }
 async function getReplicaState(sql, shard, id) {
 	const results = await sql`
@@ -401,7 +404,7 @@ async function getInternalShardConfig(sql, shard) {
 * Sets up and returns all publications (including internal ones) for
 * the given shard.
 */
-async function setupTablesAndReplication(lc, sql, requested) {
+async function setupTablesAndReplication(lc, sql, requested, includePartialIndexes = true) {
 	const { publications } = requested;
 	for (const pub of publications) {
 		validatePublicationName(pub);
@@ -431,12 +434,12 @@ async function setupTablesAndReplication(lc, sql, requested) {
 	};
 	await sql.unsafe(globalSetup(shard) + shardSetup(shard, metadataPublication));
 	await replicaIdentitiesForTablesWithoutPrimaryKeys(await getPublicationInfo(sql, allPublications))?.apply(lc, sql);
-	await setupTriggers(lc, sql, shard);
+	await setupTriggers(lc, sql, shard, includePartialIndexes);
 }
-async function setupTriggers(lc, tx, shard) {
+async function setupTriggers(lc, tx, shard, includePartialIndexes = true) {
 	const [{ ddlDetection }] = await tx`
     SELECT "ddlDetection" FROM ${tx(upstreamSchema(shard))}."shardConfig"`;
-	await tx.unsafe(createEventFunctionStatements(shard));
+	await tx.unsafe(createEventFunctionStatements(shard, includePartialIndexes));
 	try {
 		await tx.savepoint((sub) => sub.unsafe(triggerSetup(shard)));
 	} catch (e) {
@@ -476,6 +479,6 @@ function replicaIdentitiesForTablesWithoutPrimaryKeys(pubs) {
 	} };
 }
 //#endregion
-export { SHARD_CONFIG_TABLE, createReplica, dropShard, ensureGlobalTables, getActiveReplicas, getInternalShardConfig, getMutationsTableDefinition, getReplicaAtVersion, getReplicaState, getRestoreCandidates, initInitialSyncReplica, initRestoreReplica, internalPublicationPrefix, legacyReplicationSlot, metadataPublicationName, replicaIdentitiesForTablesWithoutPrimaryKeys, replicationSlotExpression, replicationSlotPrefix, setupTablesAndReplication, setupTriggers, validatePublications };
+export { SHARD_CONFIG_TABLE, createReplica, dropShard, ensureGlobalTables, getActiveReplicas, getClientsTableDefinition, getInternalShardConfig, getMutationsTableDefinition, getReplicaAtVersion, getReplicaState, getRestoreCandidates, initInitialSyncReplica, initRestoreReplica, internalPublicationPrefix, legacyReplicationSlot, metadataPublicationName, replicaIdentitiesForTablesWithoutPrimaryKeys, replicationSlotExpression, replicationSlotPrefix, setupTablesAndReplication, setupTriggers, shardSetup, validatePublicationName, validatePublications };
 
 //# sourceMappingURL=shard.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"shard.js","names":[],"sources":["../../../../../../../../zero-cache/src/services/change-source/pg/schema/shard.ts"],"sourcesContent":["import {PG_INSUFFICIENT_PRIVILEGE} from '@drdgvhbh/postgres-error-codes';\nimport type {LogContext} from '@rocicorp/logger';\nimport {literal} from 'pg-format';\nimport postgres from 'postgres';\nimport {assert} from '../../../../../../shared/src/asserts.ts';\nimport {\n  jsonObjectSchema,\n  stringify,\n  type JSONObject,\n} from '../../../../../../shared/src/bigint-json.ts';\nimport * as v from '../../../../../../shared/src/valita.ts';\nimport {Default} from '../../../../db/postgres-replica-identity-enum.ts';\nimport type {PostgresDB, PostgresTransaction} from '../../../../types/pg.ts';\nimport type {AppID, ShardConfig, ShardID} from '../../../../types/shards.ts';\nimport {appSchema, check, upstreamSchema} from '../../../../types/shards.ts';\nimport {id} from '../../../../types/sql.ts';\nimport {\n  createEventFunctionStatements,\n  createEventTriggerStatements,\n} from './ddl.ts';\nimport {\n  getPublicationInfo,\n  publishedSchema,\n  type PublicationInfo,\n  type PublishedSchema,\n} from './published.ts';\nimport {\n  InitialSync,\n  replicaStageSchema,\n  type ReplicaStage,\n} from './replica-stage-enum.ts';\nimport {validate} from './validation.ts';\n\n/**\n * PostgreSQL unquoted identifiers must start with a letter or underscore\n * and contain only letters, digits, and underscores.\n */\nconst VALID_PUBLICATION_NAME = /^[a-zA-Z_][a-zA-Z0-9_]*$/;\n\n/**\n * Validates that a publication name is a valid PostgreSQL identifier.\n * This provides defense-in-depth against SQL injection when publication\n * names are used in replication commands.\n */\nexport function validatePublicationName(name: string): void {\n  if (!VALID_PUBLICATION_NAME.test(name)) {\n    throw new Error(\n      `Invalid publication name \"${name}\". Publication names must start with a letter or underscore ` +\n        `and contain only letters, digits, and underscores.`,\n    );\n  }\n  if (name.length > 63) {\n    throw new Error(\n      `Publication name \"${name}\" exceeds PostgreSQL's 63-character identifier limit.`,\n    );\n  }\n}\n\nexport function internalPublicationPrefix({appID}: AppID) {\n  return `_${appID}_`;\n}\n\nexport function legacyReplicationSlot({appID, shardNum}: ShardID) {\n  return `${appID}_${shardNum}`;\n}\n\nexport function replicationSlotPrefix(shard: ShardID) {\n  const {appID, shardNum} = check(shard);\n  return `${appID}_${shardNum}_`;\n}\n\n/**\n * An expression used to match replication slots in the shard\n * in a Postgres `LIKE` operator.\n */\nexport function replicationSlotExpression(shard: ShardID) {\n  // Underscores have a special meaning in LIKE values\n  // so they have to be escaped.\n  return `${replicationSlotPrefix(shard)}%`.replaceAll('_', '\\\\_');\n}\n\nfunction defaultPublicationName(appID: string, shardID: string | number) {\n  return `_${appID}_public_${shardID}`;\n}\n\nexport function metadataPublicationName(\n  appID: string,\n  shardID: string | number,\n) {\n  return `_${appID}_metadata_${shardID}`;\n}\n\n// The GLOBAL_SETUP must be idempotent as it can be run multiple times for different shards.\nfunction globalSetup(appID: AppID): string {\n  const app = id(appSchema(appID));\n\n  return /*sql*/ `\n  CREATE SCHEMA IF NOT EXISTS ${app};\n\n  CREATE TABLE IF NOT EXISTS ${app}.permissions (\n    \"permissions\" JSONB,\n    \"hash\"        TEXT,\n\n    -- Ensure that there is only a single row in the table.\n    -- Application code can be agnostic to this column, and\n    -- simply invoke UPDATE statements on the version columns.\n    \"lock\" BOOL PRIMARY KEY DEFAULT true CHECK (lock)\n  );\n\n  CREATE OR REPLACE FUNCTION ${app}.set_permissions_hash()\n  RETURNS TRIGGER AS $$\n  BEGIN\n      NEW.hash = md5(NEW.permissions::text);\n      RETURN NEW;\n  END;\n  $$ LANGUAGE plpgsql;\n\n  CREATE OR REPLACE TRIGGER on_set_permissions \n    BEFORE INSERT OR UPDATE ON ${app}.permissions\n    FOR EACH ROW\n    EXECUTE FUNCTION ${app}.set_permissions_hash();\n\n  INSERT INTO ${app}.permissions (permissions) VALUES (NULL) ON CONFLICT DO NOTHING;\n`;\n}\n\nexport async function ensureGlobalTables(db: PostgresDB, appID: AppID) {\n  await db.unsafe(globalSetup(appID));\n}\n\nexport function getClientsTableDefinition(schema: string) {\n  return /*sql*/ `\n  CREATE TABLE ${schema}.\"clients\" (\n    \"clientGroupID\"  TEXT NOT NULL,\n    \"clientID\"       TEXT NOT NULL,\n    \"lastMutationID\" BIGINT NOT NULL,\n    \"userID\"         TEXT,\n    PRIMARY KEY(\"clientGroupID\", \"clientID\")\n  );`;\n}\n\n/**\n * Tracks the results of mutations.\n * 1. It is an error for the same mutation ID to be used twice.\n * 2. The result is JSONB to allow for arbitrary results.\n *\n * The tables must be cleaned up as the clients\n * receive the mutation responses and as clients are removed.\n */\nexport function getMutationsTableDefinition(schema: string) {\n  return /*sql*/ `\n  CREATE TABLE ${schema}.\"mutations\" (\n    \"clientGroupID\"  TEXT NOT NULL,\n    \"clientID\"       TEXT NOT NULL,\n    \"mutationID\"     BIGINT NOT NULL,\n    \"result\"         JSON NOT NULL,\n    PRIMARY KEY(\"clientGroupID\", \"clientID\", \"mutationID\")\n  );`;\n}\n\nexport const SHARD_CONFIG_TABLE = 'shardConfig';\n\nexport function shardSetup(\n  shardConfig: ShardConfig,\n  metadataPublication: string,\n): string {\n  const app = id(appSchema(shardConfig));\n  const shard = id(upstreamSchema(shardConfig));\n\n  const pubs = shardConfig.publications.toSorted();\n  assert(\n    pubs.includes(metadataPublication),\n    () => `Publications must include ${metadataPublication}`,\n  );\n\n  return /*sql*/ `\n  CREATE SCHEMA IF NOT EXISTS ${shard};\n\n  ${getClientsTableDefinition(shard)}\n  ${getMutationsTableDefinition(shard)}\n\n  CREATE TABLE ${shard}.\"${SHARD_CONFIG_TABLE}\" (\n    \"publications\"  TEXT[] NOT NULL,\n    \"ddlDetection\"  BOOL NOT NULL,\n\n    -- Ensure that there is only a single row in the table.\n    \"lock\" BOOL PRIMARY KEY DEFAULT true CHECK (lock)\n  );\n\n  INSERT INTO ${shard}.\"${SHARD_CONFIG_TABLE}\" (\n      \"publications\",\n      \"ddlDetection\" \n    ) VALUES (\n      ARRAY[${literal(pubs)}], \n      false  -- set in SAVEPOINT with triggerSetup() statements\n    );\n\n  CREATE TABLE ${shard}.replicas (\n    -- The DEFAULT exists purely for backwards compatibility support.\n    -- New code always specifies a value based on Date.now().\n    \"id\"                 TEXT PRIMARY KEY DEFAULT replace(gen_random_uuid()::text, '-', ''),\n    \"rank\"               BIGSERIAL,\n    \"slot\"               TEXT NOT NULL,\n    \"version\"            TEXT,  -- replaced by generation, slated for deletion\n    \"epoch\"              INT4 DEFAULT 0,\n    \"generation\"         TEXT NOT NULL,\n    \"stage\"              INT4 DEFAULT ${InitialSync},\n    \"backupPath\"         TEXT,  -- subpath within the litestream backup URL\n    \"backupV5\"           BOOL DEFAULT false,\n    -- Whether the slot is acked only after storing in the PG change log.\n    \"pgChangeLog\"        BOOL DEFAULT false,\n    \"initialSchema\"      JSON,  -- set after initial sync\n    \"initialSyncContext\" JSON,\n    \"subscriberContext\"  JSON\n  );\n\n  DROP PUBLICATION IF EXISTS ${id(metadataPublication)};\n  CREATE PUBLICATION ${id(metadataPublication)}\n    FOR TABLE ${app}.\"permissions\", \n        TABLE ${shard}.\"clients\", \n              ${shard}.\"mutations\", \n              ${shard}.\"replicas\" (id);  -- advance the LSN/version with new replicas\n  `;\n}\n\nexport function dropShard(appID: string, shardID: string | number): string {\n  const schema = `${appID}_${shardID}`;\n  const metadataPublication = metadataPublicationName(appID, shardID);\n  const defaultPublication = defaultPublicationName(appID, shardID);\n\n  // DROP SCHEMA ... CASCADE does not drop dependent PUBLICATIONS,\n  // so PUBLICATIONs must be dropped explicitly.\n  return /*sql*/ `\n    DROP PUBLICATION IF EXISTS ${id(defaultPublication)};\n    DROP PUBLICATION IF EXISTS ${id(metadataPublication)};\n    DROP SCHEMA IF EXISTS ${id(schema)} CASCADE;\n  `;\n}\n\nconst internalShardConfigSchema = v.object({\n  publications: v.array(v.string()),\n  ddlDetection: v.boolean(),\n});\n\nexport type InternalShardConfig = v.Infer<typeof internalShardConfigSchema>;\n\nconst replicaInfoSchema = v.object({\n  id: v.string(),\n  rank: v.bigint(),\n  slot: v.string(),\n  epoch: v.number(),\n  generation: v.string(),\n  stage: replicaStageSchema,\n  backupPath: v.string().nullable(),\n  backupV5: v.boolean(),\n  /**\n   * Whether the replication-manager that took over the replica's slot acks it\n   * only after storing transactions in the PG change log (i.e. RMv1.5). The\n   * slot's position past the change log's head then reflects acked\n   * keepalives, rather than transactions missing from the change log.\n   * False if unknown.\n   */\n  pgChangeLog: v.boolean(),\n});\n\nconst fullReplicaRowSchema = replicaInfoSchema.extend({\n  initialSchema: publishedSchema,\n  initialSyncContext: jsonObjectSchema.nullable(),\n  subscriberContext: jsonObjectSchema.nullable(),\n});\n\nconst replicaSchema = internalShardConfigSchema.extend(\n  fullReplicaRowSchema.shape,\n);\n\nexport type Replica = v.Infer<typeof replicaSchema>;\n\nconst replicationSlotStateSchema = v.object({\n  active: v.boolean(),\n  confirmedFlushLsn: v.string(),\n});\n\nconst replicaStateSchema = replicaInfoSchema.extend(\n  replicationSlotStateSchema.shape,\n);\n\nexport type ReplicaState = v.Infer<typeof replicaStateSchema>;\n\n// triggerSetup is run separately in a sub-transaction (i.e. SAVEPOINT) so\n// that a failure (e.g. due to lack of superuser permissions) can be handled\n// by continuing in a degraded mode (ddlDetection = false).\nfunction triggerSetup(shard: ShardConfig): string {\n  const schema = id(upstreamSchema(shard));\n  return (\n    createEventTriggerStatements(shard) +\n    /*sql*/ `UPDATE ${schema}.\"shardConfig\" SET \"ddlDetection\" = true;`\n  );\n}\n\nexport type BackupOptions = {\n  backupPath: string | null;\n  backupV5: boolean;\n  /** See `pgChangeLog` in {@link ReplicaState}. */\n  pgChangeLog: boolean;\n};\n\n/**\n * Creates a new replica to mark it as the owner of a specified `slot`.\n * This should be done with an advisory lock for replica/slot management\n * to ensure that the slot does not get dropped by concurrent cleanup\n * logic.\n *\n * Once initial sync is complete, {@link initInitialSyncReplica} should be called to\n * make the replica usable for incremental sync.\n */\nexport async function createReplica(\n  sql: PostgresDB,\n  shard: ShardID,\n  id: string,\n  slot: string,\n  epoch: number,\n  replicaVersion: string,\n  {backupPath, backupV5, pgChangeLog}: BackupOptions,\n  stage: ReplicaStage,\n) {\n  const schema = upstreamSchema(shard);\n  const values: Partial<v.Infer<typeof fullReplicaRowSchema>> & {\n    version: string;\n  } = {\n    id,\n    slot,\n    epoch,\n    generation: replicaVersion,\n    // No longer read, but zero-cache 1.10 fails to start on a NULL \"version\",\n    // so it is still written for rollbacks to 1.10.\n    version: replicaVersion,\n    backupPath,\n    backupV5,\n    pgChangeLog,\n    stage,\n  };\n  await sql`INSERT INTO ${sql(schema)}.replicas ${sql(values)}`;\n}\n\n// Called in initial-sync to store the exact schema that was initially synced.\nexport async function initInitialSyncReplica(\n  sql: PostgresDB,\n  shard: ShardID,\n  id: string,\n  {tables, indexes}: PublishedSchema,\n  initialSyncContext: JSONObject,\n) {\n  const schema = upstreamSchema(shard);\n  const synced: PublishedSchema = {tables, indexes};\n  const values = {initialSchema: synced, initialSyncContext};\n  await sql`UPDATE ${sql(schema)}.replicas SET ${sql(values)} WHERE id = ${id}`;\n}\n\n// Called to initialize a Restore replica (`destID`) with the generation\n// and initial sync context of the `sourceID` replica.\nexport async function initRestoreReplica(\n  sql: PostgresDB,\n  shard: ShardID,\n  {sourceID, destID}: {sourceID: string; destID: string},\n): Promise<ReplicaState | null> {\n  const schema = upstreamSchema(shard);\n  await sql`\n    UPDATE ${sql(schema)}.replicas dest \n      SET \"generation\"         = source.\"generation\",\n          \"version\"            = source.\"generation\",\n          \"initialSchema\"      = source.\"initialSchema\",\n          \"initialSyncContext\" = source.\"initialSyncContext\"\n      FROM ${sql(schema)}.replicas source\n      WHERE source.id = ${sourceID} AND dest.id = ${destID};\n  `;\n  return getReplicaState(sql, shard, destID);\n}\n\n/**\n * Gets at the given version and optional ID. If no ID is specified, gets\n * the latest (i.e. highest rank) replica with that version.\n */\nexport async function getReplicaAtVersion(\n  lc: LogContext,\n  sql: PostgresDB,\n  shard: ShardID,\n  replicaVersion: string,\n  id: string | null = null,\n  context?: JSONObject,\n): Promise<Replica | null> {\n  const schema = sql(upstreamSchema(shard));\n  const result = await sql`\n    SELECT\n      replicas.\"id\",\n      replicas.\"rank\",\n      replicas.\"slot\",\n      replicas.\"epoch\",\n      replicas.\"generation\",\n      replicas.\"stage\",\n      replicas.\"backupPath\",\n      replicas.\"backupV5\",\n      replicas.\"pgChangeLog\",\n      replicas.\"initialSchema\",\n      replicas.\"initialSyncContext\",\n      replicas.\"subscriberContext\",\n      \"shardConfig\".\"publications\",\n      \"shardConfig\".\"ddlDetection\"\n    FROM ${schema}.replicas JOIN ${schema}.\"shardConfig\" ON true\n      WHERE generation = ${replicaVersion} AND \"initialSyncContext\" IS NOT NULL\n      AND id = COALESCE(${id}, id)\n      ORDER BY rank DESC LIMIT 1;\n  `;\n  if (result.length === 0) {\n    // log out all the replicas and the joined shardConfig\n    const allReplicas = await sql`\n      SELECT id, slot, generation, \"initialSyncContext\", \"subscriberContext\" \n        FROM ${schema}.replicas`;\n    lc.info?.(\n      `Replica ${id}@${replicaVersion}` +\n        (context ? `(context: ${stringify(context)}) ` : '') +\n        `not found in: ${stringify(allReplicas)}`,\n    );\n    return null;\n  }\n  return v.parse(result[0], replicaSchema, 'passthrough');\n}\n\nexport async function getActiveReplicas(\n  lc: LogContext,\n  sql: PostgresDB,\n  shard: ShardID,\n): Promise<ReplicaState[]> {\n  const schema = sql(upstreamSchema(shard));\n  const results = await sql`\n    SELECT\n      replicas.\"id\",\n      replicas.\"rank\",\n      replicas.\"slot\",\n      replicas.\"epoch\",\n      replicas.\"generation\",\n      replicas.\"stage\",\n      replicas.\"backupPath\",\n      replicas.\"backupV5\",\n      replicas.\"pgChangeLog\",\n      slots.\"active\",\n      slots.\"confirmed_flush_lsn\" as \"confirmedFlushLsn\"\n    FROM ${schema}.replicas JOIN pg_replication_slots slots ON slot = slot_name\n      WHERE \"initialSyncContext\" IS NOT NULL\n        -- Exclude replicas whose slot has been invalidated (e.g. for exceeding\n        -- max_slot_wal_keep_size). Such a replica can never be resumed, and\n        -- restoring it just results in an AutoResetSignal on every attempt.\n        AND slots.restart_lsn IS NOT NULL\n        AND slots.wal_status IS DISTINCT FROM 'lost'\n      ORDER BY generation DESC, confirmed_flush_lsn DESC;\n  `;\n  const replicas = v.parse(results, v.array(replicaStateSchema), 'passthrough');\n  lc.info?.(`current replicas`, {replicas});\n  return replicas;\n}\n\n/**\n * Returns candidates for restoring a new replica from. These include\n * all replicas in the newest `generation` of the given `epoch`, in order\n * of earliest available backup:\n * - An active InitialSync replica, which will be the only replica in\n *   its generation by definition. Orphaned/inactive initial syncs are skipped.\n * - Replicas in the Replicate stage, active first.\n * - Replicas in the Restore stage, potentially available for resumption\n *   as a last resort.\n */\nexport async function getRestoreCandidates(\n  sql: PostgresDB,\n  shard: ShardID,\n  epoch: number,\n): Promise<ReplicaState[]> {\n  const schema = sql(upstreamSchema(shard));\n  const results = await sql`\n    SELECT\n      replicas.\"id\",\n      replicas.\"rank\",\n      replicas.\"slot\",\n      replicas.\"epoch\",\n      replicas.\"generation\",\n      replicas.\"stage\",\n      replicas.\"backupPath\",\n      replicas.\"backupV5\",\n      replicas.\"pgChangeLog\",\n      slots.\"active\",\n      slots.\"confirmed_flush_lsn\" as \"confirmedFlushLsn\"\n    FROM ${schema}.replicas JOIN pg_replication_slots slots ON slot = slot_name\n\n      -- coalesce on the newest generation in the epoch\n      WHERE generation = (\n        SELECT MAX(r.generation)\n          FROM ${schema}.replicas r\n          JOIN pg_replication_slots s ON r.slot = s.slot_name\n         WHERE r.\"epoch\" = ${epoch} AND r.\"backupV5\"\n           -- ignore orphaned InitialSyncs, which cannot be restored from\n           AND (s.\"active\" OR r.\"stage\" != ${InitialSync})\n           AND s.restart_lsn IS NOT NULL\n           AND s.wal_status IS DISTINCT FROM 'lost'\n      )\n           AND \"epoch\" = ${epoch} AND \"backupV5\"\n           AND (slots.active OR \"stage\" != ${InitialSync})\n           AND slots.restart_lsn IS NOT NULL\n           AND slots.wal_status IS DISTINCT FROM 'lost'\n\n      ORDER BY \n        stage ASC,                 -- ordered by backup availalibility\n        active DESC,               -- prefer active slots (fork over resume)\n        confirmed_flush_lsn DESC;  -- prefer replicas further ahead\n  `;\n  return v.parse(results, v.array(replicaStateSchema), 'passthrough');\n}\n\nexport async function getReplicaState(\n  sql: PostgresDB,\n  shard: ShardID,\n  id: string,\n): Promise<ReplicaState | null> {\n  const schema = sql(upstreamSchema(shard));\n  const results = await sql`\n    SELECT\n      replicas.\"id\",\n      replicas.\"rank\",\n      replicas.\"slot\",\n      replicas.\"epoch\",\n      replicas.\"generation\",\n      replicas.\"stage\",\n      replicas.\"backupPath\",\n      replicas.\"backupV5\",\n      replicas.\"pgChangeLog\",\n      slots.\"active\",\n      slots.\"confirmed_flush_lsn\" as \"confirmedFlushLsn\"\n    FROM ${schema}.replicas JOIN pg_replication_slots slots ON slot = slot_name\n      WHERE \"id\" = ${id};\n  `;\n  return results.length\n    ? v.parse(results[0], replicaStateSchema, 'passthrough')\n    : null;\n}\n\nexport async function getInternalShardConfig(\n  sql: PostgresDB,\n  shard: ShardID,\n): Promise<InternalShardConfig> {\n  const result = await sql`\n    SELECT \"publications\", \"ddlDetection\"\n      FROM ${sql(upstreamSchema(shard))}.\"shardConfig\";\n  `;\n  assert(\n    result.length === 1,\n    () => `Expected exactly one shardConfig row, got ${result.length}`,\n  );\n  return v.parse(result[0], internalShardConfigSchema, 'passthrough');\n}\n\n/**\n * Sets up and returns all publications (including internal ones) for\n * the given shard.\n */\nexport async function setupTablesAndReplication(\n  lc: LogContext,\n  sql: PostgresTransaction,\n  requested: ShardConfig,\n) {\n  const {publications} = requested;\n  // Validate requested publications.\n  for (const pub of publications) {\n    validatePublicationName(pub);\n    if (pub.startsWith('_')) {\n      throw new Error(\n        `Publication names starting with \"_\" are reserved for internal use.\\n` +\n          `Please use a different name for publication \"${pub}\".`,\n      );\n    }\n  }\n  const allPublications: string[] = [];\n\n  // Setup application publications.\n  if (publications.length) {\n    const results = await sql<{pubname: string}[]>`\n    SELECT pubname from pg_publication WHERE pubname IN ${sql(\n      publications,\n    )}`.values();\n\n    if (results.length !== publications.length) {\n      throw new Error(\n        `Unknown or invalid publications. Specified: [${publications}]. Found: [${results.flat()}]`,\n      );\n    }\n    allPublications.push(...publications);\n  } else {\n    const defaultPublication = defaultPublicationName(\n      requested.appID,\n      requested.shardNum,\n    );\n    await sql`\n      DROP PUBLICATION IF EXISTS ${sql(defaultPublication)}`;\n    await sql`\n      CREATE PUBLICATION ${sql(defaultPublication)} \n        FOR TABLES IN SCHEMA public\n        WITH (publish_via_partition_root = true)`;\n    allPublications.push(defaultPublication);\n  }\n\n  const metadataPublication = metadataPublicationName(\n    requested.appID,\n    requested.shardNum,\n  );\n  allPublications.push(metadataPublication);\n\n  const shard = {...requested, publications: allPublications};\n\n  // Setup the global tables and shard tables / publications.\n  await sql.unsafe(globalSetup(shard) + shardSetup(shard, metadataPublication));\n\n  const pubs = await getPublicationInfo(sql, allPublications);\n  await replicaIdentitiesForTablesWithoutPrimaryKeys(pubs)?.apply(lc, sql);\n\n  await setupTriggers(lc, sql, shard);\n}\n\nexport async function setupTriggers(\n  lc: LogContext,\n  tx: PostgresTransaction,\n  shard: ShardConfig,\n) {\n  const schema = upstreamSchema(shard);\n  const [{ddlDetection}] = await tx<InternalShardConfig[]> /*sql*/ `\n    SELECT \"ddlDetection\" FROM ${tx(schema)}.\"shardConfig\"`;\n\n  // The functions invoked by event triggers are installed even if\n  // event triggers are not supported/allowed by the db provider.\n  // This allows users to manually invoke the update_schemas() function\n  // as a workaround.\n  await tx.unsafe(createEventFunctionStatements(shard));\n  try {\n    await tx.savepoint(sub => sub.unsafe(triggerSetup(shard)));\n  } catch (e) {\n    if (ddlDetection) {\n      // If ddlDetection has already been enabled, subsequent failures to\n      // upgrade the trigger should be propagated rather than swallowed.\n      throw e;\n    }\n    if (\n      !(\n        e instanceof postgres.PostgresError &&\n        e.code === PG_INSUFFICIENT_PRIVILEGE\n      )\n    ) {\n      throw e;\n    }\n    // If triggerSetup() fails, replication continues in ddlDetection=false mode.\n    lc.warn?.(\n      `Unable to create event triggers for schema change detection:\\n\\n` +\n        `\"${e.hint ?? e.message}\"\\n\\n` +\n        `Proceeding in degraded mode: schema changes will halt replication,\\n` +\n        `requiring the replica to be reset (manually or with --auto-reset).`,\n    );\n  }\n}\n\nexport function validatePublications(\n  lc: LogContext,\n  published: PublicationInfo,\n) {\n  // Verify that all publications export the proper events.\n  published.publications.forEach(pub => {\n    if (\n      !pub.pubinsert ||\n      !pub.pubupdate ||\n      !pub.pubdelete ||\n      !pub.pubtruncate\n    ) {\n      // TODO: Make APIError?\n      throw new Error(\n        `PUBLICATION ${pub.pubname} must publish insert, update, delete, and truncate`,\n      );\n    }\n  });\n\n  published.tables.forEach(table => validate(lc, table));\n}\n\ntype ReplicaIdentities = {\n  apply(lc: LogContext, db: PostgresDB): Promise<void>;\n};\n\nexport function replicaIdentitiesForTablesWithoutPrimaryKeys(\n  pubs: PublishedSchema,\n): ReplicaIdentities | undefined {\n  const replicaIdentities: {\n    schema: string;\n    tableName: string;\n    indexName: string;\n  }[] = [];\n  for (const table of pubs.tables) {\n    if (!table.primaryKey?.length && table.replicaIdentity === Default) {\n      // Look for an index that can serve as the REPLICA IDENTITY USING INDEX. It must be:\n      // - UNIQUE\n      // - NOT NULL columns\n      // - not deferrable (i.e. isImmediate)\n      // - not partial\n      //\n      // https://www.postgresql.org/docs/current/sql-altertable.html#SQL-ALTERTABLE-REPLICA-IDENTITY\n      const {schema, name: tableName} = table;\n      for (const {columns, name: indexName} of pubs.indexes.filter(\n        idx =>\n          idx.schema === schema &&\n          idx.tableName === tableName &&\n          idx.unique &&\n          idx.isImmediate &&\n          idx.predicate === undefined,\n      )) {\n        if (Object.keys(columns).some(col => !table.columns[col].notNull)) {\n          continue; // Only indexes with all NOT NULL columns are suitable.\n        }\n        replicaIdentities.push({schema, tableName, indexName});\n        break;\n      }\n    }\n  }\n\n  if (replicaIdentities.length === 0) {\n    return undefined;\n  }\n  return {\n    apply: async (lc: LogContext, sql: PostgresDB) => {\n      for (const {schema, tableName, indexName} of replicaIdentities) {\n        lc.info?.(\n          `setting \"${indexName}\" as the REPLICA IDENTITY for \"${tableName}\"`,\n        );\n        await sql`\n        ALTER TABLE ${sql(schema)}.${sql(tableName)} \n          REPLICA IDENTITY USING INDEX ${sql(indexName)}`;\n      }\n    },\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"shard.js","names":["v","v.parse"],"sources":["../../../../../../../../zero-cache/src/services/change-source/pg/schema/shard.ts"],"sourcesContent":["import {PG_INSUFFICIENT_PRIVILEGE} from '@drdgvhbh/postgres-error-codes';\nimport type {LogContext} from '@rocicorp/logger';\nimport {literal} from 'pg-format';\nimport postgres from 'postgres';\nimport {assert} from '../../../../../../shared/src/asserts.ts';\nimport {\n  jsonObjectSchema,\n  stringify,\n  type JSONObject,\n} from '../../../../../../shared/src/bigint-json.ts';\nimport * as v from '../../../../../../shared/src/valita.ts';\nimport {Default} from '../../../../db/postgres-replica-identity-enum.ts';\nimport type {PostgresDB, PostgresTransaction} from '../../../../types/pg.ts';\nimport type {AppID, ShardConfig, ShardID} from '../../../../types/shards.ts';\nimport {appSchema, check, upstreamSchema} from '../../../../types/shards.ts';\nimport {id} from '../../../../types/sql.ts';\nimport {\n  createEventFunctionStatements,\n  createEventTriggerStatements,\n} from './ddl.ts';\nimport {\n  getPublicationInfo,\n  publishedSchema,\n  type PublicationInfo,\n  type PublishedSchema,\n} from './published.ts';\nimport {\n  InitialSync,\n  replicaStageSchema,\n  type ReplicaStage,\n} from './replica-stage-enum.ts';\nimport {validate} from './validation.ts';\n\n/**\n * PostgreSQL unquoted identifiers must start with a letter or underscore\n * and contain only letters, digits, and underscores.\n */\nconst VALID_PUBLICATION_NAME = /^[a-zA-Z_][a-zA-Z0-9_]*$/;\n\n/**\n * Validates that a publication name is a valid PostgreSQL identifier.\n * This provides defense-in-depth against SQL injection when publication\n * names are used in replication commands.\n */\nexport function validatePublicationName(name: string): void {\n  if (!VALID_PUBLICATION_NAME.test(name)) {\n    throw new Error(\n      `Invalid publication name \"${name}\". Publication names must start with a letter or underscore ` +\n        `and contain only letters, digits, and underscores.`,\n    );\n  }\n  if (name.length > 63) {\n    throw new Error(\n      `Publication name \"${name}\" exceeds PostgreSQL's 63-character identifier limit.`,\n    );\n  }\n}\n\nexport function internalPublicationPrefix({appID}: AppID) {\n  return `_${appID}_`;\n}\n\nexport function legacyReplicationSlot({appID, shardNum}: ShardID) {\n  return `${appID}_${shardNum}`;\n}\n\nexport function replicationSlotPrefix(shard: ShardID) {\n  const {appID, shardNum} = check(shard);\n  return `${appID}_${shardNum}_`;\n}\n\n/**\n * An expression used to match replication slots in the shard\n * in a Postgres `LIKE` operator.\n */\nexport function replicationSlotExpression(shard: ShardID) {\n  // Underscores have a special meaning in LIKE values\n  // so they have to be escaped.\n  return `${replicationSlotPrefix(shard)}%`.replaceAll('_', '\\\\_');\n}\n\nfunction defaultPublicationName(appID: string, shardID: string | number) {\n  return `_${appID}_public_${shardID}`;\n}\n\nexport function metadataPublicationName(\n  appID: string,\n  shardID: string | number,\n) {\n  return `_${appID}_metadata_${shardID}`;\n}\n\n// The GLOBAL_SETUP must be idempotent as it can be run multiple times for different shards.\nfunction globalSetup(appID: AppID): string {\n  const app = id(appSchema(appID));\n\n  return /*sql*/ `\n  CREATE SCHEMA IF NOT EXISTS ${app};\n\n  CREATE TABLE IF NOT EXISTS ${app}.permissions (\n    \"permissions\" JSONB,\n    \"hash\"        TEXT,\n\n    -- Ensure that there is only a single row in the table.\n    -- Application code can be agnostic to this column, and\n    -- simply invoke UPDATE statements on the version columns.\n    \"lock\" BOOL PRIMARY KEY DEFAULT true CHECK (lock)\n  );\n\n  CREATE OR REPLACE FUNCTION ${app}.set_permissions_hash()\n  RETURNS TRIGGER AS $$\n  BEGIN\n      NEW.hash = md5(NEW.permissions::text);\n      RETURN NEW;\n  END;\n  $$ LANGUAGE plpgsql;\n\n  CREATE OR REPLACE TRIGGER on_set_permissions \n    BEFORE INSERT OR UPDATE ON ${app}.permissions\n    FOR EACH ROW\n    EXECUTE FUNCTION ${app}.set_permissions_hash();\n\n  INSERT INTO ${app}.permissions (permissions) VALUES (NULL) ON CONFLICT DO NOTHING;\n`;\n}\n\nexport async function ensureGlobalTables(db: PostgresDB, appID: AppID) {\n  await db.unsafe(globalSetup(appID));\n}\n\nexport function getClientsTableDefinition(schema: string) {\n  return /*sql*/ `\n  CREATE TABLE ${schema}.\"clients\" (\n    \"clientGroupID\"  TEXT NOT NULL,\n    \"clientID\"       TEXT NOT NULL,\n    \"lastMutationID\" BIGINT NOT NULL,\n    \"userID\"         TEXT,\n    PRIMARY KEY(\"clientGroupID\", \"clientID\")\n  );`;\n}\n\n/**\n * Tracks the results of mutations.\n * 1. It is an error for the same mutation ID to be used twice.\n * 2. The result is JSONB to allow for arbitrary results.\n *\n * The tables must be cleaned up as the clients\n * receive the mutation responses and as clients are removed.\n */\nexport function getMutationsTableDefinition(schema: string) {\n  return /*sql*/ `\n  CREATE TABLE ${schema}.\"mutations\" (\n    \"clientGroupID\"  TEXT NOT NULL,\n    \"clientID\"       TEXT NOT NULL,\n    \"mutationID\"     BIGINT NOT NULL,\n    \"result\"         JSON NOT NULL,\n    PRIMARY KEY(\"clientGroupID\", \"clientID\", \"mutationID\")\n  );`;\n}\n\nexport const SHARD_CONFIG_TABLE = 'shardConfig';\n\nexport function shardSetup(\n  shardConfig: ShardConfig,\n  metadataPublication: string,\n): string {\n  const app = id(appSchema(shardConfig));\n  const shard = id(upstreamSchema(shardConfig));\n\n  const pubs = shardConfig.publications.toSorted();\n  assert(\n    pubs.includes(metadataPublication),\n    () => `Publications must include ${metadataPublication}`,\n  );\n\n  return /*sql*/ `\n  CREATE SCHEMA IF NOT EXISTS ${shard};\n\n  ${getClientsTableDefinition(shard)}\n  ${getMutationsTableDefinition(shard)}\n\n  CREATE TABLE ${shard}.\"${SHARD_CONFIG_TABLE}\" (\n    \"publications\"  TEXT[] NOT NULL,\n    \"ddlDetection\"  BOOL NOT NULL,\n\n    -- Ensure that there is only a single row in the table.\n    \"lock\" BOOL PRIMARY KEY DEFAULT true CHECK (lock)\n  );\n\n  INSERT INTO ${shard}.\"${SHARD_CONFIG_TABLE}\" (\n      \"publications\",\n      \"ddlDetection\" \n    ) VALUES (\n      ARRAY[${literal(pubs)}], \n      false  -- set in SAVEPOINT with triggerSetup() statements\n    );\n\n  CREATE TABLE ${shard}.replicas (\n    -- The DEFAULT exists purely for backwards compatibility support.\n    -- New code always specifies a value based on Date.now().\n    \"id\"                 TEXT PRIMARY KEY DEFAULT replace(gen_random_uuid()::text, '-', ''),\n    \"rank\"               BIGSERIAL,\n    \"slot\"               TEXT NOT NULL,\n    \"version\"            TEXT,  -- replaced by generation, slated for deletion\n    \"epoch\"              INT4 DEFAULT 0,\n    \"generation\"         TEXT NOT NULL,\n    \"stage\"              INT4 DEFAULT ${InitialSync},\n    \"backupPath\"         TEXT,  -- subpath within the litestream backup URL\n    \"backupV5\"           BOOL DEFAULT false,\n    -- Whether the slot is acked only after storing in the PG change log.\n    \"pgChangeLog\"        BOOL DEFAULT false,\n    \"initialSchema\"      JSON,  -- set after initial sync\n    \"initialSyncContext\" JSON,\n    \"subscriberContext\"  JSON\n  );\n\n  DROP PUBLICATION IF EXISTS ${id(metadataPublication)};\n  CREATE PUBLICATION ${id(metadataPublication)}\n    FOR TABLE ${app}.\"permissions\", \n        TABLE ${shard}.\"clients\", \n              ${shard}.\"mutations\", \n              ${shard}.\"replicas\" (id);  -- advance the LSN/version with new replicas\n  `;\n}\n\nexport function dropShard(appID: string, shardID: string | number): string {\n  const schema = `${appID}_${shardID}`;\n  const metadataPublication = metadataPublicationName(appID, shardID);\n  const defaultPublication = defaultPublicationName(appID, shardID);\n\n  // DROP SCHEMA ... CASCADE does not drop dependent PUBLICATIONS,\n  // so PUBLICATIONs must be dropped explicitly.\n  return /*sql*/ `\n    DROP PUBLICATION IF EXISTS ${id(defaultPublication)};\n    DROP PUBLICATION IF EXISTS ${id(metadataPublication)};\n    DROP SCHEMA IF EXISTS ${id(schema)} CASCADE;\n  `;\n}\n\nconst internalShardConfigSchema = v.object({\n  publications: v.array(v.string()),\n  ddlDetection: v.boolean(),\n});\n\nexport type InternalShardConfig = v.Infer<typeof internalShardConfigSchema>;\n\nconst replicaInfoSchema = v.object({\n  id: v.string(),\n  rank: v.bigint(),\n  slot: v.string(),\n  epoch: v.number(),\n  generation: v.string(),\n  stage: replicaStageSchema,\n  backupPath: v.string().nullable(),\n  backupV5: v.boolean(),\n  /**\n   * Whether the replication-manager that took over the replica's slot acks it\n   * only after storing transactions in the PG change log (i.e. RMv1.5). The\n   * slot's position past the change log's head then reflects acked\n   * keepalives, rather than transactions missing from the change log.\n   * False if unknown.\n   */\n  pgChangeLog: v.boolean(),\n});\n\nconst fullReplicaRowSchema = replicaInfoSchema.extend({\n  initialSchema: publishedSchema,\n  initialSyncContext: jsonObjectSchema.nullable(),\n  subscriberContext: jsonObjectSchema.nullable(),\n});\n\nconst replicaSchema = internalShardConfigSchema.extend(\n  fullReplicaRowSchema.shape,\n);\n\nexport type Replica = v.Infer<typeof replicaSchema>;\n\nconst replicationSlotStateSchema = v.object({\n  active: v.boolean(),\n  confirmedFlushLsn: v.string(),\n});\n\nconst replicaStateSchema = replicaInfoSchema.extend(\n  replicationSlotStateSchema.shape,\n);\n\nexport type ReplicaState = v.Infer<typeof replicaStateSchema>;\n\n// triggerSetup is run separately in a sub-transaction (i.e. SAVEPOINT) so\n// that a failure (e.g. due to lack of superuser permissions) can be handled\n// by continuing in a degraded mode (ddlDetection = false).\nfunction triggerSetup(shard: ShardConfig): string {\n  const schema = id(upstreamSchema(shard));\n  return (\n    createEventTriggerStatements(shard) +\n    /*sql*/ `UPDATE ${schema}.\"shardConfig\" SET \"ddlDetection\" = true;`\n  );\n}\n\nexport type BackupOptions = {\n  backupPath: string | null;\n  backupV5: boolean;\n  /** See `pgChangeLog` in {@link ReplicaState}. */\n  pgChangeLog: boolean;\n};\n\n/**\n * Creates a new replica to mark it as the owner of a specified `slot`.\n * This should be done with an advisory lock for replica/slot management\n * to ensure that the slot does not get dropped by concurrent cleanup\n * logic.\n *\n * Once initial sync is complete, {@link initInitialSyncReplica} should be called to\n * make the replica usable for incremental sync.\n */\nexport async function createReplica(\n  sql: PostgresDB,\n  shard: ShardID,\n  id: string,\n  slot: string,\n  epoch: number,\n  replicaVersion: string,\n  {backupPath, backupV5, pgChangeLog}: BackupOptions,\n  stage: ReplicaStage,\n) {\n  const schema = upstreamSchema(shard);\n  const values: Partial<v.Infer<typeof fullReplicaRowSchema>> & {\n    version: string;\n  } = {\n    id,\n    slot,\n    epoch,\n    generation: replicaVersion,\n    // No longer read, but zero-cache 1.10 fails to start on a NULL \"version\",\n    // so it is still written for rollbacks to 1.10.\n    version: replicaVersion,\n    backupPath,\n    backupV5,\n    pgChangeLog,\n    stage,\n  };\n  await sql`INSERT INTO ${sql(schema)}.replicas ${sql(values)}`;\n}\n\n// Called in initial-sync to store the exact schema that was initially synced.\nexport async function initInitialSyncReplica(\n  sql: PostgresDB,\n  shard: ShardID,\n  id: string,\n  {tables, indexes}: PublishedSchema,\n  initialSyncContext: JSONObject,\n) {\n  const schema = upstreamSchema(shard);\n  const synced: PublishedSchema = {tables, indexes};\n  const values = {initialSchema: synced, initialSyncContext};\n  await sql`UPDATE ${sql(schema)}.replicas SET ${sql(values)} WHERE id = ${id}`;\n}\n\n// Called to initialize a Restore replica (`destID`) with the generation\n// and initial sync context of the `sourceID` replica.\nexport async function initRestoreReplica(\n  sql: PostgresDB,\n  shard: ShardID,\n  {sourceID, destID}: {sourceID: string; destID: string},\n): Promise<ReplicaState | null> {\n  const schema = upstreamSchema(shard);\n  await sql`\n    UPDATE ${sql(schema)}.replicas dest \n      SET \"generation\"         = source.\"generation\",\n          \"version\"            = source.\"generation\",\n          \"initialSchema\"      = source.\"initialSchema\",\n          \"initialSyncContext\" = source.\"initialSyncContext\"\n      FROM ${sql(schema)}.replicas source\n      WHERE source.id = ${sourceID} AND dest.id = ${destID};\n  `;\n  return getReplicaState(sql, shard, destID);\n}\n\n/**\n * Gets at the given version and optional ID. If no ID is specified, gets\n * the latest (i.e. highest rank) replica with that version.\n */\nexport async function getReplicaAtVersion(\n  lc: LogContext,\n  sql: PostgresDB,\n  shard: ShardID,\n  replicaVersion: string,\n  id: string | null = null,\n  context?: JSONObject,\n): Promise<Replica | null> {\n  const schema = sql(upstreamSchema(shard));\n  const result = await sql`\n    SELECT\n      replicas.\"id\",\n      replicas.\"rank\",\n      replicas.\"slot\",\n      replicas.\"epoch\",\n      replicas.\"generation\",\n      replicas.\"stage\",\n      replicas.\"backupPath\",\n      replicas.\"backupV5\",\n      replicas.\"pgChangeLog\",\n      replicas.\"initialSchema\",\n      replicas.\"initialSyncContext\",\n      replicas.\"subscriberContext\",\n      \"shardConfig\".\"publications\",\n      \"shardConfig\".\"ddlDetection\"\n    FROM ${schema}.replicas JOIN ${schema}.\"shardConfig\" ON true\n      WHERE generation = ${replicaVersion} AND \"initialSyncContext\" IS NOT NULL\n      AND id = COALESCE(${id}, id)\n      ORDER BY rank DESC LIMIT 1;\n  `;\n  if (result.length === 0) {\n    // log out all the replicas and the joined shardConfig\n    const allReplicas = await sql`\n      SELECT id, slot, generation, \"initialSyncContext\", \"subscriberContext\" \n        FROM ${schema}.replicas`;\n    lc.info?.(\n      `Replica ${id}@${replicaVersion}` +\n        (context ? `(context: ${stringify(context)}) ` : '') +\n        `not found in: ${stringify(allReplicas)}`,\n    );\n    return null;\n  }\n  return v.parse(result[0], replicaSchema, 'passthrough');\n}\n\nexport async function getActiveReplicas(\n  lc: LogContext,\n  sql: PostgresDB,\n  shard: ShardID,\n): Promise<ReplicaState[]> {\n  const schema = sql(upstreamSchema(shard));\n  const results = await sql`\n    SELECT\n      replicas.\"id\",\n      replicas.\"rank\",\n      replicas.\"slot\",\n      replicas.\"epoch\",\n      replicas.\"generation\",\n      replicas.\"stage\",\n      replicas.\"backupPath\",\n      replicas.\"backupV5\",\n      replicas.\"pgChangeLog\",\n      slots.\"active\",\n      slots.\"confirmed_flush_lsn\" as \"confirmedFlushLsn\"\n    FROM ${schema}.replicas JOIN pg_replication_slots slots ON slot = slot_name\n      WHERE \"initialSyncContext\" IS NOT NULL\n        -- Exclude replicas whose slot has been invalidated (e.g. for exceeding\n        -- max_slot_wal_keep_size). Such a replica can never be resumed, and\n        -- restoring it just results in an AutoResetSignal on every attempt.\n        AND slots.restart_lsn IS NOT NULL\n        AND slots.wal_status IS DISTINCT FROM 'lost'\n      ORDER BY generation DESC, confirmed_flush_lsn DESC;\n  `;\n  const replicas = v.parse(results, v.array(replicaStateSchema), 'passthrough');\n  lc.info?.(`current replicas`, {replicas});\n  return replicas;\n}\n\n/**\n * Returns candidates for restoring a new replica from. These include\n * all replicas in the newest `generation` of the given `epoch`, in order\n * of earliest available backup:\n * - An active InitialSync replica, which will be the only replica in\n *   its generation by definition. Orphaned/inactive initial syncs are skipped.\n * - Replicas in the Replicate stage, active first.\n * - Replicas in the Restore stage, potentially available for resumption\n *   as a last resort.\n */\nexport async function getRestoreCandidates(\n  sql: PostgresDB,\n  shard: ShardID,\n  epoch: number,\n): Promise<ReplicaState[]> {\n  const schema = sql(upstreamSchema(shard));\n  const results = await sql`\n    SELECT\n      replicas.\"id\",\n      replicas.\"rank\",\n      replicas.\"slot\",\n      replicas.\"epoch\",\n      replicas.\"generation\",\n      replicas.\"stage\",\n      replicas.\"backupPath\",\n      replicas.\"backupV5\",\n      replicas.\"pgChangeLog\",\n      slots.\"active\",\n      slots.\"confirmed_flush_lsn\" as \"confirmedFlushLsn\"\n    FROM ${schema}.replicas JOIN pg_replication_slots slots ON slot = slot_name\n\n      -- coalesce on the newest generation in the epoch\n      WHERE generation = (\n        SELECT MAX(r.generation)\n          FROM ${schema}.replicas r\n          JOIN pg_replication_slots s ON r.slot = s.slot_name\n         WHERE r.\"epoch\" = ${epoch} AND r.\"backupV5\"\n           -- ignore orphaned InitialSyncs, which cannot be restored from\n           AND (s.\"active\" OR r.\"stage\" != ${InitialSync})\n           AND s.restart_lsn IS NOT NULL\n           AND s.wal_status IS DISTINCT FROM 'lost'\n      )\n           AND \"epoch\" = ${epoch} AND \"backupV5\"\n           AND (slots.active OR \"stage\" != ${InitialSync})\n           AND slots.restart_lsn IS NOT NULL\n           AND slots.wal_status IS DISTINCT FROM 'lost'\n\n      ORDER BY \n        stage ASC,                 -- ordered by backup availalibility\n        active DESC,               -- prefer active slots (fork over resume)\n        confirmed_flush_lsn DESC;  -- prefer replicas further ahead\n  `;\n  return v.parse(results, v.array(replicaStateSchema), 'passthrough');\n}\n\nexport async function getReplicaState(\n  sql: PostgresDB,\n  shard: ShardID,\n  id: string,\n): Promise<ReplicaState | null> {\n  const schema = sql(upstreamSchema(shard));\n  const results = await sql`\n    SELECT\n      replicas.\"id\",\n      replicas.\"rank\",\n      replicas.\"slot\",\n      replicas.\"epoch\",\n      replicas.\"generation\",\n      replicas.\"stage\",\n      replicas.\"backupPath\",\n      replicas.\"backupV5\",\n      replicas.\"pgChangeLog\",\n      slots.\"active\",\n      slots.\"confirmed_flush_lsn\" as \"confirmedFlushLsn\"\n    FROM ${schema}.replicas JOIN pg_replication_slots slots ON slot = slot_name\n      WHERE \"id\" = ${id};\n  `;\n  return results.length\n    ? v.parse(results[0], replicaStateSchema, 'passthrough')\n    : null;\n}\n\nexport async function getInternalShardConfig(\n  sql: PostgresDB,\n  shard: ShardID,\n): Promise<InternalShardConfig> {\n  const result = await sql`\n    SELECT \"publications\", \"ddlDetection\"\n      FROM ${sql(upstreamSchema(shard))}.\"shardConfig\";\n  `;\n  assert(\n    result.length === 1,\n    () => `Expected exactly one shardConfig row, got ${result.length}`,\n  );\n  return v.parse(result[0], internalShardConfigSchema, 'passthrough');\n}\n\n/**\n * Sets up and returns all publications (including internal ones) for\n * the given shard.\n */\nexport async function setupTablesAndReplication(\n  lc: LogContext,\n  sql: PostgresTransaction,\n  requested: ShardConfig,\n  includePartialIndexes = true,\n) {\n  const {publications} = requested;\n  // Validate requested publications.\n  for (const pub of publications) {\n    validatePublicationName(pub);\n    if (pub.startsWith('_')) {\n      throw new Error(\n        `Publication names starting with \"_\" are reserved for internal use.\\n` +\n          `Please use a different name for publication \"${pub}\".`,\n      );\n    }\n  }\n  const allPublications: string[] = [];\n\n  // Setup application publications.\n  if (publications.length) {\n    const results = await sql<{pubname: string}[]>`\n    SELECT pubname from pg_publication WHERE pubname IN ${sql(\n      publications,\n    )}`.values();\n\n    if (results.length !== publications.length) {\n      throw new Error(\n        `Unknown or invalid publications. Specified: [${publications}]. Found: [${results.flat()}]`,\n      );\n    }\n    allPublications.push(...publications);\n  } else {\n    const defaultPublication = defaultPublicationName(\n      requested.appID,\n      requested.shardNum,\n    );\n    await sql`\n      DROP PUBLICATION IF EXISTS ${sql(defaultPublication)}`;\n    await sql`\n      CREATE PUBLICATION ${sql(defaultPublication)} \n        FOR TABLES IN SCHEMA public\n        WITH (publish_via_partition_root = true)`;\n    allPublications.push(defaultPublication);\n  }\n\n  const metadataPublication = metadataPublicationName(\n    requested.appID,\n    requested.shardNum,\n  );\n  allPublications.push(metadataPublication);\n\n  const shard = {...requested, publications: allPublications};\n\n  // Setup the global tables and shard tables / publications.\n  await sql.unsafe(globalSetup(shard) + shardSetup(shard, metadataPublication));\n\n  const pubs = await getPublicationInfo(sql, allPublications);\n  await replicaIdentitiesForTablesWithoutPrimaryKeys(pubs)?.apply(lc, sql);\n\n  await setupTriggers(lc, sql, shard, includePartialIndexes);\n}\n\nexport async function setupTriggers(\n  lc: LogContext,\n  tx: PostgresTransaction,\n  shard: ShardConfig,\n  includePartialIndexes = true,\n) {\n  const schema = upstreamSchema(shard);\n  const [{ddlDetection}] = await tx<InternalShardConfig[]> /*sql*/ `\n    SELECT \"ddlDetection\" FROM ${tx(schema)}.\"shardConfig\"`;\n\n  // The functions invoked by event triggers are installed even if\n  // event triggers are not supported/allowed by the db provider.\n  // This allows users to manually invoke the update_schemas() function\n  // as a workaround.\n  await tx.unsafe(createEventFunctionStatements(shard, includePartialIndexes));\n  try {\n    await tx.savepoint(sub => sub.unsafe(triggerSetup(shard)));\n  } catch (e) {\n    if (ddlDetection) {\n      // If ddlDetection has already been enabled, subsequent failures to\n      // upgrade the trigger should be propagated rather than swallowed.\n      throw e;\n    }\n    if (\n      !(\n        e instanceof postgres.PostgresError &&\n        e.code === PG_INSUFFICIENT_PRIVILEGE\n      )\n    ) {\n      throw e;\n    }\n    // If triggerSetup() fails, replication continues in ddlDetection=false mode.\n    lc.warn?.(\n      `Unable to create event triggers for schema change detection:\\n\\n` +\n        `\"${e.hint ?? e.message}\"\\n\\n` +\n        `Proceeding in degraded mode: schema changes will halt replication,\\n` +\n        `requiring the replica to be reset (manually or with --auto-reset).`,\n    );\n  }\n}\n\nexport function validatePublications(\n  lc: LogContext,\n  published: PublicationInfo,\n) {\n  // Verify that all publications export the proper events.\n  published.publications.forEach(pub => {\n    if (\n      !pub.pubinsert ||\n      !pub.pubupdate ||\n      !pub.pubdelete ||\n      !pub.pubtruncate\n    ) {\n      // TODO: Make APIError?\n      throw new Error(\n        `PUBLICATION ${pub.pubname} must publish insert, update, delete, and truncate`,\n      );\n    }\n  });\n\n  published.tables.forEach(table => validate(lc, table));\n}\n\ntype ReplicaIdentities = {\n  apply(lc: LogContext, db: PostgresDB): Promise<void>;\n};\n\nexport function replicaIdentitiesForTablesWithoutPrimaryKeys(\n  pubs: PublishedSchema,\n): ReplicaIdentities | undefined {\n  const replicaIdentities: {\n    schema: string;\n    tableName: string;\n    indexName: string;\n  }[] = [];\n  for (const table of pubs.tables) {\n    if (!table.primaryKey?.length && table.replicaIdentity === Default) {\n      // Look for an index that can serve as the REPLICA IDENTITY USING INDEX. It must be:\n      // - UNIQUE\n      // - NOT NULL columns\n      // - not deferrable (i.e. isImmediate)\n      // - not partial\n      //\n      // https://www.postgresql.org/docs/current/sql-altertable.html#SQL-ALTERTABLE-REPLICA-IDENTITY\n      const {schema, name: tableName} = table;\n      for (const {columns, name: indexName} of pubs.indexes.filter(\n        idx =>\n          idx.schema === schema &&\n          idx.tableName === tableName &&\n          idx.unique &&\n          idx.isImmediate &&\n          idx.predicate === undefined,\n      )) {\n        if (Object.keys(columns).some(col => !table.columns[col].notNull)) {\n          continue; // Only indexes with all NOT NULL columns are suitable.\n        }\n        replicaIdentities.push({schema, tableName, indexName});\n        break;\n      }\n    }\n  }\n\n  if (replicaIdentities.length === 0) {\n    return undefined;\n  }\n  return {\n    apply: async (lc: LogContext, sql: PostgresDB) => {\n      for (const {schema, tableName, indexName} of replicaIdentities) {\n        lc.info?.(\n          `setting \"${indexName}\" as the REPLICA IDENTITY for \"${tableName}\"`,\n        );\n        await sql`\n        ALTER TABLE ${sql(schema)}.${sql(tableName)} \n          REPLICA IDENTITY USING INDEX ${sql(indexName)}`;\n      }\n    },\n  };\n}\n"],"mappings":"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"}

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

@@ -21,6 +21,6 @@ var UnsupportedTableSchemaError = class extends Error {
 	}
 };
 //#endregion
-export { validate };
+export { UnsupportedTableSchemaError, validate };
 
 //# sourceMappingURL=validation.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"validation.js","names":[],"sources":["../../../../../../../../zero-cache/src/services/change-source/pg/schema/validation.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {\n  mapPostgresToLite,\n  warnIfDataTypeSupported,\n} from '../../../../db/pg-to-lite.ts';\nimport {\n  Default,\n  Index,\n  Nothing,\n} from '../../../../db/postgres-replica-identity-enum.ts';\nimport {ZERO_VERSION_COLUMN_NAME} from '../../../replicator/schema/constants.ts';\nimport type {PublishedTableWithReplicaIdentity} from './published.ts';\n\nexport const ALLOWED_APP_ID_CHARACTERS = /^[a-z0-9_]+$/;\n\nconst ALLOWED_TABLE_CHARS = /^[A-Za-z_]+[A-Za-z0-9_-]*$/;\n\n// Dots are allowed in column names since there is no need for\n// a schema/table delimiter when mapped to SQLite names.\nconst ALLOWED_COLUMN_CHARS = /^[A-Za-z_]+[.A-Za-z0-9_-]*$/;\n\nexport function validate(\n  lc: LogContext,\n  table: PublishedTableWithReplicaIdentity,\n) {\n  if (ZERO_VERSION_COLUMN_NAME in table.columns) {\n    throw new UnsupportedTableSchemaError(\n      `Table \"${table.name}\" uses reserved column name \"${ZERO_VERSION_COLUMN_NAME}\"`,\n    );\n  }\n  if (!table.primaryKey?.length && table.replicaIdentity === Default) {\n    lc.warn?.(\n      `\\n\\n\\n` +\n        `Table \"${table.name}\" needs a primary key in order to be synced to clients. ` +\n        `Add one with 'ALTER TABLE \"${table.name}\" ADD PRIMARY KEY (...)'.` +\n        `\\n\\n\\n`,\n    );\n  }\n  if (table.replicaIdentity === Nothing) {\n    throw new UnsupportedTableSchemaError(\n      `Table \"${table.name}\" with REPLICA IDENTITY NOTHING cannot be replicated`,\n    );\n  }\n  if (\n    table.replicaIdentity === Index &&\n    table.replicaIdentityColumns.length === 0\n  ) {\n    throw new UnsupportedTableSchemaError(\n      `Table \"${table.name}\" is missing its REPLICA IDENTITY INDEX`,\n    );\n  }\n  if (!ALLOWED_TABLE_CHARS.test(table.name)) {\n    throw new UnsupportedTableSchemaError(\n      `Table \"${table.name}\" has invalid characters.`,\n    );\n  }\n  for (const [col, spec] of Object.entries(mapPostgresToLite(table).columns)) {\n    if (!ALLOWED_COLUMN_CHARS.test(col)) {\n      throw new UnsupportedTableSchemaError(\n        `Column \"${col}\" in table \"${table.name}\" has invalid characters.`,\n      );\n    }\n    warnIfDataTypeSupported(lc, spec.dataType, table.name, col);\n  }\n}\n\nexport class UnsupportedTableSchemaError extends Error {\n  readonly name = 'UnsupportedTableSchemaError';\n\n  constructor(msg: string) {\n    super(msg);\n  }\n}\n"],"mappings":";;;AAeA,IAAM,sBAAsB;AAI5B,IAAM,uBAAuB;AAE7B,SAAgB,SACd,IACA,OACA;CACA,IAAA,gBAAgC,MAAM,SACpC,MAAM,IAAI,4BACR,UAAU,MAAM,KAAK,+BAA+B,yBAAyB,EAC/E;CAEF,IAAI,CAAC,MAAM,YAAY,UAAU,MAAM,oBAAA,KACrC,GAAG,OACD,gBACY,MAAM,KAAK,qFACS,MAAM,KAAK,gCAE7C;CAEF,IAAI,MAAM,oBAAA,KACR,MAAM,IAAI,4BACR,UAAU,MAAM,KAAK,qDACvB;CAEF,IACE,MAAM,oBAAA,OACN,MAAM,uBAAuB,WAAW,GAExC,MAAM,IAAI,4BACR,UAAU,MAAM,KAAK,wCACvB;CAEF,IAAI,CAAC,oBAAoB,KAAK,MAAM,IAAI,GACtC,MAAM,IAAI,4BACR,UAAU,MAAM,KAAK,0BACvB;CAEF,KAAK,MAAM,CAAC,KAAK,SAAS,OAAO,QAAQ,kBAAkB,KAAK,EAAE,OAAO,GAAG;EAC1E,IAAI,CAAC,qBAAqB,KAAK,GAAG,GAChC,MAAM,IAAI,4BACR,WAAW,IAAI,cAAc,MAAM,KAAK,0BAC1C;EAEF,wBAAwB,IAAI,KAAK,UAAU,MAAM,MAAM,GAAG;CAC5D;AACF;AAEA,IAAa,8BAAb,cAAiD,MAAM;CACrD,OAAgB;CAEhB,YAAY,KAAa;EACvB,MAAM,GAAG;CACX;AACF"}
+{"version":3,"file":"validation.js","names":[],"sources":["../../../../../../../../zero-cache/src/services/change-source/pg/schema/validation.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {\n  mapPostgresToLite,\n  warnIfDataTypeSupported,\n} from '../../../../db/pg-to-lite.ts';\nimport {\n  Default,\n  Index,\n  Nothing,\n} from '../../../../db/postgres-replica-identity-enum.ts';\nimport {ZERO_VERSION_COLUMN_NAME} from '../../../replicator/schema/constants.ts';\nimport type {PublishedTableWithReplicaIdentity} from './published.ts';\n\nexport const ALLOWED_APP_ID_CHARACTERS = /^[a-z0-9_]+$/;\n\nconst ALLOWED_TABLE_CHARS = /^[A-Za-z_]+[A-Za-z0-9_-]*$/;\n\n// Dots are allowed in column names since there is no need for\n// a schema/table delimiter when mapped to SQLite names.\nconst ALLOWED_COLUMN_CHARS = /^[A-Za-z_]+[.A-Za-z0-9_-]*$/;\n\nexport function validate(\n  lc: LogContext,\n  table: PublishedTableWithReplicaIdentity,\n) {\n  if (ZERO_VERSION_COLUMN_NAME in table.columns) {\n    throw new UnsupportedTableSchemaError(\n      `Table \"${table.name}\" uses reserved column name \"${ZERO_VERSION_COLUMN_NAME}\"`,\n    );\n  }\n  if (!table.primaryKey?.length && table.replicaIdentity === Default) {\n    lc.warn?.(\n      `\\n\\n\\n` +\n        `Table \"${table.name}\" needs a primary key in order to be synced to clients. ` +\n        `Add one with 'ALTER TABLE \"${table.name}\" ADD PRIMARY KEY (...)'.` +\n        `\\n\\n\\n`,\n    );\n  }\n  if (table.replicaIdentity === Nothing) {\n    throw new UnsupportedTableSchemaError(\n      `Table \"${table.name}\" with REPLICA IDENTITY NOTHING cannot be replicated`,\n    );\n  }\n  if (\n    table.replicaIdentity === Index &&\n    table.replicaIdentityColumns.length === 0\n  ) {\n    throw new UnsupportedTableSchemaError(\n      `Table \"${table.name}\" is missing its REPLICA IDENTITY INDEX`,\n    );\n  }\n  if (!ALLOWED_TABLE_CHARS.test(table.name)) {\n    throw new UnsupportedTableSchemaError(\n      `Table \"${table.name}\" has invalid characters.`,\n    );\n  }\n  for (const [col, spec] of Object.entries(mapPostgresToLite(table).columns)) {\n    if (!ALLOWED_COLUMN_CHARS.test(col)) {\n      throw new UnsupportedTableSchemaError(\n        `Column \"${col}\" in table \"${table.name}\" has invalid characters.`,\n      );\n    }\n    warnIfDataTypeSupported(lc, spec.dataType, table.name, col);\n  }\n}\n\nexport class UnsupportedTableSchemaError extends Error {\n  readonly name = 'UnsupportedTableSchemaError';\n\n  constructor(msg: string) {\n    super(msg);\n  }\n}\n"],"mappings":";;;AAeA,IAAM,sBAAsB;AAI5B,IAAM,uBAAuB;AAE7B,SAAgB,SACd,IACA,OACA;CACA,IAAA,gBAAgC,MAAM,SACpC,MAAM,IAAI,4BACR,UAAU,MAAM,KAAK,+BAA+B,yBAAyB,EAC/E;CAEF,IAAI,CAAC,MAAM,YAAY,UAAU,MAAM,oBAAA,KACrC,GAAG,OACD,gBACY,MAAM,KAAK,qFACS,MAAM,KAAK,gCAE7C;CAEF,IAAI,MAAM,oBAAA,KACR,MAAM,IAAI,4BACR,UAAU,MAAM,KAAK,qDACvB;CAEF,IACE,MAAM,oBAAA,OACN,MAAM,uBAAuB,WAAW,GAExC,MAAM,IAAI,4BACR,UAAU,MAAM,KAAK,wCACvB;CAEF,IAAI,CAAC,oBAAoB,KAAK,MAAM,IAAI,GACtC,MAAM,IAAI,4BACR,UAAU,MAAM,KAAK,0BACvB;CAEF,KAAK,MAAM,CAAC,KAAK,SAAS,OAAO,QAAQ,kBAAkB,KAAK,CAAC,CAAC,OAAO,GAAG;EAC1E,IAAI,CAAC,qBAAqB,KAAK,GAAG,GAChC,MAAM,IAAI,4BACR,WAAW,IAAI,cAAc,MAAM,KAAK,0BAC1C;EAEF,wBAAwB,IAAI,KAAK,UAAU,MAAM,MAAM,GAAG;CAC5D;AACF;AAEA,IAAa,8BAAb,cAAiD,MAAM;CACrD,OAAgB;CAEhB,YAAY,KAAa;EACvB,MAAM,GAAG;CACX;AACF"}

package/out/zero-cache/src/services/change-source/protocol/backfill-progress.js

@@ -136,6 +136,6 @@ function getSuperset(...requestSets) {
 	return [...merged.values()];
 }
 //#endregion
-export { acceptBackfill, covers, getSuperset, resumePoint, withResumePoint };
+export { acceptBackfill, covers, getSuperset, getTableSuperset, resumePoint, withResumePoint };
 
 //# sourceMappingURL=backfill-progress.js.map

package/out/zero-cache/src/services/change-source/protocol/backfill-progress.js.map

@@ -1 +1 @@
-{"version":3,"file":"backfill-progress.js","names":[],"sources":["../../../../../../../zero-cache/src/services/change-source/protocol/backfill-progress.ts"],"sourcesContent":["import {deepEqual} from '../../../../../shared/src/json.ts';\nimport type {\n  BackfillProgressMark,\n  BackfillRequest,\n  Identifier,\n} from './current.ts';\n\n/**\n * Whether two progress marks are on the same timeline, and are thus comparable.\n */\nfunction sameTimeline(a: BackfillProgressMark, b: BackfillProgressMark) {\n  return a.timeline === b.timeline;\n}\n\n/** Returns the earlier of two marks on the same timeline. */\nfunction earlier(\n  a: BackfillProgressMark,\n  b: BackfillProgressMark,\n): BackfillProgressMark {\n  return b.progressMark < a.progressMark ? b : a;\n}\n\n/** Returns the later of two marks on the same timeline. */\nfunction later(\n  a: BackfillProgressMark,\n  b: BackfillProgressMark,\n): BackfillProgressMark {\n  return b.progressMark > a.progressMark ? b : a;\n}\n\n/**\n * The result of applying a backfill message to a column's tracked progress.\n * If `accept` is true, `progress` is the column's new progress.\n */\nexport type AcceptResult =\n  | {accept: true; progress: BackfillProgressMark | undefined}\n  | {accept: false};\n\n/**\n * Applies the continuity policy of `backfill` (and `backfill-completed`)\n * messages to a column's `own` tracked progress, where `undefined` means that\n * the column has not received any backfill data (i.e. it needs a backfill\n * from scratch).\n *\n * * Messages without `progressMarks` are from pre-v8 replication-managers\n *   and are accepted unconditionally (i.e. the legacy behavior), with no\n *   change to the tracked progress.\n * * A message without a `previous` mark starts a backfill from scratch (or on\n *   a new timeline), and is always accepted.\n * * Otherwise, the message is only accepted if it is on the same timeline as\n *   `own`, and continues from a position at or before `own` (i.e. it does not\n *   create a gap).\n *\n * `current` is unset for `backfill-completed` messages, which do not advance\n * the progress.\n */\nexport function acceptBackfill(\n  own: BackfillProgressMark | undefined,\n  marks:\n    | {\n        previous?: BackfillProgressMark | undefined;\n        current?: BackfillProgressMark;\n      }\n    | undefined,\n): AcceptResult {\n  if (marks === undefined) {\n    return {accept: true, progress: own}; // legacy (pre-v8)\n  }\n  const {previous, current} = marks;\n  // Starting from scratch is always accepted, as there can be no gap.\n  if (previous === undefined) {\n    return {accept: true, progress: current};\n  }\n  if (\n    own === undefined ||\n    !sameTimeline(own, previous) ||\n    previous.progressMark > own.progressMark\n  ) {\n    return {accept: false};\n  }\n  return {\n    accept: true,\n    progress:\n      current === undefined\n        ? own\n        : sameTimeline(own, current)\n          ? later(own, current)\n          : current,\n  };\n}\n\n/**\n * Returns whether a stream whose progress (for a column) is at `stream`\n * will deliver all of the data needed by a subscriber whose progress (for the\n * same column) is at `subscriber`. A `stream` progress of `undefined` indicates\n * a backfill that will start from scratch, which covers all subscribers.\n */\nexport function covers(\n  stream: BackfillProgressMark | undefined,\n  subscriber: BackfillProgressMark | undefined,\n): boolean {\n  return (\n    stream === undefined ||\n    (subscriber !== undefined &&\n      sameTimeline(stream, subscriber) &&\n      stream.progressMark <= subscriber.progressMark)\n  );\n}\n\n/**\n * Returns the position from which a backfill for the `req` must start\n * in order to satisfy the progress of all of its columns, i.e. the earliest\n * progress mark, or `undefined` (i.e. from scratch) if any column has no\n * progress or if the columns are on different timelines.\n */\nexport function resumePoint(\n  req: BackfillRequest,\n): BackfillProgressMark | undefined {\n  let point: BackfillProgressMark | undefined;\n  for (const {progress} of Object.values(req.columns)) {\n    if (progress === undefined) {\n      return undefined;\n    }\n    if (point === undefined) {\n      point = progress;\n    } else if (!sameTimeline(point, progress)) {\n      return undefined;\n    } else {\n      point = earlier(point, progress);\n    }\n  }\n  return point;\n}\n\n/**\n * Returns a copy of the `req` with the progress of every column set to\n * the request's {@link resumePoint}, i.e. the position from which the\n * backfill of the request will actually start.\n */\nexport function withResumePoint(req: BackfillRequest): BackfillRequest {\n  const progress = resumePoint(req);\n  return {\n    table: req.table,\n    columns: Object.fromEntries(\n      Object.entries(req.columns).map(([col, {id}]) => [\n        col,\n        progress === undefined ? {id} : {id, progress},\n      ]),\n    ),\n  };\n}\n\n/**\n * Merges two BackfillRequests for the same table into one that satisfies\n * both. Both requests are expected to reflect the same (current) upstream\n * schema. For columns in both requests, the earlier progress mark is chosen,\n * or no progress mark (i.e. from scratch) if they are on different timelines.\n * If a column's backfill IDs differ (which is unexpected), the ID of `req1`\n * is chosen, and the column is backfilled from scratch.\n */\nexport function getTableSuperset(\n  req1: BackfillRequest,\n  req2: BackfillRequest,\n): BackfillRequest {\n  const columns = {...req1.columns};\n  for (const [name, col] of Object.entries(req2.columns)) {\n    const exists = columns[name];\n    if (!exists) {\n      columns[name] = col;\n      continue;\n    }\n    const {id, progress} = exists;\n    if (\n      progress === undefined ||\n      col.progress === undefined ||\n      !sameTimeline(progress, col.progress) ||\n      !deepEqual(id, col.id)\n    ) {\n      // Different timelines (or IDs). Start from scratch.\n      columns[name] = {id};\n    } else {\n      columns[name] = {id, progress: earlier(progress, col.progress)};\n    }\n  }\n  return {\n    table: {\n      ...req1.table,\n      metadata: req1.table.metadata ?? req2.table.metadata,\n    },\n    columns,\n  };\n}\n\nfunction tableKey({schema, name}: Identifier) {\n  return JSON.stringify([schema, name]);\n}\n\n/**\n * Merges the BackfillRequests of multiple parties (e.g. subscribers) into\n * one request per table, using {@link getTableSuperset}.\n */\nexport function getSuperset(\n  ...requestSets: Iterable<BackfillRequest>[]\n): BackfillRequest[] {\n  const merged = new Map<string, BackfillRequest>();\n  for (const requests of requestSets) {\n    for (const req of requests) {\n      const key = tableKey(req.table);\n      const existing = merged.get(key);\n      merged.set(key, existing ? getTableSuperset(existing, req) : req);\n    }\n  }\n  return [...merged.values()];\n}\n"],"mappings":"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"}
+{"version":3,"file":"backfill-progress.js","names":[],"sources":["../../../../../../../zero-cache/src/services/change-source/protocol/backfill-progress.ts"],"sourcesContent":["import {deepEqual} from '../../../../../shared/src/json.ts';\nimport type {\n  BackfillProgressMark,\n  BackfillRequest,\n  Identifier,\n} from './current.ts';\n\n/**\n * Whether two progress marks are on the same timeline, and are thus comparable.\n */\nfunction sameTimeline(a: BackfillProgressMark, b: BackfillProgressMark) {\n  return a.timeline === b.timeline;\n}\n\n/** Returns the earlier of two marks on the same timeline. */\nfunction earlier(\n  a: BackfillProgressMark,\n  b: BackfillProgressMark,\n): BackfillProgressMark {\n  return b.progressMark < a.progressMark ? b : a;\n}\n\n/** Returns the later of two marks on the same timeline. */\nfunction later(\n  a: BackfillProgressMark,\n  b: BackfillProgressMark,\n): BackfillProgressMark {\n  return b.progressMark > a.progressMark ? b : a;\n}\n\n/**\n * The result of applying a backfill message to a column's tracked progress.\n * If `accept` is true, `progress` is the column's new progress.\n */\nexport type AcceptResult =\n  | {accept: true; progress: BackfillProgressMark | undefined}\n  | {accept: false};\n\n/**\n * Applies the continuity policy of `backfill` (and `backfill-completed`)\n * messages to a column's `own` tracked progress, where `undefined` means that\n * the column has not received any backfill data (i.e. it needs a backfill\n * from scratch).\n *\n * * Messages without `progressMarks` are from pre-v8 replication-managers\n *   and are accepted unconditionally (i.e. the legacy behavior), with no\n *   change to the tracked progress.\n * * A message without a `previous` mark starts a backfill from scratch (or on\n *   a new timeline), and is always accepted.\n * * Otherwise, the message is only accepted if it is on the same timeline as\n *   `own`, and continues from a position at or before `own` (i.e. it does not\n *   create a gap).\n *\n * `current` is unset for `backfill-completed` messages, which do not advance\n * the progress.\n */\nexport function acceptBackfill(\n  own: BackfillProgressMark | undefined,\n  marks:\n    | {\n        previous?: BackfillProgressMark | undefined;\n        current?: BackfillProgressMark;\n      }\n    | undefined,\n): AcceptResult {\n  if (marks === undefined) {\n    return {accept: true, progress: own}; // legacy (pre-v8)\n  }\n  const {previous, current} = marks;\n  // Starting from scratch is always accepted, as there can be no gap.\n  if (previous === undefined) {\n    return {accept: true, progress: current};\n  }\n  if (\n    own === undefined ||\n    !sameTimeline(own, previous) ||\n    previous.progressMark > own.progressMark\n  ) {\n    return {accept: false};\n  }\n  return {\n    accept: true,\n    progress:\n      current === undefined\n        ? own\n        : sameTimeline(own, current)\n          ? later(own, current)\n          : current,\n  };\n}\n\n/**\n * Returns whether a stream whose progress (for a column) is at `stream`\n * will deliver all of the data needed by a subscriber whose progress (for the\n * same column) is at `subscriber`. A `stream` progress of `undefined` indicates\n * a backfill that will start from scratch, which covers all subscribers.\n */\nexport function covers(\n  stream: BackfillProgressMark | undefined,\n  subscriber: BackfillProgressMark | undefined,\n): boolean {\n  return (\n    stream === undefined ||\n    (subscriber !== undefined &&\n      sameTimeline(stream, subscriber) &&\n      stream.progressMark <= subscriber.progressMark)\n  );\n}\n\n/**\n * Returns the position from which a backfill for the `req` must start\n * in order to satisfy the progress of all of its columns, i.e. the earliest\n * progress mark, or `undefined` (i.e. from scratch) if any column has no\n * progress or if the columns are on different timelines.\n */\nexport function resumePoint(\n  req: BackfillRequest,\n): BackfillProgressMark | undefined {\n  let point: BackfillProgressMark | undefined;\n  for (const {progress} of Object.values(req.columns)) {\n    if (progress === undefined) {\n      return undefined;\n    }\n    if (point === undefined) {\n      point = progress;\n    } else if (!sameTimeline(point, progress)) {\n      return undefined;\n    } else {\n      point = earlier(point, progress);\n    }\n  }\n  return point;\n}\n\n/**\n * Returns a copy of the `req` with the progress of every column set to\n * the request's {@link resumePoint}, i.e. the position from which the\n * backfill of the request will actually start.\n */\nexport function withResumePoint(req: BackfillRequest): BackfillRequest {\n  const progress = resumePoint(req);\n  return {\n    table: req.table,\n    columns: Object.fromEntries(\n      Object.entries(req.columns).map(([col, {id}]) => [\n        col,\n        progress === undefined ? {id} : {id, progress},\n      ]),\n    ),\n  };\n}\n\n/**\n * Merges two BackfillRequests for the same table into one that satisfies\n * both. Both requests are expected to reflect the same (current) upstream\n * schema. For columns in both requests, the earlier progress mark is chosen,\n * or no progress mark (i.e. from scratch) if they are on different timelines.\n * If a column's backfill IDs differ (which is unexpected), the ID of `req1`\n * is chosen, and the column is backfilled from scratch.\n */\nexport function getTableSuperset(\n  req1: BackfillRequest,\n  req2: BackfillRequest,\n): BackfillRequest {\n  const columns = {...req1.columns};\n  for (const [name, col] of Object.entries(req2.columns)) {\n    const exists = columns[name];\n    if (!exists) {\n      columns[name] = col;\n      continue;\n    }\n    const {id, progress} = exists;\n    if (\n      progress === undefined ||\n      col.progress === undefined ||\n      !sameTimeline(progress, col.progress) ||\n      !deepEqual(id, col.id)\n    ) {\n      // Different timelines (or IDs). Start from scratch.\n      columns[name] = {id};\n    } else {\n      columns[name] = {id, progress: earlier(progress, col.progress)};\n    }\n  }\n  return {\n    table: {\n      ...req1.table,\n      metadata: req1.table.metadata ?? req2.table.metadata,\n    },\n    columns,\n  };\n}\n\nfunction tableKey({schema, name}: Identifier) {\n  return JSON.stringify([schema, name]);\n}\n\n/**\n * Merges the BackfillRequests of multiple parties (e.g. subscribers) into\n * one request per table, using {@link getTableSuperset}.\n */\nexport function getSuperset(\n  ...requestSets: Iterable<BackfillRequest>[]\n): BackfillRequest[] {\n  const merged = new Map<string, BackfillRequest>();\n  for (const requests of requestSets) {\n    for (const req of requests) {\n      const key = tableKey(req.table);\n      const existing = merged.get(key);\n      merged.set(key, existing ? getTableSuperset(existing, req) : req);\n    }\n  }\n  return [...merged.values()];\n}\n"],"mappings":";;;;;AAUA,SAAS,aAAa,GAAyB,GAAyB;CACtE,OAAO,EAAE,aAAa,EAAE;AAC1B;;AAGA,SAAS,QACP,GACA,GACsB;CACtB,OAAO,EAAE,eAAe,EAAE,eAAe,IAAI;AAC/C;;AAGA,SAAS,MACP,GACA,GACsB;CACtB,OAAO,EAAE,eAAe,EAAE,eAAe,IAAI;AAC/C;;;;;;;;;;;;;;;;;;;AA4BA,SAAgB,eACd,KACA,OAMc;CACd,IAAI,UAAU,KAAA,GACZ,OAAO;EAAC,QAAQ;EAAM,UAAU;CAAG;CAErC,MAAM,EAAC,UAAU,YAAW;CAE5B,IAAI,aAAa,KAAA,GACf,OAAO;EAAC,QAAQ;EAAM,UAAU;CAAO;CAEzC,IACE,QAAQ,KAAA,KACR,CAAC,aAAa,KAAK,QAAQ,KAC3B,SAAS,eAAe,IAAI,cAE5B,OAAO,EAAC,QAAQ,MAAK;CAEvB,OAAO;EACL,QAAQ;EACR,UACE,YAAY,KAAA,IACR,MACA,aAAa,KAAK,OAAO,IACvB,MAAM,KAAK,OAAO,IAClB;CACV;AACF;;;;;;;AAQA,SAAgB,OACd,QACA,YACS;CACT,OACE,WAAW,KAAA,KACV,eAAe,KAAA,KACd,aAAa,QAAQ,UAAU,KAC/B,OAAO,gBAAgB,WAAW;AAExC;;;;;;;AAQA,SAAgB,YACd,KACkC;CAClC,IAAI;CACJ,KAAK,MAAM,EAAC,cAAa,OAAO,OAAO,IAAI,OAAO,GAAG;EACnD,IAAI,aAAa,KAAA,GACf;EAEF,IAAI,UAAU,KAAA,GACZ,QAAQ;OACH,IAAI,CAAC,aAAa,OAAO,QAAQ,GACtC;OAEA,QAAQ,QAAQ,OAAO,QAAQ;CAEnC;CACA,OAAO;AACT;;;;;;AAOA,SAAgB,gBAAgB,KAAuC;CACrE,MAAM,WAAW,YAAY,GAAG;CAChC,OAAO;EACL,OAAO,IAAI;EACX,SAAS,OAAO,YACd,OAAO,QAAQ,IAAI,OAAO,CAAC,CAAC,KAAK,CAAC,KAAK,EAAC,UAAS,CAC/C,KACA,aAAa,KAAA,IAAY,EAAC,GAAE,IAAI;GAAC;GAAI;EAAQ,CAC/C,CAAC,CACH;CACF;AACF;;;;;;;;;AAUA,SAAgB,iBACd,MACA,MACiB;CACjB,MAAM,UAAU,EAAC,GAAG,KAAK,QAAO;CAChC,KAAK,MAAM,CAAC,MAAM,QAAQ,OAAO,QAAQ,KAAK,OAAO,GAAG;EACtD,MAAM,SAAS,QAAQ;EACvB,IAAI,CAAC,QAAQ;GACX,QAAQ,QAAQ;GAChB;EACF;EACA,MAAM,EAAC,IAAI,aAAY;EACvB,IACE,aAAa,KAAA,KACb,IAAI,aAAa,KAAA,KACjB,CAAC,aAAa,UAAU,IAAI,QAAQ,KACpC,CAAC,UAAU,IAAI,IAAI,EAAE,GAGrB,QAAQ,QAAQ,EAAC,GAAE;OAEnB,QAAQ,QAAQ;GAAC;GAAI,UAAU,QAAQ,UAAU,IAAI,QAAQ;EAAC;CAElE;CACA,OAAO;EACL,OAAO;GACL,GAAG,KAAK;GACR,UAAU,KAAK,MAAM,YAAY,KAAK,MAAM;EAC9C;EACA;CACF;AACF;AAEA,SAAS,SAAS,EAAC,QAAQ,QAAmB;CAC5C,OAAO,KAAK,UAAU,CAAC,QAAQ,IAAI,CAAC;AACtC;;;;;AAMA,SAAgB,YACd,GAAG,aACgB;CACnB,MAAM,yBAAS,IAAI,IAA6B;CAChD,KAAK,MAAM,YAAY,aACrB,KAAK,MAAM,OAAO,UAAU;EAC1B,MAAM,MAAM,SAAS,IAAI,KAAK;EAC9B,MAAM,WAAW,OAAO,IAAI,GAAG;EAC/B,OAAO,IAAI,KAAK,WAAW,iBAAiB,UAAU,GAAG,IAAI,GAAG;CAClE;CAEF,OAAO,CAAC,GAAG,OAAO,OAAO,CAAC;AAC5B"}

package/out/zero-cache/src/services/change-source/protocol/current/control.js.map

@@ -1 +1 @@
-{"version":3,"file":"control.js","names":[],"sources":["../../../../../../../../zero-cache/src/services/change-source/protocol/current/control.ts"],"sourcesContent":["/**\n * Control plane messages communicate non-content related signals between a\n * ChangeSource and ChangeStreamer. These are not forwarded to subscribers\n * of the ChangeStreamer.\n */\nimport * as v from '../../../../../../shared/src/valita.ts';\nimport {jsonObjectSchema} from './json.ts';\n\n/**\n * Indicates that replication cannot continue and that the replica must be resynced\n * from scratch. The replication-manager will shutdown in response to this message,\n * and upon being restarted, it will wipe the current replica and resync if the\n * `--auto-reset` option is specified.\n *\n * This signal should only be used in well advertised scenarios, and is not suitable\n * as a common occurrence in production.\n */\nexport const resetRequiredSchema = v.object({\n  tag: v.literal('reset-required'),\n  message: v.string().optional(),\n\n  // errorDetails can contain any standard JSON object. This will be\n  // published in the `errorDetails` field of a replication ERROR event.\n  errorDetails: jsonObjectSchema.optional(),\n});\n"],"mappings":";;;;;;;;;;;;;;;;;AAiBA,IAAa,sBAAsB,eAAE,OAAO;CAC1C,KAAK,eAAE,QAAQ,gBAAgB;CAC/B,SAAS,eAAE,OAAO,EAAE,SAAS;CAI7B,cAAc,iBAAiB,SAAS;AAC1C,CAAC"}
+{"version":3,"file":"control.js","names":["v"],"sources":["../../../../../../../../zero-cache/src/services/change-source/protocol/current/control.ts"],"sourcesContent":["/**\n * Control plane messages communicate non-content related signals between a\n * ChangeSource and ChangeStreamer. These are not forwarded to subscribers\n * of the ChangeStreamer.\n */\nimport * as v from '../../../../../../shared/src/valita.ts';\nimport {jsonObjectSchema} from './json.ts';\n\n/**\n * Indicates that replication cannot continue and that the replica must be resynced\n * from scratch. The replication-manager will shutdown in response to this message,\n * and upon being restarted, it will wipe the current replica and resync if the\n * `--auto-reset` option is specified.\n *\n * This signal should only be used in well advertised scenarios, and is not suitable\n * as a common occurrence in production.\n */\nexport const resetRequiredSchema = v.object({\n  tag: v.literal('reset-required'),\n  message: v.string().optional(),\n\n  // errorDetails can contain any standard JSON object. This will be\n  // published in the `errorDetails` field of a replication ERROR event.\n  errorDetails: jsonObjectSchema.optional(),\n});\n"],"mappings":";;;;;;;;;;;;;;;;;AAiBA,IAAa,sBAAsBA,eAAE,OAAO;CAC1C,KAAKA,eAAE,QAAQ,gBAAgB;CAC/B,SAASA,eAAE,OAAO,CAAC,CAAC,SAAS;CAI7B,cAAc,iBAAiB,SAAS;AAC1C,CAAC"}