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

package/out/zero-cache/src/types/lite.d.ts

@@ -1,6 +1,6 @@
 import type { SchemaValue, ValueType } from '../../../zero-schema/src/table-schema.ts';
-import type { LiteTableSpec } from '../db/specs.ts';
-import { type PostgresValueType } from './pg.ts';
+import type { ColumnSpec, LiteTableSpec } from '../db/specs.ts';
+import type { PostgresValueType } from './pg.ts';
 import type { RowValue } from './row-key.ts';
 /** Javascript value types supported by better-sqlite3. */
 export type LiteValueType = number | bigint | string | null | Uint8Array;
@@ -37,15 +37,11 @@ export declare const TEXT_ARRAY_ATTRIBUTE = "|TEXT_ARRAY";
  * but nonetheless determines how higher level logic handles the data.
  *
  * The format of the type string is the original upstream type, followed
- * by any number of attributes, each of which begins with the `|` character,
- * and optionally ending with `[]` to indicate an array type.
+ * by any number of attributes, each of which begins with the `|` character.
  * The current list of attributes are:
  * * `|NOT_NULL` to indicate that the upstream column does not allow nulls
  * * `|TEXT_ENUM` to indicate an enum that should be treated as a string
- * * `[]` suffix to indicate an array type
- *
- * Note: The legacy `|TEXT_ARRAY` attribute is still supported for backwards
- * compatibility but new data uses the `[]` suffix instead.
+ * * `|TEXT_ARRAY` to indicate an array
  *
  * Examples:
  * * `int8`
@@ -54,15 +50,20 @@ export declare const TEXT_ARRAY_ATTRIBUTE = "|TEXT_ARRAY";
  * * `timestamp with time zone|NOT_NULL`
  * * `nomz|TEXT_ENUM`
  * * `nomz|NOT_NULL|TEXT_ENUM`
- * * `int8[]`
- * * `int8|NOT_NULL[]`
- * * `nomz|TEXT_ENUM[]`
+ * * `int8[]` - Legacy (read support)
+ * * `int8[]|TEXT_ARRAY`
+ * * `int8|TEXT_ARRAY[]` - Legacy (read support)
+ * * `int8[]|TEXT_ARRAY[]` - Legacy (read support)
+ * * `int8|NOT_NULL[]` - Legacy (read support)
+ * * `nomz[]|TEXT_ENUM|TEXT_ARRAY`
+ * * `nomz|TEXT_ENUM[]` - Legacy (read support)
+ * * `nomz|TEXT_ENUM|TEXT_ARRAY[]` - Legacy (read support)
  */
 export type LiteTypeString = string;
 /**
  * Formats a {@link LiteTypeString}.
  */
-export declare function liteTypeString(upstreamDataType: string, notNull: boolean | null | undefined, textEnum: boolean): LiteTypeString;
+export declare function liteTypeString(upstreamDataType: string, notNull: boolean | null | undefined, textEnum: boolean, textArray: boolean): LiteTypeString;
 export declare function upstreamDataType(liteTypeString: LiteTypeString): string;
 export declare function nullableUpstream(liteTypeString: LiteTypeString): boolean;
 /**
@@ -71,7 +72,8 @@ export declare function nullableUpstream(liteTypeString: LiteTypeString): boolea
  *
  * For types not supported by ZQL, returns `undefined`.
  */
-export declare function dataTypeToZqlValueType(liteTypeString: LiteTypeString): ValueType | undefined;
+export declare function liteTypeToZqlValueType(liteTypeString: LiteTypeString): ValueType | undefined;
 export declare function isEnum(liteTypeString: LiteTypeString): boolean;
 export declare function isArray(liteTypeString: LiteTypeString): boolean;
+export declare function assertValidLiteColumnSpec(spec: ColumnSpec): void;
 //# sourceMappingURL=lite.d.ts.map

package/out/zero-cache/src/types/lite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lite.d.ts","sourceRoot":"","sources":["../../../../../zero-cache/src/types/lite.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,WAAW,EACX,SAAS,EACV,MAAM,0CAA0C,CAAC;AAClD,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,cAAc,CAAC;AAE3C,0DAA0D;AAC1D,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,UAAU,CAAC;AAEzE,MAAM,MAAM,OAAO,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC;AAC9D,MAAM,MAAM,UAAU,GAAG,OAAO,CAAC;AAQjC,eAAO,MAAM,gBAAgB,MAAM,CAAC;AACpC,eAAO,MAAM,WAAW,MAAM,CAAC;AAE/B,MAAM,MAAM,UAAU,GAAG,OAAO,gBAAgB,GAAG,OAAO,WAAW,CAAC;AAEtE;;;GAGG;AACH,wBAAgB,OAAO,CACrB,GAAG,EAAE,QAAQ,EACb,KAAK,EAAE,aAAa,EACpB,UAAU,EAAE,UAAU,GACrB;IAAC,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAwBjC;AAED;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CACvB,GAAG,EAAE,iBAAiB,EACtB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,GACrB,aAAa,CAef;AAwBD,wBAAgB,+BAA+B,CAC7C,YAAY,EAAE,cAAc,GAC3B,WAAW,CAEb;AAaD,eAAO,MAAM,oBAAoB,gBAAgB,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC;AAEpC;;GAEG;AACH,wBAAgB,cAAc,CAC5B,gBAAgB,EAAE,MAAM,EACxB,OAAO,EAAE,OAAO,GAAG,IAAI,GAAG,SAAS,EACnC,QAAQ,EAAE,OAAO,GAChB,cAAc,CAShB;AAED,wBAAgB,gBAAgB,CAAC,cAAc,EAAE,cAAc,UAG9D;AAED,wBAAgB,gBAAgB,CAAC,cAAc,EAAE,cAAc,WAE9D;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,cAAc,EAAE,cAAc,GAC7B,SAAS,GAAG,SAAS,CAMvB;AAED,wBAAgB,MAAM,CAAC,cAAc,EAAE,cAAc,WAEpD;AAED,wBAAgB,OAAO,CAAC,cAAc,EAAE,cAAc,WAKrD"}
+{"version":3,"file":"lite.d.ts","sourceRoot":"","sources":["../../../../../zero-cache/src/types/lite.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,WAAW,EACX,SAAS,EACV,MAAM,0CAA0C,CAAC;AAClD,OAAO,KAAK,EAAC,UAAU,EAAE,aAAa,EAAC,MAAM,gBAAgB,CAAC;AAE9D,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,SAAS,CAAC;AAC/C,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,cAAc,CAAC;AAE3C,0DAA0D;AAC1D,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,UAAU,CAAC;AAEzE,MAAM,MAAM,OAAO,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC;AAC9D,MAAM,MAAM,UAAU,GAAG,OAAO,CAAC;AAQjC,eAAO,MAAM,gBAAgB,MAAM,CAAC;AACpC,eAAO,MAAM,WAAW,MAAM,CAAC;AAE/B,MAAM,MAAM,UAAU,GAAG,OAAO,gBAAgB,GAAG,OAAO,WAAW,CAAC;AAEtE;;;GAGG;AACH,wBAAgB,OAAO,CACrB,GAAG,EAAE,QAAQ,EACb,KAAK,EAAE,aAAa,EACpB,UAAU,EAAE,UAAU,GACrB;IAAC,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAwBjC;AAED;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CACvB,GAAG,EAAE,iBAAiB,EACtB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,GACrB,aAAa,CAef;AAwBD,wBAAgB,+BAA+B,CAC7C,YAAY,EAAE,cAAc,GAC3B,WAAW,CAEb;AAaD,eAAO,MAAM,oBAAoB,gBAAgB,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC;AAEpC;;GAEG;AACH,wBAAgB,cAAc,CAC5B,gBAAgB,EAAE,MAAM,EACxB,OAAO,EAAE,OAAO,GAAG,IAAI,GAAG,SAAS,EACnC,QAAQ,EAAE,OAAO,EACjB,SAAS,EAAE,OAAO,GACjB,cAAc,CAahB;AAED,wBAAgB,gBAAgB,CAAC,cAAc,EAAE,cAAc,UAG9D;AAED,wBAAgB,gBAAgB,CAAC,cAAc,EAAE,cAAc,WAE9D;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,cAAc,EAAE,cAAc,GAC7B,SAAS,GAAG,SAAS,CAMvB;AAED,wBAAgB,MAAM,CAAC,cAAc,EAAE,cAAc,WAEpD;AAED,wBAAgB,OAAO,CAAC,cAAc,EAAE,cAAc,WAMrD;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,UAAU,QAOzD"}

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

@@ -1,133 +1,138 @@
 import { assert } from "../../../shared/src/asserts.js";
 import { stringify } from "../../../shared/src/bigint-json.js";
-import { dataTypeToZqlValueType as upstreamDataTypeToZqlValueType, } from "./pg.js";
+import { dataTypeToZqlValueType } from "./pg-data-type.js";
 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;
 }
-export const JSON_STRINGIFIED = 's';
-export 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.
- */
-export 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;
-        }
+const JSON_STRINGIFIED = "s";
+const JSON_PARSED = "p";
+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: row, numCols };
-    }
-    // Slow path for when a conversion is needed.
-    numCols = 0;
-    const converted = {};
-    for (const key in row) {
-        numCols++;
-        converted[key] = liteValue(row[key], columnType(key, table), jsonFormat);
-    }
-    return { row: converted, numCols };
+  }
+  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.
- */
-export function liteValue(val, pgType, jsonFormat) {
-    if (val instanceof Uint8Array || val === null) {
-        return val;
-    }
-    const valueType = dataTypeToZqlValueType(pgType);
-    if (valueType === 'json') {
-        if (jsonFormat === JSON_STRINGIFIED && typeof val === 'string') {
-            // JSON and JSONB values are already strings if the JSON was not parsed.
-            return val;
-        }
-        // Non-JSON/JSONB values will always appear as objects / arrays.
-        return stringify(val);
+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;
     }
-    const obj = toLiteValue(val);
-    return obj && typeof obj === 'object' ? stringify(obj) : obj;
+    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; // JSON
+  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;
 }
-export function mapLiteDataTypeToZqlSchemaValue(liteDataType) {
-    return { type: mapLiteDataTypeToZqlValueType(liteDataType) };
+function mapLiteDataTypeToZqlSchemaValue(liteDataType) {
+  return { type: mapLiteDataTypeToZqlValueType(liteDataType) };
 }
 function mapLiteDataTypeToZqlValueType(dataType) {
-    const type = dataTypeToZqlValueType(dataType);
-    if (type === undefined) {
-        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;
 }
-// Note: Includes the "TEXT" substring for SQLite type affinity
-const TEXT_ENUM_ATTRIBUTE = '|TEXT_ENUM';
-const NOT_NULL_ATTRIBUTE = '|NOT_NULL';
-export const TEXT_ARRAY_ATTRIBUTE = '|TEXT_ARRAY';
-/**
- * Formats a {@link LiteTypeString}.
- */
-export function liteTypeString(upstreamDataType, notNull, textEnum) {
-    let typeString = upstreamDataType;
-    if (notNull) {
-        typeString += NOT_NULL_ATTRIBUTE;
-    }
-    if (textEnum) {
-        typeString += TEXT_ENUM_ATTRIBUTE;
-    }
-    return typeString;
+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;
+}
+function upstreamDataType(liteTypeString2) {
+  const delim = liteTypeString2.indexOf("|");
+  return delim > 0 ? liteTypeString2.substring(0, delim) : liteTypeString2;
 }
-export function upstreamDataType(liteTypeString) {
-    const delim = liteTypeString.indexOf('|');
-    return delim > 0 ? liteTypeString.substring(0, delim) : liteTypeString;
+function nullableUpstream(liteTypeString2) {
+  return !liteTypeString2.includes(NOT_NULL_ATTRIBUTE);
 }
-export 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`.
- */
-export function dataTypeToZqlValueType(liteTypeString) {
-    return upstreamDataTypeToZqlValueType(upstreamDataType(liteTypeString).toLowerCase(), liteTypeString.includes(TEXT_ENUM_ATTRIBUTE), isArray(liteTypeString));
+function isEnum(liteTypeString2) {
+  return liteTypeString2.includes(TEXT_ENUM_ATTRIBUTE);
 }
-export 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("[]");
 }
-export function isArray(liteTypeString) {
-    return (liteTypeString.includes(TEXT_ARRAY_ATTRIBUTE) ||
-        liteTypeString.includes('[]'));
+function assertValidLiteColumnSpec(spec) {
+  const { dataType } = spec;
+  assert(dataType.includes(TEXT_ARRAY_ATTRIBUTE) === dataType.includes("[]"));
+  assert(dataType.includes("[]") === (spec.elemPgTypeClass !== null));
+  assert(!/^.+\|.*\[\]/.test(dataType), `Invalid dataType ${dataType}`);
 }
-//# sourceMappingURL=lite.js.map
+export {
+  JSON_PARSED,
+  JSON_STRINGIFIED,
+  TEXT_ARRAY_ATTRIBUTE,
+  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","sourceRoot":"","sources":["../../../../../zero-cache/src/types/lite.ts"],"names":[],"mappings":"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"}
+{"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(dataType.includes(TEXT_ARRAY_ATTRIBUTE) === dataType.includes('[]'));\n  assert(dataType.includes('[]') === (spec.elemPgTypeClass !== null));\n\n  // and no [] after |\n  assert(!/^.+\\|.*\\[\\]/.test(dataType), `Invalid dataType ${dataType}`);\n}\n"],"names":["upstreamDataType","liteTypeString","upstreamDataTypeToZqlValueType"],"mappings":"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"}

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

@@ -1,4 +1,7 @@
-export function liteTableName(t) {
-    return t.schema === 'public' ? t.name : `${t.schema}.${t.name}`;
+function liteTableName(t) {
+  return t.schema === "public" ? t.name : `${t.schema}.${t.name}`;
 }
-//# sourceMappingURL=names.js.map
+export {
+  liteTableName
+};
+//# sourceMappingURL=names.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"names.js","sourceRoot":"","sources":["../../../../../zero-cache/src/types/names.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,aAAa,CAAC,CAAiC;IAC7D,OAAO,CAAC,CAAC,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC;AAClE,CAAC"}
+{"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;"}

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

@@ -0,0 +1,73 @@
+import type { ValueType } from '../../../zero-protocol/src/client-schema.ts';
+export declare const pgToZqlNumericTypeMap: Readonly<{
+    smallint: "number";
+    integer: "number";
+    int: "number";
+    int2: "number";
+    int4: "number";
+    int8: "number";
+    bigint: "number";
+    smallserial: "number";
+    serial: "number";
+    serial2: "number";
+    serial4: "number";
+    serial8: "number";
+    bigserial: "number";
+    decimal: "number";
+    numeric: "number";
+    real: "number";
+    'double precision': "number";
+    float: "number";
+    float4: "number";
+    float8: "number";
+}>;
+export declare function isPgNumberType(pgType: string): boolean;
+export declare const pgToZqlStringTypeMap: Readonly<{
+    bpchar: "string";
+    character: "string";
+    'character varying': "string";
+    text: "string";
+    uuid: "string";
+    varchar: "string";
+}>;
+export declare function isPgStringType(pgType: string): boolean;
+export declare const pgToZqlTypeMap: Readonly<{
+    bool: "boolean";
+    boolean: "boolean";
+    json: "json";
+    jsonb: "json";
+    bpchar: "string";
+    character: "string";
+    'character varying': "string";
+    text: "string";
+    uuid: "string";
+    varchar: "string";
+    date: "number";
+    time: "number";
+    timestamp: "number";
+    timestamptz: "number";
+    'timestamp with time zone': "number";
+    'timestamp without time zone': "number";
+    smallint: "number";
+    integer: "number";
+    int: "number";
+    int2: "number";
+    int4: "number";
+    int8: "number";
+    bigint: "number";
+    smallserial: "number";
+    serial: "number";
+    serial2: "number";
+    serial4: "number";
+    serial8: "number";
+    bigserial: "number";
+    decimal: "number";
+    numeric: "number";
+    real: "number";
+    'double precision': "number";
+    float: "number";
+    float4: "number";
+    float8: "number";
+}>;
+export declare function dataTypeToZqlValueType(pgType: string, isEnum: boolean, isArray: boolean): ValueType | undefined;
+//# sourceMappingURL=pg-data-type.d.ts.map

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

@@ -0,0 +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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwBzB,CAAC;AAEH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,OAAO,EACf,OAAO,EAAE,OAAO,GACf,SAAS,GAAG,SAAS,CAavB"}

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

@@ -0,0 +1,82 @@
+const pgToZqlNumericTypeMap = Object.freeze({
+  "smallint": "number",
+  "integer": "number",
+  "int": "number",
+  "int2": "number",
+  "int4": "number",
+  "int8": "number",
+  "bigint": "number",
+  "smallserial": "number",
+  "serial": "number",
+  "serial2": "number",
+  "serial4": "number",
+  "serial8": "number",
+  "bigserial": "number",
+  "decimal": "number",
+  "numeric": "number",
+  "real": "number",
+  "double precision": "number",
+  "float": "number",
+  "float4": "number",
+  "float8": "number"
+});
+function isPgNumberType(pgType) {
+  return Object.hasOwn(pgToZqlNumericTypeMap, formatTypeForLookup(pgType));
+}
+const pgToZqlStringTypeMap = Object.freeze({
+  "bpchar": "string",
+  "character": "string",
+  "character varying": "string",
+  "text": "string",
+  "uuid": "string",
+  "varchar": "string"
+});
+function isPgStringType(pgType) {
+  return Object.hasOwn(pgToZqlStringTypeMap, formatTypeForLookup(pgType));
+}
+const pgToZqlTypeMap = Object.freeze({
+  // Numeric types
+  ...pgToZqlNumericTypeMap,
+  // Date/Time types
+  "date": "number",
+  "time": "number",
+  "timestamp": "number",
+  "timestamptz": "number",
+  "timestamp with time zone": "number",
+  "timestamp without time zone": "number",
+  // String types
+  ...pgToZqlStringTypeMap,
+  // Boolean types
+  "bool": "boolean",
+  "boolean": "boolean",
+  "json": "json",
+  "jsonb": "json"
+  // TODO: Add support for these.
+  // 'bytea':
+});
+function dataTypeToZqlValueType(pgType, isEnum, isArray) {
+  if (isArray) {
+    return "json";
+  }
+  const valueType = pgToZqlTypeMap[formatTypeForLookup(pgType)];
+  if (valueType === void 0 && isEnum) {
+    return "string";
+  }
+  return valueType;
+}
+function formatTypeForLookup(pgType) {
+  const startOfArgs = pgType.indexOf("(");
+  if (startOfArgs === -1) {
+    return pgType.toLocaleLowerCase();
+  }
+  return pgType.toLocaleLowerCase().substring(0, startOfArgs);
+}
+export {
+  dataTypeToZqlValueType,
+  isPgNumberType,
+  isPgStringType,
+  pgToZqlNumericTypeMap,
+  pgToZqlStringTypeMap,
+  pgToZqlTypeMap
+};
+//# sourceMappingURL=pg-data-type.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pg-data-type.js","sources":["../../../../../zero-cache/src/types/pg-data-type.ts"],"sourcesContent":["import type {ValueType} from '../../../zero-protocol/src/client-schema.ts';\n\nexport const pgToZqlNumericTypeMap = Object.freeze({\n  'smallint': 'number',\n  'integer': 'number',\n  'int': 'number',\n  'int2': 'number',\n  'int4': 'number',\n  'int8': 'number',\n  'bigint': 'number',\n  'smallserial': 'number',\n  'serial': 'number',\n  'serial2': 'number',\n  'serial4': 'number',\n  'serial8': 'number',\n  'bigserial': 'number',\n  'decimal': 'number',\n  'numeric': 'number',\n  'real': 'number',\n  'double precision': 'number',\n  'float': 'number',\n  'float4': 'number',\n  'float8': 'number',\n});\n\nexport function isPgNumberType(pgType: string): boolean {\n  return Object.hasOwn(pgToZqlNumericTypeMap, formatTypeForLookup(pgType));\n}\n\nexport const pgToZqlStringTypeMap = Object.freeze({\n  'bpchar': 'string',\n  'character': 'string',\n  'character varying': 'string',\n  'text': 'string',\n  'uuid': 'string',\n  'varchar': 'string',\n});\n\nexport function isPgStringType(pgType: string): boolean {\n  return Object.hasOwn(pgToZqlStringTypeMap, formatTypeForLookup(pgType));\n}\n\nexport const pgToZqlTypeMap = Object.freeze({\n  // Numeric types\n  ...pgToZqlNumericTypeMap,\n\n  // Date/Time types\n  'date': 'number',\n  'time': 'number',\n  'timestamp': 'number',\n  'timestamptz': 'number',\n  'timestamp with time zone': 'number',\n  'timestamp without time zone': 'number',\n\n  // String types\n  ...pgToZqlStringTypeMap,\n\n  // Boolean types\n  'bool': 'boolean',\n  'boolean': 'boolean',\n\n  'json': 'json',\n  'jsonb': 'json',\n\n  // TODO: Add support for these.\n  // 'bytea':\n});\n\nexport function dataTypeToZqlValueType(\n  pgType: string,\n  isEnum: boolean,\n  isArray: boolean,\n): ValueType | undefined {\n  // We treat pg arrays as JSON values.\n  if (isArray) {\n    return 'json';\n  }\n\n  const valueType = (pgToZqlTypeMap as Record<string, ValueType>)[\n    formatTypeForLookup(pgType)\n  ];\n  if (valueType === undefined && isEnum) {\n    return 'string';\n  }\n  return valueType;\n}\n\n// Strips args (i.e. (32) in char(32)) and lowercases.\nfunction formatTypeForLookup(pgType: string): string {\n  const startOfArgs = pgType.indexOf('(');\n  if (startOfArgs === -1) {\n    return pgType.toLocaleLowerCase();\n  }\n  return pgType.toLocaleLowerCase().substring(0, startOfArgs);\n}\n"],"names":[],"mappings":"AAEO,MAAM,wBAAwB,OAAO,OAAO;AAAA,EACjD,YAAY;AAAA,EACZ,WAAW;AAAA,EACX,OAAO;AAAA,EACP,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,eAAe;AAAA,EACf,UAAU;AAAA,EACV,WAAW;AAAA,EACX,WAAW;AAAA,EACX,WAAW;AAAA,EACX,aAAa;AAAA,EACb,WAAW;AAAA,EACX,WAAW;AAAA,EACX,QAAQ;AAAA,EACR,oBAAoB;AAAA,EACpB,SAAS;AAAA,EACT,UAAU;AAAA,EACV,UAAU;AACZ,CAAC;AAEM,SAAS,eAAe,QAAyB;AACtD,SAAO,OAAO,OAAO,uBAAuB,oBAAoB,MAAM,CAAC;AACzE;AAEO,MAAM,uBAAuB,OAAO,OAAO;AAAA,EAChD,UAAU;AAAA,EACV,aAAa;AAAA,EACb,qBAAqB;AAAA,EACrB,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,WAAW;AACb,CAAC;AAEM,SAAS,eAAe,QAAyB;AACtD,SAAO,OAAO,OAAO,sBAAsB,oBAAoB,MAAM,CAAC;AACxE;AAEO,MAAM,iBAAiB,OAAO,OAAO;AAAA;AAAA,EAE1C,GAAG;AAAA;AAAA,EAGH,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,aAAa;AAAA,EACb,eAAe;AAAA,EACf,4BAA4B;AAAA,EAC5B,+BAA+B;AAAA;AAAA,EAG/B,GAAG;AAAA;AAAA,EAGH,QAAQ;AAAA,EACR,WAAW;AAAA,EAEX,QAAQ;AAAA,EACR,SAAS;AAAA;AAAA;AAIX,CAAC;AAEM,SAAS,uBACd,QACA,QACA,SACuB;AAEvB,MAAI,SAAS;AACX,WAAO;AAAA,EACT;AAEA,QAAM,YAAa,eACjB,oBAAoB,MAAM,CAC5B;AACA,MAAI,cAAc,UAAa,QAAQ;AACrC,WAAO;AAAA,EACT;AACA,SAAO;AACT;AAGA,SAAS,oBAAoB,QAAwB;AACnD,QAAM,cAAc,OAAO,QAAQ,GAAG;AACtC,MAAI,gBAAgB,IAAI;AACtB,WAAO,OAAO,kBAAA;AAAA,EAChB;AACA,SAAO,OAAO,kBAAA,EAAoB,UAAU,GAAG,WAAW;AAC5D;"}

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

@@ -1,72 +1,17 @@
-// Forked from https=//github.com/brianc/node-pg-types/blob/5b26b826466cff4a9092b8c9e31960fe293ef3d9/lib/builtins.js
-/**
- * Following query was used to generate this file=
-
- SELECT json_object_agg(UPPER(PT.typname), PT.oid==int4 ORDER BY pt.oid)
- FROM pg_type PT
- WHERE typnamespace = (SELECT pgn.oid FROM pg_namespace pgn WHERE nspname = 'pg_catalog') -- Take only builting Postgres types with stable OID (extension types are not guaranted to be stable)
- AND typtype = 'b' -- Only basic types
- AND typelem = 0 -- Ignore aliases
- AND typisdefined -- Ignore undefined types
- */
-export const BOOL = 16;
-export const BYTEA = 17;
-export const CHAR = 18;
-export const INT8 = 20;
-export const INT2 = 21;
-export const INT4 = 23;
-export const REGPROC = 24;
-export const TEXT = 25;
-export const OID = 26;
-export const TID = 27;
-export const XID = 28;
-export const CID = 29;
-export const JSON = 114;
-export const XML = 142;
-export const PG_NODE_TREE = 194;
-export const SMGR = 210;
-export const PATH = 602;
-export const POLYGON = 604;
-export const CIDR = 650;
-export const FLOAT4 = 700;
-export const FLOAT8 = 701;
-export const ABSTIME = 702;
-export const RELTIME = 703;
-export const TINTERVAL = 704;
-export const CIRCLE = 718;
-export const MACADDR8 = 774;
-export const MONEY = 790;
-export const MACADDR = 829;
-export const INET = 869;
-export const ACLITEM = 1033;
-export const BPCHAR = 1042;
-export const VARCHAR = 1043;
-export const DATE = 1082;
-export const TIME = 1083;
-export const TIMESTAMP = 1114;
-export const TIMESTAMPTZ = 1184;
-export const INTERVAL = 1186;
-export const TIMETZ = 1266;
-export const BIT = 1560;
-export const VARBIT = 1562;
-export const NUMERIC = 1700;
-export const REFCURSOR = 1790;
-export const REGPROCEDURE = 2202;
-export const REGOPER = 2203;
-export const REGOPERATOR = 2204;
-export const REGCLASS = 2205;
-export const REGTYPE = 2206;
-export const UUID = 2950;
-export const TXID_SNAPSHOT = 2970;
-export const PG_LSN = 3220;
-export const PG_NDISTINCT = 3361;
-export const PG_DEPENDENCIES = 3402;
-export const TSVECTOR = 3614;
-export const TSQUERY = 3615;
-export const GTSVECTOR = 3642;
-export const REGCONFIG = 3734;
-export const REGDICTIONARY = 3769;
-export const JSONB = 3802;
-export const REGNAMESPACE = 4089;
-export const REGROLE = 4096;
-//# sourceMappingURL=pg-types.js.map
+const JSON = 114;
+const DATE = 1082;
+const TIME = 1083;
+const TIMESTAMP = 1114;
+const TIMESTAMPTZ = 1184;
+const NUMERIC = 1700;
+const JSONB = 3802;
+export {
+  DATE,
+  JSON,
+  JSONB,
+  NUMERIC,
+  TIME,
+  TIMESTAMP,
+  TIMESTAMPTZ
+};
+//# sourceMappingURL=pg-types.js.map