okmodel 0.1.0 → 0.2.1

package/dist/shared/7mht49yd.js

@@ -0,0 +1,1091 @@
+import {
+  encodeText,
+  decodeText
+} from "./sacqha1y.js";
+import {
+  catalog,
+  enumType,
+  sameEnumLabels
+} from "./qxa0yb9j.js";
+import {
+  snakeCase,
+  emittedTypeName,
+  rejectLater
+} from "./x9v1qgeb.js";
+import {
+  withLocation
+} from "./k7dwkhvq.js";
+import {
+  ColumnBuilder2,
+  formatType
+} from "./dd4f8mnx.js";
+import {
+  definition,
+  unavailable,
+  quoteLiteral
+} from "./xatfg0gn.js";
+import {
+  staticNamespace2,
+  table3,
+  column2,
+  index3,
+  constraint2,
+  sequence2,
+  compareText
+} from "./t4tbsy9h.js";
+import {
+  assertIdentifier2,
+  fitIdentifier2,
+  assertStoredText
+} from "./nfzc5z0w.js";
+import {
+  OkmError2,
+  catalogError2,
+  throwNamed2
+} from "./52szzakm.js";
+import {
+  readClientGenerator
+} from "./rwmrejjz.js";
+
+// src/dialects/pg/through.ts
+var emit = (planner, schema, relation, child, sink, parent, alias, depth) => {
+  const through = relation.through;
+  const join = through === undefined ? undefined : planner.indexes(schema).get(through.table);
+  if (through === undefined || join === undefined) {
+    return catalogError2("OKM1020", `Relation ${relation.name} names a join table that is not in the schema.`);
+  }
+  const { quote } = planner;
+  const joinAlias = `j${alias}`;
+  sink.mark(`via:${through.table}`);
+  sink.text(`${quote(join.model.sql)} ${joinAlias} join ${quote(child.model.sql)} ${alias} on `);
+  for (let index = 0;index < through.local.length; index += 1) {
+    const local = through.local[index];
+    const remote = through.remote[index];
+    if (local === undefined || remote === undefined)
+      continue;
+    if (index > 0)
+      sink.text(" and ");
+    sink.text(`${alias}.${quote(remote)} = ${joinAlias}.${quote(local)}`);
+  }
+  sink.text(" where ");
+  planner.join(sink, parent, joinAlias, relation);
+  planner.where(schema, join, undefined, sink, joinAlias, depth + 1, true);
+};
+function resolveThrough(scope, table, through, from, to) {
+  for (const name of [table, through]) {
+    if (!scope.tables.includes(name)) {
+      throwNamed2("OKM1020", name, scope.tables, `Relation ${scope.owner}.${scope.name} names ${name}, which is not in the schema. Accepted names: ${scope.tables.join(", ")}.`);
+    }
+  }
+  const toOwner = pick(scope, through, scope.owner, from, `${scope.owner}.${scope.name}`, "from");
+  const toTable = pick(scope, through, table, to, `${scope.owner}.${scope.name}`, "to");
+  if (toOwner === toTable) {
+    catalogError2("OKM1021", `Relation ${scope.owner}.${scope.name} uses ${toOwner.fromField} on ${through} for both ends. Pass from and to.`);
+  }
+  return {
+    name: scope.name,
+    kind: "many",
+    table,
+    local: toOwner.remote,
+    remote: toOwner.local,
+    through: { table: through, local: toTable.local, remote: toTable.remote, emit }
+  };
+}
+function pick(scope, through, target, field, label, end) {
+  const matches = scope.edges.filter((edge) => edge.fromTable === through && edge.toTable === target && (field === undefined || edge.fromField === field));
+  const [only] = matches;
+  if (matches.length === 1 && only !== undefined)
+    return only;
+  const fields = matches.map((edge) => edge.fromField).sort();
+  catalogError2("OKM1021", `Relation ${label} through ${through} is ambiguous at ${end}. Accepted columns: ${fields.length === 0 ? "(none)" : fields.join(", ")}.`);
+}
+
+// src/dialects/pg/relations.ts
+function one2(table, field) {
+  return { kind: "one", table, field };
+}
+function many2(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";
+}
+function manyThrough2(table, options) {
+  const { through, from, to } = options;
+  return {
+    kind: "many",
+    table,
+    field: undefined,
+    through,
+    resolve: (scope) => resolveThrough(scope, table, through, from, to)
+  };
+}
+
+// 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
+    });
+  }
+  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.collation !== undefined ? { collation: state.collation } : {},
+    ...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/tenancy.ts
+function readTenancy(value) {
+  if (value === undefined)
+    return;
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    definition("schema() tenancy must be columnTenancy() from okmodel/tenancy.");
+  }
+  const record = value;
+  if (record.strategy !== "column" || typeof record.rewrite !== "function") {
+    definition("schema() tenancy must be columnTenancy() from okmodel/tenancy.");
+  }
+  return value;
+}
+
+// src/dialects/pg/schema.ts
+var SCHEMA_KNOWN = new Set([
+  "casing",
+  "codecs",
+  "defaults",
+  "requires",
+  "tables",
+  "tenancy",
+  "traits",
+  "types",
+  "validation"
+]);
+var SCHEMA_LATER = {
+  extensions: "0.3",
+  functions: "0.3",
+  triggers: "0.3",
+  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 schema2(config) {
+  rejectLater(config, SCHEMA_KNOWN, SCHEMA_LATER, "schema()");
+  const schemaTraits = openSchemaTraits(config.traits);
+  const tenancy = readTenancy(config.tenancy);
+  if (!Array.isArray(config.tables)) {
+    definition("schema() needs a tables array.");
+  }
+  const casing = readCasing(config.casing);
+  const tables = rewritePass(config.tables, tenancy, schemaTraits, casing);
+  const hooks = collectHooks(tenancy, schemaTraits, config.tables);
+  const types = readTypes(config.types);
+  const codecs = readCodecs(config.codecs);
+  const requires = readRequires(config.requires);
+  const idDefault = readIdDefault(config.defaults);
+  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 tables) {
+    const built = compileTable(item, namespace, casing, codecs, requires, idDefault, jobs, enums, schemaTraits);
+    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,
+    ...schemaTraits !== undefined && schemaTraits.length > 0 ? { traits: schemaTraits } : {},
+    ...tenancy !== undefined ? { tenancy } : {},
+    ...hooks !== undefined ? { hooks } : {},
+    ...config.validation !== undefined ? { validation: config.validation } : {}
+  };
+}
+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", withLocation(`Table ${item.name} is declared more than once. Accepted names: ${list([...names].sort())}.`, item.source));
+    }
+    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 rewritePass(tables, tenancy, schemaTraits, casing) {
+  let next = tenancy === undefined ? bareTables(tables) : tenancy.rewrite(tables);
+  const seen = new Set;
+  const pending = [];
+  const add = (value) => {
+    if (seen.has(value))
+      return;
+    if (typeof value.rewrite !== "function")
+      return;
+    seen.add(value);
+    pending.push(value);
+  };
+  if (schemaTraits !== undefined) {
+    for (const trait of schemaTraits)
+      add(trait);
+  }
+  for (const item of tables) {
+    const own = item.options?.traits;
+    if (!Array.isArray(own))
+      continue;
+    for (const trait of own) {
+      if (typeof trait === "object" && trait !== null)
+        add(trait);
+    }
+  }
+  for (const trait of pending) {
+    const rewrite = trait.rewrite;
+    next = rewrite.call(trait, next, casing, schemaTraits);
+  }
+  return next;
+}
+var registeredHooks = [];
+function addSchemaHook(hook) {
+  registeredHooks.push(hook);
+}
+function collectHooks(tenancy, schemaTraits, tables) {
+  const found = [];
+  const seen = new Set;
+  const add = (value) => {
+    if (seen.has(value))
+      return;
+    const hook = value.hook;
+    if (typeof hook !== "function")
+      return;
+    seen.add(value);
+    found.push(hook.bind(value));
+  };
+  if (tenancy !== undefined)
+    add(tenancy);
+  if (schemaTraits !== undefined) {
+    for (const trait of schemaTraits)
+      add(trait);
+  }
+  for (const item of tables) {
+    const own = item.options?.traits;
+    if (!Array.isArray(own))
+      continue;
+    for (const trait of own) {
+      if (typeof trait === "object" && trait !== null)
+        add(trait);
+    }
+  }
+  for (const hook of registeredHooks)
+    found.push(hook);
+  return found.length === 0 ? undefined : found;
+}
+function archiveModel(item) {
+  const archive = item.archiveModel;
+  return archive === undefined ? undefined : { archive };
+}
+function bareTables(tables) {
+  for (const item of tables) {
+    const mark = item.options?.tenancy;
+    if (mark !== undefined) {
+      definition(`Table ${item.name} sets tenancy, and the schema does not.`);
+    }
+  }
+  return tables;
+}
+function openSchemaTraits(value) {
+  if (value === undefined)
+    return;
+  if (!Array.isArray(value))
+    definition("schema() traits must be a list of traits.");
+  return value.length === 0 ? undefined : value;
+}
+function openTableTraits(table, columns, schemaTraits, options) {
+  let shared = schemaTraits;
+  const omit = options?.omitDefaults;
+  if (omit !== undefined) {
+    if (typeof omit !== "string" || omit.trim().length === 0) {
+      definition(`Table ${table} omitDefaults needs a reason.`);
+    }
+    shared = undefined;
+  }
+  const own = options?.traits;
+  if (own !== undefined && !Array.isArray(own)) {
+    definition(`Table ${table} traits must be a list of traits.`);
+  }
+  const local = Array.isArray(own) && own.length > 0 ? own : undefined;
+  if ((shared === undefined || shared.length === 0) && local === undefined)
+    return;
+  const traits = local === undefined ? shared : shared === undefined || shared.length === 0 ? local : [...shared, ...local];
+  if (traits === undefined)
+    return;
+  const model = { columns: { ...columns }, presets: options?.presets };
+  for (const trait of traits)
+    trait.apply(model, { table });
+  return { ...model, traits };
+}
+function compileTable(item, namespace, casing, codecs, requires, idDefault, jobs, enums, schemaTraits) {
+  const options = item.options;
+  const applied = openTableTraits(item.name, item.columns, schemaTraits, item.options);
+  readTableNames(item.name, options);
+  const sqlName = options?.sqlName ?? (casing === "snake" ? snakeCase(item.name) : item.name);
+  assertIdentifier2(sqlName, `table ${item.name}`);
+  const provenance = item.source === undefined ? { origin: "file", name: item.name } : { origin: "file", name: item.name, source: item.source };
+  const parent = { namespace, name: sqlName };
+  stage(jobs, () => table3({ namespace, name: sqlName, provenance }));
+  const columns = [];
+  const columnPrimary = [];
+  const byField = new Map;
+  const bySql = new Map;
+  const handles = {};
+  const sourceColumns = applied === undefined ? item.columns : applied.columns;
+  for (const [field, builder] of Object.entries(sourceColumns)) {
+    if (!(builder instanceof ColumnBuilder2)) {
+      definition(`Column ${item.name}.${field} must be a column builder.`);
+    }
+    const column = applySchemaId(builder, idDefault);
+    const columnSql = column.state.sqlName ?? (casing === "snake" ? snakeCase(field) : field);
+    assertCodec(item.name, field, column, codecs);
+    const mark = applied !== undefined ? builder.trait : undefined;
+    const traitName = typeof mark === "string" ? mark : undefined;
+    const columnProvenance = traitName === undefined ? provenance : {
+      origin: "trait",
+      name: traitName,
+      ...provenance.source !== undefined ? { source: provenance.source } : {}
+    };
+    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: columnProvenance,
+          dependencies: [seq.identity]
+        });
+      });
+    } else {
+      jobs.push((objects) => {
+        pushCompiled(objects, column, {
+          parent,
+          name: columnSql,
+          provenance: columnProvenance
+        });
+      });
+    }
+    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,
+      sensitive: column.state.sensitive,
+      guarded: column.state.guarded,
+      writable: column.state.guarded !== true && column.state.omitWrite !== true && column.state.generated === undefined,
+      unique: column.state.unique !== undefined,
+      clientDefault: column.state.clientDefault === undefined ? undefined : "client",
+      elementEncode: column.state.dims > 0 ? column.state.elementEncode : undefined,
+      fill: column.state.clientDefault,
+      accepts: column.state.accepts
+    };
+    columns.push(prepared);
+    byField.set(field, prepared);
+    bySql.set(prepared.sqlName, prepared);
+    handles[field] = { name: prepared.sqlName };
+    if (column.state.primaryKey) {
+      if (column.state.nullable) {
+        catalogError2("OKM1020", `Primary key ${item.name}.${field} is nullable.`);
+      }
+      columnPrimary.push(prepared.sqlName);
+    }
+    if (column.state.defaultSql === "uuidv7()") {
+      refuseUuidV7(item.name, field, requires);
+    }
+    const labels = column.state.enumLabels;
+    if (labels !== undefined) {
+      noteEnum(enums, labels, column.state.typeDependency ?? prepared.sqlName, sqlName, provenance);
+    }
+  }
+  const optionPrimary = readPrimaryKey(item.name, options, byField);
+  if (columnPrimary.length > 1) {
+    catalogError2("OKM1020", `Table ${item.name} has more than one primary key (${columnPrimary.join(", ")}). One primary key is accepted.`);
+  }
+  if (columnPrimary.length > 0 && optionPrimary.length > 0) {
+    catalogError2("OKM1020", `Table ${item.name} has two primary keys. One primary key is accepted.`);
+  }
+  const primary = optionPrimary.length > 0 ? optionPrimary : columnPrimary;
+  if (primary.length > 0) {
+    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, handles),
+    byField,
+    bySql,
+    relationOptions: relationInput(item.name, options),
+    ...applied !== undefined ? { traits: applied.traits } : {},
+    presets: applied?.presets ?? options?.presets,
+    ...archiveModel(item)
+  };
+}
+function uniqueTargets(primary, columns, bySql, options, handles) {
+  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]);
+  }
+  const build = options?.indexes;
+  if (build !== undefined) {
+    const calls = build(handles);
+    if (Array.isArray(calls)) {
+      for (const call of calls) {
+        if (call.isUnique !== true || call.predicate === undefined)
+          continue;
+        const fields = [];
+        let whole = true;
+        for (const sqlName of call.columns) {
+          const column = bySql.get(sqlName);
+          if (column === undefined) {
+            whole = false;
+            break;
+          }
+          fields.push(column.field);
+        }
+        if (whole && fields.length > 0)
+          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("_"),
+      ...built.predicate !== undefined ? { predicate: built.predicate } : {},
+      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 localColumns = localKey(item, column, reference);
+    const targetColumns = resolveTarget(item, column, target, reference);
+    if (localColumns.length !== targetColumns.length) {
+      catalogError2("OKM1021", `Foreign key ${item.tsName}.${column.field} on ${target.tsName} has ${localColumns.length} local columns and ${targetColumns.length} target columns.`);
+    }
+    if (reference.onDelete === "set null" || reference.onUpdate === "set null") {
+      for (const local of localColumns) {
+        if (!local.nullable) {
+          definition(`Foreign key ${item.tsName}.${column.field} uses set null. ${item.tsName}.${local.field} must be nullable.`);
+        }
+      }
+    }
+    const localNames = [];
+    const remoteNames = [];
+    for (let index = 0;index < localColumns.length; index += 1) {
+      const local = localColumns[index];
+      const remote = targetColumns[index];
+      if (local === undefined || remote === undefined)
+        continue;
+      if (local.dataType !== remote.dataType) {
+        catalogError2("OKM1022", `Foreign key ${item.tsName}.${local.field} is ${local.dataType} and ${target.tsName}.${remote.field} is ${remote.dataType}. Accepted type: ${remote.dataType}.`);
+      }
+      localNames.push(local.sqlName);
+      remoteNames.push(remote.sqlName);
+    }
+    stage(jobs, () => constraint2({
+      parent: item.parent,
+      constraintKind: "foreignKey",
+      columns: localNames,
+      nameKey: column.sqlName,
+      provenance: item.provenance,
+      references: {
+        parent: target.parent,
+        columns: remoteNames,
+        ...reference.onDelete !== undefined ? { onDelete: reference.onDelete } : {},
+        ...reference.onUpdate !== undefined ? { onUpdate: reference.onUpdate } : {}
+      }
+    }));
+    edges.push({
+      fromTable: item.tsName,
+      fromField: column.field,
+      toTable: target.tsName,
+      local: localNames,
+      remote: remoteNames
+    });
+  }
+}
+function localKey(item, column, reference) {
+  const along = reference.along;
+  if (along === undefined || along.length === 0)
+    return [column];
+  const accepted = [...item.byField.keys()].sort();
+  const columns = [column];
+  for (const name of along) {
+    const extra = item.byField.get(name) ?? item.bySql.get(name);
+    if (extra === undefined) {
+      throwNamed2("OKM1021", name, accepted, `Foreign key ${item.tsName}.${column.field} includes ${name}, which is not a column. Accepted columns: ${list(accepted)}.`);
+    }
+    columns.push(extra);
+  }
+  return columns;
+}
+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 && reference.along === undefined) {
+      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 primary = [];
+  for (const sqlName of item.primary) {
+    const column = item.bySql.get(sqlName);
+    if (column !== undefined)
+      primary.push(column.field);
+  }
+  let conceal = false;
+  const columns = item.columns.map((column) => {
+    if (column.hidden || column.sensitive)
+      conceal = true;
+    return {
+      field: column.field,
+      sql: column.sqlName,
+      dataType: column.dataType,
+      encode: column.encode,
+      decode: column.decode,
+      hidden: column.hidden,
+      sensitive: column.sensitive,
+      guarded: column.guarded,
+      writable: column.writable,
+      guardUpdate: column.writable && primary.includes(column.field),
+      ...column.fill !== undefined ? { fill: column.fill, clientDefault: "client" } : {},
+      ...column.elementEncode !== undefined ? { elementEncode: column.elementEncode } : {},
+      accepts: column.accepts
+    };
+  });
+  return {
+    name: item.tsName,
+    sql: item.sqlName,
+    primary,
+    uniques: item.uniques,
+    columns,
+    relations: resolveRelations(item, edges, byName, accepted),
+    ...conceal ? { conceal: true } : {},
+    ...item.traits !== undefined ? { traits: item.traits } : {},
+    ...item.provenance.source !== undefined ? { source: item.provenance.source } : {},
+    ...item.archive !== undefined ? { archive: item.archive } : {},
+    ...item.presets !== undefined ? { presets: item.presets } : {}
+  };
+}
+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(), many(), and manyThrough() are accepted. morph arrives later.`);
+    }
+    const own = call.resolve;
+    if (own !== undefined) {
+      resolved.push(own({ owner: item.tsName, name, edges, tables: accepted }));
+      continue;
+    }
+    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.local, remote: edge.remote } : { name, kind: "many", table: call.table, local: edge.remote, remote: edge.local });
+  }
+  return resolved;
+}
+function readPrimaryKey(tableName, options, byField) {
+  const listed = options?.primaryKey;
+  if (listed === undefined)
+    return [];
+  if (!Array.isArray(listed) || listed.length === 0) {
+    definition(`Table ${tableName} primaryKey needs a column.`);
+  }
+  const columns = [];
+  const seen = new Set;
+  for (const field of listed) {
+    if (typeof field !== "string" || field.length === 0 || seen.has(field)) {
+      definition(`Table ${tableName} primaryKey repeats a column.`);
+    }
+    seen.add(field);
+    const column = byField.get(field);
+    if (column === undefined || column.nullable) {
+      catalogError2("OKM1020", `Primary key ${tableName}.${field} is missing or nullable.`);
+    }
+    columns.push(column.sqlName);
+  }
+  return columns;
+}
+function applySchemaId(column, idDefault) {
+  if (idDefault === undefined || column.state.idSource !== "implicit")
+    return column;
+  const fill = idDefault.kind === "client" ? idDefault.fill : undefined;
+  const okid = fill?.name === "okid";
+  return new ColumnBuilder2({
+    ...column.state,
+    defaultSql: idDefault.kind === "database" ? idDefault.sql : undefined,
+    clientDefault: fill,
+    idSource: "column",
+    ...okid ? {
+      baseType: "text",
+      collation: "C",
+      encode: encodeText,
+      decode: decodeText,
+      sqlForm: "quote"
+    } : {}
+  });
+}
+function readIdDefault(defaults) {
+  if (defaults === undefined)
+    return;
+  if (typeof defaults !== "object" || defaults === null) {
+    definition("schema() defaults must be an object.");
+  }
+  for (const key of Object.keys(defaults)) {
+    if (key !== "id") {
+      definition(`schema() defaults.${key} is not a schema default. Accepted names: id.`);
+    }
+  }
+  const id = defaults.id;
+  if (id === undefined)
+    return;
+  if (id === "uuidv7")
+    return { kind: "database", sql: "uuidv7()" };
+  if (id === "uuidv4")
+    return { kind: "database", sql: "gen_random_uuid()" };
+  const fill = readClientGenerator(id);
+  if (fill !== undefined)
+    return { kind: "client", fill };
+  definition('schema() defaults.id must be "uuidv7", "uuidv4", or a client generator.');
+}
+function refuseUuidV7(tableName, field, requires) {
+  const declared = Number(/^>=(\d+)$/.exec(requires?.postgres ?? "")?.[1]);
+  if (!(declared > 0) || declared >= 18)
+    return;
+  throw new OkmError2("OKM1812", `Column ${tableName}.${field} uses uuidv7(). Set defaults.id to "uuidv4" or a client generator.`, { fix: { summary: "Set defaults.id." } });
+}
+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(", ");
+}
+
+export { one2, many2, manyThrough2, schema2, addSchemaHook };