@rocicorp/zero 0.26.1-canary.9 → 0.26.2-canary.1

package/out/zero-cache/src/db/pg-to-lite.js

@@ -1,129 +1,93 @@
+import "./specs.js";
 import { ZERO_VERSION_COLUMN_NAME } from "../services/replicator/schema/constants.js";
 import { liteTypeString, liteTypeToZqlValueType, upstreamDataType } from "../types/lite.js";
 import { liteTableName } from "../types/names.js";
-import { Enum } from "./postgres-type-class-enum.js";
-import "./specs.js";
+//#region ../zero-cache/src/db/pg-to-lite.ts
+/**
+* Determines if a PostgreSQL column is an enum type.
+* This checks both the element type class (for arrays of enums) and the main type class.
+*/
 function isEnumColumn(spec) {
-  return (spec.elemPgTypeClass ?? spec.pgTypeClass) === Enum;
+	return (spec.elemPgTypeClass ?? spec.pgTypeClass) === "e";
 }
+/**
+* Determines if a PostgreSQL column is an array type.
+* In PostgreSQL's system, array columns have a non-null elemPgTypeClass.
+*/
 function isArrayColumn(spec) {
-  return spec.elemPgTypeClass !== null && spec.elemPgTypeClass !== void 0;
+	return spec.elemPgTypeClass !== null && spec.elemPgTypeClass !== void 0;
 }
 function zeroVersionColumnSpec(defaultVersion) {
-  return {
-    pos: Number.MAX_SAFE_INTEGER,
-    // i.e. last
-    characterMaximumLength: null,
-    dataType: "text",
-    notNull: false,
-    dflt: !defaultVersion ? null : `'${defaultVersion}'`,
-    elemPgTypeClass: null
-  };
+	return {
+		pos: Number.MAX_SAFE_INTEGER,
+		characterMaximumLength: null,
+		dataType: "text",
+		notNull: false,
+		dflt: !defaultVersion ? null : `'${defaultVersion}'`,
+		elemPgTypeClass: null
+	};
 }
-function warnIfDataTypeSupported(lc, liteTypeString2, table, column) {
-  if (liteTypeToZqlValueType(liteTypeString2) === void 0) {
-    lc.warn?.(
-      `
-
-WARNING: zero does not yet support the "${upstreamDataType(
-        liteTypeString2
-      )}" data type.
-The "${table}"."${column}" column will not be synced to clients.
-
-`
-    );
-  }
+function warnIfDataTypeSupported(lc, liteTypeString, table, column) {
+	if (liteTypeToZqlValueType(liteTypeString) === void 0) lc.warn?.(`\n\nWARNING: zero does not yet support the "${upstreamDataType(liteTypeString)}" data type.\nThe "${table}"."${column}" column will not be synced to clients.\n\n`);
 }
-const SIMPLE_TOKEN_EXPRESSION_REGEX = /^[^'()]+$/;
-const UNSUPPORTED_TOKENS = /\b(current_time|current_date|current_timestamp)\b/i;
-const STRING_EXPRESSION_REGEX = /^('.*')::[^']+$/;
+var SIMPLE_TOKEN_EXPRESSION_REGEX = /^[^'()]+$/;
+var UNSUPPORTED_TOKENS = /\b(current_time|current_date|current_timestamp)\b/i;
+var STRING_EXPRESSION_REGEX = /^('.*')::[^']+$/;
 function mapPostgresToLiteDefault(table, column, dataType, defaultExpression) {
-  if (!defaultExpression) {
-    return null;
-  }
-  if (UNSUPPORTED_TOKENS.test(defaultExpression)) {
-    throw new UnsupportedColumnDefaultError(
-      `Cannot ADD a column with CURRENT_TIME, CURRENT_DATE, or CURRENT_TIMESTAMP`
-    );
-  }
-  if (SIMPLE_TOKEN_EXPRESSION_REGEX.test(defaultExpression)) {
-    if (liteTypeToZqlValueType(dataType) === "boolean") {
-      return defaultExpression === "true" ? "1" : "0";
-    }
-    return defaultExpression;
-  }
-  const match = STRING_EXPRESSION_REGEX.exec(defaultExpression);
-  if (!match) {
-    throw new UnsupportedColumnDefaultError(
-      `Unsupported default value for ${table}.${column}: ${defaultExpression}`
-    );
-  }
-  return match[1];
+	if (!defaultExpression) return null;
+	if (UNSUPPORTED_TOKENS.test(defaultExpression)) throw new UnsupportedColumnDefaultError(`Cannot ADD a column with CURRENT_TIME, CURRENT_DATE, or CURRENT_TIMESTAMP`);
+	if (SIMPLE_TOKEN_EXPRESSION_REGEX.test(defaultExpression)) {
+		if (liteTypeToZqlValueType(dataType) === "boolean") return defaultExpression === "true" ? "1" : "0";
+		return defaultExpression;
+	}
+	const match = STRING_EXPRESSION_REGEX.exec(defaultExpression);
+	if (!match) throw new UnsupportedColumnDefaultError(`Unsupported default value for ${table}.${column}: ${defaultExpression}`);
+	return match[1];
 }
 function mapPostgresToLiteColumn(table, column, ignoreDefault) {
-  const { pos, dataType, notNull, dflt, elemPgTypeClass = null } = column.spec;
-  const liteType = liteTypeString(
-    dataType,
-    notNull,
-    isEnumColumn(column.spec),
-    isArrayColumn(column.spec)
-  );
-  return {
-    pos,
-    dataType: liteType,
-    characterMaximumLength: null,
-    // Note: NOT NULL constraints are always ignored for SQLite (replica) tables.
-    // 1. They are enforced by the replication stream.
-    // 2. We need nullability for columns with defaults to support
-    // write permissions on the "proposed mutation" state. Proposed
-    // mutations are written to SQLite in a `BEGIN CONCURRENT` transaction in mutagen.
-    // Permission policies are run against that state (to get their ruling) then the
-    // transaction is rolled back.
-    notNull: false,
-    // Note: DEFAULT constraints are ignored when creating new tables, but are
-    //       necessary for adding columns to tables with existing rows.
-    dflt: ignoreDefault === "ignore-default" ? null : mapPostgresToLiteDefault(table, column.name, dataType, dflt),
-    elemPgTypeClass
-  };
+	const { pos, dataType, notNull, dflt, elemPgTypeClass = null } = column.spec;
+	return {
+		pos,
+		dataType: liteTypeString(dataType, notNull, isEnumColumn(column.spec), isArrayColumn(column.spec)),
+		characterMaximumLength: null,
+		notNull: false,
+		dflt: ignoreDefault === "ignore-default" ? null : mapPostgresToLiteDefault(table, column.name, dataType, dflt),
+		elemPgTypeClass
+	};
 }
 function mapPostgresToLite(t, defaultVersion) {
-  const { schema: _, primaryKey: _dropped, ...liteSpec } = t;
-  const name = liteTableName(t);
-  return {
-    ...liteSpec,
-    name,
-    columns: {
-      ...Object.fromEntries(
-        Object.entries(t.columns).map(([col, spec]) => [
-          col,
-          // `ignore-default` for create table statements because
-          // there are no rows to set the default for.
-          mapPostgresToLiteColumn(name, { name: col, spec }, "ignore-default")
-        ])
-      ),
-      [ZERO_VERSION_COLUMN_NAME]: zeroVersionColumnSpec(defaultVersion)
-    }
-  };
+	const { schema: _, primaryKey: _dropped, ...liteSpec } = t;
+	const name = liteTableName(t);
+	return {
+		...liteSpec,
+		name,
+		columns: {
+			...Object.fromEntries(Object.entries(t.columns).map(([col, spec]) => [col, mapPostgresToLiteColumn(name, {
+				name: col,
+				spec
+			}, "ignore-default")])),
+			[ZERO_VERSION_COLUMN_NAME]: zeroVersionColumnSpec(defaultVersion)
+		}
+	};
 }
 function mapPostgresToLiteIndex(index) {
-  const { schema, tableName, name, ...liteIndex } = index;
-  return {
-    tableName: liteTableName({ schema, name: tableName }),
-    name: liteTableName({ schema, name }),
-    ...liteIndex
-  };
-}
-class UnsupportedColumnDefaultError extends Error {
-  name = "UnsupportedColumnDefaultError";
+	const { schema, tableName, name, ...liteIndex } = index;
+	return {
+		tableName: liteTableName({
+			schema,
+			name: tableName
+		}),
+		name: liteTableName({
+			schema,
+			name
+		}),
+		...liteIndex
+	};
 }
-export {
-  UnsupportedColumnDefaultError,
-  isArrayColumn,
-  isEnumColumn,
-  mapPostgresToLite,
-  mapPostgresToLiteColumn,
-  mapPostgresToLiteDefault,
-  mapPostgresToLiteIndex,
-  warnIfDataTypeSupported
+var UnsupportedColumnDefaultError = class extends Error {
+	name = "UnsupportedColumnDefaultError";
 };
-//# sourceMappingURL=pg-to-lite.js.map
+//#endregion
+export { UnsupportedColumnDefaultError, isArrayColumn, isEnumColumn, mapPostgresToLite, mapPostgresToLiteColumn, mapPostgresToLiteIndex, warnIfDataTypeSupported };
+
+//# sourceMappingURL=pg-to-lite.js.map

package/out/zero-cache/src/db/pg-to-lite.js.map

@@ -1 +1 @@
-{"version":3,"file":"pg-to-lite.js","sources":["../../../../../zero-cache/src/db/pg-to-lite.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {ZERO_VERSION_COLUMN_NAME} from '../services/replicator/schema/constants.ts';\nimport {\n  liteTypeString,\n  liteTypeToZqlValueType,\n  upstreamDataType,\n  type LiteTypeString,\n} from '../types/lite.ts';\nimport {liteTableName} from '../types/names.ts';\nimport * as PostgresTypeClass from './postgres-type-class-enum.ts';\nimport {\n  type ColumnSpec,\n  type IndexSpec,\n  type LiteIndexSpec,\n  type LiteTableSpec,\n  type TableSpec,\n} from './specs.ts';\n\n/**\n * Determines if a PostgreSQL column is an enum type.\n * This checks both the element type class (for arrays of enums) and the main type class.\n */\nexport function isEnumColumn(\n  spec: Pick<ColumnSpec, 'pgTypeClass' | 'elemPgTypeClass'>,\n): boolean {\n  return (spec.elemPgTypeClass ?? spec.pgTypeClass) === PostgresTypeClass.Enum;\n}\n\n/**\n * Determines if a PostgreSQL column is an array type.\n * In PostgreSQL's system, array columns have a non-null elemPgTypeClass.\n */\nexport function isArrayColumn(\n  spec: Pick<ColumnSpec, 'elemPgTypeClass'>,\n): boolean {\n  return spec.elemPgTypeClass !== null && spec.elemPgTypeClass !== undefined;\n}\n\nfunction zeroVersionColumnSpec(defaultVersion: string | undefined): ColumnSpec {\n  return {\n    pos: Number.MAX_SAFE_INTEGER, // i.e. last\n    characterMaximumLength: null,\n    dataType: 'text',\n    notNull: false,\n    dflt: !defaultVersion ? null : `'${defaultVersion}'`,\n    elemPgTypeClass: null,\n  };\n}\n\nexport function warnIfDataTypeSupported(\n  lc: LogContext,\n  liteTypeString: LiteTypeString,\n  table: string,\n  column: string,\n) {\n  if (liteTypeToZqlValueType(liteTypeString) === undefined) {\n    lc.warn?.(\n      `\\n\\nWARNING: zero does not yet support the \"${upstreamDataType(\n        liteTypeString,\n      )}\" data type.\\n` +\n        `The \"${table}\".\"${column}\" column will not be synced to clients.\\n\\n`,\n    );\n  }\n}\n\n// As per https://www.sqlite.org/lang_altertable.html#altertabaddcol,\n// expressions with parentheses are disallowed ...\nconst SIMPLE_TOKEN_EXPRESSION_REGEX = /^[^'()]+$/; // e.g. true, false, 1234, 1234.5678\n\n// as well as current_time, current_date, and current_timestamp ...\nconst UNSUPPORTED_TOKENS = /\\b(current_time|current_date|current_timestamp)\\b/i;\n\n// For strings and certain incarnations of primitives (e.g. integers greater\n// than 2^31-1, Postgres' nodeToString() represents the values as type-casted\n// 'string' values, e.g. `'2147483648'::bigint`, `'foo'::text`.\n//\n// These type-qualifiers must be removed, as SQLite doesn't understand or\n// care about them.\nconst STRING_EXPRESSION_REGEX = /^('.*')::[^']+$/;\n\n// Exported for testing.\nexport function mapPostgresToLiteDefault(\n  table: string,\n  column: string,\n  dataType: string,\n  defaultExpression: string | null | undefined,\n) {\n  if (!defaultExpression) {\n    return null;\n  }\n  if (UNSUPPORTED_TOKENS.test(defaultExpression)) {\n    throw new UnsupportedColumnDefaultError(\n      `Cannot ADD a column with CURRENT_TIME, CURRENT_DATE, or CURRENT_TIMESTAMP`,\n    );\n  }\n  if (SIMPLE_TOKEN_EXPRESSION_REGEX.test(defaultExpression)) {\n    if (liteTypeToZqlValueType(dataType) === 'boolean') {\n      return defaultExpression === 'true' ? '1' : '0';\n    }\n    return defaultExpression;\n  }\n  const match = STRING_EXPRESSION_REGEX.exec(defaultExpression);\n  if (!match) {\n    throw new UnsupportedColumnDefaultError(\n      `Unsupported default value for ${table}.${column}: ${defaultExpression}`,\n    );\n  }\n  return match[1];\n}\n\nexport function mapPostgresToLiteColumn(\n  table: string,\n  column: {name: string; spec: ColumnSpec},\n  ignoreDefault?: 'ignore-default',\n): ColumnSpec {\n  const {pos, dataType, notNull, dflt, elemPgTypeClass = null} = column.spec;\n\n  // PostgreSQL includes [] in dataType for array types (e.g., 'int4[]',\n  // 'int4[][]'). liteTypeString() appends attributes:\n  // \"varchar[]|NOT_NULL|TEXT_ARRAY\", \"my_enum[][]|TEXT_ENUM|TEXT_ARRAY\"\n  const liteType = liteTypeString(\n    dataType,\n    notNull,\n    isEnumColumn(column.spec),\n    isArrayColumn(column.spec),\n  );\n\n  return {\n    pos,\n    dataType: liteType,\n    characterMaximumLength: null,\n    // Note: NOT NULL constraints are always ignored for SQLite (replica) tables.\n    // 1. They are enforced by the replication stream.\n    // 2. We need nullability for columns with defaults to support\n    // write permissions on the \"proposed mutation\" state. Proposed\n    // mutations are written to SQLite in a `BEGIN CONCURRENT` transaction in mutagen.\n    // Permission policies are run against that state (to get their ruling) then the\n    // transaction is rolled back.\n    notNull: false,\n    // Note: DEFAULT constraints are ignored when creating new tables, but are\n    //       necessary for adding columns to tables with existing rows.\n    dflt:\n      ignoreDefault === 'ignore-default'\n        ? null\n        : mapPostgresToLiteDefault(table, column.name, dataType, dflt),\n    elemPgTypeClass,\n  };\n}\n\nexport function mapPostgresToLite(\n  t: TableSpec,\n  defaultVersion?: string,\n): LiteTableSpec {\n  // PRIMARY KEYS are not written to the replica. Instead, we rely\n  // UNIQUE indexes, including those created for upstream PRIMARY KEYs.\n  const {schema: _, primaryKey: _dropped, ...liteSpec} = t;\n  const name = liteTableName(t);\n  return {\n    ...liteSpec,\n    name,\n    columns: {\n      ...Object.fromEntries(\n        Object.entries(t.columns).map(([col, spec]) => [\n          col,\n          // `ignore-default` for create table statements because\n          // there are no rows to set the default for.\n          mapPostgresToLiteColumn(name, {name: col, spec}, 'ignore-default'),\n        ]),\n      ),\n      [ZERO_VERSION_COLUMN_NAME]: zeroVersionColumnSpec(defaultVersion),\n    },\n  };\n}\n\nexport function mapPostgresToLiteIndex(index: IndexSpec): LiteIndexSpec {\n  const {schema, tableName, name, ...liteIndex} = index;\n  return {\n    tableName: liteTableName({schema, name: tableName}),\n    name: liteTableName({schema, name}),\n    ...liteIndex,\n  };\n}\n\nexport class UnsupportedColumnDefaultError extends Error {\n  readonly name = 'UnsupportedColumnDefaultError';\n}\n"],"names":["PostgresTypeClass.Enum","liteTypeString"],"mappings":";;;;;AAsBO,SAAS,aACd,MACS;AACT,UAAQ,KAAK,mBAAmB,KAAK,iBAAiBA;AACxD;AAMO,SAAS,cACd,MACS;AACT,SAAO,KAAK,oBAAoB,QAAQ,KAAK,oBAAoB;AACnE;AAEA,SAAS,sBAAsB,gBAAgD;AAC7E,SAAO;AAAA,IACL,KAAK,OAAO;AAAA;AAAA,IACZ,wBAAwB;AAAA,IACxB,UAAU;AAAA,IACV,SAAS;AAAA,IACT,MAAM,CAAC,iBAAiB,OAAO,IAAI,cAAc;AAAA,IACjD,iBAAiB;AAAA,EAAA;AAErB;AAEO,SAAS,wBACd,IACAC,iBACA,OACA,QACA;AACA,MAAI,uBAAuBA,eAAc,MAAM,QAAW;AACxD,OAAG;AAAA,MACD;AAAA;AAAA,0CAA+C;AAAA,QAC7CA;AAAAA,MAAA,CACD;AAAA,OACS,KAAK,MAAM,MAAM;AAAA;AAAA;AAAA,IAAA;AAAA,EAE/B;AACF;AAIA,MAAM,gCAAgC;AAGtC,MAAM,qBAAqB;AAQ3B,MAAM,0BAA0B;AAGzB,SAAS,yBACd,OACA,QACA,UACA,mBACA;AACA,MAAI,CAAC,mBAAmB;AACtB,WAAO;AAAA,EACT;AACA,MAAI,mBAAmB,KAAK,iBAAiB,GAAG;AAC9C,UAAM,IAAI;AAAA,MACR;AAAA,IAAA;AAAA,EAEJ;AACA,MAAI,8BAA8B,KAAK,iBAAiB,GAAG;AACzD,QAAI,uBAAuB,QAAQ,MAAM,WAAW;AAClD,aAAO,sBAAsB,SAAS,MAAM;AAAA,IAC9C;AACA,WAAO;AAAA,EACT;AACA,QAAM,QAAQ,wBAAwB,KAAK,iBAAiB;AAC5D,MAAI,CAAC,OAAO;AACV,UAAM,IAAI;AAAA,MACR,iCAAiC,KAAK,IAAI,MAAM,KAAK,iBAAiB;AAAA,IAAA;AAAA,EAE1E;AACA,SAAO,MAAM,CAAC;AAChB;AAEO,SAAS,wBACd,OACA,QACA,eACY;AACZ,QAAM,EAAC,KAAK,UAAU,SAAS,MAAM,kBAAkB,SAAQ,OAAO;AAKtE,QAAM,WAAW;AAAA,IACf;AAAA,IACA;AAAA,IACA,aAAa,OAAO,IAAI;AAAA,IACxB,cAAc,OAAO,IAAI;AAAA,EAAA;AAG3B,SAAO;AAAA,IACL;AAAA,IACA,UAAU;AAAA,IACV,wBAAwB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAQxB,SAAS;AAAA;AAAA;AAAA,IAGT,MACE,kBAAkB,mBACd,OACA,yBAAyB,OAAO,OAAO,MAAM,UAAU,IAAI;AAAA,IACjE;AAAA,EAAA;AAEJ;AAEO,SAAS,kBACd,GACA,gBACe;AAGf,QAAM,EAAC,QAAQ,GAAG,YAAY,UAAU,GAAG,aAAY;AACvD,QAAM,OAAO,cAAc,CAAC;AAC5B,SAAO;AAAA,IACL,GAAG;AAAA,IACH;AAAA,IACA,SAAS;AAAA,MACP,GAAG,OAAO;AAAA,QACR,OAAO,QAAQ,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC,KAAK,IAAI,MAAM;AAAA,UAC7C;AAAA;AAAA;AAAA,UAGA,wBAAwB,MAAM,EAAC,MAAM,KAAK,KAAA,GAAO,gBAAgB;AAAA,QAAA,CAClE;AAAA,MAAA;AAAA,MAEH,CAAC,wBAAwB,GAAG,sBAAsB,cAAc;AAAA,IAAA;AAAA,EAClE;AAEJ;AAEO,SAAS,uBAAuB,OAAiC;AACtE,QAAM,EAAC,QAAQ,WAAW,MAAM,GAAG,cAAa;AAChD,SAAO;AAAA,IACL,WAAW,cAAc,EAAC,QAAQ,MAAM,WAAU;AAAA,IAClD,MAAM,cAAc,EAAC,QAAQ,MAAK;AAAA,IAClC,GAAG;AAAA,EAAA;AAEP;AAEO,MAAM,sCAAsC,MAAM;AAAA,EAC9C,OAAO;AAClB;"}
+{"version":3,"file":"pg-to-lite.js","names":[],"sources":["../../../../../zero-cache/src/db/pg-to-lite.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {ZERO_VERSION_COLUMN_NAME} from '../services/replicator/schema/constants.ts';\nimport {\n  liteTypeString,\n  liteTypeToZqlValueType,\n  upstreamDataType,\n  type LiteTypeString,\n} from '../types/lite.ts';\nimport {liteTableName} from '../types/names.ts';\nimport * as PostgresTypeClass from './postgres-type-class-enum.ts';\nimport {\n  type ColumnSpec,\n  type IndexSpec,\n  type LiteIndexSpec,\n  type LiteTableSpec,\n  type TableSpec,\n} from './specs.ts';\n\n/**\n * Determines if a PostgreSQL column is an enum type.\n * This checks both the element type class (for arrays of enums) and the main type class.\n */\nexport function isEnumColumn(\n  spec: Pick<ColumnSpec, 'pgTypeClass' | 'elemPgTypeClass'>,\n): boolean {\n  return (spec.elemPgTypeClass ?? spec.pgTypeClass) === PostgresTypeClass.Enum;\n}\n\n/**\n * Determines if a PostgreSQL column is an array type.\n * In PostgreSQL's system, array columns have a non-null elemPgTypeClass.\n */\nexport function isArrayColumn(\n  spec: Pick<ColumnSpec, 'elemPgTypeClass'>,\n): boolean {\n  return spec.elemPgTypeClass !== null && spec.elemPgTypeClass !== undefined;\n}\n\nfunction zeroVersionColumnSpec(defaultVersion: string | undefined): ColumnSpec {\n  return {\n    pos: Number.MAX_SAFE_INTEGER, // i.e. last\n    characterMaximumLength: null,\n    dataType: 'text',\n    notNull: false,\n    dflt: !defaultVersion ? null : `'${defaultVersion}'`,\n    elemPgTypeClass: null,\n  };\n}\n\nexport function warnIfDataTypeSupported(\n  lc: LogContext,\n  liteTypeString: LiteTypeString,\n  table: string,\n  column: string,\n) {\n  if (liteTypeToZqlValueType(liteTypeString) === undefined) {\n    lc.warn?.(\n      `\\n\\nWARNING: zero does not yet support the \"${upstreamDataType(\n        liteTypeString,\n      )}\" data type.\\n` +\n        `The \"${table}\".\"${column}\" column will not be synced to clients.\\n\\n`,\n    );\n  }\n}\n\n// As per https://www.sqlite.org/lang_altertable.html#altertabaddcol,\n// expressions with parentheses are disallowed ...\nconst SIMPLE_TOKEN_EXPRESSION_REGEX = /^[^'()]+$/; // e.g. true, false, 1234, 1234.5678\n\n// as well as current_time, current_date, and current_timestamp ...\nconst UNSUPPORTED_TOKENS = /\\b(current_time|current_date|current_timestamp)\\b/i;\n\n// For strings and certain incarnations of primitives (e.g. integers greater\n// than 2^31-1, Postgres' nodeToString() represents the values as type-casted\n// 'string' values, e.g. `'2147483648'::bigint`, `'foo'::text`.\n//\n// These type-qualifiers must be removed, as SQLite doesn't understand or\n// care about them.\nconst STRING_EXPRESSION_REGEX = /^('.*')::[^']+$/;\n\n// Exported for testing.\nexport function mapPostgresToLiteDefault(\n  table: string,\n  column: string,\n  dataType: string,\n  defaultExpression: string | null | undefined,\n) {\n  if (!defaultExpression) {\n    return null;\n  }\n  if (UNSUPPORTED_TOKENS.test(defaultExpression)) {\n    throw new UnsupportedColumnDefaultError(\n      `Cannot ADD a column with CURRENT_TIME, CURRENT_DATE, or CURRENT_TIMESTAMP`,\n    );\n  }\n  if (SIMPLE_TOKEN_EXPRESSION_REGEX.test(defaultExpression)) {\n    if (liteTypeToZqlValueType(dataType) === 'boolean') {\n      return defaultExpression === 'true' ? '1' : '0';\n    }\n    return defaultExpression;\n  }\n  const match = STRING_EXPRESSION_REGEX.exec(defaultExpression);\n  if (!match) {\n    throw new UnsupportedColumnDefaultError(\n      `Unsupported default value for ${table}.${column}: ${defaultExpression}`,\n    );\n  }\n  return match[1];\n}\n\nexport function mapPostgresToLiteColumn(\n  table: string,\n  column: {name: string; spec: ColumnSpec},\n  ignoreDefault?: 'ignore-default',\n): ColumnSpec {\n  const {pos, dataType, notNull, dflt, elemPgTypeClass = null} = column.spec;\n\n  // PostgreSQL includes [] in dataType for array types (e.g., 'int4[]',\n  // 'int4[][]'). liteTypeString() appends attributes:\n  // \"varchar[]|NOT_NULL|TEXT_ARRAY\", \"my_enum[][]|TEXT_ENUM|TEXT_ARRAY\"\n  const liteType = liteTypeString(\n    dataType,\n    notNull,\n    isEnumColumn(column.spec),\n    isArrayColumn(column.spec),\n  );\n\n  return {\n    pos,\n    dataType: liteType,\n    characterMaximumLength: null,\n    // Note: NOT NULL constraints are always ignored for SQLite (replica) tables.\n    // 1. They are enforced by the replication stream.\n    // 2. We need nullability for columns with defaults to support\n    // write permissions on the \"proposed mutation\" state. Proposed\n    // mutations are written to SQLite in a `BEGIN CONCURRENT` transaction in mutagen.\n    // Permission policies are run against that state (to get their ruling) then the\n    // transaction is rolled back.\n    notNull: false,\n    // Note: DEFAULT constraints are ignored when creating new tables, but are\n    //       necessary for adding columns to tables with existing rows.\n    dflt:\n      ignoreDefault === 'ignore-default'\n        ? null\n        : mapPostgresToLiteDefault(table, column.name, dataType, dflt),\n    elemPgTypeClass,\n  };\n}\n\nexport function mapPostgresToLite(\n  t: TableSpec,\n  defaultVersion?: string,\n): LiteTableSpec {\n  // PRIMARY KEYS are not written to the replica. Instead, we rely\n  // UNIQUE indexes, including those created for upstream PRIMARY KEYs.\n  const {schema: _, primaryKey: _dropped, ...liteSpec} = t;\n  const name = liteTableName(t);\n  return {\n    ...liteSpec,\n    name,\n    columns: {\n      ...Object.fromEntries(\n        Object.entries(t.columns).map(([col, spec]) => [\n          col,\n          // `ignore-default` for create table statements because\n          // there are no rows to set the default for.\n          mapPostgresToLiteColumn(name, {name: col, spec}, 'ignore-default'),\n        ]),\n      ),\n      [ZERO_VERSION_COLUMN_NAME]: zeroVersionColumnSpec(defaultVersion),\n    },\n  };\n}\n\nexport function mapPostgresToLiteIndex(index: IndexSpec): LiteIndexSpec {\n  const {schema, tableName, name, ...liteIndex} = index;\n  return {\n    tableName: liteTableName({schema, name: tableName}),\n    name: liteTableName({schema, name}),\n    ...liteIndex,\n  };\n}\n\nexport class UnsupportedColumnDefaultError extends Error {\n  readonly name = 'UnsupportedColumnDefaultError';\n}\n"],"mappings":";;;;;;;;;AAsBA,SAAgB,aACd,MACS;AACT,SAAQ,KAAK,mBAAmB,KAAK,iBAAiB;;;;;;AAOxD,SAAgB,cACd,MACS;AACT,QAAO,KAAK,oBAAoB,QAAQ,KAAK,oBAAoB,KAAA;;AAGnE,SAAS,sBAAsB,gBAAgD;AAC7E,QAAO;EACL,KAAK,OAAO;EACZ,wBAAwB;EACxB,UAAU;EACV,SAAS;EACT,MAAM,CAAC,iBAAiB,OAAO,IAAI,eAAe;EAClD,iBAAiB;EAClB;;AAGH,SAAgB,wBACd,IACA,gBACA,OACA,QACA;AACA,KAAI,uBAAuB,eAAe,KAAK,KAAA,EAC7C,IAAG,OACD,+CAA+C,iBAC7C,eACD,CAAC,qBACQ,MAAM,KAAK,OAAO,6CAC7B;;AAML,IAAM,gCAAgC;AAGtC,IAAM,qBAAqB;AAQ3B,IAAM,0BAA0B;AAGhC,SAAgB,yBACd,OACA,QACA,UACA,mBACA;AACA,KAAI,CAAC,kBACH,QAAO;AAET,KAAI,mBAAmB,KAAK,kBAAkB,CAC5C,OAAM,IAAI,8BACR,4EACD;AAEH,KAAI,8BAA8B,KAAK,kBAAkB,EAAE;AACzD,MAAI,uBAAuB,SAAS,KAAK,UACvC,QAAO,sBAAsB,SAAS,MAAM;AAE9C,SAAO;;CAET,MAAM,QAAQ,wBAAwB,KAAK,kBAAkB;AAC7D,KAAI,CAAC,MACH,OAAM,IAAI,8BACR,iCAAiC,MAAM,GAAG,OAAO,IAAI,oBACtD;AAEH,QAAO,MAAM;;AAGf,SAAgB,wBACd,OACA,QACA,eACY;CACZ,MAAM,EAAC,KAAK,UAAU,SAAS,MAAM,kBAAkB,SAAQ,OAAO;AAYtE,QAAO;EACL;EACA,UATe,eACf,UACA,SACA,aAAa,OAAO,KAAK,EACzB,cAAc,OAAO,KAAK,CAC3B;EAKC,wBAAwB;EAQxB,SAAS;EAGT,MACE,kBAAkB,mBACd,OACA,yBAAyB,OAAO,OAAO,MAAM,UAAU,KAAK;EAClE;EACD;;AAGH,SAAgB,kBACd,GACA,gBACe;CAGf,MAAM,EAAC,QAAQ,GAAG,YAAY,UAAU,GAAG,aAAY;CACvD,MAAM,OAAO,cAAc,EAAE;AAC7B,QAAO;EACL,GAAG;EACH;EACA,SAAS;GACP,GAAG,OAAO,YACR,OAAO,QAAQ,EAAE,QAAQ,CAAC,KAAK,CAAC,KAAK,UAAU,CAC7C,KAGA,wBAAwB,MAAM;IAAC,MAAM;IAAK;IAAK,EAAE,iBAAiB,CACnE,CAAC,CACH;IACA,2BAA2B,sBAAsB,eAAe;GAClE;EACF;;AAGH,SAAgB,uBAAuB,OAAiC;CACtE,MAAM,EAAC,QAAQ,WAAW,MAAM,GAAG,cAAa;AAChD,QAAO;EACL,WAAW,cAAc;GAAC;GAAQ,MAAM;GAAU,CAAC;EACnD,MAAM,cAAc;GAAC;GAAQ;GAAK,CAAC;EACnC,GAAG;EACJ;;AAGH,IAAa,gCAAb,cAAmD,MAAM;CACvD,OAAgB"}

package/out/zero-cache/src/db/pg-type-parser.js

@@ -1,40 +1,23 @@
 import { assert } from "../../../shared/src/asserts.js";
 import { mapEntries } from "../../../shared/src/objects.js";
-import { JSON, JSONB } from "../types/pg-types.js";
-const INT4_ARRAY_TYPE = 1007;
-const JSON_TYPE = String(JSON);
-const JSONB_TYPE = String(JSONB);
+import { JSONB } from "../types/pg-types.js";
+//#region ../zero-cache/src/db/pg-type-parser.ts
+var INT4_ARRAY_TYPE = 1007;
+var JSON_TYPE = String(114);
+var JSONB_TYPE = String(JSONB);
 async function getTypeParsers(db, { returnJsonAsString } = {}) {
-  if (!db.options.parsers[INT4_ARRAY_TYPE]) {
-    assert(db.options.fetch_types, `Supplied db must fetch_types`);
-    await db`SELECT 1`.simple();
-    assert(
-      db.options.parsers[INT4_ARRAY_TYPE],
-      `array types not fetched ${Object.keys(db.options.parsers)}`
-    );
-  }
-  const parsers = mapEntries(db.options.parsers, (type, parse) => {
-    if ((type === JSON_TYPE || type === JSONB_TYPE) && returnJsonAsString) {
-      return [type, (x) => x];
-    }
-    const isArrayType = parse.array;
-    return [
-      type,
-      isArrayType ? (val) => parse(val.substring(1)) : parse
-    ];
-  });
-  return {
-    // A type OID for which a parser is not explicitly defined
-    // is parsed as a String.
-    // https://github.com/porsager/postgres/blob/b0d8c8f363e006a74472d76f859da60c52a80368/src/connection.js#L494
-    //
-    // This is also consistent with the `pg` library, in which the absence of a
-    // TypeParser defaults to "noParse":
-    // https://github.com/brianc/node-pg-types/blob/5b26b826466cff4a9092b8c9e31960fe293ef3d9/index.js#L15
-    getTypeParser: (typeOID) => parsers[typeOID] ?? String
-  };
+	if (!db.options.parsers[INT4_ARRAY_TYPE]) {
+		assert(db.options.fetch_types, `Supplied db must fetch_types`);
+		await db`SELECT 1`.simple();
+		assert(db.options.parsers[INT4_ARRAY_TYPE], `array types not fetched ${Object.keys(db.options.parsers)}`);
+	}
+	const parsers = mapEntries(db.options.parsers, (type, parse) => {
+		if ((type === JSON_TYPE || type === JSONB_TYPE) && returnJsonAsString) return [type, (x) => x];
+		return [type, parse.array ? (val) => parse(val.substring(1)) : parse];
+	});
+	return { getTypeParser: (typeOID) => parsers[typeOID] ?? String };
 }
-export {
-  getTypeParsers
-};
-//# sourceMappingURL=pg-type-parser.js.map
+//#endregion
+export { getTypeParsers };
+
+//# sourceMappingURL=pg-type-parser.js.map

package/out/zero-cache/src/db/pg-type-parser.js.map

@@ -1 +1 @@
-{"version":3,"file":"pg-type-parser.js","sources":["../../../../../zero-cache/src/db/pg-type-parser.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport {mapEntries} from '../../../shared/src/objects.ts';\nimport {JSON, JSONB} from '../types/pg-types.ts';\nimport type {PostgresDB} from '../types/pg.ts';\n\n// Arbitrary array type to test if the PostgresDB client has fetched types.\nconst INT4_ARRAY_TYPE = 1007;\n\nexport type TypeParser = (val: string) => unknown;\nexport interface TypeParsers {\n  getTypeParser(typeOID: number): TypeParser;\n}\n\nexport type ParseOptions = {\n  /**\n   * Returns JSON and JSONB values as raw JSON strings (i.e. unparsed).\n   * Note that JSON[] and JSONB[] values are returned as arrays of (parsed)\n   * JSON values.\n   */\n  returnJsonAsString?: boolean;\n};\n\nconst JSON_TYPE = String(JSON);\nconst JSONB_TYPE = String(JSONB);\n\n// postgres.js has default type parsers with user-defined overrides\n// configurable per-client (see `postgresTypeConfig` in types/pg.ts).\n//\n// From these, the postgres.js client will automatically derive parsers\n// for array versions of these types, provided that the client was\n// configured with `fetch_types: true` (which is the default).\n//\n// A replication session (with `database: replication`), however, does\n// not support this type fetching, so it is done on a connection from\n// a default client.\nexport async function getTypeParsers(\n  db: PostgresDB,\n  {returnJsonAsString}: ParseOptions = {},\n): Promise<TypeParsers> {\n  if (!db.options.parsers[INT4_ARRAY_TYPE]) {\n    assert(db.options.fetch_types, `Supplied db must fetch_types`);\n\n    // Execute a query to ensure that fetchArrayTypes() gets executed:\n    // https://github.com/porsager/postgres/blob/089214e85c23c90cf142d47fb30bd03f42874984/src/connection.js#L536\n    await db`SELECT 1`.simple();\n    assert(\n      db.options.parsers[INT4_ARRAY_TYPE],\n      `array types not fetched ${Object.keys(db.options.parsers)}`,\n    );\n  }\n  const parsers = mapEntries(db.options.parsers, (type, parse) => {\n    if ((type === JSON_TYPE || type === JSONB_TYPE) && returnJsonAsString) {\n      return [type, (x: string) => x];\n    }\n    // The postgres.js library tags parsers for array types with an `array: true` field.\n    // https://github.com/porsager/postgres/blob/089214e85c23c90cf142d47fb30bd03f42874984/src/connection.js#L760\n    const isArrayType = (parse as unknown as {array?: boolean}).array;\n\n    // And then skips the first character when parsing the string,\n    // e.g. an array parser will parse '{1,2,3}' from '1,2,3}'.\n    // https://github.com/porsager/postgres/blob/089214e85c23c90cf142d47fb30bd03f42874984/src/connection.js#L496\n    return [\n      type,\n      isArrayType ? (val: string) => parse(val.substring(1)) : parse,\n    ];\n  });\n  return {\n    // A type OID for which a parser is not explicitly defined\n    // is parsed as a String.\n    // https://github.com/porsager/postgres/blob/b0d8c8f363e006a74472d76f859da60c52a80368/src/connection.js#L494\n    //\n    // This is also consistent with the `pg` library, in which the absence of a\n    // TypeParser defaults to \"noParse\":\n    // https://github.com/brianc/node-pg-types/blob/5b26b826466cff4a9092b8c9e31960fe293ef3d9/index.js#L15\n    getTypeParser: typeOID => parsers[typeOID] ?? String,\n  };\n}\n"],"names":[],"mappings":";;;AAMA,MAAM,kBAAkB;AAgBxB,MAAM,YAAY,OAAO,IAAI;AAC7B,MAAM,aAAa,OAAO,KAAK;AAY/B,eAAsB,eACpB,IACA,EAAC,mBAAA,IAAoC,CAAA,GACf;AACtB,MAAI,CAAC,GAAG,QAAQ,QAAQ,eAAe,GAAG;AACxC,WAAO,GAAG,QAAQ,aAAa,8BAA8B;AAI7D,UAAM,aAAa,OAAA;AACnB;AAAA,MACE,GAAG,QAAQ,QAAQ,eAAe;AAAA,MAClC,2BAA2B,OAAO,KAAK,GAAG,QAAQ,OAAO,CAAC;AAAA,IAAA;AAAA,EAE9D;AACA,QAAM,UAAU,WAAW,GAAG,QAAQ,SAAS,CAAC,MAAM,UAAU;AAC9D,SAAK,SAAS,aAAa,SAAS,eAAe,oBAAoB;AACrE,aAAO,CAAC,MAAM,CAAC,MAAc,CAAC;AAAA,IAChC;AAGA,UAAM,cAAe,MAAuC;AAK5D,WAAO;AAAA,MACL;AAAA,MACA,cAAc,CAAC,QAAgB,MAAM,IAAI,UAAU,CAAC,CAAC,IAAI;AAAA,IAAA;AAAA,EAE7D,CAAC;AACD,SAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAQL,eAAe,CAAA,YAAW,QAAQ,OAAO,KAAK;AAAA,EAAA;AAElD;"}
+{"version":3,"file":"pg-type-parser.js","names":[],"sources":["../../../../../zero-cache/src/db/pg-type-parser.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport {mapEntries} from '../../../shared/src/objects.ts';\nimport {JSON, JSONB} from '../types/pg-types.ts';\nimport type {PostgresDB} from '../types/pg.ts';\n\n// Arbitrary array type to test if the PostgresDB client has fetched types.\nconst INT4_ARRAY_TYPE = 1007;\n\nexport type TypeParser = (val: string) => unknown;\nexport interface TypeParsers {\n  getTypeParser(typeOID: number): TypeParser;\n}\n\nexport type ParseOptions = {\n  /**\n   * Returns JSON and JSONB values as raw JSON strings (i.e. unparsed).\n   * Note that JSON[] and JSONB[] values are returned as arrays of (parsed)\n   * JSON values.\n   */\n  returnJsonAsString?: boolean;\n};\n\nconst JSON_TYPE = String(JSON);\nconst JSONB_TYPE = String(JSONB);\n\n// postgres.js has default type parsers with user-defined overrides\n// configurable per-client (see `postgresTypeConfig` in types/pg.ts).\n//\n// From these, the postgres.js client will automatically derive parsers\n// for array versions of these types, provided that the client was\n// configured with `fetch_types: true` (which is the default).\n//\n// A replication session (with `database: replication`), however, does\n// not support this type fetching, so it is done on a connection from\n// a default client.\nexport async function getTypeParsers(\n  db: PostgresDB,\n  {returnJsonAsString}: ParseOptions = {},\n): Promise<TypeParsers> {\n  if (!db.options.parsers[INT4_ARRAY_TYPE]) {\n    assert(db.options.fetch_types, `Supplied db must fetch_types`);\n\n    // Execute a query to ensure that fetchArrayTypes() gets executed:\n    // https://github.com/porsager/postgres/blob/089214e85c23c90cf142d47fb30bd03f42874984/src/connection.js#L536\n    await db`SELECT 1`.simple();\n    assert(\n      db.options.parsers[INT4_ARRAY_TYPE],\n      `array types not fetched ${Object.keys(db.options.parsers)}`,\n    );\n  }\n  const parsers = mapEntries(db.options.parsers, (type, parse) => {\n    if ((type === JSON_TYPE || type === JSONB_TYPE) && returnJsonAsString) {\n      return [type, (x: string) => x];\n    }\n    // The postgres.js library tags parsers for array types with an `array: true` field.\n    // https://github.com/porsager/postgres/blob/089214e85c23c90cf142d47fb30bd03f42874984/src/connection.js#L760\n    const isArrayType = (parse as unknown as {array?: boolean}).array;\n\n    // And then skips the first character when parsing the string,\n    // e.g. an array parser will parse '{1,2,3}' from '1,2,3}'.\n    // https://github.com/porsager/postgres/blob/089214e85c23c90cf142d47fb30bd03f42874984/src/connection.js#L496\n    return [\n      type,\n      isArrayType ? (val: string) => parse(val.substring(1)) : parse,\n    ];\n  });\n  return {\n    // A type OID for which a parser is not explicitly defined\n    // is parsed as a String.\n    // https://github.com/porsager/postgres/blob/b0d8c8f363e006a74472d76f859da60c52a80368/src/connection.js#L494\n    //\n    // This is also consistent with the `pg` library, in which the absence of a\n    // TypeParser defaults to \"noParse\":\n    // https://github.com/brianc/node-pg-types/blob/5b26b826466cff4a9092b8c9e31960fe293ef3d9/index.js#L15\n    getTypeParser: typeOID => parsers[typeOID] ?? String,\n  };\n}\n"],"mappings":";;;;AAMA,IAAM,kBAAkB;AAgBxB,IAAM,YAAY,OAAA,IAAY;AAC9B,IAAM,aAAa,OAAO,MAAM;AAYhC,eAAsB,eACpB,IACA,EAAC,uBAAoC,EAAE,EACjB;AACtB,KAAI,CAAC,GAAG,QAAQ,QAAQ,kBAAkB;AACxC,SAAO,GAAG,QAAQ,aAAa,+BAA+B;AAI9D,QAAM,EAAE,WAAW,QAAQ;AAC3B,SACE,GAAG,QAAQ,QAAQ,kBACnB,2BAA2B,OAAO,KAAK,GAAG,QAAQ,QAAQ,GAC3D;;CAEH,MAAM,UAAU,WAAW,GAAG,QAAQ,UAAU,MAAM,UAAU;AAC9D,OAAK,SAAS,aAAa,SAAS,eAAe,mBACjD,QAAO,CAAC,OAAO,MAAc,EAAE;AASjC,SAAO,CACL,MANmB,MAAuC,SAO3C,QAAgB,MAAM,IAAI,UAAU,EAAE,CAAC,GAAG,MAC1D;GACD;AACF,QAAO,EAQL,gBAAe,YAAW,QAAQ,YAAY,QAC/C"}

package/out/zero-cache/src/db/run-transaction.js

@@ -1,24 +1,23 @@
 import "../types/pg.js";
 import { READ_COMMITTED } from "./mode-enum.js";
-const IDLE_IN_TRANSACTION_SESSION_TIMEOUT_MS = parseInt(
-  process.env.ZERO_IDLE_IN_TRANSACTION_SESSION_TIMEOUT ?? "60000"
-);
+//#region ../zero-cache/src/db/run-transaction.ts
+var IDLE_IN_TRANSACTION_SESSION_TIMEOUT_MS = parseInt(process.env.ZERO_IDLE_IN_TRANSACTION_SESSION_TIMEOUT ?? "60000");
+/**
+* Runs a zero-cache transaction on the given postgres DB. For consistency
+* across various postgres providers, certain transaction-level parameters
+* are set to override any defaults set by the provider, including:
+* * `statement_timeout` (disabled)
+* * `idle_in_transaction_session_timeout` (1min)
+*/
 function runTx(db, fn, opts = {}) {
-  const {
-    // Explicitly default to the Postgres default to override any custom
-    // `default_transaction_isolation`.
-    mode = READ_COMMITTED
-  } = opts;
-  return db.begin(mode, (sql) => {
-    void sql`SET LOCAL statement_timeout = 0;`.execute();
-    void sql.unsafe(
-      /*sql*/
-      `SET LOCAL idle_in_transaction_session_timeout = ${IDLE_IN_TRANSACTION_SESSION_TIMEOUT_MS}`
-    ).execute();
-    return fn(sql);
-  });
+	const { mode = READ_COMMITTED } = opts;
+	return db.begin(mode, (sql) => {
+		sql`SET LOCAL statement_timeout = 0;`.execute();
+		sql.unsafe(`SET LOCAL idle_in_transaction_session_timeout = ${IDLE_IN_TRANSACTION_SESSION_TIMEOUT_MS}`).execute();
+		return fn(sql);
+	});
 }
-export {
-  runTx
-};
-//# sourceMappingURL=run-transaction.js.map
+//#endregion
+export { runTx };
+
+//# sourceMappingURL=run-transaction.js.map

package/out/zero-cache/src/db/run-transaction.js.map

@@ -1 +1 @@
-{"version":3,"file":"run-transaction.js","sources":["../../../../../zero-cache/src/db/run-transaction.ts"],"sourcesContent":["import type {Enum} from '../../../shared/src/enum.ts';\nimport {type PostgresDB, type PostgresTransaction} from '../types/pg.ts';\nimport type * as Mode from './mode-enum.ts';\nimport {READ_COMMITTED} from './mode-enum.ts';\n\ntype Mode = Enum<typeof Mode>;\n\n// The default timeout is settable by ZERO_IDLE_IN_TRANSACTION_SESSION_TIMEOUT\n// as an emergency measure and is explicitly not made available as a server\n// option. This value is function of how the zero-cache uses transactions, and\n// should never need to be \"tuned\" or adjusted for different environments.\nconst IDLE_IN_TRANSACTION_SESSION_TIMEOUT_MS = parseInt(\n  process.env.ZERO_IDLE_IN_TRANSACTION_SESSION_TIMEOUT ?? '60000',\n);\n\nexport type TransactionOptions = {\n  mode?: Mode;\n};\n\n/**\n * Runs a zero-cache transaction on the given postgres DB. For consistency\n * across various postgres providers, certain transaction-level parameters\n * are set to override any defaults set by the provider, including:\n * * `statement_timeout` (disabled)\n * * `idle_in_transaction_session_timeout` (1min)\n */\nexport function runTx<T>(\n  db: PostgresDB,\n  fn: (tx: PostgresTransaction) => T | Promise<T>,\n  opts: TransactionOptions = {},\n) {\n  const {\n    // Explicitly default to the Postgres default to override any custom\n    // `default_transaction_isolation`.\n    mode = READ_COMMITTED,\n  } = opts;\n  return db.begin(mode, sql => {\n    // Disable any statement_timeout for the current transaction. By default,\n    // Postgres does not impose a statement timeout, but some users and\n    // providers set one at the database level (even though it is explicitly\n    // discouraged by the Postgres documentation).\n    //\n    // Zero logic in particular often does not fit into the category of general\n    // application logic; for potentially long-running operations like\n    // migrations and background cleanup, the statement timeout should be\n    // disabled to prevent these operations from timing out.\n    void sql`SET LOCAL statement_timeout = 0;`.execute();\n\n    // Set an idle_in_transaction_session_timeout to limit the blast radius of\n    // orphaned transactions. The zero-cache does not keep transactions open\n    // and idle (though this may change if support for streaming of in-progress\n    // transactions is added to our logical replication layer).\n    void sql\n      .unsafe(\n        /*sql*/ `SET LOCAL idle_in_transaction_session_timeout = ${IDLE_IN_TRANSACTION_SESSION_TIMEOUT_MS}`,\n      )\n      .execute();\n\n    return fn(sql);\n  });\n}\n"],"names":[],"mappings":";;AAWA,MAAM,yCAAyC;AAAA,EAC7C,QAAQ,IAAI,4CAA4C;AAC1D;AAaO,SAAS,MACd,IACA,IACA,OAA2B,CAAA,GAC3B;AACA,QAAM;AAAA;AAAA;AAAA,IAGJ,OAAO;AAAA,EAAA,IACL;AACJ,SAAO,GAAG,MAAM,MAAM,CAAA,QAAO;AAU3B,SAAK,sCAAsC,QAAA;AAM3C,SAAK,IACF;AAAA;AAAA,MACS,mDAAmD,sCAAsC;AAAA,IAAA,EAElG,QAAA;AAEH,WAAO,GAAG,GAAG;AAAA,EACf,CAAC;AACH;"}
+{"version":3,"file":"run-transaction.js","names":[],"sources":["../../../../../zero-cache/src/db/run-transaction.ts"],"sourcesContent":["import type {Enum} from '../../../shared/src/enum.ts';\nimport {type PostgresDB, type PostgresTransaction} from '../types/pg.ts';\nimport type * as Mode from './mode-enum.ts';\nimport {READ_COMMITTED} from './mode-enum.ts';\n\ntype Mode = Enum<typeof Mode>;\n\n// The default timeout is settable by ZERO_IDLE_IN_TRANSACTION_SESSION_TIMEOUT\n// as an emergency measure and is explicitly not made available as a server\n// option. This value is function of how the zero-cache uses transactions, and\n// should never need to be \"tuned\" or adjusted for different environments.\nconst IDLE_IN_TRANSACTION_SESSION_TIMEOUT_MS = parseInt(\n  process.env.ZERO_IDLE_IN_TRANSACTION_SESSION_TIMEOUT ?? '60000',\n);\n\nexport type TransactionOptions = {\n  mode?: Mode;\n};\n\n/**\n * Runs a zero-cache transaction on the given postgres DB. For consistency\n * across various postgres providers, certain transaction-level parameters\n * are set to override any defaults set by the provider, including:\n * * `statement_timeout` (disabled)\n * * `idle_in_transaction_session_timeout` (1min)\n */\nexport function runTx<T>(\n  db: PostgresDB,\n  fn: (tx: PostgresTransaction) => T | Promise<T>,\n  opts: TransactionOptions = {},\n) {\n  const {\n    // Explicitly default to the Postgres default to override any custom\n    // `default_transaction_isolation`.\n    mode = READ_COMMITTED,\n  } = opts;\n  return db.begin(mode, sql => {\n    // Disable any statement_timeout for the current transaction. By default,\n    // Postgres does not impose a statement timeout, but some users and\n    // providers set one at the database level (even though it is explicitly\n    // discouraged by the Postgres documentation).\n    //\n    // Zero logic in particular often does not fit into the category of general\n    // application logic; for potentially long-running operations like\n    // migrations and background cleanup, the statement timeout should be\n    // disabled to prevent these operations from timing out.\n    void sql`SET LOCAL statement_timeout = 0;`.execute();\n\n    // Set an idle_in_transaction_session_timeout to limit the blast radius of\n    // orphaned transactions. The zero-cache does not keep transactions open\n    // and idle (though this may change if support for streaming of in-progress\n    // transactions is added to our logical replication layer).\n    void sql\n      .unsafe(\n        /*sql*/ `SET LOCAL idle_in_transaction_session_timeout = ${IDLE_IN_TRANSACTION_SESSION_TIMEOUT_MS}`,\n      )\n      .execute();\n\n    return fn(sql);\n  });\n}\n"],"mappings":";;;AAWA,IAAM,yCAAyC,SAC7C,QAAQ,IAAI,4CAA4C,QACzD;;;;;;;;AAaD,SAAgB,MACd,IACA,IACA,OAA2B,EAAE,EAC7B;CACA,MAAM,EAGJ,OAAO,mBACL;AACJ,QAAO,GAAG,MAAM,OAAM,QAAO;AAUtB,KAAG,mCAAmC,SAAS;AAM/C,MACF,OACS,mDAAmD,yCAC5D,CACA,SAAS;AAEZ,SAAO,GAAG,IAAI;GACd"}

package/out/zero-cache/src/db/specs.d.ts

@@ -75,7 +75,7 @@ export declare const publishedTableSpec: v.ObjectType<Omit<Omit<{
 }, undefined>;
 export type MutableLiteTableSpec = v.Infer<typeof liteTableSpec>;
 export type LiteTableSpec = Readonly<MutableLiteTableSpec>;
-export type LiteTableSpecWithKeys = Omit<LiteTableSpec, 'primaryKey'> & {
+export type LiteTableSpecWithKeysAndVersion = Omit<LiteTableSpec, 'primaryKey'> & {
     /**
      * All keys associated with a unique index.  Includes indexes with
      * nullable columns.
@@ -92,9 +92,15 @@ export type LiteTableSpecWithKeys = Omit<LiteTableSpec, 'primaryKey'> & {
      * columns, i.e. suitable as a primary key.
      */
     allPotentialPrimaryKeys: PrimaryKey[];
+    /**
+     * The minimum `_0_version` value for every row in the table. If this is
+     * present, `_0_version` value in the row itself should only be used if
+     * it is greater (i.e. later) than the `minRowVersion`.
+     */
+    minRowVersion: string | null;
 };
 export type LiteAndZqlSpec = {
-    tableSpec: LiteTableSpecWithKeys;
+    tableSpec: LiteTableSpecWithKeysAndVersion;
     zqlSpec: Record<string, SchemaValue>;
 };
 export type TableSpec = Readonly<v.Infer<typeof tableSpec>>;

package/out/zero-cache/src/db/specs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"specs.d.ts","sourceRoot":"","sources":["../../../../../zero-cache/src/db/specs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,6BAA6B,CAAC;AAC9D,OAAO,KAAK,CAAC,MAAM,+BAA+B,CAAC;AACnD,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,2CAA2C,CAAC;AAC1E,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,0CAA0C,CAAC;AAI1E,eAAO,MAAM,iBAAiB,iDAQ7B,CAAC;AASF,eAAO,MAAM,UAAU;;;;;;;;aAarB,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC,CAAC;AAM9D,eAAO,MAAM,aAAa;;;;;;;;;;;;aAIxB,CAAC;AAEH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;aAEpB,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAQ7B,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAEjE,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC,oBAAoB,CAAC,CAAC;AAE3D,MAAM,MAAM,qBAAqB,GAAG,IAAI,CAAC,aAAa,EAAE,YAAY,CAAC,GAAG;IACtE;;;OAGG;IACH,UAAU,EAAE,UAAU,EAAE,CAAC;IAEzB;;;;OAIG;IACH,UAAU,EAAE,UAAU,CAAC;IAEvB;;;OAGG;IACH,uBAAuB,EAAE,UAAU,EAAE,CAAC;CACvC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,SAAS,EAAE,qBAAqB,CAAC;IACjC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC,CAAC;AAE5D,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC,CAAC;AAE9E,eAAO,MAAM,eAAe,wBAAgC,CAAC;AAE7D,eAAO,MAAM,aAAa;;;;;aAKxB,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAEjE,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC,oBAAoB,CAAC,CAAC;AAE3D,eAAO,MAAM,SAAS;;;;;;;aAEpB,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC,CAAC;AAEhE,eAAO,MAAM,kBAAkB;;;;;;;;;;;aAI7B,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,YAAY,CAC3C,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CACnC,CAAC"}
+{"version":3,"file":"specs.d.ts","sourceRoot":"","sources":["../../../../../zero-cache/src/db/specs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,6BAA6B,CAAC;AAC9D,OAAO,KAAK,CAAC,MAAM,+BAA+B,CAAC;AACnD,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,2CAA2C,CAAC;AAC1E,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,0CAA0C,CAAC;AAI1E,eAAO,MAAM,iBAAiB,iDAQ7B,CAAC;AASF,eAAO,MAAM,UAAU;;;;;;;;aAarB,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC,CAAC;AAM9D,eAAO,MAAM,aAAa;;;;;;;;;;;;aAIxB,CAAC;AAEH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;aAEpB,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAQ7B,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAEjE,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC,oBAAoB,CAAC,CAAC;AAE3D,MAAM,MAAM,+BAA+B,GAAG,IAAI,CAChD,aAAa,EACb,YAAY,CACb,GAAG;IACF;;;OAGG;IACH,UAAU,EAAE,UAAU,EAAE,CAAC;IAEzB;;;;OAIG;IACH,UAAU,EAAE,UAAU,CAAC;IAEvB;;;OAGG;IACH,uBAAuB,EAAE,UAAU,EAAE,CAAC;IAEtC;;;;OAIG;IACH,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,SAAS,EAAE,+BAA+B,CAAC;IAC3C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC,CAAC;AAE5D,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC,CAAC;AAE9E,eAAO,MAAM,eAAe,wBAAgC,CAAC;AAE7D,eAAO,MAAM,aAAa;;;;;aAKxB,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAEjE,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC,oBAAoB,CAAC,CAAC;AAE3D,eAAO,MAAM,SAAS;;;;;;;aAEpB,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC,CAAC;AAEhE,eAAO,MAAM,kBAAkB;;;;;;;;;;;aAI7B,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,YAAY,CAC3C,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CACnC,CAAC"}

package/out/zero-cache/src/db/specs.js

@@ -1,78 +1,42 @@
-import { literalUnion } from "../../../shared/src/valita.js";
-import { Index, Full, Nothing, Default } from "./postgres-replica-identity-enum.js";
-import { Multirange, Range, Pseudo, Enum, Domain, Composite, Base } from "./postgres-type-class-enum.js";
-import { object, string, boolean, number, array, record } from "@badrap/valita";
-const pgTypeClassSchema = literalUnion(
-  Base,
-  Composite,
-  Domain,
-  Enum,
-  Pseudo,
-  Range,
-  Multirange
-);
-const pgReplicaIdentitySchema = literalUnion(
-  Default,
-  Nothing,
-  Full,
-  Index
-);
-const columnSpec = object({
-  pos: number(),
-  dataType: string(),
-  pgTypeClass: pgTypeClassSchema.optional(),
-  // If the column is an array, this will be the type of the
-  // elements in the array. If the column is not an array,
-  // this will be null.
-  elemPgTypeClass: pgTypeClassSchema.nullable().optional(),
-  characterMaximumLength: number().nullable().optional(),
-  notNull: boolean().nullable().optional(),
-  dflt: string().nullable().optional()
-});
-const publishedColumnSpec = columnSpec.extend({
-  typeOID: number()
-});
-const liteTableSpec = object({
-  name: string(),
-  columns: record(columnSpec),
-  primaryKey: array(string()).optional()
-});
-const tableSpec = liteTableSpec.extend({
-  schema: string()
-});
-const publishedTableSpec = tableSpec.extend({
-  oid: number(),
-  // Always present for new instances (e.g. from DDL triggers), but
-  // may from `initialSchema` object stored in the `replicas` table.
-  schemaOID: number().optional(),
-  columns: record(publishedColumnSpec),
-  replicaIdentity: pgReplicaIdentitySchema.optional(),
-  publications: record(object({ rowFilter: string().nullable() }))
-});
-const directionSchema = literalUnion("ASC", "DESC");
-const liteIndexSpec = object({
-  name: string(),
-  tableName: string(),
-  unique: boolean(),
-  columns: record(directionSchema)
-});
-const indexSpec = liteIndexSpec.extend({
-  schema: string()
-});
-const publishedIndexSpec = indexSpec.extend({
-  isReplicaIdentity: boolean().optional(),
-  isPrimaryKey: boolean().optional(),
-  isImmediate: boolean().optional()
-});
-export {
-  columnSpec,
-  directionSchema,
-  indexSpec,
-  liteIndexSpec,
-  liteTableSpec,
-  pgTypeClassSchema,
-  publishedIndexSpec,
-  publishedTableSpec,
-  tableSpec
-};
-//# sourceMappingURL=specs.js.map
+import { literalUnion, valita_exports } from "../../../shared/src/valita.js";
+//#region ../zero-cache/src/db/specs.ts
+var pgTypeClassSchema = literalUnion("b", "c", "d", "e", "p", "r", "m");
+var pgReplicaIdentitySchema = literalUnion("d", "n", "f", "i");
+var columnSpec = valita_exports.object({
+	pos: valita_exports.number(),
+	dataType: valita_exports.string(),
+	pgTypeClass: pgTypeClassSchema.optional(),
+	elemPgTypeClass: pgTypeClassSchema.nullable().optional(),
+	characterMaximumLength: valita_exports.number().nullable().optional(),
+	notNull: valita_exports.boolean().nullable().optional(),
+	dflt: valita_exports.string().nullable().optional()
+});
+var publishedColumnSpec = columnSpec.extend({ typeOID: valita_exports.number() });
+var tableSpec = valita_exports.object({
+	name: valita_exports.string(),
+	columns: valita_exports.record(columnSpec),
+	primaryKey: valita_exports.array(valita_exports.string()).optional()
+}).extend({ schema: valita_exports.string() });
+var publishedTableSpec = tableSpec.extend({
+	oid: valita_exports.number(),
+	schemaOID: valita_exports.number().optional(),
+	columns: valita_exports.record(publishedColumnSpec),
+	replicaIdentity: pgReplicaIdentitySchema.optional(),
+	publications: valita_exports.record(valita_exports.object({ rowFilter: valita_exports.string().nullable() }))
+});
+var directionSchema = literalUnion("ASC", "DESC");
+var indexSpec = valita_exports.object({
+	name: valita_exports.string(),
+	tableName: valita_exports.string(),
+	unique: valita_exports.boolean(),
+	columns: valita_exports.record(directionSchema)
+}).extend({ schema: valita_exports.string() });
+var publishedIndexSpec = indexSpec.extend({
+	isReplicaIdentity: valita_exports.boolean().optional(),
+	isPrimaryKey: valita_exports.boolean().optional(),
+	isImmediate: valita_exports.boolean().optional()
+});
+//#endregion
+export { columnSpec, indexSpec, publishedIndexSpec, publishedTableSpec, tableSpec };
+
+//# sourceMappingURL=specs.js.map

package/out/zero-cache/src/db/specs.js.map

@@ -1 +1 @@
-{"version":3,"file":"specs.js","sources":["../../../../../zero-cache/src/db/specs.ts"],"sourcesContent":["import type {DeepReadonly} from '../../../shared/src/json.ts';\nimport * as v from '../../../shared/src/valita.ts';\nimport type {PrimaryKey} from '../../../zero-protocol/src/primary-key.ts';\nimport type {SchemaValue} from '../../../zero-schema/src/table-schema.ts';\nimport * as PostgresReplicaIdentity from './postgres-replica-identity-enum.ts';\nimport * as PostgresTypeClass from './postgres-type-class-enum.ts';\n\nexport const pgTypeClassSchema = v.literalUnion(\n  PostgresTypeClass.Base,\n  PostgresTypeClass.Composite,\n  PostgresTypeClass.Domain,\n  PostgresTypeClass.Enum,\n  PostgresTypeClass.Pseudo,\n  PostgresTypeClass.Range,\n  PostgresTypeClass.Multirange,\n);\n\nconst pgReplicaIdentitySchema = v.literalUnion(\n  PostgresReplicaIdentity.Default,\n  PostgresReplicaIdentity.Nothing,\n  PostgresReplicaIdentity.Full,\n  PostgresReplicaIdentity.Index,\n);\n\nexport const columnSpec = v.object({\n  pos: v.number(),\n  dataType: v.string(),\n  pgTypeClass: pgTypeClassSchema.optional(),\n\n  // If the column is an array, this will be the type of the\n  // elements in the array. If the column is not an array,\n  // this will be null.\n  elemPgTypeClass: pgTypeClassSchema.nullable().optional(),\n\n  characterMaximumLength: v.number().nullable().optional(),\n  notNull: v.boolean().nullable().optional(),\n  dflt: v.string().nullable().optional(),\n});\n\nexport type ColumnSpec = Readonly<v.Infer<typeof columnSpec>>;\n\nconst publishedColumnSpec = columnSpec.extend({\n  typeOID: v.number(),\n});\n\nexport const liteTableSpec = v.object({\n  name: v.string(),\n  columns: v.record(columnSpec),\n  primaryKey: v.array(v.string()).optional(),\n});\n\nexport const tableSpec = liteTableSpec.extend({\n  schema: v.string(),\n});\n\nexport const publishedTableSpec = tableSpec.extend({\n  oid: v.number(),\n  // Always present for new instances (e.g. from DDL triggers), but\n  // may from `initialSchema` object stored in the `replicas` table.\n  schemaOID: v.number().optional(),\n  columns: v.record(publishedColumnSpec),\n  replicaIdentity: pgReplicaIdentitySchema.optional(),\n  publications: v.record(v.object({rowFilter: v.string().nullable()})),\n});\n\nexport type MutableLiteTableSpec = v.Infer<typeof liteTableSpec>;\n\nexport type LiteTableSpec = Readonly<MutableLiteTableSpec>;\n\nexport type LiteTableSpecWithKeys = Omit<LiteTableSpec, 'primaryKey'> & {\n  /**\n   * All keys associated with a unique index.  Includes indexes with\n   * nullable columns.\n   */\n  uniqueKeys: PrimaryKey[];\n\n  /**\n   * The key selected to act as the \"primary key\". Primary keys\n   * are not explicitly set on the replica, but an appropriate\n   * unique index is required.\n   */\n  primaryKey: PrimaryKey; // note: required\n\n  /**\n   * All keys associated with a unique index over non-null\n   * columns, i.e. suitable as a primary key.\n   */\n  allPotentialPrimaryKeys: PrimaryKey[];\n};\n\nexport type LiteAndZqlSpec = {\n  tableSpec: LiteTableSpecWithKeys;\n  zqlSpec: Record<string, SchemaValue>;\n};\n\nexport type TableSpec = Readonly<v.Infer<typeof tableSpec>>;\n\nexport type PublishedTableSpec = Readonly<v.Infer<typeof publishedTableSpec>>;\n\nexport const directionSchema = v.literalUnion('ASC', 'DESC');\n\nexport const liteIndexSpec = v.object({\n  name: v.string(),\n  tableName: v.string(),\n  unique: v.boolean(),\n  columns: v.record(directionSchema),\n});\n\nexport type MutableLiteIndexSpec = v.Infer<typeof liteIndexSpec>;\n\nexport type LiteIndexSpec = Readonly<MutableLiteIndexSpec>;\n\nexport const indexSpec = liteIndexSpec.extend({\n  schema: v.string(),\n});\n\nexport type IndexSpec = DeepReadonly<v.Infer<typeof indexSpec>>;\n\nexport const publishedIndexSpec = indexSpec.extend({\n  isReplicaIdentity: v.boolean().optional(),\n  isPrimaryKey: v.boolean().optional(),\n  isImmediate: v.boolean().optional(),\n});\n\nexport type PublishedIndexSpec = DeepReadonly<\n  v.Infer<typeof publishedIndexSpec>\n>;\n"],"names":["v.literalUnion","PostgresTypeClass.Base","PostgresTypeClass.Composite","PostgresTypeClass.Domain","PostgresTypeClass.Enum","PostgresTypeClass.Pseudo","PostgresTypeClass.Range","PostgresTypeClass.Multirange","PostgresReplicaIdentity.Default","PostgresReplicaIdentity.Nothing","PostgresReplicaIdentity.Full","PostgresReplicaIdentity.Index","v.object","v.number","v.string","v.boolean","v.record","v.array"],"mappings":";;;;AAOO,MAAM,oBAAoBA;AAAAA,EAC/BC;AAAAA,EACAC;AAAAA,EACAC;AAAAA,EACAC;AAAAA,EACAC;AAAAA,EACAC;AAAAA,EACAC;AACF;AAEA,MAAM,0BAA0BP;AAAAA,EAC9BQ;AAAAA,EACAC;AAAAA,EACAC;AAAAA,EACAC;AACF;AAEO,MAAM,aAAaC,OAAS;AAAA,EACjC,KAAKC,OAAE;AAAA,EACP,UAAUC,OAAE;AAAA,EACZ,aAAa,kBAAkB,SAAA;AAAA;AAAA;AAAA;AAAA,EAK/B,iBAAiB,kBAAkB,SAAA,EAAW,SAAA;AAAA,EAE9C,wBAAwBD,OAAE,EAAS,SAAA,EAAW,SAAA;AAAA,EAC9C,SAASE,QAAE,EAAU,SAAA,EAAW,SAAA;AAAA,EAChC,MAAMD,OAAE,EAAS,SAAA,EAAW,SAAA;AAC9B,CAAC;AAID,MAAM,sBAAsB,WAAW,OAAO;AAAA,EAC5C,SAASD,OAAE;AACb,CAAC;AAEM,MAAM,gBAAgBD,OAAS;AAAA,EACpC,MAAME,OAAE;AAAA,EACR,SAASE,OAAS,UAAU;AAAA,EAC5B,YAAYC,MAAQH,OAAE,CAAQ,EAAE,SAAA;AAClC,CAAC;AAEM,MAAM,YAAY,cAAc,OAAO;AAAA,EAC5C,QAAQA,OAAE;AACZ,CAAC;AAEM,MAAM,qBAAqB,UAAU,OAAO;AAAA,EACjD,KAAKD,OAAE;AAAA;AAAA;AAAA,EAGP,WAAWA,OAAE,EAAS,SAAA;AAAA,EACtB,SAASG,OAAS,mBAAmB;AAAA,EACrC,iBAAiB,wBAAwB,SAAA;AAAA,EACzC,cAAcA,OAASJ,OAAS,EAAC,WAAWE,OAAE,EAAS,SAAA,GAAW,CAAC;AACrE,CAAC;AAoCM,MAAM,kBAAkBd,aAAe,OAAO,MAAM;AAEpD,MAAM,gBAAgBY,OAAS;AAAA,EACpC,MAAME,OAAE;AAAA,EACR,WAAWA,OAAE;AAAA,EACb,QAAQC,QAAE;AAAA,EACV,SAASC,OAAS,eAAe;AACnC,CAAC;AAMM,MAAM,YAAY,cAAc,OAAO;AAAA,EAC5C,QAAQF,OAAE;AACZ,CAAC;AAIM,MAAM,qBAAqB,UAAU,OAAO;AAAA,EACjD,mBAAmBC,QAAE,EAAU,SAAA;AAAA,EAC/B,cAAcA,QAAE,EAAU,SAAA;AAAA,EAC1B,aAAaA,QAAE,EAAU,SAAA;AAC3B,CAAC;"}
+{"version":3,"file":"specs.js","names":[],"sources":["../../../../../zero-cache/src/db/specs.ts"],"sourcesContent":["import type {DeepReadonly} from '../../../shared/src/json.ts';\nimport * as v from '../../../shared/src/valita.ts';\nimport type {PrimaryKey} from '../../../zero-protocol/src/primary-key.ts';\nimport type {SchemaValue} from '../../../zero-schema/src/table-schema.ts';\nimport * as PostgresReplicaIdentity from './postgres-replica-identity-enum.ts';\nimport * as PostgresTypeClass from './postgres-type-class-enum.ts';\n\nexport const pgTypeClassSchema = v.literalUnion(\n  PostgresTypeClass.Base,\n  PostgresTypeClass.Composite,\n  PostgresTypeClass.Domain,\n  PostgresTypeClass.Enum,\n  PostgresTypeClass.Pseudo,\n  PostgresTypeClass.Range,\n  PostgresTypeClass.Multirange,\n);\n\nconst pgReplicaIdentitySchema = v.literalUnion(\n  PostgresReplicaIdentity.Default,\n  PostgresReplicaIdentity.Nothing,\n  PostgresReplicaIdentity.Full,\n  PostgresReplicaIdentity.Index,\n);\n\nexport const columnSpec = v.object({\n  pos: v.number(),\n  dataType: v.string(),\n  pgTypeClass: pgTypeClassSchema.optional(),\n\n  // If the column is an array, this will be the type of the\n  // elements in the array. If the column is not an array,\n  // this will be null.\n  elemPgTypeClass: pgTypeClassSchema.nullable().optional(),\n\n  characterMaximumLength: v.number().nullable().optional(),\n  notNull: v.boolean().nullable().optional(),\n  dflt: v.string().nullable().optional(),\n});\n\nexport type ColumnSpec = Readonly<v.Infer<typeof columnSpec>>;\n\nconst publishedColumnSpec = columnSpec.extend({\n  typeOID: v.number(),\n});\n\nexport const liteTableSpec = v.object({\n  name: v.string(),\n  columns: v.record(columnSpec),\n  primaryKey: v.array(v.string()).optional(),\n});\n\nexport const tableSpec = liteTableSpec.extend({\n  schema: v.string(),\n});\n\nexport const publishedTableSpec = tableSpec.extend({\n  oid: v.number(),\n  // Always present for new instances (e.g. from DDL triggers), but\n  // may from `initialSchema` object stored in the `replicas` table.\n  schemaOID: v.number().optional(),\n  columns: v.record(publishedColumnSpec),\n  replicaIdentity: pgReplicaIdentitySchema.optional(),\n  publications: v.record(v.object({rowFilter: v.string().nullable()})),\n});\n\nexport type MutableLiteTableSpec = v.Infer<typeof liteTableSpec>;\n\nexport type LiteTableSpec = Readonly<MutableLiteTableSpec>;\n\nexport type LiteTableSpecWithKeysAndVersion = Omit<\n  LiteTableSpec,\n  'primaryKey'\n> & {\n  /**\n   * All keys associated with a unique index.  Includes indexes with\n   * nullable columns.\n   */\n  uniqueKeys: PrimaryKey[];\n\n  /**\n   * The key selected to act as the \"primary key\". Primary keys\n   * are not explicitly set on the replica, but an appropriate\n   * unique index is required.\n   */\n  primaryKey: PrimaryKey; // note: required\n\n  /**\n   * All keys associated with a unique index over non-null\n   * columns, i.e. suitable as a primary key.\n   */\n  allPotentialPrimaryKeys: PrimaryKey[];\n\n  /**\n   * The minimum `_0_version` value for every row in the table. If this is\n   * present, `_0_version` value in the row itself should only be used if\n   * it is greater (i.e. later) than the `minRowVersion`.\n   */\n  minRowVersion: string | null;\n};\n\nexport type LiteAndZqlSpec = {\n  tableSpec: LiteTableSpecWithKeysAndVersion;\n  zqlSpec: Record<string, SchemaValue>;\n};\n\nexport type TableSpec = Readonly<v.Infer<typeof tableSpec>>;\n\nexport type PublishedTableSpec = Readonly<v.Infer<typeof publishedTableSpec>>;\n\nexport const directionSchema = v.literalUnion('ASC', 'DESC');\n\nexport const liteIndexSpec = v.object({\n  name: v.string(),\n  tableName: v.string(),\n  unique: v.boolean(),\n  columns: v.record(directionSchema),\n});\n\nexport type MutableLiteIndexSpec = v.Infer<typeof liteIndexSpec>;\n\nexport type LiteIndexSpec = Readonly<MutableLiteIndexSpec>;\n\nexport const indexSpec = liteIndexSpec.extend({\n  schema: v.string(),\n});\n\nexport type IndexSpec = DeepReadonly<v.Infer<typeof indexSpec>>;\n\nexport const publishedIndexSpec = indexSpec.extend({\n  isReplicaIdentity: v.boolean().optional(),\n  isPrimaryKey: v.boolean().optional(),\n  isImmediate: v.boolean().optional(),\n});\n\nexport type PublishedIndexSpec = DeepReadonly<\n  v.Infer<typeof publishedIndexSpec>\n>;\n"],"mappings":";;AAOA,IAAa,oBAAoB,aAC/B,KACA,KACA,KACA,KACA,KACA,KACA,IACD;AAED,IAAM,0BAA0B,aAC9B,KACA,KACA,KACA,IACD;AAED,IAAa,aAAa,eAAE,OAAO;CACjC,KAAK,eAAE,QAAQ;CACf,UAAU,eAAE,QAAQ;CACpB,aAAa,kBAAkB,UAAU;CAKzC,iBAAiB,kBAAkB,UAAU,CAAC,UAAU;CAExD,wBAAwB,eAAE,QAAQ,CAAC,UAAU,CAAC,UAAU;CACxD,SAAS,eAAE,SAAS,CAAC,UAAU,CAAC,UAAU;CAC1C,MAAM,eAAE,QAAQ,CAAC,UAAU,CAAC,UAAU;CACvC,CAAC;AAIF,IAAM,sBAAsB,WAAW,OAAO,EAC5C,SAAS,eAAE,QAAQ,EACpB,CAAC;AAQF,IAAa,YANgB,eAAE,OAAO;CACpC,MAAM,eAAE,QAAQ;CAChB,SAAS,eAAE,OAAO,WAAW;CAC7B,YAAY,eAAE,MAAM,eAAE,QAAQ,CAAC,CAAC,UAAU;CAC3C,CAAC,CAEqC,OAAO,EAC5C,QAAQ,eAAE,QAAQ,EACnB,CAAC;AAEF,IAAa,qBAAqB,UAAU,OAAO;CACjD,KAAK,eAAE,QAAQ;CAGf,WAAW,eAAE,QAAQ,CAAC,UAAU;CAChC,SAAS,eAAE,OAAO,oBAAoB;CACtC,iBAAiB,wBAAwB,UAAU;CACnD,cAAc,eAAE,OAAO,eAAE,OAAO,EAAC,WAAW,eAAE,QAAQ,CAAC,UAAU,EAAC,CAAC,CAAC;CACrE,CAAC;AA8CF,IAAa,kBAAkB,aAAe,OAAO,OAAO;AAa5D,IAAa,YAXgB,eAAE,OAAO;CACpC,MAAM,eAAE,QAAQ;CAChB,WAAW,eAAE,QAAQ;CACrB,QAAQ,eAAE,SAAS;CACnB,SAAS,eAAE,OAAO,gBAAgB;CACnC,CAAC,CAMqC,OAAO,EAC5C,QAAQ,eAAE,QAAQ,EACnB,CAAC;AAIF,IAAa,qBAAqB,UAAU,OAAO;CACjD,mBAAmB,eAAE,SAAS,CAAC,UAAU;CACzC,cAAc,eAAE,SAAS,CAAC,UAAU;CACpC,aAAa,eAAE,SAAS,CAAC,UAAU;CACpC,CAAC"}