okmodel 0.1.1 → 0.3.0

package/dist/dialects/pg/index.js

@@ -1,773 +1,80 @@
 import {
-  tag
-} from "../../shared/cn0n68ft.js";
+  jsonReplacer2,
+  json2,
+  jsonb2
+} from "../../shared/gjthds9j.js";
+import {
+  encodeInstant,
+  decodeInstant,
+  encodeDate,
+  decodeDate,
+  timestamptz2,
+  timestamp2,
+  date2,
+  time2,
+  timetz2,
+  interval2
+} from "../../shared/1g0drakv.js";
+import {
+  one2,
+  many2,
+  manyThrough2,
+  schema2
+} from "../../shared/x6wysh83.js";
+import {
+  domainType
+} from "../../shared/qbxzvwwc.js";
+import {
+  id2,
+  uuid2
+} from "../../shared/dyj86cmj.js";
+import {
+  table2,
+  index2,
+  sql2
+} from "../../shared/6w5j844a.js";
+import {
+  text2,
+  varchar2,
+  char2,
+  citext2,
+  encodeText,
+  decodeText
+} from "../../shared/4m9fn52z.js";
 import {
-  definition,
-  unavailable,
-  rejected,
-  quoteLiteral,
   ColumnBuilder2,
   required,
   openColumn,
-  formatType,
-  table2,
-  index2,
-  sql2,
-  snakeCase,
-  emittedTypeName,
-  rejectLater
-} from "../../shared/gk7cs7sp.js";
+  formatType
+} from "../../shared/c9z5g0fm.js";
 import {
-  catalog,
-  enumType,
-  sameEnumLabels
-} from "../../shared/g5fhqmwe.js";
+  definition,
+  rejected
+} from "../../shared/tmbdywx0.js";
 import {
-  staticNamespace2,
-  table3,
-  column2,
-  index3,
-  constraint2,
-  sequence2,
+  sameNamespace2,
   compareText
-} from "../../shared/j5cn2963.js";
+} from "../../shared/t4tbsy9h.js";
 import {
-  assertIdentifier2,
-  fitIdentifier2,
-  assertStoredText
-} from "../../shared/mkjmqjv4.js";
+  tag
+} from "../../shared/cn0n68ft.js";
 import {
-  catalogError2,
-  throwNamed2
-} from "../../shared/ycwz42az.js";
-
-// src/dialects/pg/compile.ts
-function compileColumn(builder, input) {
-  const state = builder.state;
-  const name = state.sqlName ?? input.name;
-  const dependencies = [];
-  if (state.extension !== undefined) {
-    assertIdentifier2(state.extension, "extension");
-    dependencies.push({ kind: "extension", name: state.extension });
-  }
-  if (state.typeDependency !== undefined) {
-    assertIdentifier2(state.typeDependency, "type");
-    dependencies.push({
-      kind: "type",
-      namespace: input.parent.namespace,
-      name: state.typeDependency
+  catalogError2
+} from "../../shared/52szzakm.js";
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
     });
-  }
-  if (state.renamedFrom !== undefined) {
-    assertIdentifier2(state.renamedFrom, "renamed column");
-  }
-  if (state.comment !== undefined) {
-    assertStoredText(state.comment, "column comment");
-  }
-  if (state.picklist !== undefined) {
-    for (const value of state.picklist.values) {
-      assertStoredText(value, "picklist value");
-    }
-  }
-  const built = column2({
-    parent: input.parent,
-    name,
-    dataType: formatType(state.baseType, state.dims),
-    nullable: state.nullable,
-    provenance: input.provenance,
-    ...input.owner !== undefined ? { owner: input.owner } : {},
-    ...state.defaultSql !== undefined ? { defaultExpression: state.defaultSql } : {},
-    ...state.identity !== undefined ? { identity: state.identity } : {},
-    ...state.generated !== undefined ? { generated: state.generated } : {},
-    ...dependencies.length > 0 || (input.dependencies?.length ?? 0) > 0 ? { dependencies: [...dependencies, ...input.dependencies ?? []] } : {}
-  });
-  const check = state.picklist !== undefined && state.picklist.check ? constraint2({
-    parent: input.parent,
-    constraintKind: "check",
-    columns: [name],
-    nameKey: name,
-    expression: picklistExpression(name, state.picklist.values),
-    provenance: input.provenance,
-    ...input.owner !== undefined ? { owner: input.owner } : {}
-  }) : undefined;
-  const unique = state.unique !== undefined ? constraint2({
-    parent: input.parent,
-    constraintKind: "unique",
-    columns: [name],
-    nameKey: name,
-    provenance: input.provenance,
-    ...input.owner !== undefined ? { owner: input.owner } : {}
-  }) : undefined;
-  return {
-    column: built,
-    guarded: state.guarded,
-    hidden: state.hidden,
-    ...check !== undefined ? { check } : {},
-    ...unique !== undefined ? { unique } : {},
-    ...state.renamedFrom !== undefined ? { renamedFrom: state.renamedFrom } : {},
-    ...state.comment !== undefined ? { comment: state.comment } : {},
-    ...state.unique?.reason !== undefined ? { uniqueReason: state.unique.reason } : {},
-    ...state.unique?.global !== undefined ? { uniqueGlobal: state.unique.global } : {},
-    ...state.domain !== undefined ? { domain: state.domain } : {}
-  };
-}
-function picklistExpression(name, values) {
-  const list = values.map((value) => quoteLiteral(value)).join(", ");
-  return `(${name} IN (${list}))`;
-}
-
-// src/dialects/pg/relations.ts
-function one(table, field) {
-  return { kind: "one", table, field };
-}
-function many(table, field) {
-  return { kind: "many", table, field };
-}
-function isRelationCall(value) {
-  if (typeof value !== "object" || value === null)
-    return false;
-  if (!("kind" in value) || !("table" in value))
-    return false;
-  const kind = value.kind;
-  return (kind === "one" || kind === "many") && typeof value.table === "string";
-}
-
-// src/dialects/pg/text.ts
-function text() {
-  return required({ baseType: "text", encode: encodeText, decode: decodeText, sqlForm: "quote" });
-}
-function varchar(length) {
-  const limit = boundedLength(length, "varchar");
-  return required({
-    baseType: `varchar(${String(limit)})`,
-    encode: (value) => encodeLimited(value, limit, "varchar"),
-    decode: decodeText,
-    sqlForm: "quote"
-  });
-}
-function char(length) {
-  const limit = boundedLength(length, "char");
-  return required({
-    baseType: `char(${String(limit)})`,
-    encode: (value) => encodeLimited(value, limit, "char"),
-    decode: decodeText,
-    sqlForm: "quote"
-  });
-}
-function citext() {
-  return required({
-    baseType: "citext",
-    encode: encodeText,
-    decode: decodeText,
-    sqlForm: "quote",
-    extension: "citext"
-  });
-}
-function encodeText(value) {
-  return value;
-}
-function decodeText(wire) {
-  return wire;
-}
-function encodeLimited(value, limit, role) {
-  if (characterLength(value) > limit) {
-    rejected(`${role} accepts at most ${String(limit)} characters.`);
-  }
-  return value;
-}
-function boundedLength(length, role) {
-  if (!Number.isInteger(length) || length < 1 || length > 10485760) {
-    definition(`${role} length ${String(length)} must be an integer from 1 to 10485760.`);
-  }
-  return length;
-}
-function characterLength(value) {
-  let count = 0;
-  for (let index = 0;index < value.length; index += 1) {
-    const code = value.charCodeAt(index);
-    if (code >= 55296 && code <= 56319) {
-      index += 1;
-    }
-    count += 1;
-  }
-  return count;
-}
-
-// src/dialects/pg/schema.ts
-var SCHEMA_KNOWN = new Set(["casing", "codecs", "requires", "tables", "types"]);
-var SCHEMA_LATER = {
-  extensions: "0.3",
-  functions: "0.3",
-  tenancy: "0.2",
-  traits: "0.2",
-  triggers: "0.3",
-  validation: "0.2",
-  views: "0.3"
 };
-var BIGINT_CODECS = new Set(["string", "number", "bigint"]);
-var NUMERIC_CODECS = new Set(["string", "number"]);
-function stage(jobs, build) {
-  jobs.push((objects) => {
-    objects.push(build());
-  });
-}
-function schema(config) {
-  rejectLater(config, SCHEMA_KNOWN, SCHEMA_LATER, "schema()");
-  if (!Array.isArray(config.tables)) {
-    definition("schema() needs a tables array.");
-  }
-  const types = readTypes(config.types);
-  const casing = readCasing(config.casing);
-  const codecs = readCodecs(config.codecs);
-  const requires = readRequires(config.requires);
-  const namespace = staticNamespace2("public");
-  const accepted = acceptTables(config.tables);
-  const jobs = [];
-  const prepared = [];
-  const sqlNames = new Set;
-  const enums = new Map;
-  for (const item of config.tables) {
-    const built = compileTable(item, namespace, casing, codecs, jobs, enums);
-    if (sqlNames.has(built.sqlName)) {
-      catalogError2("OKM1023", `Table ${built.tsName} uses SQL name ${built.sqlName}, which another table already uses. Accepted names: ${list(accepted)}.`);
-    }
-    sqlNames.add(built.sqlName);
-    prepared.push(built);
-  }
-  const byName = new Map;
-  for (const item of prepared) {
-    byName.set(item.tsName, item);
-  }
-  const edges = [];
-  for (const item of prepared) {
-    compileForeignKeys(item, byName, accepted, jobs, edges);
-  }
-  const model = {};
-  for (const item of prepared) {
-    model[item.tsName] = tableModel(item, edges, byName, accepted);
-  }
-  let document;
-  return {
-    get catalog() {
-      if (document === undefined) {
-        const objects = [];
-        for (const job of jobs)
-          job(objects);
-        for (const [name, note] of [...enums.entries()].sort((left, right) => compareText(left[0], right[0]))) {
-          objects.push(enumType({
-            namespace,
-            name,
-            labels: note.labels,
-            provenance: note.provenance
-          }));
-        }
-        document = catalog(objects);
-      }
-      return document;
-    },
-    types,
-    casing,
-    codecs,
-    requires,
-    tables: config.tables,
-    model
-  };
-}
-function acceptTables(tables) {
-  const names = [];
-  const seen = new Set;
-  const emitted = new Map;
-  for (const item of tables) {
-    if (typeof item.name !== "string" || item.name.length === 0) {
-      definition("schema() tables need a name.");
-    }
-    if (seen.has(item.name)) {
-      catalogError2("OKM1023", `Table ${item.name} is declared more than once. Accepted names: ${list([...names].sort())}.`);
-    }
-    seen.add(item.name);
-    names.push(item.name);
-    const typeName = emittedTypeName(item.name);
-    const previous = emitted.get(typeName);
-    if (previous !== undefined) {
-      catalogError2("OKM1023", `Table ${item.name} and ${previous} both emit ${typeName}. Accepted names: ${list([...names].sort())}.`);
-    }
-    emitted.set(typeName, item.name);
-  }
-  names.sort();
-  return names;
-}
-function noteEnum(notes, labels, name, table, provenance) {
-  const previous = notes.get(name);
-  if (previous !== undefined && !sameEnumLabels(previous.labels, labels)) {
-    catalogError2("OKM1020", `Enum ${name} lists ${previous.labels.join(", ")} on ${previous.table} and ${labels.join(", ")} on ${table}. One enum has one label list.`);
-  }
-  if (previous === undefined || compareText(table, previous.table) < 0) {
-    notes.set(name, { labels, table, provenance });
-  }
-}
-function compileTable(item, namespace, casing, codecs, jobs, enums) {
-  const options = item.options;
-  readTableNames(item.name, options);
-  const sqlName = options?.sqlName ?? (casing === "snake" ? snakeCase(item.name) : item.name);
-  assertIdentifier2(sqlName, `table ${item.name}`);
-  const provenance = { origin: "file", name: item.name };
-  const parent = { namespace, name: sqlName };
-  stage(jobs, () => table3({ namespace, name: sqlName, provenance }));
-  const columns = [];
-  const primary = [];
-  const byField = new Map;
-  const bySql = new Map;
-  const handles = {};
-  for (const [field, builder] of Object.entries(item.columns)) {
-    if (!(builder instanceof ColumnBuilder2)) {
-      definition(`Column ${item.name}.${field} must be a column builder.`);
-    }
-    const column = builder;
-    const columnSql = column.state.sqlName ?? (casing === "snake" ? snakeCase(field) : field);
-    assertCodec(item.name, field, column, codecs);
-    const identity = column.state.identity;
-    if (identity !== undefined) {
-      const seqName = fitIdentifier2(`${sqlName}_${columnSql}_seq`);
-      jobs.push((objects) => {
-        const seq = sequence2({
-          namespace,
-          name: seqName,
-          dataType: "bigint",
-          provenance,
-          dependencies: [{ kind: "table", namespace, name: sqlName }]
-        });
-        objects.push(seq);
-        pushCompiled(objects, column, {
-          parent,
-          name: columnSql,
-          provenance,
-          dependencies: [seq.identity]
-        });
-      });
-    } else {
-      jobs.push((objects) => {
-        pushCompiled(objects, column, { parent, name: columnSql, provenance });
-      });
-    }
-    const decode = column.state.decode;
-    const prepared = {
-      field,
-      sqlName: columnSql,
-      dataType: formatType(column.state.baseType, column.state.dims),
-      nullable: column.state.nullable,
-      references: column.state.references,
-      encode: column.state.encode,
-      decode: decode === decodeText ? undefined : decode,
-      hidden: column.state.hidden,
-      guarded: column.state.guarded,
-      writable: column.state.guarded !== true && column.state.omitWrite !== true && column.state.generated === undefined,
-      unique: column.state.unique !== undefined
-    };
-    columns.push(prepared);
-    byField.set(field, prepared);
-    bySql.set(prepared.sqlName, prepared);
-    handles[field] = { name: prepared.sqlName };
-    if (column.state.primaryKey) {
-      primary.push(prepared.sqlName);
-    }
-    const labels = column.state.enumLabels;
-    if (labels !== undefined) {
-      noteEnum(enums, labels, column.state.typeDependency ?? prepared.sqlName, sqlName, provenance);
-    }
-  }
-  if (primary.length > 1) {
-    catalogError2("OKM1020", `Table ${item.name} has more than one primary key (${primary.join(", ")}). One primary key is accepted.`);
-  }
-  if (primary.length === 1) {
-    stage(jobs, () => constraint2({
-      parent,
-      constraintKind: "primaryKey",
-      columns: primary,
-      provenance
-    }));
-  }
-  if (options?.unique !== undefined) {
-    compileUniques(item.name, options, parent, provenance, byField, jobs);
-  }
-  if (options?.indexes !== undefined) {
-    compileIndexes(item.name, options, handles, parent, provenance, jobs);
-  }
-  if (options?.checks !== undefined) {
-    compileChecks(item.name, options, handles, parent, provenance, byField, jobs);
-  }
-  return {
-    tsName: item.name,
-    sqlName,
-    parent,
-    provenance,
-    columns,
-    primary,
-    uniques: uniqueTargets(primary, columns, bySql, options),
-    byField,
-    bySql,
-    relationOptions: relationInput(item.name, options)
-  };
-}
-function uniqueTargets(primary, columns, bySql, options) {
-  const uniques = [];
-  if (primary.length > 0) {
-    const fields = [];
-    for (const sqlName of primary) {
-      const column = bySql.get(sqlName);
-      if (column !== undefined)
-        fields.push(column.field);
-    }
-    if (fields.length > 0)
-      uniques.push(fields);
-  }
-  for (const column of columns) {
-    if (column.unique)
-      uniques.push([column.field]);
-  }
-  const named = options?.unique;
-  if (named !== undefined) {
-    for (const fields of Object.values(named))
-      uniques.push([...fields]);
-  }
-  return uniques;
-}
-function relationInput(tableName, options) {
-  const relations = options?.relations;
-  if (relations === undefined)
-    return;
-  if (typeof relations !== "object" || relations === null || Array.isArray(relations)) {
-    definition(`Table ${tableName} relations must be an object of one() and many() calls.`);
-  }
-  return relations;
-}
-function pushCompiled(objects, column, input) {
-  const compiled = compileColumn(column, input);
-  objects.push(compiled.column);
-  if (compiled.check !== undefined)
-    objects.push(compiled.check);
-  if (compiled.unique !== undefined)
-    objects.push(compiled.unique);
-}
-function compileUniques(tableName, options, parent, provenance, byField, jobs) {
-  const unique = options?.unique;
-  if (unique === undefined) {
-    return;
-  }
-  const accepted = [...byField.keys()].sort();
-  for (const [name, fields] of Object.entries(unique)) {
-    if (fields.length === 0) {
-      definition(`Unique ${tableName}.${name} needs a column.`);
-    }
-    const columns = [];
-    for (const field of fields) {
-      const column = byField.get(field);
-      if (column === undefined) {
-        throwNamed2("OKM1020", field, accepted, `Unique ${tableName}.${name} names ${field}, which is not a column of ${tableName}. Accepted names: ${list(accepted)}.`);
-      }
-      columns.push(column.sqlName);
-    }
-    stage(jobs, () => constraint2({
-      parent,
-      constraintKind: "unique",
-      columns,
-      nameKey: name,
-      provenance
-    }));
-  }
-}
-function compileIndexes(tableName, options, handles, parent, provenance, jobs) {
-  const build = options?.indexes;
-  if (build === undefined) {
-    return;
-  }
-  const calls = build(handles);
-  if (!Array.isArray(calls)) {
-    definition(`Table ${tableName} indexes must return an array.`);
-  }
-  for (const call of calls) {
-    const built = readIndex(tableName, call);
-    stage(jobs, () => index3({
-      parent,
-      columns: built.columns,
-      unique: built.isUnique === true,
-      nameKey: built.columns.join("_"),
-      provenance
-    }));
-  }
-}
-function compileChecks(tableName, options, handles, parent, provenance, byField, jobs) {
-  const checks = options?.checks;
-  if (checks === undefined) {
-    return;
-  }
-  for (const [name, build] of Object.entries(checks)) {
-    const used = [];
-    const value = build(track(handles, used));
-    const text = readCheck(tableName, name, value);
-    const columns = [];
-    for (const field of used) {
-      const column = byField.get(field);
-      if (column !== undefined) {
-        columns.push(column.sqlName);
-      }
-    }
-    stage(jobs, () => constraint2({
-      parent,
-      constraintKind: "check",
-      columns,
-      nameKey: name,
-      expression: text,
-      provenance
-    }));
-  }
-}
-function compileForeignKeys(item, byName, accepted, jobs, edges) {
-  for (const column of item.columns) {
-    const reference = column.references;
-    if (reference === undefined) {
-      continue;
-    }
-    const target = byName.get(reference.table);
-    if (target === undefined) {
-      throwNamed2("OKM1020", reference.table, accepted, `Table ${reference.table} is not in the schema. Accepted names: ${list(accepted)}.`);
-    }
-    const targetColumns = resolveTarget(item, column, target, reference);
-    if (reference.onDelete === "set null" || reference.onUpdate === "set null") {
-      if (!column.nullable) {
-        definition(`Foreign key ${item.tsName}.${column.field} uses set null. ${item.tsName}.${column.field} must be nullable.`);
-      }
-    }
-    const localType = column.dataType;
-    const remote = targetColumns[0];
-    if (remote === undefined || targetColumns.length !== 1) {
-      const names = [...target.byField.keys()].sort();
-      catalogError2("OKM1021", `Foreign key ${item.tsName}.${column.field} on ${target.tsName} is ambiguous. Accepted columns: ${list(names)}.`);
-    }
-    if (localType !== remote.dataType) {
-      catalogError2("OKM1022", `Foreign key ${item.tsName}.${column.field} is ${localType} and ${target.tsName}.${remote.field} is ${remote.dataType}. Accepted type: ${remote.dataType}.`);
-    }
-    stage(jobs, () => constraint2({
-      parent: item.parent,
-      constraintKind: "foreignKey",
-      columns: [column.sqlName],
-      nameKey: column.sqlName,
-      provenance: item.provenance,
-      references: {
-        parent: target.parent,
-        columns: [remote.sqlName],
-        ...reference.onDelete !== undefined ? { onDelete: reference.onDelete } : {},
-        ...reference.onUpdate !== undefined ? { onUpdate: reference.onUpdate } : {}
-      }
-    }));
-    edges.push({
-      fromTable: item.tsName,
-      fromField: column.field,
-      fromSql: column.sqlName,
-      toTable: target.tsName,
-      toSql: remote.sqlName
-    });
-  }
-}
-function resolveTarget(item, column, target, reference) {
-  const accepted = [...target.byField.keys()].sort();
-  const named = reference.columns;
-  if (named !== undefined) {
-    const found = [];
-    for (const name of named) {
-      const match = target.byField.get(name) ?? target.bySql.get(name);
-      if (match === undefined) {
-        throwNamed2("OKM1021", name, accepted, `Foreign key ${item.tsName}.${column.field} references ${name} on ${target.tsName}, which is not a column. Accepted columns: ${list(accepted)}.`);
-      }
-      found.push(match);
-    }
-    if (found.length !== 1) {
-      catalogError2("OKM1021", `Foreign key ${item.tsName}.${column.field} on ${target.tsName} is ambiguous. Accepted columns: ${list(accepted)}.`);
-    }
-    return found;
-  }
-  if (target.primary.length === 0) {
-    catalogError2("OKM1021", `Foreign key ${item.tsName}.${column.field} on ${target.tsName} has no primary key. Accepted columns: ${list(accepted)}.`);
-  }
-  if (target.primary.length !== 1) {
-    catalogError2("OKM1021", `Foreign key ${item.tsName}.${column.field} on ${target.tsName} is ambiguous. Accepted columns: ${list(target.primary)}.`);
-  }
-  const sqlName = target.primary[0] ?? "";
-  const match = target.bySql.get(sqlName);
-  if (match === undefined) {
-    catalogError2("OKM1021", `Foreign key ${item.tsName}.${column.field} on ${target.tsName} is missing its target. Accepted columns: ${list(accepted)}.`);
-  }
-  return [match];
-}
-function assertCodec(tableName, field, builder, codecs) {
-  const base = builder.state.baseType;
-  if (base === "bigint" && codecs.bigint !== "string") {
-    const label = builder.state.typeLabel ?? "string";
-    if (label !== codecs.bigint) {
-      definition(`Schema codecs.bigint is ${codecs.bigint}, and ${tableName}.${field} was built as ${label}. Set as: "${codecs.bigint}" on that column.`);
-    }
-  }
-  if (base.startsWith("numeric") && codecs.numeric !== "string") {
-    const label = builder.state.typeLabel ?? "string";
-    if (label !== codecs.numeric) {
-      definition(`Schema codecs.numeric is ${codecs.numeric}, and ${tableName}.${field} was built as ${label}. Set as: "${codecs.numeric}" on that column.`);
-    }
-  }
-}
-function readTableNames(tableName, options) {
-  if (options?.sqlName !== undefined) {
-    if (options.sqlName.length === 0) {
-      definition(`Table ${tableName} sqlName must be a non-empty SQL identifier.`);
-    }
-    assertIdentifier2(options.sqlName, `table ${tableName} sqlName`);
-  }
-  if (options?.renamedFrom !== undefined) {
-    if (options.renamedFrom.length === 0) {
-      definition(`Table ${tableName} renamedFrom must be a non-empty previous name.`);
-    }
-    assertIdentifier2(options.renamedFrom, `table ${tableName} renamedFrom`);
-  }
-  if (options?.comment !== undefined) {
-    assertStoredText(options.comment, `table ${tableName} comment`);
-    if (options.comment.length === 0) {
-      definition(`Table ${tableName} comment must be non-empty.`);
-    }
-  }
-}
-function readTypes(types) {
-  if (types === undefined) {
-    return "emitted";
-  }
-  if (types !== "emitted" && types !== "inferred") {
-    definition(`schema() types ${String(types)} must be emitted or inferred.`);
-  }
-  return types;
-}
-function readCasing(casing) {
-  if (casing === undefined) {
-    return;
-  }
-  if (casing !== "snake") {
-    definition(`schema() casing ${String(casing)} must be snake.`);
-  }
-  return casing;
-}
-function readCodecs(codecs) {
-  const bigint = codecs?.bigint ?? "string";
-  const numeric = codecs?.numeric ?? "string";
-  const timestamps = codecs?.timestamps ?? "temporal";
-  if (!BIGINT_CODECS.has(bigint)) {
-    definition(`schema() codecs.bigint ${String(bigint)} must be string, number, or bigint.`);
-  }
-  if (!NUMERIC_CODECS.has(numeric)) {
-    definition(`schema() codecs.numeric ${String(numeric)} must be string or number.`);
-  }
-  if (timestamps !== "temporal") {
-    definition(`schema() codecs.timestamps ${String(timestamps)} must be temporal.`);
-  }
-  return { bigint, numeric, timestamps };
-}
-function tableModel(item, edges, byName, accepted) {
-  const columns = item.columns.map((column) => ({
-    field: column.field,
-    sql: column.sqlName,
-    dataType: column.dataType,
-    encode: column.encode,
-    decode: column.decode,
-    hidden: column.hidden,
-    guarded: column.guarded,
-    writable: column.writable
-  }));
-  const primary = [];
-  for (const sqlName of item.primary) {
-    const column = item.bySql.get(sqlName);
-    if (column !== undefined)
-      primary.push(column.field);
-  }
-  return {
-    name: item.tsName,
-    sql: item.sqlName,
-    primary,
-    uniques: item.uniques,
-    columns,
-    relations: resolveRelations(item, edges, byName, accepted)
-  };
-}
-function resolveRelations(item, edges, byName, accepted) {
-  const raw = item.relationOptions;
-  if (raw === undefined)
-    return [];
-  const record = raw;
-  const names = Object.keys(record);
-  const resolved = [];
-  const seen = new Set;
-  for (const name of names) {
-    if (seen.has(name))
-      continue;
-    seen.add(name);
-    const call = record[name];
-    if (!isRelationCall(call)) {
-      unavailable(`Table ${item.tsName} relation ${name} is not available yet. one() and many() are accepted. manyThrough arrives in 0.2. morph arrives later.`);
-    }
-    if (!byName.has(call.table)) {
-      throwNamed2("OKM1020", call.table, accepted, `Relation ${item.tsName}.${name} names ${call.table}, which is not in the schema. Accepted names: ${list(accepted)}.`);
-    }
-    const field = call.field;
-    const matches = call.kind === "one" ? edges.filter((edge) => edge.fromTable === item.tsName && edge.toTable === call.table && (field === undefined || edge.fromField === field)) : edges.filter((edge) => edge.toTable === item.tsName && edge.fromTable === call.table && (field === undefined || edge.fromField === field));
-    if (matches.length !== 1) {
-      const hint = matches.map((edge) => edge.fromField).sort();
-      const which = hint.length === 0 ? "none" : hint.join(", ");
-      catalogError2("OKM1021", `Relation ${item.tsName}.${name} on ${call.table} is ambiguous. Accepted columns: ${which}.`);
-    }
-    const edge = matches[0];
-    if (edge === undefined) {
-      catalogError2("OKM1021", `Relation ${item.tsName}.${name} on ${call.table} is ambiguous. Accepted columns: (none).`);
-    }
-    resolved.push(call.kind === "one" ? { name, kind: "one", table: call.table, local: [edge.fromSql], remote: [edge.toSql] } : { name, kind: "many", table: call.table, local: [edge.toSql], remote: [edge.fromSql] });
-  }
-  return resolved;
-}
-function readRequires(requires) {
-  if (requires === undefined) {
-    return;
-  }
-  const postgres = requires.postgres;
-  if (postgres !== undefined && postgres.length === 0) {
-    definition("schema() requires.postgres must be a version range such as >=17.");
-  }
-  return postgres === undefined ? {} : { postgres };
-}
-function readIndex(tableName, call) {
-  if (call.columns.length === 0) {
-    definition(`Index on ${tableName} needs a column.`);
-  }
-  for (const name of call.columns) {
-    if (typeof name !== "string" || name.length === 0) {
-      definition(`Index on ${tableName} must be built from column handles.`);
-    }
-  }
-  return call;
-}
-function readCheck(tableName, name, value) {
-  if (value === undefined || typeof value.text !== "string" || value.text.length === 0) {
-    definition(`Check ${tableName}.${name} must return sql text.`);
-  }
-  assertStoredText(value.text, `check ${tableName}.${name}`);
-  return value.text;
-}
-function track(handles, used) {
-  return new Proxy(handles, {
-    get(target, key) {
-      if (typeof key === "string" && Object.hasOwn(target, key)) {
-        used.push(key);
-        return target[key];
-      }
-      return;
-    }
-  });
-}
-function list(names) {
-  return names.length === 0 ? "(none)" : names.join(", ");
-}
 // src/dialects/pg/custom.ts
 function custom(spec) {
   if (spec.sqlType.length === 0) {
@@ -777,6 +84,7 @@ function custom(spec) {
     baseType: spec.sqlType,
     encode: spec.encode,
     decode: spec.decode,
+    ...spec.accepts !== undefined ? { accepts: spec.accepts } : {},
     sqlForm: spec.sqlForm ?? "quote",
     ...spec.extension !== undefined ? { extension: spec.extension } : {}
   });
@@ -1024,6 +332,7 @@ function bytea() {
     baseType: "bytea",
     encode: encodeBytea,
     decode: decodeBytea,
+    accepts: ["Uint8Array"],
     sqlForm: "quote"
   });
 }
@@ -1066,276 +375,6 @@ function hexText() {
   return hexPattern;
 }
 var hexPattern;
-// src/dialects/pg/json.ts
-function jsonReplacer(_key, value) {
-  if (typeof value === "bigint") {
-    return value.toString();
-  }
-  return value;
-}
-function json() {
-  return required({
-    baseType: "json",
-    encode: encodeJson,
-    decode: decodeJson,
-    sqlForm: "json"
-  });
-}
-function jsonb() {
-  return required({
-    baseType: "jsonb",
-    encode: encodeJson,
-    decode: decodeJson,
-    sqlForm: "jsonb"
-  });
-}
-function encodeJson(value) {
-  const text = JSON.stringify(value, jsonReplacer);
-  if (text === undefined) {
-    rejected("json value must be JSON data. undefined and functions are not accepted. bigint is written as a decimal string.");
-  }
-  return text;
-}
-function decodeJson(wire) {
-  try {
-    return JSON.parse(wire);
-  } catch {
-    rejected("json text must be JSON, for example null, a string, a number, true, {}, or [].");
-  }
-}
-// src/dialects/pg/keys.ts
-function id() {
-  return openColumn({
-    baseType: "uuid",
-    nullable: false,
-    hasDefault: true,
-    generated: false,
-    guarded: true,
-    hidden: false,
-    omitWrite: true,
-    defaultSql: "uuidv7()",
-    primaryKey: true,
-    encode: encodeUuid,
-    decode: decodeUuid,
-    sqlForm: "quote"
-  });
-}
-function uuid() {
-  return required({
-    baseType: "uuid",
-    encode: encodeUuid,
-    decode: decodeUuid,
-    sqlForm: "quote"
-  });
-}
-function encodeUuid(value) {
-  const text = value.toLowerCase();
-  if (!uuidText().test(text)) {
-    rejected(`uuid ${value} must be 8-4-4-4-12 hexadecimal digits, for example 01890c5a-8f0e-7c3a-9b2d-6e4f1a0b9c8d.`);
-  }
-  return text;
-}
-function decodeUuid(wire) {
-  return encodeUuid(wire);
-}
-function uuidText() {
-  uuidPattern ??= /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
-  return uuidPattern;
-}
-var uuidPattern;
-// src/dialects/pg/temporal.ts
-var TEMPORAL_MISSING = "Date and time codecs need the Temporal global. okmodel does not ship a polyfill. Use a runtime that provides Temporal, or assign a polyfill to globalThis.Temporal before using these columns.";
-function requireTemporal() {
-  const temporal = globalThis.Temporal;
-  if (typeof temporal !== "object" || temporal === null || !("Instant" in temporal)) {
-    rejected(TEMPORAL_MISSING);
-  }
-}
-function timePrecision(precision, role) {
-  if (precision === undefined) {
-    return;
-  }
-  if (!Number.isInteger(precision) || precision < 0 || precision > 6) {
-    definition(`${role} precision ${String(precision)} must be an integer from 0 to 6.`);
-  }
-  return precision;
-}
-function encodeInstant(value, precision) {
-  requireTemporal();
-  if (precision === undefined) {
-    return value.toString();
-  }
-  return value.toString({ fractionalSecondDigits: precision });
-}
-function decodeInstant(wire) {
-  requireTemporal();
-  try {
-    return Temporal.Instant.from(wire);
-  } catch {
-    rejected(`timestamptz ${wire} must be an ISO-8601 instant, for example 2020-01-01T00:00:00Z.`);
-  }
-}
-function encodeDateTime(value, precision) {
-  requireTemporal();
-  if (precision === undefined) {
-    return value.toString();
-  }
-  return value.toString({ fractionalSecondDigits: precision });
-}
-function decodeDateTime(wire) {
-  requireTemporal();
-  try {
-    return Temporal.PlainDateTime.from(wire);
-  } catch {
-    rejected(`timestamp ${wire} must be an ISO-8601 date-time without a zone, for example 2020-01-01T00:00:00.`);
-  }
-}
-function encodeDate(value) {
-  requireTemporal();
-  return value.toString();
-}
-function decodeDate(wire) {
-  requireTemporal();
-  try {
-    return Temporal.PlainDate.from(wire);
-  } catch {
-    rejected(`date ${wire} must be YYYY-MM-DD.`);
-  }
-}
-function encodeTime(value, precision) {
-  requireTemporal();
-  if (precision === undefined) {
-    return value.toString();
-  }
-  return value.toString({ fractionalSecondDigits: precision });
-}
-function decodeTime(wire) {
-  requireTemporal();
-  try {
-    return Temporal.PlainTime.from(wire);
-  } catch {
-    rejected(`time ${wire} must be a time of day, for example 00:00:00.`);
-  }
-}
-function encodeTimeZone(value, precision) {
-  requireTemporal();
-  if (!offsetText().test(value.offset)) {
-    rejected(`timetz offset ${value.offset} must be ±HH:MM.`);
-  }
-  return `${encodeTime(value.time, precision)}${value.offset}`;
-}
-function decodeTimeZone(wire) {
-  const match = timeZoneText().exec(wire);
-  const time = match?.[1];
-  const offset = match?.[2];
-  if (time === undefined || offset === undefined) {
-    rejected(`timetz ${wire} must be a time of day plus ±HH:MM, for example 00:00:00+00:00.`);
-  }
-  return { time: decodeTime(time), offset };
-}
-function encodeDuration(value) {
-  requireTemporal();
-  return value.toString();
-}
-function decodeDuration(wire) {
-  requireTemporal();
-  try {
-    return Temporal.Duration.from(wire);
-  } catch {
-    rejected(`interval ${wire} must be an ISO-8601 duration, for example PT1H.`);
-  }
-}
-function intervalFields(fields) {
-  switch (fields) {
-    case "year":
-    case "month":
-    case "day":
-    case "hour":
-    case "minute":
-    case "second":
-    case "year to month":
-    case "day to hour":
-    case "day to minute":
-    case "day to second":
-    case "hour to minute":
-    case "hour to second":
-    case "minute to second":
-      return fields;
-    default:
-      definition(`interval fields ${fields} must be one of: year, month, day, hour, minute, second, year to month, day to hour, day to minute, day to second, hour to minute, hour to second, minute to second.`);
-  }
-}
-function offsetText() {
-  offsetPattern ??= /^[+-]\d{2}:\d{2}$/;
-  return offsetPattern;
-}
-function timeZoneText() {
-  timeZonePattern ??= /^(.+)([+-]\d{2}:\d{2})$/;
-  return timeZonePattern;
-}
-var offsetPattern;
-var timeZonePattern;
-
-// src/dialects/pg/time.ts
-function timestamptz(precision) {
-  const digits = timePrecision(precision, "timestamptz");
-  return required({
-    baseType: timed("timestamptz", digits),
-    encode: (value) => encodeInstant(value, digits),
-    decode: decodeInstant,
-    sqlForm: "quote"
-  });
-}
-function timestamp(precision) {
-  const digits = timePrecision(precision, "timestamp");
-  return required({
-    baseType: timed("timestamp", digits),
-    encode: (value) => encodeDateTime(value, digits),
-    decode: decodeDateTime,
-    sqlForm: "quote"
-  });
-}
-function date() {
-  return required({
-    baseType: "date",
-    encode: encodeDate,
-    decode: decodeDate,
-    sqlForm: "quote"
-  });
-}
-function time(precision) {
-  const digits = timePrecision(precision, "time");
-  return required({
-    baseType: timed("time", digits),
-    encode: (value) => encodeTime(value, digits),
-    decode: decodeTime,
-    sqlForm: "quote"
-  });
-}
-function timetz(precision) {
-  const digits = timePrecision(precision, "timetz");
-  return required({
-    baseType: timed("timetz", digits),
-    encode: (value) => encodeTimeZone(value, digits),
-    decode: decodeTimeZone,
-    sqlForm: "quote"
-  });
-}
-function interval(fields) {
-  const qualifier = fields === undefined ? undefined : intervalFields(fields);
-  return required({
-    baseType: qualifier === undefined ? "interval" : `interval ${qualifier}`,
-    encode: encodeDuration,
-    decode: decodeDuration,
-    sqlForm: "quote"
-  });
-}
-function timed(name, precision) {
-  if (precision === undefined) {
-    return name;
-  }
-  return `${name}(${String(precision)})`;
-}
 // src/dialects/pg/range.ts
 function tstzrange() {
   return rangeColumn("tstzrange", encodeInstant, decodeInstant, true);
@@ -1357,6 +396,7 @@ function rangeColumn(baseType, encodeBound, decodeBound, quote) {
     baseType,
     encode: (value) => writeRange(value, encodeBound, quote),
     decode: (wire) => readRange(wire, decodeBound, quote),
+    accepts: ["Object"],
     sqlForm: "cast"
   });
 }
@@ -1364,6 +404,9 @@ function writeRange(value, encodeBound, quote) {
   if (value.empty) {
     return "empty";
   }
+  if (value.empty !== false) {
+    rejected("range needs empty: true, or empty: false with lower and upper.");
+  }
   const lower = value.lower === null ? "" : boundText(encodeBound(value.lower), quote);
   const upper = value.upper === null ? "" : boundText(encodeBound(value.upper), quote);
   const open = value.lowerInclusive ? "[" : "(";
@@ -1506,6 +549,7 @@ function point() {
     baseType: "point",
     encode: encodePoint,
     decode: decodePoint,
+    accepts: ["Object"],
     sqlForm: "quote"
   });
 }
@@ -1514,6 +558,7 @@ function line() {
     baseType: "line",
     encode: encodeLine,
     decode: decodeLine,
+    accepts: ["Object"],
     sqlForm: "quote"
   });
 }
@@ -1629,34 +674,109 @@ function enumColumn(name, values) {
     sqlForm: "quote"
   });
 }
-function domain(_name, _base, _check) {
-  unavailable("t.domain() is not available yet. It arrives in 0.3.");
+function domain(name, base, check) {
+  if (name.length === 0)
+    definition("domain name must be a non-empty type name.");
+  if (check.length === 0)
+    definition("domain check must be a non-empty expression.");
+  if (base.state.enumLabels !== undefined) {
+    definition("A domain cannot use an enum as its base in this version. Use a scalar column type.");
+  }
+  const baseSql = canonicalBase(formatType(base.state.baseType, base.state.dims));
+  const extension = base.state.extension;
+  const inner = base.state.baseType;
+  const nested = base.state.domain !== undefined;
+  return new ColumnBuilder2({
+    ...base.state,
+    baseType: name,
+    dims: 0,
+    typeDependency: name,
+    enumLabels: undefined,
+    domain: {
+      base: baseSql,
+      check,
+      emit(namespace, provenance, objects) {
+        base.state.domain?.emit?.(namespace, provenance, objects);
+        const dependencies = [];
+        if (extension !== undefined)
+          dependencies.push({ kind: "extension", name: extension });
+        if (nested)
+          dependencies.push({ kind: "type", namespace, name: inner });
+        const built = domainType({
+          namespace,
+          name,
+          base: baseSql,
+          check,
+          provenance,
+          ...dependencies.length > 0 ? { dependencies } : {}
+        });
+        const index = objects.findIndex((object) => object.kind === "type" && object.identity.name === name && sameNamespace2(object.identity.namespace, namespace));
+        const previous = index >= 0 ? objects[index] : undefined;
+        if (previous !== undefined && previous.kind === "type") {
+          const definition = previous.definition;
+          if (!("base" in definition) || definition.base !== baseSql || definition.check !== check) {
+            catalogError2("OKM1020", `Domain ${name} is ${"base" in definition ? definition.base : "an enum"} on ${previous.provenance.name} and ${baseSql} on ${provenance.name}. One domain has one base and one check.`);
+          }
+          if (compareText(provenance.name, previous.provenance.name) < 0)
+            objects[index] = built;
+          return;
+        }
+        objects.push(built);
+      }
+    }
+  });
+}
+function canonicalBase(typeName) {
+  const bracket = typeName.indexOf("[");
+  const scalar = bracket === -1 ? typeName : typeName.slice(0, bracket);
+  const suffix = bracket === -1 ? "" : typeName.slice(bracket);
+  return canonicalScalar(scalar) + suffix;
+}
+function canonicalScalar(typeName) {
+  const varchar = /^varchar\((\d+)\)$/.exec(typeName);
+  if (varchar !== null)
+    return `character varying(${varchar[1] ?? ""})`;
+  const fixed = /^char\((\d+)\)$/.exec(typeName);
+  if (fixed !== null)
+    return `character(${fixed[1] ?? ""})`;
+  const timed = /^(timestamptz|timestamp|timetz|time)(\(\d+\))?$/.exec(typeName);
+  if (timed === null)
+    return typeName;
+  const name = timed[1];
+  const precision = timed[2] ?? "";
+  if (name === "timestamptz")
+    return `timestamp${precision} with time zone`;
+  if (name === "timestamp")
+    return `timestamp${precision} without time zone`;
+  if (name === "timetz")
+    return `time${precision} with time zone`;
+  return `time${precision} without time zone`;
 }
 // src/dialects/pg/namespace.ts
 var t = {
-  id,
+  id: id2,
   identity,
-  uuid,
+  uuid: uuid2,
   smallint,
   integer,
   bigint,
   numeric,
   real,
   double,
-  text,
-  varchar,
-  char,
-  citext,
+  text: text2,
+  varchar: varchar2,
+  char: char2,
+  citext: citext2,
   boolean,
   bytea,
-  json,
-  jsonb,
-  timestamptz,
-  timestamp,
-  date,
-  time,
-  timetz,
-  interval,
+  json: json2,
+  jsonb: jsonb2,
+  timestamptz: timestamptz2,
+  timestamp: timestamp2,
+  date: date2,
+  time: time2,
+  timetz: timetz2,
+  interval: interval2,
   tstzrange,
   daterange,
   int4range,
@@ -1674,10 +794,39 @@ var t = {
   domain,
   custom
 };
+// src/dialects/pg/ops/arr-ns.ts
+var exports_arr_ns = {};
+__export(exports_arr_ns, {
+  append: () => append,
+  remove: () => remove
+});
+
+// src/dialects/pg/ops/arr-append.ts
+function append(value) {
+  return tag("arr.append", value);
+}
+// src/dialects/pg/ops/arr-remove.ts
+function remove(value) {
+  return tag("arr.remove", value);
+}
+// src/dialects/pg/ops/json-ns.ts
+var exports_json_ns = {};
+__export(exports_json_ns, {
+  set: () => set
+});
+
+// src/dialects/pg/ops/json-set.ts
+function set(path, value) {
+  return tag("json.set", { path, value });
+}
 // src/dialects/pg/ops/between.ts
 function between(from, to) {
   return tag("between", [from, to]);
 }
+// src/dialects/pg/ops/containedBy.ts
+function containedBy(value) {
+  return tag("containedBy", value);
+}
 // src/dialects/pg/ops/contains.ts
 function contains(value) {
   return tag("contains", value);
@@ -1710,6 +859,14 @@ function gte(value) {
 function has(where) {
   return tag("has", where);
 }
+// src/dialects/pg/ops/hasAnyKey.ts
+function hasAnyKey(keys) {
+  return tag("hasAnyKey", keys);
+}
+// src/dialects/pg/ops/hasKey.ts
+function hasKey(key) {
+  return tag("hasKey", key);
+}
 // src/dialects/pg/ops/ilike.ts
 function ilike(pattern) {
   return tag("ilike", pattern);
@@ -1722,6 +879,14 @@ function inList(values) {
 function like(pattern) {
   return tag("like", pattern);
 }
+// src/dialects/pg/ops/matches.ts
+function matches(query, options) {
+  return tag("matches", {
+    query,
+    mode: options?.mode ?? "websearch",
+    config: options?.config
+  });
+}
 // src/dialects/pg/ops/lt.ts
 function lt(value) {
   return tag("lt", value);
@@ -1746,22 +911,32 @@ function notIn(values) {
 function or(branches) {
   return tag("or", branches);
 }
+// src/dialects/pg/ops/overlaps.ts
+function overlaps(value) {
+  return tag("overlaps", value);
+}
+// src/dialects/pg/ops/path.ts
+function path(segments, op) {
+  return tag("path", { segments, op });
+}
 // src/dialects/pg/ops/startsWith.ts
 function startsWith(value) {
   return tag("startsWith", value);
 }
 export {
   ColumnBuilder2 as ColumnBuilder,
+  exports_arr_ns as arr,
   between,
   bigint,
   boolean,
   bytea,
-  char,
+  char2 as char,
   cidr,
-  citext,
+  citext2 as citext,
+  containedBy,
   contains,
   custom,
-  date,
+  date2 as date,
   daterange,
   domain,
   double,
@@ -1772,7 +947,9 @@ export {
   gt,
   gte,
   has,
-  id,
+  hasAnyKey,
+  hasKey,
+  id2 as id,
   identity,
   ilike,
   inList,
@@ -1782,10 +959,10 @@ export {
   int4range,
   int8range,
   integer,
-  interval,
-  json,
-  jsonReplacer,
-  jsonb,
+  interval2 as interval,
+  exports_json_ns as json,
+  jsonReplacer2 as jsonReplacer,
+  jsonb2 as jsonb,
   like,
   line,
   lt,
@@ -1793,29 +970,33 @@ export {
   ltree,
   macaddr,
   macaddr8,
-  many,
+  many2 as many,
+  manyThrough2 as manyThrough,
+  matches,
   none,
   not,
   notIn,
   numeric,
   numrange,
-  one,
+  one2 as one,
   or,
+  overlaps,
+  path,
   point,
   real,
-  schema,
+  schema2 as schema,
   smallint,
   sql2 as sql,
   startsWith,
   t,
   table2 as table,
-  text,
-  time,
-  timestamp,
-  timestamptz,
-  timetz,
+  text2 as text,
+  time2 as time,
+  timestamp2 as timestamp,
+  timestamptz2 as timestamptz,
+  timetz2 as timetz,
   tstzrange,
   tsvector,
-  uuid,
-  varchar
+  uuid2 as uuid,
+  varchar2 as varchar
 };