@rocicorp/zero 0.26.1 → 0.26.2-canary.4

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

@@ -1 +1 @@
-{"version":3,"file":"validation.js","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"],"names":[],"mappings":";;;AAeA,MAAM,sBAAsB;AAI5B,MAAM,uBAAuB;AAEtB,SAAS,SACd,IACA,OACA;AACA,MAAI,4BAA4B,MAAM,SAAS;AAC7C,UAAM,IAAI;AAAA,MACR,UAAU,MAAM,IAAI,gCAAgC,wBAAwB;AAAA,IAAA;AAAA,EAEhF;AACA,MAAI,CAAC,MAAM,YAAY,UAAU,MAAM,oBAAoB,SAAS;AAClE,OAAG;AAAA,MACD;AAAA;AAAA;AAAA,SACY,MAAM,IAAI,sFACU,MAAM,IAAI;AAAA;AAAA;AAAA;AAAA,IAAA;AAAA,EAG9C;AACA,MAAI,MAAM,oBAAoB,SAAS;AACrC,UAAM,IAAI;AAAA,MACR,UAAU,MAAM,IAAI;AAAA,IAAA;AAAA,EAExB;AACA,MACE,MAAM,oBAAoB,SAC1B,MAAM,uBAAuB,WAAW,GACxC;AACA,UAAM,IAAI;AAAA,MACR,UAAU,MAAM,IAAI;AAAA,IAAA;AAAA,EAExB;AACA,MAAI,CAAC,oBAAoB,KAAK,MAAM,IAAI,GAAG;AACzC,UAAM,IAAI;AAAA,MACR,UAAU,MAAM,IAAI;AAAA,IAAA;AAAA,EAExB;AACA,aAAW,CAAC,KAAK,IAAI,KAAK,OAAO,QAAQ,kBAAkB,KAAK,EAAE,OAAO,GAAG;AAC1E,QAAI,CAAC,qBAAqB,KAAK,GAAG,GAAG;AACnC,YAAM,IAAI;AAAA,QACR,WAAW,GAAG,eAAe,MAAM,IAAI;AAAA,MAAA;AAAA,IAE3C;AACA,4BAAwB,IAAI,KAAK,UAAU,MAAM,MAAM,GAAG;AAAA,EAC5D;AACF;AAEO,MAAM,oCAAoC,MAAM;AAAA,EAC5C,OAAO;AAAA,EAEhB,YAAY,KAAa;AACvB,UAAM,GAAG;AAAA,EACX;AACF;"}
+{"version":3,"file":"validation.js","names":[],"sources":["../../../../../../../../zero-cache/src/services/change-source/pg/schema/validation.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {\n  mapPostgresToLite,\n  warnIfDataTypeSupported,\n} from '../../../../db/pg-to-lite.ts';\nimport {\n  Default,\n  Index,\n  Nothing,\n} from '../../../../db/postgres-replica-identity-enum.ts';\nimport {ZERO_VERSION_COLUMN_NAME} from '../../../replicator/schema/constants.ts';\nimport type {PublishedTableWithReplicaIdentity} from './published.ts';\n\nexport const ALLOWED_APP_ID_CHARACTERS = /^[a-z0-9_]+$/;\n\nconst ALLOWED_TABLE_CHARS = /^[A-Za-z_]+[A-Za-z0-9_-]*$/;\n\n// Dots are allowed in column names since there is no need for\n// a schema/table delimiter when mapped to SQLite names.\nconst ALLOWED_COLUMN_CHARS = /^[A-Za-z_]+[.A-Za-z0-9_-]*$/;\n\nexport function validate(\n  lc: LogContext,\n  table: PublishedTableWithReplicaIdentity,\n) {\n  if (ZERO_VERSION_COLUMN_NAME in table.columns) {\n    throw new UnsupportedTableSchemaError(\n      `Table \"${table.name}\" uses reserved column name \"${ZERO_VERSION_COLUMN_NAME}\"`,\n    );\n  }\n  if (!table.primaryKey?.length && table.replicaIdentity === Default) {\n    lc.warn?.(\n      `\\n\\n\\n` +\n        `Table \"${table.name}\" needs a primary key in order to be synced to clients. ` +\n        `Add one with 'ALTER TABLE \"${table.name}\" ADD PRIMARY KEY (...)'.` +\n        `\\n\\n\\n`,\n    );\n  }\n  if (table.replicaIdentity === Nothing) {\n    throw new UnsupportedTableSchemaError(\n      `Table \"${table.name}\" with REPLICA IDENTITY NOTHING cannot be replicated`,\n    );\n  }\n  if (\n    table.replicaIdentity === Index &&\n    table.replicaIdentityColumns.length === 0\n  ) {\n    throw new UnsupportedTableSchemaError(\n      `Table \"${table.name}\" is missing its REPLICA IDENTITY INDEX`,\n    );\n  }\n  if (!ALLOWED_TABLE_CHARS.test(table.name)) {\n    throw new UnsupportedTableSchemaError(\n      `Table \"${table.name}\" has invalid characters.`,\n    );\n  }\n  for (const [col, spec] of Object.entries(mapPostgresToLite(table).columns)) {\n    if (!ALLOWED_COLUMN_CHARS.test(col)) {\n      throw new UnsupportedTableSchemaError(\n        `Column \"${col}\" in table \"${table.name}\" has invalid characters.`,\n      );\n    }\n    warnIfDataTypeSupported(lc, spec.dataType, table.name, col);\n  }\n}\n\nexport class UnsupportedTableSchemaError extends Error {\n  readonly name = 'UnsupportedTableSchemaError';\n\n  constructor(msg: string) {\n    super(msg);\n  }\n}\n"],"mappings":";;;AAeA,IAAM,sBAAsB;AAI5B,IAAM,uBAAuB;AAE7B,SAAgB,SACd,IACA,OACA;AACA,KAAA,gBAAgC,MAAM,QACpC,OAAM,IAAI,4BACR,UAAU,MAAM,KAAK,+BAA+B,yBAAyB,GAC9E;AAEH,KAAI,CAAC,MAAM,YAAY,UAAU,MAAM,oBAAA,IACrC,IAAG,OACD,gBACY,MAAM,KAAK,qFACS,MAAM,KAAK,iCAE5C;AAEH,KAAI,MAAM,oBAAA,IACR,OAAM,IAAI,4BACR,UAAU,MAAM,KAAK,sDACtB;AAEH,KACE,MAAM,oBAAA,OACN,MAAM,uBAAuB,WAAW,EAExC,OAAM,IAAI,4BACR,UAAU,MAAM,KAAK,yCACtB;AAEH,KAAI,CAAC,oBAAoB,KAAK,MAAM,KAAK,CACvC,OAAM,IAAI,4BACR,UAAU,MAAM,KAAK,2BACtB;AAEH,MAAK,MAAM,CAAC,KAAK,SAAS,OAAO,QAAQ,kBAAkB,MAAM,CAAC,QAAQ,EAAE;AAC1E,MAAI,CAAC,qBAAqB,KAAK,IAAI,CACjC,OAAM,IAAI,4BACR,WAAW,IAAI,cAAc,MAAM,KAAK,2BACzC;AAEH,0BAAwB,IAAI,KAAK,UAAU,MAAM,MAAM,IAAI;;;AAI/D,IAAa,8BAAb,cAAiD,MAAM;CACrD,OAAgB;CAEhB,YAAY,KAAa;AACvB,QAAM,IAAI"}

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

@@ -1,14 +1,26 @@
-import "../../../../../../shared/src/valita.js";
+import { valita_exports } from "../../../../../../shared/src/valita.js";
 import { jsonObjectSchema } from "./json.js";
-import { object, string, literal } from "@badrap/valita";
-const resetRequiredSchema = object({
-  tag: literal("reset-required"),
-  message: string().optional(),
-  // errorDetails can contain any standard JSON object. This will be
-  // published in the `errorDetails` field of a replication ERROR event.
-  errorDetails: jsonObjectSchema.optional()
+//#region ../zero-cache/src/services/change-source/protocol/current/control.ts
+/**
+* Control plane messages communicate non-content related signals between a
+* ChangeSource and ChangeStreamer. These are not forwarded to subscribers
+* of the ChangeStreamer.
+*/
+/**
+* Indicates that replication cannot continue and that the replica must be resynced
+* from scratch. The replication-manager will shutdown in response to this message,
+* and upon being restarted, it will wipe the current replica and resync if the
+* `--auto-reset` option is specified.
+*
+* This signal should only be used in well advertised scenarios, and is not suitable
+* as a common occurrence in production.
+*/
+var resetRequiredSchema = valita_exports.object({
+	tag: valita_exports.literal("reset-required"),
+	message: valita_exports.string().optional(),
+	errorDetails: jsonObjectSchema.optional()
 });
-export {
-  resetRequiredSchema
-};
-//# sourceMappingURL=control.js.map
+//#endregion
+export { resetRequiredSchema };
+
+//# sourceMappingURL=control.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"control.js","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"],"names":["v.object","v.literal","v.string"],"mappings":";;;AAiBO,MAAM,sBAAsBA,OAAS;AAAA,EAC1C,KAAKC,QAAU,gBAAgB;AAAA,EAC/B,SAASC,OAAE,EAAS,SAAA;AAAA;AAAA;AAAA,EAIpB,cAAc,iBAAiB,SAAA;AACjC,CAAC;"}
+{"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,iBAAiB;CAChC,SAAS,eAAE,QAAQ,CAAC,UAAU;CAI9B,cAAc,iBAAiB,UAAU;CAC1C,CAAC"}

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

@@ -1,302 +1,192 @@
-import { jsonValueSchema } from "../../../../../../shared/src/bigint-json.js";
+import { literalUnion, valita_exports } from "../../../../../../shared/src/valita.js";
 import { must } from "../../../../../../shared/src/must.js";
-import { literalUnion } from "../../../../../../shared/src/valita.js";
-import { tableSpec, columnSpec, indexSpec } from "../../../../db/specs.js";
 import { jsonObjectSchema } from "./json.js";
-import { object, boolean, literal, array, string, record, number, union } from "@badrap/valita";
-const beginSchema = object({
-  tag: literal("begin"),
-  // The format of values of "json"-typed columns (e.g. "JSON" and "JSONB").
-  // - 'p' is for parsed JSON, which may include JSON values or JSON objects.
-  //   These values are parsed and stringified at every process boundary
-  //   between the change-source and the replica.
-  // - 's' is for stringified JSON. These values skip the parsing and
-  //   stringification, and are directly ferried to the replica as a JSON
-  //   string. For JSON values this improves performance by 20~25% in the
-  //   change-streamer and 25~30% in the replicator.
-  //
-  // If absent, the format is assumed to be 'p' (parsed JSON objects/values).
-  json: literalUnion("p", "s").optional(),
-  // Directs the change-streamer to skip the ACK for the corresponding commit.
-  skipAck: boolean().optional()
-});
-const commitSchema = object({
-  tag: literal("commit")
-});
-const rollbackSchema = object({
-  tag: literal("rollback")
-});
-const rowKeySchema = object({
-  // The columns used to identify a row in insert, update, and delete changes.
-  columns: array(string()),
-  // An optional qualifier identifying how the key is chosen. Currently this
-  // is postgres-specific, describing the REPLICA IDENTITY, for which replica
-  // identity 'full' (FULL) is handled differently; the replicator handles
-  // these tables by extracting a row key from the full row based on the
-  // table's PRIMARY KEY or UNIQUE INDEX.
-  type: literalUnion("default", "nothing", "full", "index").optional()
-});
-const relationSchema = object({
-  schema: string(),
-  name: string(),
-  // This will become required.
-  rowKey: rowKeySchema.optional(),
-  /** Deprecated: set the rowKey.columns instead. */
-  keyColumns: array(string()).optional(),
-  /** Deprecated: set the rowKey.columns instead. */
-  replicaIdentity: literalUnion("default", "nothing", "full", "index").optional()
+import { jsonValueSchema } from "../../../../../../shared/src/bigint-json.js";
+import { columnSpec, indexSpec, tableSpec } from "../../../../db/specs.js";
+//#region ../zero-cache/src/services/change-source/protocol/current/data.ts
+/**
+* Data plane messages encapsulate changes that are sent by ChangeSources,
+* forwarded / fanned out to subscribers by the ChangeStreamerService, and
+* stored in the Change DB for catchup of old subscribers.
+*/
+var beginSchema = valita_exports.object({
+	tag: valita_exports.literal("begin"),
+	json: literalUnion("p", "s").optional(),
+	skipAck: valita_exports.boolean().optional()
+});
+var commitSchema = valita_exports.object({ tag: valita_exports.literal("commit") });
+var rollbackSchema = valita_exports.object({ tag: valita_exports.literal("rollback") });
+var rowKeySchema = valita_exports.object({
+	columns: valita_exports.array(valita_exports.string()),
+	type: literalUnion("default", "nothing", "full", "index").optional()
+});
+var relationSchema = valita_exports.object({
+	schema: valita_exports.string(),
+	name: valita_exports.string(),
+	rowKey: rowKeySchema.optional(),
+	keyColumns: valita_exports.array(valita_exports.string()).optional(),
+	replicaIdentity: literalUnion("default", "nothing", "full", "index").optional()
 }).map((rel) => {
-  const { rowKey, ...rest } = rel;
-  if (rowKey) {
-    return { ...rest, rowKey };
-  }
-  return {
-    ...rest,
-    rowKey: {
-      columns: must(rel.keyColumns),
-      type: rel.replicaIdentity
-    }
-  };
-});
-const newRelationSchema = object({
-  schema: string(),
-  name: string(),
-  rowKey: rowKeySchema
-});
-const tableMetadataSchema = object({ rowKey: record(jsonValueSchema) }).rest(jsonValueSchema);
-const rowSchema = record(jsonValueSchema);
-const insertSchema = object({
-  tag: literal("insert"),
-  relation: relationSchema,
-  new: rowSchema
-});
-const updateSchema = object({
-  tag: literal("update"),
-  relation: relationSchema,
-  // `key` is present if the update changed the key of the row, or if the
-  // table's replicaIdentity === 'full'
-  key: rowSchema.nullable(),
-  // `new` is the full row (and not just the updated columns). This is
-  // necessary for "catchup" replication scenarios such as adding tables
-  // to a publication, or resharding.
-  new: rowSchema
-});
-const deleteSchema = object({
-  tag: literal("delete"),
-  relation: relationSchema,
-  // key is the full row if replicaIdentity === 'full'
-  key: rowSchema
-});
-const truncateSchema = object({
-  tag: literal("truncate"),
-  relations: array(relationSchema)
-});
-const identifierSchema = object({
-  schema: string(),
-  name: string()
-});
-const backfillIDSchema = jsonObjectSchema;
-const createTableSchema = object({
-  tag: literal("create-table"),
-  spec: tableSpec,
-  // This must be set by change source implementations that support
-  // table/column backfill.
-  //
-  // TODO: to simplify the protocol, see if we can make this required
-  metadata: tableMetadataSchema.optional(),
-  // Indicate that columns of the table require backfilling. These columns
-  // should be created on the replica but not yet synced the clients.
-  //
-  // ## State Persistence
-  //
-  // To obviate the need for change-source implementations to persist state
-  // related to backfill progress, the change-source only tracks backfills
-  // **for the current session**. In the event that the session is interrupted
-  // before columns have been fully backfilled, it is the responsibility of the
-  // change-streamer to send {@link BackfillRequest}s when it reconnects.
-  //
-  // This means that the change-streamer must track and persist:
-  // * the backfill IDs of the columns requiring backfilling
-  // * the most current table metadata of the associated table(s)
-  //
-  // The change-streamer then uses this information to send backfill requests
-  // when it reconnects.
-  backfill: record(backfillIDSchema).optional()
-});
-const renameTableSchema = object({
-  tag: literal("rename-table"),
-  old: identifierSchema,
-  new: identifierSchema
-});
-const updateTableMetadataSchema = object({
-  tag: literal("update-table-metadata"),
-  table: identifierSchema,
-  old: tableMetadataSchema,
-  new: tableMetadataSchema
-});
-const columnSchema = object({
-  name: string(),
-  spec: columnSpec
-});
-const addColumnSchema = object({
-  tag: literal("add-column"),
-  table: identifierSchema,
-  column: columnSchema,
-  // This must be set by change source implementations that support
-  // table/column backfill.
-  //
-  // TODO: to simplify the protocol, see if we can make this required
-  tableMetadata: tableMetadataSchema.optional(),
-  // See documentation for the `backfill` field of the `create-table` change.
-  backfill: backfillIDSchema.optional()
-});
-const updateColumnSchema = object({
-  tag: literal("update-column"),
-  table: identifierSchema,
-  old: columnSchema,
-  new: columnSchema
-});
-const dropColumnSchema = object({
-  tag: literal("drop-column"),
-  table: identifierSchema,
-  column: string()
-});
-const dropTableSchema = object({
-  tag: literal("drop-table"),
-  id: identifierSchema
-});
-const createIndexSchema = object({
-  tag: literal("create-index"),
-  spec: indexSpec
-});
-const dropIndexSchema = object({
-  tag: literal("drop-index"),
-  id: identifierSchema
-});
-const downloadStatusSchema = object({
-  rows: number(),
-  totalRows: number(),
-  totalBytes: number().optional()
-});
-const backfillSchema = object({
-  tag: literal("backfill"),
-  relation: newRelationSchema,
-  // The columns to be backfilled. `rowKey` columns are automatically excluded,
-  // which means that this field may be empty.
-  columns: array(string()),
-  // The watermark at which the backfill data was queried. Note that this
-  // generally will be different from the commit watermarks of the main change
-  // stream, and in particular, the commit watermark of the backfill change's
-  // enclosing transaction.
-  watermark: string(),
-  // A batch of row values, each row consisting of the `rowKey`
-  // values, followed by the `column` values, in the same order in which
-  // the column names appear in their respective fields, e.g.
-  //
-  // ```
-  // [
-  //   [...rowKeyValues, ...columnValues],  // row 1
-  //   [...rowKeyValues, ...columnValues],  // row 2
-  // ]
-  // ```
-  rowValues: array(array(jsonValueSchema)),
-  // Optionally includes the progress of the backfill operation,
-  // for display purposes.
-  status: downloadStatusSchema.optional()
-});
-const backfillCompletedSchema = object({
-  tag: literal("backfill-completed"),
-  relation: newRelationSchema,
-  // The columns to be backfilled. `rowKey` columns are automatically excluded,
-  // which means that this field may be empty.
-  columns: array(string()),
-  // The watermark at which the backfill data was queried. Note that this
-  // generally will be different from the commit watermarks of the main change
-  // stream, and in particular, the commit watermark of the backfill change's
-  // enclosing transaction.
-  watermark: string(),
-  // Optionally includes the final status of the backfill operation,
-  // for display purposes.
-  status: downloadStatusSchema.optional()
-});
-const dataChangeSchema = union(
-  insertSchema,
-  updateSchema,
-  deleteSchema,
-  truncateSchema,
-  backfillSchema
-);
-const dataChangeTags = [
-  "insert",
-  "update",
-  "delete",
-  "truncate",
-  "backfill"
+	const { rowKey, ...rest } = rel;
+	if (rowKey) return {
+		...rest,
+		rowKey
+	};
+	return {
+		...rest,
+		rowKey: {
+			columns: must(rel.keyColumns),
+			type: rel.replicaIdentity
+		}
+	};
+});
+var newRelationSchema = valita_exports.object({
+	schema: valita_exports.string(),
+	name: valita_exports.string(),
+	rowKey: rowKeySchema
+});
+var tableMetadataSchema = valita_exports.object({ rowKey: valita_exports.record(jsonValueSchema) }).rest(jsonValueSchema);
+var rowSchema = valita_exports.record(jsonValueSchema);
+var insertSchema = valita_exports.object({
+	tag: valita_exports.literal("insert"),
+	relation: relationSchema,
+	new: rowSchema
+});
+var updateSchema = valita_exports.object({
+	tag: valita_exports.literal("update"),
+	relation: relationSchema,
+	key: rowSchema.nullable(),
+	new: rowSchema
+});
+var deleteSchema = valita_exports.object({
+	tag: valita_exports.literal("delete"),
+	relation: relationSchema,
+	key: rowSchema
+});
+var truncateSchema = valita_exports.object({
+	tag: valita_exports.literal("truncate"),
+	relations: valita_exports.array(relationSchema)
+});
+var identifierSchema = valita_exports.object({
+	schema: valita_exports.string(),
+	name: valita_exports.string()
+});
+var backfillIDSchema = jsonObjectSchema;
+var createTableSchema = valita_exports.object({
+	tag: valita_exports.literal("create-table"),
+	spec: tableSpec,
+	metadata: tableMetadataSchema.optional(),
+	backfill: valita_exports.record(backfillIDSchema).optional()
+});
+var renameTableSchema = valita_exports.object({
+	tag: valita_exports.literal("rename-table"),
+	old: identifierSchema,
+	new: identifierSchema
+});
+var updateTableMetadataSchema = valita_exports.object({
+	tag: valita_exports.literal("update-table-metadata"),
+	table: identifierSchema,
+	old: tableMetadataSchema,
+	new: tableMetadataSchema
+});
+var columnSchema = valita_exports.object({
+	name: valita_exports.string(),
+	spec: columnSpec
+});
+var addColumnSchema = valita_exports.object({
+	tag: valita_exports.literal("add-column"),
+	table: identifierSchema,
+	column: columnSchema,
+	tableMetadata: tableMetadataSchema.optional(),
+	backfill: backfillIDSchema.optional()
+});
+var updateColumnSchema = valita_exports.object({
+	tag: valita_exports.literal("update-column"),
+	table: identifierSchema,
+	old: columnSchema,
+	new: columnSchema
+});
+var dropColumnSchema = valita_exports.object({
+	tag: valita_exports.literal("drop-column"),
+	table: identifierSchema,
+	column: valita_exports.string()
+});
+var dropTableSchema = valita_exports.object({
+	tag: valita_exports.literal("drop-table"),
+	id: identifierSchema
+});
+var createIndexSchema = valita_exports.object({
+	tag: valita_exports.literal("create-index"),
+	spec: indexSpec
+});
+var dropIndexSchema = valita_exports.object({
+	tag: valita_exports.literal("drop-index"),
+	id: identifierSchema
+});
+var downloadStatusSchema = valita_exports.object({
+	rows: valita_exports.number(),
+	totalRows: valita_exports.number(),
+	totalBytes: valita_exports.number().optional()
+});
+var backfillSchema = valita_exports.object({
+	tag: valita_exports.literal("backfill"),
+	relation: newRelationSchema,
+	columns: valita_exports.array(valita_exports.string()),
+	watermark: valita_exports.string(),
+	rowValues: valita_exports.array(valita_exports.array(jsonValueSchema)),
+	status: downloadStatusSchema.optional()
+});
+var backfillCompletedSchema = valita_exports.object({
+	tag: valita_exports.literal("backfill-completed"),
+	relation: newRelationSchema,
+	columns: valita_exports.array(valita_exports.string()),
+	watermark: valita_exports.string(),
+	status: downloadStatusSchema.optional()
+});
+var dataChangeSchema = valita_exports.union(insertSchema, updateSchema, deleteSchema, truncateSchema, backfillSchema);
+var dataChangeTags = [
+	"insert",
+	"update",
+	"delete",
+	"truncate",
+	"backfill"
 ];
 literalUnion(...dataChangeTags);
-const schemaChanges = [
-  createTableSchema,
-  renameTableSchema,
-  updateTableMetadataSchema,
-  addColumnSchema,
-  updateColumnSchema,
-  dropColumnSchema,
-  dropTableSchema,
-  createIndexSchema,
-  dropIndexSchema,
-  backfillCompletedSchema
+var schemaChanges = [
+	createTableSchema,
+	renameTableSchema,
+	updateTableMetadataSchema,
+	addColumnSchema,
+	updateColumnSchema,
+	dropColumnSchema,
+	dropTableSchema,
+	createIndexSchema,
+	dropIndexSchema,
+	backfillCompletedSchema
 ];
-const schemaChangeTags = [
-  "create-table",
-  "rename-table",
-  "update-table-metadata",
-  "add-column",
-  "update-column",
-  "drop-column",
-  "drop-table",
-  "create-index",
-  "drop-index",
-  "backfill-completed"
+var schemaChangeTags = [
+	"create-table",
+	"rename-table",
+	"update-table-metadata",
+	"add-column",
+	"update-column",
+	"drop-column",
+	"drop-table",
+	"create-index",
+	"drop-index",
+	"backfill-completed"
 ];
-const schemaChangeSchema = union(...schemaChanges);
+var schemaChangeSchema = valita_exports.union(...schemaChanges);
 literalUnion(...schemaChangeTags);
-const schemaChangeTagSet = new Set(schemaChangeTags);
+var schemaChangeTagSet = new Set(schemaChangeTags);
 function isSchemaChange(change) {
-  return schemaChangeTagSet.has(change.tag);
+	return schemaChangeTagSet.has(change.tag);
 }
-const dataChangeTagSet = new Set(dataChangeTags);
+var dataChangeTagSet = new Set(dataChangeTags);
 function isDataChange(change) {
-  return dataChangeTagSet.has(change.tag);
+	return dataChangeTagSet.has(change.tag);
 }
-export {
-  addColumnSchema,
-  backfillCompletedSchema,
-  backfillIDSchema,
-  backfillSchema,
-  beginSchema,
-  commitSchema,
-  createIndexSchema,
-  createTableSchema,
-  dataChangeSchema,
-  deleteSchema,
-  downloadStatusSchema,
-  dropColumnSchema,
-  dropIndexSchema,
-  dropTableSchema,
-  identifierSchema,
-  insertSchema,
-  isDataChange,
-  isSchemaChange,
-  newRelationSchema,
-  relationSchema,
-  renameTableSchema,
-  rollbackSchema,
-  rowSchema,
-  schemaChangeSchema,
-  tableMetadataSchema,
-  truncateSchema,
-  updateColumnSchema,
-  updateSchema,
-  updateTableMetadataSchema
-};
-//# sourceMappingURL=data.js.map
+//#endregion
+export { addColumnSchema, backfillCompletedSchema, backfillIDSchema, backfillSchema, beginSchema, commitSchema, createIndexSchema, createTableSchema, dataChangeSchema, deleteSchema, downloadStatusSchema, dropColumnSchema, dropIndexSchema, dropTableSchema, identifierSchema, insertSchema, isDataChange, isSchemaChange, newRelationSchema, relationSchema, renameTableSchema, rollbackSchema, rowSchema, schemaChangeSchema, tableMetadataSchema, truncateSchema, updateColumnSchema, updateSchema, updateTableMetadataSchema };
+
+//# sourceMappingURL=data.js.map