@rocicorp/zero 0.26.1 → 0.26.2-canary.1

package/out/zero-cache/src/types/http.js

@@ -1,28 +1,19 @@
+//#region ../zero-cache/src/types/http.ts
 function serializableSubset(msg) {
-  const {
-    headers,
-    headersDistinct,
-    httpVersion,
-    method = "GET",
-    rawHeaders,
-    rawTrailers,
-    trailers,
-    trailersDistinct,
-    url
-  } = msg;
-  return {
-    headers,
-    headersDistinct,
-    httpVersion,
-    method,
-    rawHeaders,
-    rawTrailers,
-    trailers,
-    trailersDistinct,
-    url
-  };
+	const { headers, headersDistinct, httpVersion, method = "GET", rawHeaders, rawTrailers, trailers, trailersDistinct, url } = msg;
+	return {
+		headers,
+		headersDistinct,
+		httpVersion,
+		method,
+		rawHeaders,
+		rawTrailers,
+		trailers,
+		trailersDistinct,
+		url
+	};
 }
-export {
-  serializableSubset
-};
-//# sourceMappingURL=http.js.map
+//#endregion
+export { serializableSubset };
+
+//# sourceMappingURL=http.js.map

package/out/zero-cache/src/types/http.js.map

@@ -1 +1 @@
-{"version":3,"file":"http.js","sources":["../../../../../zero-cache/src/types/http.ts"],"sourcesContent":["import type {IncomingMessage} from 'http';\n\n/**\n * Contains the subset of {@link IncomingMessage} fields suitable for\n * passing across processes.\n */\nexport type IncomingMessageSubset = Pick<\n  IncomingMessage,\n  | 'headers'\n  | 'headersDistinct'\n  | 'httpVersion'\n  | 'method'\n  | 'rawHeaders'\n  | 'rawTrailers'\n  | 'trailers'\n  | 'trailersDistinct'\n  | 'url'\n>;\n\nexport function serializableSubset(\n  msg: IncomingMessageSubset,\n): IncomingMessageSubset {\n  const {\n    headers,\n    headersDistinct,\n    httpVersion,\n    method = 'GET',\n    rawHeaders,\n    rawTrailers,\n    trailers,\n    trailersDistinct,\n    url,\n  } = msg;\n\n  return {\n    headers,\n    headersDistinct,\n    httpVersion,\n    method,\n    rawHeaders,\n    rawTrailers,\n    trailers,\n    trailersDistinct,\n    url,\n  };\n}\n"],"names":[],"mappings":"AAmBO,SAAS,mBACd,KACuB;AACvB,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA,SAAS;AAAA,IACT;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EAAA,IACE;AAEJ,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EAAA;AAEJ;"}
+{"version":3,"file":"http.js","names":[],"sources":["../../../../../zero-cache/src/types/http.ts"],"sourcesContent":["import type {IncomingMessage} from 'http';\n\n/**\n * Contains the subset of {@link IncomingMessage} fields suitable for\n * passing across processes.\n */\nexport type IncomingMessageSubset = Pick<\n  IncomingMessage,\n  | 'headers'\n  | 'headersDistinct'\n  | 'httpVersion'\n  | 'method'\n  | 'rawHeaders'\n  | 'rawTrailers'\n  | 'trailers'\n  | 'trailersDistinct'\n  | 'url'\n>;\n\nexport function serializableSubset(\n  msg: IncomingMessageSubset,\n): IncomingMessageSubset {\n  const {\n    headers,\n    headersDistinct,\n    httpVersion,\n    method = 'GET',\n    rawHeaders,\n    rawTrailers,\n    trailers,\n    trailersDistinct,\n    url,\n  } = msg;\n\n  return {\n    headers,\n    headersDistinct,\n    httpVersion,\n    method,\n    rawHeaders,\n    rawTrailers,\n    trailers,\n    trailersDistinct,\n    url,\n  };\n}\n"],"mappings":";AAmBA,SAAgB,mBACd,KACuB;CACvB,MAAM,EACJ,SACA,iBACA,aACA,SAAS,OACT,YACA,aACA,UACA,kBACA,QACE;AAEJ,QAAO;EACL;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACD"}

package/out/zero-cache/src/types/lexi-version.js

@@ -1,52 +1,38 @@
 import { assert } from "../../../shared/src/asserts.js";
 import { parseBigInt } from "../../../shared/src/parse-big-int.js";
+//#region ../zero-cache/src/types/lexi-version.ts
 function versionToLexi(v) {
-  assert(v >= 0, "Negative versions are not supported");
-  assert(
-    typeof v === "bigint" || v <= Number.MAX_SAFE_INTEGER && Number.isInteger(v),
-    `Invalid or unsafe version ${v}`
-  );
-  const base36Version = BigInt(v).toString(36);
-  const length = BigInt(base36Version.length - 1).toString(36);
-  assert(
-    length.length === 1,
-    `Value is too large to be encoded as a LexiVersion: ${v.toString()}`
-  );
-  return `${length}${base36Version}`;
+	assert(v >= 0, "Negative versions are not supported");
+	assert(typeof v === "bigint" || v <= Number.MAX_SAFE_INTEGER && Number.isInteger(v), `Invalid or unsafe version ${v}`);
+	const base36Version = BigInt(v).toString(36);
+	const length = BigInt(base36Version.length - 1).toString(36);
+	assert(length.length === 1, `Value is too large to be encoded as a LexiVersion: ${v.toString()}`);
+	return `${length}${base36Version}`;
 }
 function versionFromLexi(lexiVersion) {
-  assert(
-    lexiVersion.length >= 2,
-    () => `LexiVersion must have at least 2 characters, got ${lexiVersion.length}`
-  );
-  const length = lexiVersion.substring(0, 1);
-  const base36Version = lexiVersion.substring(1);
-  assert(
-    base36Version.length === parseInt(length, 36) + 1,
-    `Invalid LexiVersion: ${lexiVersion}`
-  );
-  return parseBigInt(base36Version, 36);
+	assert(lexiVersion.length >= 2, () => `LexiVersion must have at least 2 characters, got ${lexiVersion.length}`);
+	const length = lexiVersion.substring(0, 1);
+	const base36Version = lexiVersion.substring(1);
+	assert(base36Version.length === parseInt(length, 36) + 1, `Invalid LexiVersion: ${lexiVersion}`);
+	return parseBigInt(base36Version, 36);
 }
 function max(...versions) {
-  let winner = versions[0];
-  for (let i = 1; i < versions.length; i++) {
-    const b = versions[i];
-    winner = winner > b ? winner : b;
-  }
-  return winner;
+	let winner = versions[0];
+	for (let i = 1; i < versions.length; i++) {
+		const b = versions[i];
+		winner = winner > b ? winner : b;
+	}
+	return winner;
 }
 function min(...versions) {
-  let winner = versions[0];
-  for (let i = 1; i < versions.length; i++) {
-    const b = versions[i];
-    winner = winner < b ? winner : b;
-  }
-  return winner;
+	let winner = versions[0];
+	for (let i = 1; i < versions.length; i++) {
+		const b = versions[i];
+		winner = winner < b ? winner : b;
+	}
+	return winner;
 }
-export {
-  max,
-  min,
-  versionFromLexi,
-  versionToLexi
-};
-//# sourceMappingURL=lexi-version.js.map
+//#endregion
+export { max, min, versionFromLexi, versionToLexi };
+
+//# sourceMappingURL=lexi-version.js.map

package/out/zero-cache/src/types/lexi-version.js.map

@@ -1 +1 @@
-{"version":3,"file":"lexi-version.js","sources":["../../../../../zero-cache/src/types/lexi-version.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport {parseBigInt} from '../../../shared/src/parse-big-int.ts';\n\n/**\n * A LexiVersion is a lexicographically sortable representation of\n * numbers from 0 to Number.MAX_SAFE_INTEGER (which is the safe range of\n * Version values used in Zero).\n *\n * The Version is first encoded in base36, and then prepended by a single\n * base36 character representing the length (of the base36 version) minus 1.\n * This encoding can encode numbers up to 185 bits, with the maximum encoded\n * number being `\"z\".repeat(37)`, or 36^36-1 (approximately 1.0638735892371651e+56).\n *\n * Examples:\n * * 0 => \"00\"\n * * 10 => \"0a\"\n * * 35 => \"0z\"\n * * 36 => \"110\"\n * * 46655 => \"2zzz\"\n * * 2^64 => \"c3w5e11264sgsg\"\n *\n * Note that when using the `number` type, the library will assert if attempting\n * to encode a Version larger than Number.MAX_SAFE_INTEGER. For large numbers,\n * use the `bigint` type.\n */\nexport type LexiVersion = string;\n\nexport function versionToLexi(v: number | bigint): LexiVersion {\n  assert(v >= 0, 'Negative versions are not supported');\n  assert(\n    typeof v === 'bigint' ||\n      (v <= Number.MAX_SAFE_INTEGER && Number.isInteger(v)),\n    `Invalid or unsafe version ${v}`,\n  );\n  const base36Version = BigInt(v).toString(36);\n  const length = BigInt(base36Version.length - 1).toString(36);\n  assert(\n    length.length === 1,\n    `Value is too large to be encoded as a LexiVersion: ${v.toString()}`,\n  );\n  return `${length}${base36Version}`;\n}\n\nexport function versionFromLexi(lexiVersion: LexiVersion): bigint {\n  assert(\n    lexiVersion.length >= 2,\n    () =>\n      `LexiVersion must have at least 2 characters, got ${lexiVersion.length}`,\n  );\n  const length = lexiVersion.substring(0, 1);\n  const base36Version = lexiVersion.substring(1);\n  assert(\n    base36Version.length === parseInt(length, 36) + 1,\n    `Invalid LexiVersion: ${lexiVersion}`,\n  );\n  return parseBigInt(base36Version, 36);\n}\n\nexport type AtLeastOne<T> = [T, ...T[]];\n\nexport function max(...versions: AtLeastOne<LexiVersion>): LexiVersion {\n  let winner = versions[0];\n  for (let i = 1; i < versions.length; i++) {\n    const b = versions[i];\n    winner = winner > b ? winner : b;\n  }\n  return winner;\n}\n\nexport function min(...versions: AtLeastOne<LexiVersion>): LexiVersion {\n  let winner = versions[0];\n  for (let i = 1; i < versions.length; i++) {\n    const b = versions[i];\n    winner = winner < b ? winner : b;\n  }\n  return winner;\n}\n"],"names":[],"mappings":";;AA2BO,SAAS,cAAc,GAAiC;AAC7D,SAAO,KAAK,GAAG,qCAAqC;AACpD;AAAA,IACE,OAAO,MAAM,YACV,KAAK,OAAO,oBAAoB,OAAO,UAAU,CAAC;AAAA,IACrD,6BAA6B,CAAC;AAAA,EAAA;AAEhC,QAAM,gBAAgB,OAAO,CAAC,EAAE,SAAS,EAAE;AAC3C,QAAM,SAAS,OAAO,cAAc,SAAS,CAAC,EAAE,SAAS,EAAE;AAC3D;AAAA,IACE,OAAO,WAAW;AAAA,IAClB,sDAAsD,EAAE,UAAU;AAAA,EAAA;AAEpE,SAAO,GAAG,MAAM,GAAG,aAAa;AAClC;AAEO,SAAS,gBAAgB,aAAkC;AAChE;AAAA,IACE,YAAY,UAAU;AAAA,IACtB,MACE,oDAAoD,YAAY,MAAM;AAAA,EAAA;AAE1E,QAAM,SAAS,YAAY,UAAU,GAAG,CAAC;AACzC,QAAM,gBAAgB,YAAY,UAAU,CAAC;AAC7C;AAAA,IACE,cAAc,WAAW,SAAS,QAAQ,EAAE,IAAI;AAAA,IAChD,wBAAwB,WAAW;AAAA,EAAA;AAErC,SAAO,YAAY,eAAe,EAAE;AACtC;AAIO,SAAS,OAAO,UAAgD;AACrE,MAAI,SAAS,SAAS,CAAC;AACvB,WAAS,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;AACxC,UAAM,IAAI,SAAS,CAAC;AACpB,aAAS,SAAS,IAAI,SAAS;AAAA,EACjC;AACA,SAAO;AACT;AAEO,SAAS,OAAO,UAAgD;AACrE,MAAI,SAAS,SAAS,CAAC;AACvB,WAAS,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;AACxC,UAAM,IAAI,SAAS,CAAC;AACpB,aAAS,SAAS,IAAI,SAAS;AAAA,EACjC;AACA,SAAO;AACT;"}
+{"version":3,"file":"lexi-version.js","names":[],"sources":["../../../../../zero-cache/src/types/lexi-version.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport {parseBigInt} from '../../../shared/src/parse-big-int.ts';\n\n/**\n * A LexiVersion is a lexicographically sortable representation of\n * numbers from 0 to Number.MAX_SAFE_INTEGER (which is the safe range of\n * Version values used in Zero).\n *\n * The Version is first encoded in base36, and then prepended by a single\n * base36 character representing the length (of the base36 version) minus 1.\n * This encoding can encode numbers up to 185 bits, with the maximum encoded\n * number being `\"z\".repeat(37)`, or 36^36-1 (approximately 1.0638735892371651e+56).\n *\n * Examples:\n * * 0 => \"00\"\n * * 10 => \"0a\"\n * * 35 => \"0z\"\n * * 36 => \"110\"\n * * 46655 => \"2zzz\"\n * * 2^64 => \"c3w5e11264sgsg\"\n *\n * Note that when using the `number` type, the library will assert if attempting\n * to encode a Version larger than Number.MAX_SAFE_INTEGER. For large numbers,\n * use the `bigint` type.\n */\nexport type LexiVersion = string;\n\nexport function versionToLexi(v: number | bigint): LexiVersion {\n  assert(v >= 0, 'Negative versions are not supported');\n  assert(\n    typeof v === 'bigint' ||\n      (v <= Number.MAX_SAFE_INTEGER && Number.isInteger(v)),\n    `Invalid or unsafe version ${v}`,\n  );\n  const base36Version = BigInt(v).toString(36);\n  const length = BigInt(base36Version.length - 1).toString(36);\n  assert(\n    length.length === 1,\n    `Value is too large to be encoded as a LexiVersion: ${v.toString()}`,\n  );\n  return `${length}${base36Version}`;\n}\n\nexport function versionFromLexi(lexiVersion: LexiVersion): bigint {\n  assert(\n    lexiVersion.length >= 2,\n    () =>\n      `LexiVersion must have at least 2 characters, got ${lexiVersion.length}`,\n  );\n  const length = lexiVersion.substring(0, 1);\n  const base36Version = lexiVersion.substring(1);\n  assert(\n    base36Version.length === parseInt(length, 36) + 1,\n    `Invalid LexiVersion: ${lexiVersion}`,\n  );\n  return parseBigInt(base36Version, 36);\n}\n\nexport type AtLeastOne<T> = [T, ...T[]];\n\nexport function max(...versions: AtLeastOne<LexiVersion>): LexiVersion {\n  let winner = versions[0];\n  for (let i = 1; i < versions.length; i++) {\n    const b = versions[i];\n    winner = winner > b ? winner : b;\n  }\n  return winner;\n}\n\nexport function min(...versions: AtLeastOne<LexiVersion>): LexiVersion {\n  let winner = versions[0];\n  for (let i = 1; i < versions.length; i++) {\n    const b = versions[i];\n    winner = winner < b ? winner : b;\n  }\n  return winner;\n}\n"],"mappings":";;;AA2BA,SAAgB,cAAc,GAAiC;AAC7D,QAAO,KAAK,GAAG,sCAAsC;AACrD,QACE,OAAO,MAAM,YACV,KAAK,OAAO,oBAAoB,OAAO,UAAU,EAAE,EACtD,6BAA6B,IAC9B;CACD,MAAM,gBAAgB,OAAO,EAAE,CAAC,SAAS,GAAG;CAC5C,MAAM,SAAS,OAAO,cAAc,SAAS,EAAE,CAAC,SAAS,GAAG;AAC5D,QACE,OAAO,WAAW,GAClB,sDAAsD,EAAE,UAAU,GACnE;AACD,QAAO,GAAG,SAAS;;AAGrB,SAAgB,gBAAgB,aAAkC;AAChE,QACE,YAAY,UAAU,SAEpB,oDAAoD,YAAY,SACnE;CACD,MAAM,SAAS,YAAY,UAAU,GAAG,EAAE;CAC1C,MAAM,gBAAgB,YAAY,UAAU,EAAE;AAC9C,QACE,cAAc,WAAW,SAAS,QAAQ,GAAG,GAAG,GAChD,wBAAwB,cACzB;AACD,QAAO,YAAY,eAAe,GAAG;;AAKvC,SAAgB,IAAI,GAAG,UAAgD;CACrE,IAAI,SAAS,SAAS;AACtB,MAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;EACxC,MAAM,IAAI,SAAS;AACnB,WAAS,SAAS,IAAI,SAAS;;AAEjC,QAAO;;AAGT,SAAgB,IAAI,GAAG,UAAgD;CACrE,IAAI,SAAS,SAAS;AACtB,MAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;EACxC,MAAM,IAAI,SAAS;AACnB,WAAS,SAAS,IAAI,SAAS;;AAEjC,QAAO"}

package/out/zero-cache/src/types/lite.js

@@ -1,144 +1,124 @@
 import { assert } from "../../../shared/src/asserts.js";
 import { stringify } from "../../../shared/src/bigint-json.js";
 import { dataTypeToZqlValueType } from "./pg-data-type.js";
+//#region ../zero-cache/src/types/lite.ts
 function columnType(col, table) {
-  const spec = table.columns[col];
-  assert(spec, `Unknown column ${col} in table ${table.name}`);
-  return spec.dataType;
+	const spec = table.columns[col];
+	assert(spec, `Unknown column ${col} in table ${table.name}`);
+	return spec.dataType;
 }
-const JSON_STRINGIFIED = "s";
-const JSON_PARSED = "p";
+/**
+* Creates a LiteRow from the supplied RowValue. A copy of the `row`
+* is made only if a value conversion is performed.
+*/
 function liteRow(row, table, jsonFormat) {
-  let copyNeeded = false;
-  let numCols = 0;
-  for (const key in row) {
-    numCols++;
-    const val = row[key];
-    const liteVal = liteValue(val, columnType(key, table), jsonFormat);
-    if (val !== liteVal) {
-      copyNeeded = true;
-      break;
-    }
-  }
-  if (!copyNeeded) {
-    return { row, numCols };
-  }
-  numCols = 0;
-  const converted = {};
-  for (const key in row) {
-    numCols++;
-    converted[key] = liteValue(row[key], columnType(key, table), jsonFormat);
-  }
-  return { row: converted, numCols };
+	let copyNeeded = false;
+	let numCols = 0;
+	for (const key in row) {
+		numCols++;
+		const val = row[key];
+		if (val !== liteValue(val, columnType(key, table), jsonFormat)) {
+			copyNeeded = true;
+			break;
+		}
+	}
+	if (!copyNeeded) return {
+		row,
+		numCols
+	};
+	numCols = 0;
+	const converted = {};
+	for (const key in row) {
+		numCols++;
+		converted[key] = liteValue(row[key], columnType(key, table), jsonFormat);
+	}
+	return {
+		row: converted,
+		numCols
+	};
 }
+/**
+* Postgres values types that are supported by SQLite are stored as-is.
+* This includes Uint8Arrays for the `bytea` / `BLOB` type.
+* * `boolean` values are converted to `0` or `1` integers.
+* * `PreciseDate` values are converted to epoch microseconds.
+* * JSON and Array values are stored as `JSON.stringify()` strings.
+*
+* Note that this currently does not handle the `bytea[]` type, but that's
+* already a pretty questionable type.
+*/
 function liteValue(val, pgType, jsonFormat) {
-  if (val instanceof Uint8Array || val === null) {
-    return val;
-  }
-  const valueType = liteTypeToZqlValueType(pgType);
-  if (valueType === "json") {
-    if (jsonFormat === JSON_STRINGIFIED && typeof val === "string") {
-      return val;
-    }
-    return stringify(val);
-  }
-  const obj = toLiteValue(val);
-  return obj && typeof obj === "object" ? stringify(obj) : obj;
+	if (val instanceof Uint8Array || val === null) return val;
+	if (liteTypeToZqlValueType(pgType) === "json") {
+		if (jsonFormat === "s" && typeof val === "string") return val;
+		return stringify(val);
+	}
+	const obj = toLiteValue(val);
+	return obj && typeof obj === "object" ? stringify(obj) : obj;
 }
 function toLiteValue(val) {
-  switch (typeof val) {
-    case "string":
-    case "number":
-    case "bigint":
-      return val;
-    case "boolean":
-      return val ? 1 : 0;
-  }
-  if (val === null) {
-    return val;
-  }
-  if (Array.isArray(val)) {
-    return val.map((v) => toLiteValue(v));
-  }
-  assert(
-    val.constructor?.name === "Object",
-    `Unhandled object type ${val.constructor?.name}`
-  );
-  return val;
+	switch (typeof val) {
+		case "string":
+		case "number":
+		case "bigint": return val;
+		case "boolean": return val ? 1 : 0;
+	}
+	if (val === null) return val;
+	if (Array.isArray(val)) return val.map((v) => toLiteValue(v));
+	assert(val.constructor?.name === "Object", `Unhandled object type ${val.constructor?.name}`);
+	return val;
 }
 function mapLiteDataTypeToZqlSchemaValue(liteDataType) {
-  return { type: mapLiteDataTypeToZqlValueType(liteDataType) };
+	return { type: mapLiteDataTypeToZqlValueType(liteDataType) };
 }
 function mapLiteDataTypeToZqlValueType(dataType) {
-  const type = liteTypeToZqlValueType(dataType);
-  if (type === void 0) {
-    throw new Error(`Unsupported data type ${dataType}`);
-  }
-  return type;
+	const type = liteTypeToZqlValueType(dataType);
+	if (type === void 0) throw new Error(`Unsupported data type ${dataType}`);
+	return type;
 }
-const TEXT_ENUM_ATTRIBUTE = "|TEXT_ENUM";
-const NOT_NULL_ATTRIBUTE = "|NOT_NULL";
-const TEXT_ARRAY_ATTRIBUTE = "|TEXT_ARRAY";
-function liteTypeString(upstreamDataType2, notNull, textEnum, textArray) {
-  let typeString = upstreamDataType2;
-  assert(typeString.indexOf("|") === -1, "Upstream type should not contain |");
-  if (notNull) {
-    typeString += NOT_NULL_ATTRIBUTE;
-  }
-  if (textEnum) {
-    typeString += TEXT_ENUM_ATTRIBUTE;
-  }
-  if (textArray) {
-    typeString += TEXT_ARRAY_ATTRIBUTE;
-  }
-  return typeString;
+var TEXT_ENUM_ATTRIBUTE = "|TEXT_ENUM";
+var NOT_NULL_ATTRIBUTE = "|NOT_NULL";
+var TEXT_ARRAY_ATTRIBUTE = "|TEXT_ARRAY";
+/**
+* Formats a {@link LiteTypeString}.
+*/
+function liteTypeString(upstreamDataType, notNull, textEnum, textArray) {
+	let typeString = upstreamDataType;
+	assert(typeString.indexOf("|") === -1, "Upstream type should not contain |");
+	if (notNull) typeString += NOT_NULL_ATTRIBUTE;
+	if (textEnum) typeString += TEXT_ENUM_ATTRIBUTE;
+	if (textArray) typeString += TEXT_ARRAY_ATTRIBUTE;
+	return typeString;
 }
-function upstreamDataType(liteTypeString2) {
-  const delim = liteTypeString2.indexOf("|");
-  return delim > 0 ? liteTypeString2.substring(0, delim) : liteTypeString2;
+function upstreamDataType(liteTypeString) {
+	const delim = liteTypeString.indexOf("|");
+	return delim > 0 ? liteTypeString.substring(0, delim) : liteTypeString;
 }
-function nullableUpstream(liteTypeString2) {
-  return !liteTypeString2.includes(NOT_NULL_ATTRIBUTE);
+function nullableUpstream(liteTypeString) {
+	return !liteTypeString.includes(NOT_NULL_ATTRIBUTE);
 }
-function liteTypeToZqlValueType(liteTypeString2) {
-  return dataTypeToZqlValueType(
-    upstreamDataType(liteTypeString2).toLowerCase(),
-    liteTypeString2.includes(TEXT_ENUM_ATTRIBUTE),
-    isArray(liteTypeString2)
-  );
+/**
+* Returns the value type for the `pgDataType` if it is supported by ZQL.
+* (Note that `pgDataType` values are stored as-is in the SQLite column defs).
+*
+* For types not supported by ZQL, returns `undefined`.
+*/
+function liteTypeToZqlValueType(liteTypeString) {
+	return dataTypeToZqlValueType(upstreamDataType(liteTypeString).toLowerCase(), liteTypeString.includes(TEXT_ENUM_ATTRIBUTE), isArray(liteTypeString));
 }
-function isEnum(liteTypeString2) {
-  return liteTypeString2.includes(TEXT_ENUM_ATTRIBUTE);
+function isEnum(liteTypeString) {
+	return liteTypeString.includes(TEXT_ENUM_ATTRIBUTE);
 }
-function isArray(liteTypeString2) {
-  return liteTypeString2.includes(TEXT_ARRAY_ATTRIBUTE) || // Before we added `|TEXT_ARRAY`, we just used `[]` suffix to indicate arrays.
-  liteTypeString2.includes("[]");
+function isArray(liteTypeString) {
+	return liteTypeString.includes("|TEXT_ARRAY") || liteTypeString.includes("[]");
 }
 function assertValidLiteColumnSpec(spec) {
-  const { dataType } = spec;
-  assert(
-    dataType.includes(TEXT_ARRAY_ATTRIBUTE) === dataType.includes("[]"),
-    () => `TEXT_ARRAY_ATTRIBUTE and [] must be consistent in dataType: ${dataType}`
-  );
-  assert(
-    dataType.includes("[]") === (spec.elemPgTypeClass !== null),
-    () => `[] in dataType (${dataType}) must match elemPgTypeClass presence (${spec.elemPgTypeClass})`
-  );
-  assert(!/^.+\|.*\[\]/.test(dataType), `Invalid dataType ${dataType}`);
+	const { dataType } = spec;
+	assert(dataType.includes(TEXT_ARRAY_ATTRIBUTE) === dataType.includes("[]"), () => `TEXT_ARRAY_ATTRIBUTE and [] must be consistent in dataType: ${dataType}`);
+	assert(dataType.includes("[]") === (spec.elemPgTypeClass !== null), () => `[] in dataType (${dataType}) must match elemPgTypeClass presence (${spec.elemPgTypeClass})`);
+	assert(!/^.+\|.*\[\]/.test(dataType), `Invalid dataType ${dataType}`);
 }
-export {
-  JSON_PARSED,
-  JSON_STRINGIFIED,
-  TEXT_ARRAY_ATTRIBUTE,
-  assertValidLiteColumnSpec,
-  isArray,
-  isEnum,
-  liteRow,
-  liteTypeString,
-  liteTypeToZqlValueType,
-  liteValue,
-  mapLiteDataTypeToZqlSchemaValue,
-  nullableUpstream,
-  upstreamDataType
-};
-//# sourceMappingURL=lite.js.map
+//#endregion
+export { assertValidLiteColumnSpec, isArray, isEnum, liteRow, liteTypeString, liteTypeToZqlValueType, liteValue, mapLiteDataTypeToZqlSchemaValue, nullableUpstream, upstreamDataType };
+
+//# sourceMappingURL=lite.js.map

package/out/zero-cache/src/types/lite.js.map

@@ -1 +1 @@
-{"version":3,"file":"lite.js","sources":["../../../../../zero-cache/src/types/lite.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport {stringify, type JSONValue} from '../../../shared/src/bigint-json.ts';\nimport type {\n  SchemaValue,\n  ValueType,\n} from '../../../zero-schema/src/table-schema.ts';\nimport type {ColumnSpec, LiteTableSpec} from '../db/specs.ts';\nimport {dataTypeToZqlValueType as upstreamDataTypeToZqlValueType} from './pg-data-type.ts';\nimport type {PostgresValueType} from './pg.ts';\nimport type {RowValue} from './row-key.ts';\n\n/** Javascript value types supported by better-sqlite3. */\nexport type LiteValueType = number | bigint | string | null | Uint8Array;\n\nexport type LiteRow = Readonly<Record<string, LiteValueType>>;\nexport type LiteRowKey = LiteRow; // just for API readability\n\nfunction columnType(col: string, table: LiteTableSpec) {\n  const spec = table.columns[col];\n  assert(spec, `Unknown column ${col} in table ${table.name}`);\n  return spec.dataType;\n}\n\nexport const JSON_STRINGIFIED = 's';\nexport const JSON_PARSED = 'p';\n\nexport type JSONFormat = typeof JSON_STRINGIFIED | typeof JSON_PARSED;\n\n/**\n * Creates a LiteRow from the supplied RowValue. A copy of the `row`\n * is made only if a value conversion is performed.\n */\nexport function liteRow(\n  row: RowValue,\n  table: LiteTableSpec,\n  jsonFormat: JSONFormat,\n): {row: LiteRow; numCols: number} {\n  let copyNeeded = false;\n  let numCols = 0;\n\n  for (const key in row) {\n    numCols++;\n    const val = row[key];\n    const liteVal = liteValue(val, columnType(key, table), jsonFormat);\n    if (val !== liteVal) {\n      copyNeeded = true;\n      break;\n    }\n  }\n  if (!copyNeeded) {\n    return {row: row as unknown as LiteRow, numCols};\n  }\n  // Slow path for when a conversion is needed.\n  numCols = 0;\n  const converted: Record<string, LiteValueType> = {};\n  for (const key in row) {\n    numCols++;\n    converted[key] = liteValue(row[key], columnType(key, table), jsonFormat);\n  }\n  return {row: converted, numCols};\n}\n\n/**\n * Postgres values types that are supported by SQLite are stored as-is.\n * This includes Uint8Arrays for the `bytea` / `BLOB` type.\n * * `boolean` values are converted to `0` or `1` integers.\n * * `PreciseDate` values are converted to epoch microseconds.\n * * JSON and Array values are stored as `JSON.stringify()` strings.\n *\n * Note that this currently does not handle the `bytea[]` type, but that's\n * already a pretty questionable type.\n */\nexport function liteValue(\n  val: PostgresValueType,\n  pgType: string,\n  jsonFormat: JSONFormat,\n): LiteValueType {\n  if (val instanceof Uint8Array || val === null) {\n    return val;\n  }\n  const valueType = liteTypeToZqlValueType(pgType);\n  if (valueType === 'json') {\n    if (jsonFormat === JSON_STRINGIFIED && typeof val === 'string') {\n      // JSON and JSONB values are already strings if the JSON was not parsed.\n      return val;\n    }\n    // Non-JSON/JSONB values will always appear as objects / arrays.\n    return stringify(val);\n  }\n  const obj = toLiteValue(val);\n  return obj && typeof obj === 'object' ? stringify(obj) : obj;\n}\n\nfunction toLiteValue(val: JSONValue): Exclude<JSONValue, boolean> {\n  switch (typeof val) {\n    case 'string':\n    case 'number':\n    case 'bigint':\n      return val;\n    case 'boolean':\n      return val ? 1 : 0;\n  }\n  if (val === null) {\n    return val;\n  }\n  if (Array.isArray(val)) {\n    return val.map(v => toLiteValue(v));\n  }\n  assert(\n    val.constructor?.name === 'Object',\n    `Unhandled object type ${val.constructor?.name}`,\n  );\n  return val; // JSON\n}\n\nexport function mapLiteDataTypeToZqlSchemaValue(\n  liteDataType: LiteTypeString,\n): SchemaValue {\n  return {type: mapLiteDataTypeToZqlValueType(liteDataType)};\n}\n\nfunction mapLiteDataTypeToZqlValueType(dataType: LiteTypeString): ValueType {\n  const type = liteTypeToZqlValueType(dataType);\n  if (type === undefined) {\n    throw new Error(`Unsupported data type ${dataType}`);\n  }\n  return type;\n}\n\n// Note: Includes the \"TEXT\" substring for SQLite type affinity\nconst TEXT_ENUM_ATTRIBUTE = '|TEXT_ENUM';\nconst NOT_NULL_ATTRIBUTE = '|NOT_NULL';\nexport const TEXT_ARRAY_ATTRIBUTE = '|TEXT_ARRAY';\n\n/**\n * The `LiteTypeString` utilizes SQLite's loose type system to encode\n * auxiliary information about the upstream column (e.g. type and\n * constraints) that does not necessarily affect how SQLite handles the data,\n * but nonetheless determines how higher level logic handles the data.\n *\n * The format of the type string is the original upstream type, followed\n * by any number of attributes, each of which begins with the `|` character.\n * The current list of attributes are:\n * * `|NOT_NULL` to indicate that the upstream column does not allow nulls\n * * `|TEXT_ENUM` to indicate an enum that should be treated as a string\n * * `|TEXT_ARRAY` to indicate an array\n *\n * Examples:\n * * `int8`\n * * `int8|NOT_NULL`\n * * `timestamp with time zone`\n * * `timestamp with time zone|NOT_NULL`\n * * `nomz|TEXT_ENUM`\n * * `nomz|NOT_NULL|TEXT_ENUM`\n * * `int8[]` - Legacy (read support)\n * * `int8[]|TEXT_ARRAY`\n * * `int8|TEXT_ARRAY[]` - Legacy (read support)\n * * `int8[]|TEXT_ARRAY[]` - Legacy (read support)\n * * `int8|NOT_NULL[]` - Legacy (read support)\n * * `nomz[]|TEXT_ENUM|TEXT_ARRAY`\n * * `nomz|TEXT_ENUM[]` - Legacy (read support)\n * * `nomz|TEXT_ENUM|TEXT_ARRAY[]` - Legacy (read support)\n */\nexport type LiteTypeString = string;\n\n/**\n * Formats a {@link LiteTypeString}.\n */\nexport function liteTypeString(\n  upstreamDataType: string,\n  notNull: boolean | null | undefined,\n  textEnum: boolean,\n  textArray: boolean,\n): LiteTypeString {\n  let typeString = upstreamDataType;\n  assert(typeString.indexOf('|') === -1, 'Upstream type should not contain |');\n  if (notNull) {\n    typeString += NOT_NULL_ATTRIBUTE;\n  }\n  if (textEnum) {\n    typeString += TEXT_ENUM_ATTRIBUTE;\n  }\n  if (textArray) {\n    typeString += TEXT_ARRAY_ATTRIBUTE;\n  }\n  return typeString;\n}\n\nexport function upstreamDataType(liteTypeString: LiteTypeString) {\n  const delim = liteTypeString.indexOf('|');\n  return delim > 0 ? liteTypeString.substring(0, delim) : liteTypeString;\n}\n\nexport function nullableUpstream(liteTypeString: LiteTypeString) {\n  return !liteTypeString.includes(NOT_NULL_ATTRIBUTE);\n}\n\n/**\n * Returns the value type for the `pgDataType` if it is supported by ZQL.\n * (Note that `pgDataType` values are stored as-is in the SQLite column defs).\n *\n * For types not supported by ZQL, returns `undefined`.\n */\nexport function liteTypeToZqlValueType(\n  liteTypeString: LiteTypeString,\n): ValueType | undefined {\n  return upstreamDataTypeToZqlValueType(\n    upstreamDataType(liteTypeString).toLowerCase(),\n    liteTypeString.includes(TEXT_ENUM_ATTRIBUTE),\n    isArray(liteTypeString),\n  );\n}\n\nexport function isEnum(liteTypeString: LiteTypeString) {\n  return liteTypeString.includes(TEXT_ENUM_ATTRIBUTE);\n}\n\nexport function isArray(liteTypeString: LiteTypeString) {\n  return (\n    liteTypeString.includes(TEXT_ARRAY_ATTRIBUTE) ||\n    // Before we added `|TEXT_ARRAY`, we just used `[]` suffix to indicate arrays.\n    liteTypeString.includes('[]')\n  );\n}\n\nexport function assertValidLiteColumnSpec(spec: ColumnSpec) {\n  const {dataType} = spec;\n  assert(\n    dataType.includes(TEXT_ARRAY_ATTRIBUTE) === dataType.includes('[]'),\n    () =>\n      `TEXT_ARRAY_ATTRIBUTE and [] must be consistent in dataType: ${dataType}`,\n  );\n  assert(\n    dataType.includes('[]') === (spec.elemPgTypeClass !== null),\n    () =>\n      `[] in dataType (${dataType}) must match elemPgTypeClass presence (${spec.elemPgTypeClass})`,\n  );\n\n  // and no [] after |\n  assert(!/^.+\\|.*\\[\\]/.test(dataType), `Invalid dataType ${dataType}`);\n}\n"],"names":["upstreamDataType","liteTypeString","upstreamDataTypeToZqlValueType"],"mappings":"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"}
+{"version":3,"file":"lite.js","names":[],"sources":["../../../../../zero-cache/src/types/lite.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport {stringify, type JSONValue} from '../../../shared/src/bigint-json.ts';\nimport type {\n  SchemaValue,\n  ValueType,\n} from '../../../zero-schema/src/table-schema.ts';\nimport type {ColumnSpec, LiteTableSpec} from '../db/specs.ts';\nimport {dataTypeToZqlValueType as upstreamDataTypeToZqlValueType} from './pg-data-type.ts';\nimport type {PostgresValueType} from './pg.ts';\nimport type {RowValue} from './row-key.ts';\n\n/** Javascript value types supported by better-sqlite3. */\nexport type LiteValueType = number | bigint | string | null | Uint8Array;\n\nexport type LiteRow = Readonly<Record<string, LiteValueType>>;\nexport type LiteRowKey = LiteRow; // just for API readability\n\nfunction columnType(col: string, table: LiteTableSpec) {\n  const spec = table.columns[col];\n  assert(spec, `Unknown column ${col} in table ${table.name}`);\n  return spec.dataType;\n}\n\nexport const JSON_STRINGIFIED = 's';\nexport const JSON_PARSED = 'p';\n\nexport type JSONFormat = typeof JSON_STRINGIFIED | typeof JSON_PARSED;\n\n/**\n * Creates a LiteRow from the supplied RowValue. A copy of the `row`\n * is made only if a value conversion is performed.\n */\nexport function liteRow(\n  row: RowValue,\n  table: LiteTableSpec,\n  jsonFormat: JSONFormat,\n): {row: LiteRow; numCols: number} {\n  let copyNeeded = false;\n  let numCols = 0;\n\n  for (const key in row) {\n    numCols++;\n    const val = row[key];\n    const liteVal = liteValue(val, columnType(key, table), jsonFormat);\n    if (val !== liteVal) {\n      copyNeeded = true;\n      break;\n    }\n  }\n  if (!copyNeeded) {\n    return {row: row as unknown as LiteRow, numCols};\n  }\n  // Slow path for when a conversion is needed.\n  numCols = 0;\n  const converted: Record<string, LiteValueType> = {};\n  for (const key in row) {\n    numCols++;\n    converted[key] = liteValue(row[key], columnType(key, table), jsonFormat);\n  }\n  return {row: converted, numCols};\n}\n\n/**\n * Postgres values types that are supported by SQLite are stored as-is.\n * This includes Uint8Arrays for the `bytea` / `BLOB` type.\n * * `boolean` values are converted to `0` or `1` integers.\n * * `PreciseDate` values are converted to epoch microseconds.\n * * JSON and Array values are stored as `JSON.stringify()` strings.\n *\n * Note that this currently does not handle the `bytea[]` type, but that's\n * already a pretty questionable type.\n */\nexport function liteValue(\n  val: PostgresValueType,\n  pgType: string,\n  jsonFormat: JSONFormat,\n): LiteValueType {\n  if (val instanceof Uint8Array || val === null) {\n    return val;\n  }\n  const valueType = liteTypeToZqlValueType(pgType);\n  if (valueType === 'json') {\n    if (jsonFormat === JSON_STRINGIFIED && typeof val === 'string') {\n      // JSON and JSONB values are already strings if the JSON was not parsed.\n      return val;\n    }\n    // Non-JSON/JSONB values will always appear as objects / arrays.\n    return stringify(val);\n  }\n  const obj = toLiteValue(val);\n  return obj && typeof obj === 'object' ? stringify(obj) : obj;\n}\n\nfunction toLiteValue(val: JSONValue): Exclude<JSONValue, boolean> {\n  switch (typeof val) {\n    case 'string':\n    case 'number':\n    case 'bigint':\n      return val;\n    case 'boolean':\n      return val ? 1 : 0;\n  }\n  if (val === null) {\n    return val;\n  }\n  if (Array.isArray(val)) {\n    return val.map(v => toLiteValue(v));\n  }\n  assert(\n    val.constructor?.name === 'Object',\n    `Unhandled object type ${val.constructor?.name}`,\n  );\n  return val; // JSON\n}\n\nexport function mapLiteDataTypeToZqlSchemaValue(\n  liteDataType: LiteTypeString,\n): SchemaValue {\n  return {type: mapLiteDataTypeToZqlValueType(liteDataType)};\n}\n\nfunction mapLiteDataTypeToZqlValueType(dataType: LiteTypeString): ValueType {\n  const type = liteTypeToZqlValueType(dataType);\n  if (type === undefined) {\n    throw new Error(`Unsupported data type ${dataType}`);\n  }\n  return type;\n}\n\n// Note: Includes the \"TEXT\" substring for SQLite type affinity\nconst TEXT_ENUM_ATTRIBUTE = '|TEXT_ENUM';\nconst NOT_NULL_ATTRIBUTE = '|NOT_NULL';\nexport const TEXT_ARRAY_ATTRIBUTE = '|TEXT_ARRAY';\n\n/**\n * The `LiteTypeString` utilizes SQLite's loose type system to encode\n * auxiliary information about the upstream column (e.g. type and\n * constraints) that does not necessarily affect how SQLite handles the data,\n * but nonetheless determines how higher level logic handles the data.\n *\n * The format of the type string is the original upstream type, followed\n * by any number of attributes, each of which begins with the `|` character.\n * The current list of attributes are:\n * * `|NOT_NULL` to indicate that the upstream column does not allow nulls\n * * `|TEXT_ENUM` to indicate an enum that should be treated as a string\n * * `|TEXT_ARRAY` to indicate an array\n *\n * Examples:\n * * `int8`\n * * `int8|NOT_NULL`\n * * `timestamp with time zone`\n * * `timestamp with time zone|NOT_NULL`\n * * `nomz|TEXT_ENUM`\n * * `nomz|NOT_NULL|TEXT_ENUM`\n * * `int8[]` - Legacy (read support)\n * * `int8[]|TEXT_ARRAY`\n * * `int8|TEXT_ARRAY[]` - Legacy (read support)\n * * `int8[]|TEXT_ARRAY[]` - Legacy (read support)\n * * `int8|NOT_NULL[]` - Legacy (read support)\n * * `nomz[]|TEXT_ENUM|TEXT_ARRAY`\n * * `nomz|TEXT_ENUM[]` - Legacy (read support)\n * * `nomz|TEXT_ENUM|TEXT_ARRAY[]` - Legacy (read support)\n */\nexport type LiteTypeString = string;\n\n/**\n * Formats a {@link LiteTypeString}.\n */\nexport function liteTypeString(\n  upstreamDataType: string,\n  notNull: boolean | null | undefined,\n  textEnum: boolean,\n  textArray: boolean,\n): LiteTypeString {\n  let typeString = upstreamDataType;\n  assert(typeString.indexOf('|') === -1, 'Upstream type should not contain |');\n  if (notNull) {\n    typeString += NOT_NULL_ATTRIBUTE;\n  }\n  if (textEnum) {\n    typeString += TEXT_ENUM_ATTRIBUTE;\n  }\n  if (textArray) {\n    typeString += TEXT_ARRAY_ATTRIBUTE;\n  }\n  return typeString;\n}\n\nexport function upstreamDataType(liteTypeString: LiteTypeString) {\n  const delim = liteTypeString.indexOf('|');\n  return delim > 0 ? liteTypeString.substring(0, delim) : liteTypeString;\n}\n\nexport function nullableUpstream(liteTypeString: LiteTypeString) {\n  return !liteTypeString.includes(NOT_NULL_ATTRIBUTE);\n}\n\n/**\n * Returns the value type for the `pgDataType` if it is supported by ZQL.\n * (Note that `pgDataType` values are stored as-is in the SQLite column defs).\n *\n * For types not supported by ZQL, returns `undefined`.\n */\nexport function liteTypeToZqlValueType(\n  liteTypeString: LiteTypeString,\n): ValueType | undefined {\n  return upstreamDataTypeToZqlValueType(\n    upstreamDataType(liteTypeString).toLowerCase(),\n    liteTypeString.includes(TEXT_ENUM_ATTRIBUTE),\n    isArray(liteTypeString),\n  );\n}\n\nexport function isEnum(liteTypeString: LiteTypeString) {\n  return liteTypeString.includes(TEXT_ENUM_ATTRIBUTE);\n}\n\nexport function isArray(liteTypeString: LiteTypeString) {\n  return (\n    liteTypeString.includes(TEXT_ARRAY_ATTRIBUTE) ||\n    // Before we added `|TEXT_ARRAY`, we just used `[]` suffix to indicate arrays.\n    liteTypeString.includes('[]')\n  );\n}\n\nexport function assertValidLiteColumnSpec(spec: ColumnSpec) {\n  const {dataType} = spec;\n  assert(\n    dataType.includes(TEXT_ARRAY_ATTRIBUTE) === dataType.includes('[]'),\n    () =>\n      `TEXT_ARRAY_ATTRIBUTE and [] must be consistent in dataType: ${dataType}`,\n  );\n  assert(\n    dataType.includes('[]') === (spec.elemPgTypeClass !== null),\n    () =>\n      `[] in dataType (${dataType}) must match elemPgTypeClass presence (${spec.elemPgTypeClass})`,\n  );\n\n  // and no [] after |\n  assert(!/^.+\\|.*\\[\\]/.test(dataType), `Invalid dataType ${dataType}`);\n}\n"],"mappings":"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"}

package/out/zero-cache/src/types/names.js

@@ -1,7 +1,8 @@
+//#region ../zero-cache/src/types/names.ts
 function liteTableName(t) {
-  return t.schema === "public" ? t.name : `${t.schema}.${t.name}`;
+	return t.schema === "public" ? t.name : `${t.schema}.${t.name}`;
 }
-export {
-  liteTableName
-};
-//# sourceMappingURL=names.js.map
+//#endregion
+export { liteTableName };
+
+//# sourceMappingURL=names.js.map

package/out/zero-cache/src/types/names.js.map

@@ -1 +1 @@
-{"version":3,"file":"names.js","sources":["../../../../../zero-cache/src/types/names.ts"],"sourcesContent":["export function liteTableName(t: {schema: string; name: string}) {\n  return t.schema === 'public' ? t.name : `${t.schema}.${t.name}`;\n}\n"],"names":[],"mappings":"AAAO,SAAS,cAAc,GAAmC;AAC/D,SAAO,EAAE,WAAW,WAAW,EAAE,OAAO,GAAG,EAAE,MAAM,IAAI,EAAE,IAAI;AAC/D;"}
+{"version":3,"file":"names.js","names":[],"sources":["../../../../../zero-cache/src/types/names.ts"],"sourcesContent":["export function liteTableName(t: {schema: string; name: string}) {\n  return t.schema === 'public' ? t.name : `${t.schema}.${t.name}`;\n}\n"],"mappings":";AAAA,SAAgB,cAAc,GAAmC;AAC/D,QAAO,EAAE,WAAW,WAAW,EAAE,OAAO,GAAG,EAAE,OAAO,GAAG,EAAE"}

package/out/zero-cache/src/types/pg-data-type.d.ts

@@ -44,6 +44,7 @@ export declare const pgToZqlTypeMap: Readonly<{
     varchar: "string";
     date: "number";
     time: "number";
+    timetz: "number";
     'time with time zone': "number";
     'time without time zone': "number";
     timestamp: "number";

package/out/zero-cache/src/types/pg-data-type.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pg-data-type.d.ts","sourceRoot":"","sources":["../../../../../zero-cache/src/types/pg-data-type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,6CAA6C,CAAC;AAE3E,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;EAqBhC,CAAC;AAEH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEtD;AAED,eAAO,MAAM,oBAAoB;;;;;;;EAO/B,CAAC;AAEH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEtD;AAED,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0BzB,CAAC;AAEH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,OAAO,EACf,OAAO,EAAE,OAAO,GACf,SAAS,GAAG,SAAS,CAavB"}
+{"version":3,"file":"pg-data-type.d.ts","sourceRoot":"","sources":["../../../../../zero-cache/src/types/pg-data-type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,6CAA6C,CAAC;AAE3E,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;EAqBhC,CAAC;AAEH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEtD;AAED,eAAO,MAAM,oBAAoB;;;;;;;EAO/B,CAAC;AAEH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEtD;AAED,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BzB,CAAC;AAEH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,OAAO,EACf,OAAO,EAAE,OAAO,GACf,SAAS,GAAG,SAAS,CAavB"}