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

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(\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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"}
+{"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.js

@@ -2,8 +2,8 @@ import { assert } from "../../../../../../shared/src/asserts.js";
 import { parse, valita_exports } from "../../../../../../shared/src/valita.js";
 import { jsonObjectSchema, stringify } from "../../../../../../shared/src/bigint-json.js";
 import { appSchema, check, upstreamSchema } from "../../../../types/shards.js";
-import { id } from "../../../../types/sql.js";
 import { getPublicationInfo, publishedSchema } from "./published.js";
+import { id } from "../../../../types/sql.js";
 import { createEventFunctionStatements, createEventTriggerStatements } from "./ddl.js";
 import { replicaStageSchema } from "./replica-stage-enum.js";
 import { validate } from "./validation.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`
@@ -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  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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"}
+{"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.d.ts

@@ -1,6 +1,5 @@
 import type { LogContext } from '@rocicorp/logger';
 import type { PublishedTableWithReplicaIdentity } from './published.ts';
-export declare const ALLOWED_APP_ID_CHARACTERS: RegExp;
 export declare function validate(lc: LogContext, table: PublishedTableWithReplicaIdentity): void;
 export declare class UnsupportedTableSchemaError extends Error {
     readonly name = "UnsupportedTableSchemaError";

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

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../../../../../../zero-cache/src/services/change-source/pg/schema/validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAWjD,OAAO,KAAK,EAAC,iCAAiC,EAAC,MAAM,gBAAgB,CAAC;AAEtE,eAAO,MAAM,yBAAyB,QAAiB,CAAC;AAQxD,wBAAgB,QAAQ,CACtB,EAAE,EAAE,UAAU,EACd,KAAK,EAAE,iCAAiC,QAyCzC;AAED,qBAAa,2BAA4B,SAAQ,KAAK;IACpD,QAAQ,CAAC,IAAI,iCAAiC;IAE9C,YAAY,GAAG,EAAE,MAAM,EAEtB;CACF"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../../../../../../zero-cache/src/services/change-source/pg/schema/validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAWjD,OAAO,KAAK,EAAC,iCAAiC,EAAC,MAAM,gBAAgB,CAAC;AAQtE,wBAAgB,QAAQ,CACtB,EAAE,EAAE,UAAU,EACd,KAAK,EAAE,iCAAiC,QAyCzC;AAED,qBAAa,2BAA4B,SAAQ,KAAK;IACpD,QAAQ,CAAC,IAAI,iCAAiC;IAE9C,YAAY,GAAG,EAAE,MAAM,EAEtB;CACF"}

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\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":";;;AAaA,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":"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"}

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"}

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

@@ -1 +1 @@
-{"version":3,"file":"data.js","names":[],"sources":["../../../../../../../../zero-cache/src/services/change-source/protocol/current/data.ts"],"sourcesContent":["/**\n * Data plane messages encapsulate changes that are sent by ChangeSources,\n * forwarded / fanned out to subscribers by the ChangeStreamerService, and\n * stored in the Change DB for catchup of old subscribers.\n */\n\nimport {\n  jsonValueSchema,\n  type JSONObject,\n} from '../../../../../../shared/src/bigint-json.ts';\nimport {must} from '../../../../../../shared/src/must.ts';\nimport * as v from '../../../../../../shared/src/valita.ts';\nimport {columnSpec, indexSpec, tableSpec} from '../../../../db/specs.ts';\nimport type {Satisfies} from '../../../../types/satisfies.ts';\nimport {jsonObjectSchema} from './json.ts';\nimport {schemaChangeTags} from './schema-change-tags.ts';\n\nexport const beginSchema = v.object({\n  tag: v.literal('begin'),\n  // The format of values of \"json\"-typed columns (e.g. \"JSON\" and \"JSONB\").\n  // - 'p' is for parsed JSON, which may include JSON values or JSON objects.\n  //   These values are parsed and stringified at every process boundary\n  //   between the change-source and the replica.\n  // - 's' is for stringified JSON. These values skip the parsing and\n  //   stringification, and are directly ferried to the replica as a JSON\n  //   string. For JSON values this improves performance by 20~25% in the\n  //   change-streamer and 25~30% in the replicator.\n  //\n  // If absent, the format is assumed to be 'p' (parsed JSON objects/values).\n  json: v.literalUnion('p', 's').optional(),\n\n  // Directs the change-streamer to skip the ACK for the corresponding commit.\n  skipAck: v.boolean().optional(),\n});\n\nexport const commitSchema = v.object({\n  tag: v.literal('commit'),\n\n  // Millisecond epoch at which the transaction committed upstream, as reported\n  // by the upstream database (e.g. the `commitTime` of the Postgres logical\n  // replication Commit message).\n  //\n  // This is the origin timestamp of the end-to-end serving lag measurement:\n  // it is carried through the replication stream to the ViewSyncer, which\n  // records `now - commitTimeMs` once the change has been poked to clients.\n  //\n  // Optional because it is absent from changes written to the Change DB by\n  // older versions, which are replayed verbatim during catchup, and from\n  // ChangeSources that do not report a commit time.\n  commitTimeMs: v.number().optional(),\n});\n\nexport const rollbackSchema = v.object({\n  tag: v.literal('rollback'),\n});\n\nconst rowKeySchema = v.object({\n  // The columns used to identify a row in insert, update, and delete changes.\n  columns: v.array(v.string()),\n\n  // An optional qualifier identifying how the key is chosen. Currently this\n  // is postgres-specific, describing the REPLICA IDENTITY, for which replica\n  // identity 'full' (FULL) is handled differently; the replicator handles\n  // these tables by extracting a row key from the full row based on the\n  // table's PRIMARY KEY or UNIQUE INDEX.\n  type: v.literalUnion('default', 'nothing', 'full', 'index').optional(),\n});\n\nexport const relationSchema = v\n  .object({\n    schema: v.string(),\n    name: v.string(),\n\n    // This will become required.\n    rowKey: rowKeySchema.optional(),\n\n    /** Deprecated: set the rowKey.columns instead. */\n    keyColumns: v.array(v.string()).optional(),\n    /** Deprecated: set the rowKey.columns instead. */\n    replicaIdentity: v\n      .literalUnion('default', 'nothing', 'full', 'index')\n      .optional(),\n  })\n  .map(rel => {\n    const {rowKey, ...rest} = rel;\n    if (rowKey) {\n      return {...rest, rowKey};\n    }\n    return {\n      ...rest,\n      rowKey: {\n        columns: must(rel.keyColumns),\n        type: rel.replicaIdentity,\n      },\n    };\n  });\n\n// The eventual fate of relationSchema\nexport const newRelationSchema = v.object({\n  schema: v.string(),\n  name: v.string(),\n\n  rowKey: rowKeySchema,\n});\n\n// TableMetadata contains table-related configuration that does not affect the\n// actual data in the table, but rather how the table's change messages are\n// handled. The is an opaque object that clients must track (and update) based\n// on `create-table`, `add-column`, and `table-update-metadata` messages, and\n// pass in BackfillRequests when there are columns to be backfilled.\n//\n// Note that the backfill-related change-source implementation does, however,\n// rely on the rowKey (columns) being specified in the message.\nexport const tableMetadataSchema = v\n  .object({rowKey: v.record(jsonValueSchema)})\n  .rest(jsonValueSchema);\n\nexport type TableMetadata = v.Infer<typeof tableMetadataSchema>;\n\nexport const rowSchema = v.record(jsonValueSchema);\n\nexport const insertSchema = v.object({\n  tag: v.literal('insert'),\n  relation: relationSchema,\n  new: rowSchema,\n});\n\nexport const updateSchema = v.object({\n  tag: v.literal('update'),\n  relation: relationSchema,\n  // `key` is present if the update changed the key of the row, or if the\n  // table's replicaIdentity === 'full'\n  key: rowSchema.nullable(),\n  // `new` is the full row (and not just the updated columns). This is\n  // necessary for \"catchup\" replication scenarios such as adding tables\n  // to a publication, or resharding.\n  new: rowSchema,\n});\n\nexport const deleteSchema = v.object({\n  tag: v.literal('delete'),\n  relation: relationSchema,\n  // key is the full row if replicaIdentity === 'full'\n  key: rowSchema,\n});\n\nexport const truncateSchema = v.object({\n  tag: v.literal('truncate'),\n  relations: v.array(relationSchema),\n});\n\nexport const identifierSchema = v.object({\n  schema: v.string(),\n  name: v.string(),\n});\n\nexport type Identifier = v.Infer<typeof identifierSchema>;\n\n// A BackfillID is an upstream specific stable identifier for a column\n// that needs backfilling. This id is used to ensure that the schema, table,\n// and column names of a requested backfill still match the original\n// underlying upstream ID.\n//\n// The change-streamer stores these IDs as opaque values while a column is\n// being backfilled, and initiates new change-source streams with the IDs\n// in order to restart backfills that did not complete in previous sessions.\nexport const backfillIDSchema = jsonObjectSchema;\n\nexport type BackfillID = v.Infer<typeof backfillIDSchema>;\n\nexport const backfillProgressMarkSchema = v\n  .object({\n    // A lexicographically sortable string delineating the progress of a\n    // backfill. This is used to resume a backfill that did not complete.\n    progressMark: v.string(),\n\n    // Optionally, a timeline with which the progressMark is associated.\n    // A timeline is an opaque string that determines if backfill streams\n    // are \"compatible\" with each other, i.e. can be merged in a way that\n    // avoids gaps. progressMarks from different timelines are not\n    // compatible. If two timelines differ, a new backfill is started\n    // from scratch in order to get all subscribers on the same timeline.\n    //\n    // Timeline changes should be rare events (e.g. Postgres VACUUM FULL).\n    timeline: v.string().optional(),\n  })\n  // All other fields should be preserved and returned in BackfillRequests.\n  .rest(v.union(v.number(), v.string()));\n\nexport type BackfillProgressMark = v.Infer<typeof backfillProgressMarkSchema>;\n\nexport const createTableSchema = v.object({\n  tag: v.literal('create-table'),\n  spec: tableSpec,\n\n  // This must be set by change source implementations that support\n  // table/column backfill.\n  //\n  // TODO: to simplify the protocol, see if we can make this required\n  metadata: tableMetadataSchema.optional(),\n\n  // Indicate that columns of the table require backfilling. These columns\n  // should be created on the replica but not yet synced the clients.\n  //\n  // ## State Persistence\n  //\n  // To obviate the need for change-source implementations to persist state\n  // related to backfill progress, the change-source only tracks backfills\n  // **for the current session**. In the event that the session is interrupted\n  // before columns have been fully backfilled, it is the responsibility of the\n  // change-streamer to send {@link BackfillRequest}s when it reconnects.\n  //\n  // This means that the change-streamer must track and persist:\n  // * the backfill IDs of the columns requiring backfilling\n  // * the most current table metadata of the associated table(s)\n  //\n  // The change-streamer then uses this information to send backfill requests\n  // when it reconnects.\n  backfill: v.record(backfillIDSchema).optional(),\n});\n\nexport const renameTableSchema = v.object({\n  tag: v.literal('rename-table'),\n  old: identifierSchema,\n  new: identifierSchema,\n});\n\nexport const updateTableMetadataSchema = v.object({\n  tag: v.literal('update-table-metadata'),\n  table: identifierSchema,\n  old: tableMetadataSchema,\n  new: tableMetadataSchema,\n});\n\nconst columnSchema = v.object({\n  name: v.string(),\n  spec: columnSpec,\n});\n\nexport const addColumnSchema = v.object({\n  tag: v.literal('add-column'),\n  table: identifierSchema,\n  column: columnSchema,\n\n  // This must be set by change source implementations that support\n  // table/column backfill.\n  //\n  // TODO: to simplify the protocol, see if we can make this required\n  tableMetadata: tableMetadataSchema.optional(),\n\n  // See documentation for the `backfill` field of the `create-table` change.\n  backfill: backfillIDSchema.optional(),\n});\n\nexport const updateColumnSchema = v.object({\n  tag: v.literal('update-column'),\n  table: identifierSchema,\n  old: columnSchema,\n  new: columnSchema,\n});\n\nexport const dropColumnSchema = v.object({\n  tag: v.literal('drop-column'),\n  table: identifierSchema,\n  column: v.string(),\n});\n\nexport const dropTableSchema = v.object({\n  tag: v.literal('drop-table'),\n  id: identifierSchema,\n});\n\nexport const createIndexSchema = v.object({\n  tag: v.literal('create-index'),\n  spec: indexSpec,\n});\n\nexport const dropIndexSchema = v.object({\n  tag: v.literal('drop-index'),\n  id: identifierSchema,\n});\n\nexport const downloadStatusSchema = v.object({\n  rows: v.number(),\n  totalRows: v.number(),\n  totalBytes: v.number().optional(),\n});\n\nexport type DownloadStatus = v.Infer<typeof downloadStatusSchema>;\n\n// A batch of rows from a single table containing column values\n// to be backfilled.\nexport const backfillSchema = v.object({\n  tag: v.literal('backfill'),\n\n  relation: newRelationSchema,\n\n  // The columns to be backfilled. `rowKey` columns are automatically excluded,\n  // which means that this field may be empty.\n  columns: v.array(v.string()),\n\n  // The watermark at which the backfill data was queried. Note that this\n  // generally will be different from the commit watermarks of the main change\n  // stream, and in particular, the commit watermark of the backfill change's\n  // enclosing transaction.\n  watermark: v.string(),\n\n  // A batch of row values, each row consisting of the `rowKey`\n  // values, followed by the `column` values, in the same order in which\n  // the column names appear in their respective fields, e.g.\n  //\n  // ```\n  // [\n  //   [...rowKeyValues, ...columnValues],  // row 1\n  //   [...rowKeyValues, ...columnValues],  // row 2\n  // ]\n  // ```\n  rowValues: v.array(v.array(jsonValueSchema)),\n\n  // Progress marks indicating the position of this backfill message\n  // within the stream, for resumption / continuity enforcement.\n  //\n  // This should be considered non-optional as of protocol v8. It is only\n  // absent in messages from pre-v8 replication-managers (including messages\n  // persisted in a change-log by one), in which case subscribers accept the\n  // message unconditionally (i.e. the legacy behavior).\n  progressMarks: v\n    .object({\n      // The progress mark of the preceding backfill message, from which\n      // the current backfill message is a continuation. (This may be a\n      // \"logical\" continuation at which a new backfill stream is started when\n      // resuming from a previous stream.)\n      //\n      // For the first backfill message of a stream starting from scratch,\n      // this field is unset. When the field is unset, subscribers should\n      // accept the backfill message unconditionally (i.e. starting a\n      // backfill from scratch is always safe).\n      //\n      // If the field is set, subscribers should only accept the message if\n      // it is of the same timeline as that of its own tracked progressMark,\n      // and is contiguous with or earlier than its own progressMark.\n      //\n      // In other words, it should _ignore_ backfill messages from other\n      // timelines, or messages that create a gap; this can happen when\n      // receiving messages from before this subscriber's backfill requests\n      // are taken into account.\n      //\n      // Implementation note: The change-streamer applies this same policy\n      // (see `acceptBackfill()` in `protocol/backfill-progress.ts`) to track\n      // the backfill state of each subscriber, which it uses to determine the\n      // BackfillRequests with which to (re)start change streams.\n      previous: backfillProgressMarkSchema.optional(),\n\n      // The progressMark delineating the position of the last row in this\n      // message. In the steady state, this will be the `previous`\n      // progressMark of the next backfill message, unless a rewind is\n      // requested, or new timeline encountered.\n      current: backfillProgressMarkSchema,\n    })\n    .optional(),\n\n  // Optionally includes the progress of the backfill operation,\n  // for display purposes.\n  status: downloadStatusSchema.optional(),\n});\n\n// Indicates that the backfill for the specified columns have\n// been successfully backfilled and can be published to clients.\nexport const backfillCompletedSchema = v.object({\n  tag: v.literal('backfill-completed'),\n\n  relation: newRelationSchema,\n\n  // The columns to be backfilled. `rowKey` columns are automatically excluded,\n  // which means that this field may be empty.\n  columns: v.array(v.string()),\n\n  // The watermark at which the backfill data was queried. Note that this\n  // generally will be different from the commit watermarks of the main change\n  // stream, and in particular, the commit watermark of the backfill change's\n  // enclosing transaction.\n  watermark: v.string(),\n\n  // The progress mark of the last backfill message of the run, i.e. the\n  // `current` progressMark of the last `backfill` message, or the progressMark\n  // from which the run was resumed if it produced no `backfill` messages.\n  // Subscribers apply the same continuity policy as for `backfill` messages,\n  // and only consider the columns backfilled if the run is contiguous with\n  // their own progress.\n  //\n  // `previous` is only unset for a run that started from scratch and\n  // produced no rows (e.g. an empty table), which is always safe to accept.\n  //\n  // This should be considered non-optional as of protocol v8. It is only\n  // absent in messages from pre-v8 replication-managers, in which case\n  // subscribers accept the message unconditionally (i.e. legacy behavior).\n  progressMarks: v\n    .object({previous: backfillProgressMarkSchema.optional()})\n    .optional(),\n\n  // Optionally includes the final status of the backfill operation,\n  // for display purposes.\n  status: downloadStatusSchema.optional(),\n});\n\nexport type MessageBegin = v.Infer<typeof beginSchema>;\nexport type MessageCommit = v.Infer<typeof commitSchema>;\nexport type MessageRollback = v.Infer<typeof rollbackSchema>;\n\nexport type MessageRelation = v.Infer<typeof relationSchema>;\nexport type MessageInsert = v.Infer<typeof insertSchema>;\nexport type MessageUpdate = v.Infer<typeof updateSchema>;\nexport type MessageDelete = v.Infer<typeof deleteSchema>;\nexport type MessageTruncate = v.Infer<typeof truncateSchema>;\n\nexport type MessageBackfill = v.Infer<typeof backfillSchema>;\n\nexport type TableCreate = v.Infer<typeof createTableSchema>;\nexport type TableRename = v.Infer<typeof renameTableSchema>;\nexport type TableUpdateMetadata = v.Infer<typeof updateTableMetadataSchema>;\nexport type ColumnAdd = v.Infer<typeof addColumnSchema>;\nexport type ColumnUpdate = v.Infer<typeof updateColumnSchema>;\nexport type ColumnDrop = v.Infer<typeof dropColumnSchema>;\nexport type TableDrop = v.Infer<typeof dropTableSchema>;\nexport type IndexCreate = v.Infer<typeof createIndexSchema>;\nexport type IndexDrop = v.Infer<typeof dropIndexSchema>;\nexport type BackfillCompleted = v.Infer<typeof backfillCompletedSchema>;\n\nexport const dataChangeSchema = v.union(\n  insertSchema,\n  updateSchema,\n  deleteSchema,\n  truncateSchema,\n  backfillSchema,\n);\n\n// Note: keep in sync or the tag tests will fail\nconst dataChangeTags = [\n  'insert',\n  'update',\n  'delete',\n  'truncate',\n  'backfill',\n] as const;\n\nconst dataChangeTagsSchema = v.literalUnion(...dataChangeTags);\n\nexport type DataChange = Satisfies<\n  JSONObject, // guarantees serialization over IPC or network\n  v.Infer<typeof dataChangeSchema>\n>;\n\nexport type DataChangeTag = v.Infer<typeof dataChangeTagsSchema>;\n\nconst schemaChanges = [\n  createTableSchema,\n  renameTableSchema,\n  updateTableMetadataSchema,\n  addColumnSchema,\n  updateColumnSchema,\n  dropColumnSchema,\n  dropTableSchema,\n  createIndexSchema,\n  dropIndexSchema,\n  backfillCompletedSchema,\n] as const;\n\nexport const schemaChangeSchema = v.union(...schemaChanges);\n\nconst schemaChangeTagsSchema = v.literalUnion(...schemaChangeTags);\n\nexport type SchemaChange = Satisfies<\n  JSONObject,\n  v.Infer<typeof schemaChangeSchema>\n>;\n\nexport type SchemaChangeTag = v.Infer<typeof schemaChangeTagsSchema>;\n\nexport type DataOrSchemaChange = DataChange | SchemaChange;\n\nexport type Change =\n  | MessageBegin\n  | DataOrSchemaChange\n  | MessageCommit\n  | MessageRollback;\n\nexport type ChangeTag = Change['tag'];\n\nconst schemaChangeTagSet = new Set<string>(schemaChangeTags);\n\nexport function isSchemaChange(change: Change): change is SchemaChange {\n  return schemaChangeTagSet.has(change.tag);\n}\n\nconst dataChangeTagSet = new Set<string>(dataChangeTags);\n\nexport function isDataChange(change: Change): change is DataChange {\n  return dataChangeTagSet.has(change.tag);\n}\n"],"mappings":"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"}
+{"version":3,"file":"data.js","names":["v","v.literalUnion"],"sources":["../../../../../../../../zero-cache/src/services/change-source/protocol/current/data.ts"],"sourcesContent":["/**\n * Data plane messages encapsulate changes that are sent by ChangeSources,\n * forwarded / fanned out to subscribers by the ChangeStreamerService, and\n * stored in the Change DB for catchup of old subscribers.\n */\n\nimport {\n  jsonValueSchema,\n  type JSONObject,\n} from '../../../../../../shared/src/bigint-json.ts';\nimport {must} from '../../../../../../shared/src/must.ts';\nimport * as v from '../../../../../../shared/src/valita.ts';\nimport {columnSpec, indexSpec, tableSpec} from '../../../../db/specs.ts';\nimport type {Satisfies} from '../../../../types/satisfies.ts';\nimport {jsonObjectSchema} from './json.ts';\nimport {schemaChangeTags} from './schema-change-tags.ts';\n\nexport const beginSchema = v.object({\n  tag: v.literal('begin'),\n  // The format of values of \"json\"-typed columns (e.g. \"JSON\" and \"JSONB\").\n  // - 'p' is for parsed JSON, which may include JSON values or JSON objects.\n  //   These values are parsed and stringified at every process boundary\n  //   between the change-source and the replica.\n  // - 's' is for stringified JSON. These values skip the parsing and\n  //   stringification, and are directly ferried to the replica as a JSON\n  //   string. For JSON values this improves performance by 20~25% in the\n  //   change-streamer and 25~30% in the replicator.\n  //\n  // If absent, the format is assumed to be 'p' (parsed JSON objects/values).\n  json: v.literalUnion('p', 's').optional(),\n\n  // Directs the change-streamer to skip the ACK for the corresponding commit.\n  skipAck: v.boolean().optional(),\n});\n\nexport const commitSchema = v.object({\n  tag: v.literal('commit'),\n\n  // Millisecond epoch at which the transaction committed upstream, as reported\n  // by the upstream database (e.g. the `commitTime` of the Postgres logical\n  // replication Commit message).\n  //\n  // This is the origin timestamp of the end-to-end serving lag measurement:\n  // it is carried through the replication stream to the ViewSyncer, which\n  // records `now - commitTimeMs` once the change has been poked to clients.\n  //\n  // Optional because it is absent from changes written to the Change DB by\n  // older versions, which are replayed verbatim during catchup, and from\n  // ChangeSources that do not report a commit time.\n  commitTimeMs: v.number().optional(),\n});\n\nexport const rollbackSchema = v.object({\n  tag: v.literal('rollback'),\n});\n\nconst rowKeySchema = v.object({\n  // The columns used to identify a row in insert, update, and delete changes.\n  columns: v.array(v.string()),\n\n  // An optional qualifier identifying how the key is chosen. Currently this\n  // is postgres-specific, describing the REPLICA IDENTITY, for which replica\n  // identity 'full' (FULL) is handled differently; the replicator handles\n  // these tables by extracting a row key from the full row based on the\n  // table's PRIMARY KEY or UNIQUE INDEX.\n  type: v.literalUnion('default', 'nothing', 'full', 'index').optional(),\n});\n\nexport const relationSchema = v\n  .object({\n    schema: v.string(),\n    name: v.string(),\n\n    // This will become required.\n    rowKey: rowKeySchema.optional(),\n\n    /** Deprecated: set the rowKey.columns instead. */\n    keyColumns: v.array(v.string()).optional(),\n    /** Deprecated: set the rowKey.columns instead. */\n    replicaIdentity: v\n      .literalUnion('default', 'nothing', 'full', 'index')\n      .optional(),\n  })\n  .map(rel => {\n    const {rowKey, ...rest} = rel;\n    if (rowKey) {\n      return {...rest, rowKey};\n    }\n    return {\n      ...rest,\n      rowKey: {\n        columns: must(rel.keyColumns),\n        type: rel.replicaIdentity,\n      },\n    };\n  });\n\n// The eventual fate of relationSchema\nexport const newRelationSchema = v.object({\n  schema: v.string(),\n  name: v.string(),\n\n  rowKey: rowKeySchema,\n});\n\n// TableMetadata contains table-related configuration that does not affect the\n// actual data in the table, but rather how the table's change messages are\n// handled. The is an opaque object that clients must track (and update) based\n// on `create-table`, `add-column`, and `table-update-metadata` messages, and\n// pass in BackfillRequests when there are columns to be backfilled.\n//\n// Note that the backfill-related change-source implementation does, however,\n// rely on the rowKey (columns) being specified in the message.\nexport const tableMetadataSchema = v\n  .object({rowKey: v.record(jsonValueSchema)})\n  .rest(jsonValueSchema);\n\nexport type TableMetadata = v.Infer<typeof tableMetadataSchema>;\n\nexport const rowSchema = v.record(jsonValueSchema);\n\nexport const insertSchema = v.object({\n  tag: v.literal('insert'),\n  relation: relationSchema,\n  new: rowSchema,\n});\n\nexport const updateSchema = v.object({\n  tag: v.literal('update'),\n  relation: relationSchema,\n  // `key` is present if the update changed the key of the row, or if the\n  // table's replicaIdentity === 'full'\n  key: rowSchema.nullable(),\n  // `new` is the full row (and not just the updated columns). This is\n  // necessary for \"catchup\" replication scenarios such as adding tables\n  // to a publication, or resharding.\n  new: rowSchema,\n});\n\nexport const deleteSchema = v.object({\n  tag: v.literal('delete'),\n  relation: relationSchema,\n  // key is the full row if replicaIdentity === 'full'\n  key: rowSchema,\n});\n\nexport const truncateSchema = v.object({\n  tag: v.literal('truncate'),\n  relations: v.array(relationSchema),\n});\n\nexport const identifierSchema = v.object({\n  schema: v.string(),\n  name: v.string(),\n});\n\nexport type Identifier = v.Infer<typeof identifierSchema>;\n\n// A BackfillID is an upstream specific stable identifier for a column\n// that needs backfilling. This id is used to ensure that the schema, table,\n// and column names of a requested backfill still match the original\n// underlying upstream ID.\n//\n// The change-streamer stores these IDs as opaque values while a column is\n// being backfilled, and initiates new change-source streams with the IDs\n// in order to restart backfills that did not complete in previous sessions.\nexport const backfillIDSchema = jsonObjectSchema;\n\nexport type BackfillID = v.Infer<typeof backfillIDSchema>;\n\nexport const backfillProgressMarkSchema = v\n  .object({\n    // A lexicographically sortable string delineating the progress of a\n    // backfill. This is used to resume a backfill that did not complete.\n    progressMark: v.string(),\n\n    // Optionally, a timeline with which the progressMark is associated.\n    // A timeline is an opaque string that determines if backfill streams\n    // are \"compatible\" with each other, i.e. can be merged in a way that\n    // avoids gaps. progressMarks from different timelines are not\n    // compatible. If two timelines differ, a new backfill is started\n    // from scratch in order to get all subscribers on the same timeline.\n    //\n    // Timeline changes should be rare events (e.g. Postgres VACUUM FULL).\n    timeline: v.string().optional(),\n  })\n  // All other fields should be preserved and returned in BackfillRequests.\n  .rest(v.union(v.number(), v.string()));\n\nexport type BackfillProgressMark = v.Infer<typeof backfillProgressMarkSchema>;\n\nexport const createTableSchema = v.object({\n  tag: v.literal('create-table'),\n  spec: tableSpec,\n\n  // This must be set by change source implementations that support\n  // table/column backfill.\n  //\n  // TODO: to simplify the protocol, see if we can make this required\n  metadata: tableMetadataSchema.optional(),\n\n  // Indicate that columns of the table require backfilling. These columns\n  // should be created on the replica but not yet synced the clients.\n  //\n  // ## State Persistence\n  //\n  // To obviate the need for change-source implementations to persist state\n  // related to backfill progress, the change-source only tracks backfills\n  // **for the current session**. In the event that the session is interrupted\n  // before columns have been fully backfilled, it is the responsibility of the\n  // change-streamer to send {@link BackfillRequest}s when it reconnects.\n  //\n  // This means that the change-streamer must track and persist:\n  // * the backfill IDs of the columns requiring backfilling\n  // * the most current table metadata of the associated table(s)\n  //\n  // The change-streamer then uses this information to send backfill requests\n  // when it reconnects.\n  backfill: v.record(backfillIDSchema).optional(),\n});\n\nexport const renameTableSchema = v.object({\n  tag: v.literal('rename-table'),\n  old: identifierSchema,\n  new: identifierSchema,\n});\n\nexport const updateTableMetadataSchema = v.object({\n  tag: v.literal('update-table-metadata'),\n  table: identifierSchema,\n  old: tableMetadataSchema,\n  new: tableMetadataSchema,\n});\n\nconst columnSchema = v.object({\n  name: v.string(),\n  spec: columnSpec,\n});\n\nexport const addColumnSchema = v.object({\n  tag: v.literal('add-column'),\n  table: identifierSchema,\n  column: columnSchema,\n\n  // This must be set by change source implementations that support\n  // table/column backfill.\n  //\n  // TODO: to simplify the protocol, see if we can make this required\n  tableMetadata: tableMetadataSchema.optional(),\n\n  // See documentation for the `backfill` field of the `create-table` change.\n  backfill: backfillIDSchema.optional(),\n});\n\nexport const updateColumnSchema = v.object({\n  tag: v.literal('update-column'),\n  table: identifierSchema,\n  old: columnSchema,\n  new: columnSchema,\n});\n\nexport const dropColumnSchema = v.object({\n  tag: v.literal('drop-column'),\n  table: identifierSchema,\n  column: v.string(),\n});\n\nexport const dropTableSchema = v.object({\n  tag: v.literal('drop-table'),\n  id: identifierSchema,\n});\n\nexport const createIndexSchema = v.object({\n  tag: v.literal('create-index'),\n  spec: indexSpec,\n});\n\nexport const dropIndexSchema = v.object({\n  tag: v.literal('drop-index'),\n  id: identifierSchema,\n});\n\nexport const downloadStatusSchema = v.object({\n  rows: v.number(),\n  totalRows: v.number(),\n  totalBytes: v.number().optional(),\n});\n\nexport type DownloadStatus = v.Infer<typeof downloadStatusSchema>;\n\n// A batch of rows from a single table containing column values\n// to be backfilled.\nexport const backfillSchema = v.object({\n  tag: v.literal('backfill'),\n\n  relation: newRelationSchema,\n\n  // The columns to be backfilled. `rowKey` columns are automatically excluded,\n  // which means that this field may be empty.\n  columns: v.array(v.string()),\n\n  // The watermark at which the backfill data was queried. Note that this\n  // generally will be different from the commit watermarks of the main change\n  // stream, and in particular, the commit watermark of the backfill change's\n  // enclosing transaction.\n  watermark: v.string(),\n\n  // A batch of row values, each row consisting of the `rowKey`\n  // values, followed by the `column` values, in the same order in which\n  // the column names appear in their respective fields, e.g.\n  //\n  // ```\n  // [\n  //   [...rowKeyValues, ...columnValues],  // row 1\n  //   [...rowKeyValues, ...columnValues],  // row 2\n  // ]\n  // ```\n  rowValues: v.array(v.array(jsonValueSchema)),\n\n  // Progress marks indicating the position of this backfill message\n  // within the stream, for resumption / continuity enforcement.\n  //\n  // This should be considered non-optional as of protocol v8. It is only\n  // absent in messages from pre-v8 replication-managers (including messages\n  // persisted in a change-log by one), in which case subscribers accept the\n  // message unconditionally (i.e. the legacy behavior).\n  progressMarks: v\n    .object({\n      // The progress mark of the preceding backfill message, from which\n      // the current backfill message is a continuation. (This may be a\n      // \"logical\" continuation at which a new backfill stream is started when\n      // resuming from a previous stream.)\n      //\n      // For the first backfill message of a stream starting from scratch,\n      // this field is unset. When the field is unset, subscribers should\n      // accept the backfill message unconditionally (i.e. starting a\n      // backfill from scratch is always safe).\n      //\n      // If the field is set, subscribers should only accept the message if\n      // it is of the same timeline as that of its own tracked progressMark,\n      // and is contiguous with or earlier than its own progressMark.\n      //\n      // In other words, it should _ignore_ backfill messages from other\n      // timelines, or messages that create a gap; this can happen when\n      // receiving messages from before this subscriber's backfill requests\n      // are taken into account.\n      //\n      // Implementation note: The change-streamer applies this same policy\n      // (see `acceptBackfill()` in `protocol/backfill-progress.ts`) to track\n      // the backfill state of each subscriber, which it uses to determine the\n      // BackfillRequests with which to (re)start change streams.\n      previous: backfillProgressMarkSchema.optional(),\n\n      // The progressMark delineating the position of the last row in this\n      // message. In the steady state, this will be the `previous`\n      // progressMark of the next backfill message, unless a rewind is\n      // requested, or new timeline encountered.\n      current: backfillProgressMarkSchema,\n    })\n    .optional(),\n\n  // Optionally includes the progress of the backfill operation,\n  // for display purposes.\n  status: downloadStatusSchema.optional(),\n});\n\n// Indicates that the backfill for the specified columns have\n// been successfully backfilled and can be published to clients.\nexport const backfillCompletedSchema = v.object({\n  tag: v.literal('backfill-completed'),\n\n  relation: newRelationSchema,\n\n  // The columns to be backfilled. `rowKey` columns are automatically excluded,\n  // which means that this field may be empty.\n  columns: v.array(v.string()),\n\n  // The watermark at which the backfill data was queried. Note that this\n  // generally will be different from the commit watermarks of the main change\n  // stream, and in particular, the commit watermark of the backfill change's\n  // enclosing transaction.\n  watermark: v.string(),\n\n  // The progress mark of the last backfill message of the run, i.e. the\n  // `current` progressMark of the last `backfill` message, or the progressMark\n  // from which the run was resumed if it produced no `backfill` messages.\n  // Subscribers apply the same continuity policy as for `backfill` messages,\n  // and only consider the columns backfilled if the run is contiguous with\n  // their own progress.\n  //\n  // `previous` is only unset for a run that started from scratch and\n  // produced no rows (e.g. an empty table), which is always safe to accept.\n  //\n  // This should be considered non-optional as of protocol v8. It is only\n  // absent in messages from pre-v8 replication-managers, in which case\n  // subscribers accept the message unconditionally (i.e. legacy behavior).\n  progressMarks: v\n    .object({previous: backfillProgressMarkSchema.optional()})\n    .optional(),\n\n  // Optionally includes the final status of the backfill operation,\n  // for display purposes.\n  status: downloadStatusSchema.optional(),\n});\n\nexport type MessageBegin = v.Infer<typeof beginSchema>;\nexport type MessageCommit = v.Infer<typeof commitSchema>;\nexport type MessageRollback = v.Infer<typeof rollbackSchema>;\n\nexport type MessageRelation = v.Infer<typeof relationSchema>;\nexport type MessageInsert = v.Infer<typeof insertSchema>;\nexport type MessageUpdate = v.Infer<typeof updateSchema>;\nexport type MessageDelete = v.Infer<typeof deleteSchema>;\nexport type MessageTruncate = v.Infer<typeof truncateSchema>;\n\nexport type MessageBackfill = v.Infer<typeof backfillSchema>;\n\nexport type TableCreate = v.Infer<typeof createTableSchema>;\nexport type TableRename = v.Infer<typeof renameTableSchema>;\nexport type TableUpdateMetadata = v.Infer<typeof updateTableMetadataSchema>;\nexport type ColumnAdd = v.Infer<typeof addColumnSchema>;\nexport type ColumnUpdate = v.Infer<typeof updateColumnSchema>;\nexport type ColumnDrop = v.Infer<typeof dropColumnSchema>;\nexport type TableDrop = v.Infer<typeof dropTableSchema>;\nexport type IndexCreate = v.Infer<typeof createIndexSchema>;\nexport type IndexDrop = v.Infer<typeof dropIndexSchema>;\nexport type BackfillCompleted = v.Infer<typeof backfillCompletedSchema>;\n\nexport const dataChangeSchema = v.union(\n  insertSchema,\n  updateSchema,\n  deleteSchema,\n  truncateSchema,\n  backfillSchema,\n);\n\n// Note: keep in sync or the tag tests will fail\nconst dataChangeTags = [\n  'insert',\n  'update',\n  'delete',\n  'truncate',\n  'backfill',\n] as const;\n\nconst dataChangeTagsSchema = v.literalUnion(...dataChangeTags);\n\nexport type DataChange = Satisfies<\n  JSONObject, // guarantees serialization over IPC or network\n  v.Infer<typeof dataChangeSchema>\n>;\n\nexport type DataChangeTag = v.Infer<typeof dataChangeTagsSchema>;\n\nconst schemaChanges = [\n  createTableSchema,\n  renameTableSchema,\n  updateTableMetadataSchema,\n  addColumnSchema,\n  updateColumnSchema,\n  dropColumnSchema,\n  dropTableSchema,\n  createIndexSchema,\n  dropIndexSchema,\n  backfillCompletedSchema,\n] as const;\n\nexport const schemaChangeSchema = v.union(...schemaChanges);\n\nconst schemaChangeTagsSchema = v.literalUnion(...schemaChangeTags);\n\nexport type SchemaChange = Satisfies<\n  JSONObject,\n  v.Infer<typeof schemaChangeSchema>\n>;\n\nexport type SchemaChangeTag = v.Infer<typeof schemaChangeTagsSchema>;\n\nexport type DataOrSchemaChange = DataChange | SchemaChange;\n\nexport type Change =\n  | MessageBegin\n  | DataOrSchemaChange\n  | MessageCommit\n  | MessageRollback;\n\nexport type ChangeTag = Change['tag'];\n\nconst schemaChangeTagSet = new Set<string>(schemaChangeTags);\n\nexport function isSchemaChange(change: Change): change is SchemaChange {\n  return schemaChangeTagSet.has(change.tag);\n}\n\nconst dataChangeTagSet = new Set<string>(dataChangeTags);\n\nexport function isDataChange(change: Change): change is DataChange {\n  return dataChangeTagSet.has(change.tag);\n}\n"],"mappings":"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"}

package/out/zero-cache/src/services/change-source/protocol/current/downstream.d.ts

@@ -768,6 +768,7 @@ export declare const changeStreamMessageSchema: v.UnionType<[v.UnionType<[v.Tupl
         };
         nextSendTimeMs: number;
     }>;
+    syncBackupThrough: v.Optional<string>;
 }, undefined>, v.ObjectType<{
     watermark: v.Type<string>;
 }, undefined>]>]>;

package/out/zero-cache/src/services/change-source/protocol/current/downstream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"downstream.d.ts","sourceRoot":"","sources":["../../../../../../../../zero-cache/src/services/change-source/protocol/current/downstream.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,wCAAwC,CAAC;AAW5D,QAAA,MAAM,KAAK;;;;;;eAIT,CAAC;AACH,QAAA,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAGR,CAAC;AACH,QAAA,MAAM,MAAM;;;;;eAIV,CAAC;AACH,QAAA,MAAM,QAAQ;;eAAmD,CAAC;AAElE,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,KAAK,CAAC,CAAC;AAC1C,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AACxC,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC;AAC5C,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC;AAEhD,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAyC,CAAC;AAC7E,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,eAAO,MAAM,yBAAyB;;;;eAGpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,4EAA4E;AAC5E,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIrC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}
+{"version":3,"file":"downstream.d.ts","sourceRoot":"","sources":["../../../../../../../../zero-cache/src/services/change-source/protocol/current/downstream.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,wCAAwC,CAAC;AAW5D,QAAA,MAAM,KAAK;;;;;;eAIT,CAAC;AACH,QAAA,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAGR,CAAC;AACH,QAAA,MAAM,MAAM;;;;;eAIV,CAAC;AACH,QAAA,MAAM,QAAQ;;eAAmD,CAAC;AAElE,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,KAAK,CAAC,CAAC;AAC1C,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AACxC,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC;AAC5C,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC;AAEhD,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAyC,CAAC;AAC7E,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,eAAO,MAAM,yBAAyB;;;;eAGpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,4EAA4E;AAC5E,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIrC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}