okmodel 0.6.0 → 0.8.0

package/dist/shared/{31vm914h.js → cm3w0ywp.js}

@@ -96,22 +96,21 @@ function messageOf(error) {
 }
 function driverFields(input) {
   const fields = {};
-  if (input.sqlstate !== undefined)
-    fields.sqlstate = input.sqlstate;
-  if (input.constraint !== undefined)
-    fields.constraint = input.constraint;
-  if (input.table !== undefined)
-    fields.table = input.table;
-  if (input.column !== undefined)
-    fields.column = input.column;
-  if (input.detail !== undefined)
-    fields.detail = input.detail;
-  if (input.cause !== undefined)
-    fields.cause = input.cause;
-  if (input.batchIndex !== undefined)
-    fields.batchIndex = input.batchIndex;
-  if (input.kind !== undefined)
-    fields.kind = input.kind;
+  const keys = [
+    "sqlstate",
+    "constraint",
+    "table",
+    "column",
+    "detail",
+    "cause",
+    "batchIndex",
+    "kind"
+  ];
+  for (const key of keys) {
+    const value = input[key];
+    if (value !== undefined)
+      fields[key] = value;
+  }
   return fields;
 }
 

package/dist/shared/{gwn6v667.js → cnkky55j.js}

@@ -9,6 +9,7 @@ function isConnectionErrno(code) {
     case "EPIPE":
     case "ENOTFOUND":
     case "ETIMEDOUT":
+    case "CONNECT_TIMEOUT":
     case "EHOSTUNREACH":
     case "ENETUNREACH":
     case "EAI_AGAIN":
@@ -21,28 +22,38 @@ function isConnectionErrno(code) {
   }
 }
 function isConnectionFailure(error) {
-  const sqlstate = readCode(error, "sqlstate") ?? readCode(error, "code");
-  if (sqlstate !== undefined && (isConnectionSqlstate(sqlstate) || isConnectionErrno(sqlstate))) {
-    return true;
-  }
-  if (!(error instanceof Error))
-    return false;
-  const message = error.message;
-  return message.includes("ECONNREFUSED") || message.includes("ECONNRESET") || message.includes("CONNECT") || message.includes("terminating connection") || message.includes("The pool is closed");
+  return at(error, true);
 }
 function isConnectionLost(error) {
-  if (isConnectionFailure(error))
-    return true;
+  return at(error, false);
+}
+function at(error, failure) {
   if (typeof error !== "object" || error === null)
     return false;
-  if (Reflect.get(error, "kind") === "outcome_unknown")
+  const named = readCode(error, "sqlstate");
+  if (isState(named))
+    return lostState(named);
+  const code = readCode(error, "code");
+  const errno = readCode(error, "errno");
+  if (code !== undefined && (isConnectionErrno(code) || code === "ERR_POSTGRES_CONNECTION_CLOSED")) {
     return true;
-  if (readCode(error, "code") === "ERR_POSTGRES_CONNECTION_CLOSED")
+  }
+  if (errno !== undefined && isConnectionErrno(errno))
     return true;
-  if (error instanceof Error && error.message.includes("Connection terminated"))
+  if (isState(code))
+    return lostState(code);
+  if (isState(errno))
+    return lostState(errno);
+  if (!failure && Reflect.get(error, "kind") === "outcome_unknown")
     return true;
   const cause = Reflect.get(error, "cause");
-  return cause !== undefined && cause !== error && isConnectionLost(cause);
+  return cause !== undefined && cause !== error && at(cause, failure);
+}
+function lostState(state) {
+  return isConnectionSqlstate(state) && state !== "53300";
+}
+function isState(value) {
+  return value !== undefined && /^[0-9A-Z]{5}$/.test(value);
 }
 function readCode(error, key) {
   if (typeof error !== "object" || error === null || !(key in error))

package/dist/shared/{dk8v79p3.js → d5nmj7vv.js}

@@ -9,7 +9,7 @@ import {
   loadTrustedCatalog2,
   catalogFileText2,
   parseCatalog2
-} from "./qq3899ht.js";
+} from "./12z7aznj.js";
 export {
   catalogFileText2 as catalogFileText,
   catalogHash2 as catalogHash,

package/dist/shared/{ttmg09vd.js → dpc2r7rb.js}

@@ -2,10 +2,10 @@ import {
   creationOrder2,
   renameColumn2,
   renameTable2
-} from "./qq3899ht.js";
+} from "./12z7aznj.js";
 import {
   isConnectionLost
-} from "./gwn6v667.js";
+} from "./cnkky55j.js";
 import {
   quoteIdent,
   uniqueBeforeForeignKey,
@@ -21,12 +21,7 @@ import {
   identitySequence,
   createTableSql,
   qualify
-} from "./9s0ypp87.js";
-import {
-  isExactVersion,
-  compareExtensionVersions,
-  sameExtensionDefinition
-} from "./r3j8s5y0.js";
+} from "./sjk86yrx.js";
 import {
   isDomain,
   sameEnumLabels
@@ -34,6 +29,11 @@ import {
 import {
   quoteLiteral
 } from "./94ez8kzh.js";
+import {
+  isExactVersion,
+  compareExtensionVersions,
+  sameExtensionDefinition
+} from "./r3j8s5y0.js";
 import {
   staticNamespace2,
   identityKey2,

package/dist/shared/dzj09cye.js

@@ -0,0 +1,10 @@
+// src/dialects/pg/ops/search-query.ts
+function searchValue(query, options) {
+  return {
+    query,
+    match: options?.match ?? "natural",
+    language: options?.language
+  };
+}
+
+export { searchValue };

package/dist/shared/{sbdme3vy.js → e8zyaqvj.js}

@@ -3,16 +3,16 @@ import {
 } from "./n4jqhpqz.js";
 import {
   refuseUncancellableTimeout
-} from "./b4v57v3x.js";
+} from "./2d3xq4ps.js";
 import {
   withHttp,
   settleCall
-} from "./j60w0dvr.js";
+} from "./bah9nbg3.js";
 import {
   rejectKeys,
   isRecord,
-  fail
-} from "./2z7wv5tj.js";
+  fail2
+} from "./kgwp4jdd.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -26,29 +26,29 @@ async function batch(session, ops, options, replica) {
       }));
     }
     if (!Array.isArray(ops))
-      fail("OKM1121", "batch expects a list of write operations.");
+      fail2("OKM1121", "batch expects a list of write operations.");
     const record = options ?? {};
     if (!isRecord(record))
-      fail("OKM1121", "batch options must be an object.");
+      fail2("OKM1121", "batch options must be an object.");
     rejectKeys(record, ["signal", "timeout"], "batch");
     await refuseUncancellableTimeout(session.pool, typeof record["timeout"] === "number" ? record["timeout"] : undefined);
     for (const op of ops) {
       if (typeof op === "object" && op !== null && op["~refresh"] === true) {
-        fail("OKM1121", "batch does not take refresh(). Await refresh() on its own. It is one statement and cannot share the batch.");
+        fail2("OKM1121", "batch does not take refresh(). Await refresh() on its own. It is one statement and cannot share the batch.");
       }
     }
     const prepared = [];
     for (const op of ops) {
       const plan = typeof op === "object" && op !== null ? op["~plan"] : undefined;
       if (plan === undefined) {
-        fail("OKM1121", "batch takes write operations: insert, update, delete, and archive. Pass them without awaiting.");
+        fail2("OKM1121", "batch takes write operations: insert, update, delete, and archive. Pass them without awaiting.");
       }
       const item = await plan();
       if (item.checked === "parent") {
         throw new OkmError2("OKM1705", "batch does not take an update that sets a path column. The parent is checked in the statement, and a batch cannot report that after it commits. Use update({ where, set }) inside tx().", { fix: { summary: "Use update({ where, set }) inside tx()." } });
       }
       if (item.checked !== undefined) {
-        fail("OKM1121", item.checked === "restore" ? "batch does not take restore: it is refused while its parent is archived, and a batch cannot report that after it commits. Use tx()." : "batch does not take a write with expect: the count is checked after the statement ran, and a batch cannot report that after it commits. Use tx().");
+        fail2("OKM1121", item.checked === "restore" ? "batch does not take restore: it is refused while its parent is archived, and a batch cannot report that after it commits. Use tx()." : "batch does not take a write with expect: the count is checked after the statement ran, and a batch cannot report that after it commits. Use tx().");
       }
       prepared.push(item);
     }
@@ -73,11 +73,61 @@ async function run(session, prepared, options) {
   } catch (error) {
     throw at(error, starts);
   }
+  const extra = await recover(session, prepared, results, starts, options);
   return prepared.map((item, index) => {
     const from = starts[index] ?? 0;
-    return item.finish(results.slice(from, from + item.statements.length));
+    const slice = results.slice(from, from + item.statements.length);
+    const more = extra.get(index);
+    return item.finish(more === undefined ? slice : slice.concat(more));
   });
 }
+async function recover(session, prepared, results, starts, options) {
+  const pending = [];
+  for (let index = 0;index < prepared.length; index += 1) {
+    const item = prepared[index];
+    if (item?.follow === undefined)
+      continue;
+    const from = starts[index] ?? 0;
+    const more = item.follow(results.slice(from, from + item.statements.length));
+    if (more.length === 0)
+      continue;
+    pending.push({ index, statements: more });
+  }
+  const found = new Map;
+  if (pending.length === 0)
+    return found;
+  const flat = [];
+  const extraStarts = [];
+  for (const item of pending) {
+    extraStarts.push(flat.length);
+    flat.push(...item.statements);
+  }
+  let ran;
+  try {
+    ran = await runWrite(session, flat, call(options), true);
+  } catch (error) {
+    throw mapExtra(error, pending, extraStarts);
+  }
+  for (let index = 0;index < pending.length; index += 1) {
+    const item = pending[index];
+    if (item === undefined)
+      continue;
+    const from = extraStarts[index] ?? 0;
+    found.set(item.index, ran.slice(from, extraStarts[index + 1] ?? ran.length));
+  }
+  return found;
+}
+function mapExtra(error, pending, extraStarts) {
+  const failed = error?.batchIndex;
+  const move = error?.at;
+  if (typeof failed !== "number" || typeof move !== "function")
+    return error;
+  let slot = 0;
+  while (slot + 1 < extraStarts.length && (extraStarts[slot + 1] ?? Infinity) <= failed)
+    slot += 1;
+  const op = pending[slot]?.index ?? slot;
+  return op === failed ? error : move.call(error, op);
+}
 function call(options) {
   const { signal, timeout } = options;
   if (signal === undefined && timeout === undefined)

package/dist/shared/{2jd1sn0e.js → ecn8mfdq.js}

@@ -1,18 +1,18 @@
 import {
   encodeText,
   decodeText
-} from "./ed0b8k4s.js";
+} from "./typ3vy7t.js";
 import {
   required,
   openColumn
-} from "./ywr8hmey.js";
+} from "./606g0nbf.js";
+import {
+  readClientGenerator
+} from "./rwmrejjz.js";
 import {
   definition,
   rejected
 } from "./tmbdywx0.js";
-import {
-  readClientGenerator
-} from "./rwmrejjz.js";
 
 // src/dialects/pg/keys.ts
 function id2(options) {
@@ -35,7 +35,7 @@ function id2(options) {
     ...client !== undefined ? { clientDefault: client } : {},
     ...okid ? { collation: "C" } : {},
     idSource: chosen === undefined ? "implicit" : "column",
-    ...client === undefined && !supplied ? { defaultSql: chosen === "uuidv4" ? "gen_random_uuid()" : "uuidv7()" } : {},
+    ...client === undefined && !supplied ? { defaultSql: chosen === "uuidv7" ? "uuidv7()" : "gen_random_uuid()" } : {},
     primaryKey: true,
     encode: okid ? encodeText : encodeUuid,
     decode: okid ? decodeText : decodeUuid,

package/dist/shared/exn3sd90.js

@@ -0,0 +1,359 @@
+import {
+  OkmError2,
+  catalogError2,
+  throwNamed2
+} from "./52szzakm.js";
+
+// src/dialects/pg/morph.ts
+var refuseTo = (planner, schema, relation, child, sink, parent, alias, depth) => {
+  const morph = relation.morph;
+  const typeField = morph?.typeField ?? "type";
+  const idField = morph?.idField ?? "id";
+  throw new OkmError2("OKM1120", `Relation ${relation.name} is a morph. Filter ${typeField} and ${idField}, or include it. has, none, and every are not available on it.`);
+};
+function resolveMorph(scope, name, targets) {
+  const label = `${scope.owner}.${scope.name}`;
+  const owner = described(scope, scope.owner, label);
+  const typeField = `${name}Type`;
+  const idField = `${name}Id`;
+  const typeColumn = requireColumn(owner, typeField, label);
+  const idColumn = requireColumn(owner, idField, label);
+  if (typeColumn.nullable !== idColumn.nullable) {
+    catalogError2("OKM1021", `Relation ${label} columns ${owner.tsName}.${typeColumn.field} and ${owner.tsName}.${idColumn.field} must both be nullable, or neither.`);
+  }
+  if (!isTextType(typeColumn.dataType)) {
+    catalogError2("OKM1022", `Relation ${label} type column ${owner.tsName}.${typeColumn.field} is ${typeColumn.dataType}. Accepted type: text.`);
+  }
+  const seen = new Set;
+  const resolved = [];
+  for (const targetName of targets) {
+    if (seen.has(targetName)) {
+      catalogError2("OKM1023", `Relation ${label} lists ${targetName} twice.`);
+    }
+    seen.add(targetName);
+    if (!scope.tables.includes(targetName)) {
+      throwNamed2("OKM1020", targetName, scope.tables, `Relation ${label} names ${targetName}, which is not in the schema. Accepted names: ${scope.tables.join(", ")}.`);
+    }
+    const target = described(scope, targetName, label);
+    const key = requireKey(target, label, scope.scopeFields);
+    if (idColumn.dataType !== key.dataType) {
+      catalogError2("OKM1022", `Relation ${label} id column ${owner.tsName}.${idColumn.field} is ${idColumn.dataType} and ${target.tsName}.${key.field} is ${key.dataType}. Accepted type: ${key.dataType}.`);
+    }
+    const limit = textLimit(typeColumn.dataType);
+    if (limit !== undefined && targetName.length > limit) {
+      catalogError2("OKM1022", `Relation ${label} type column ${owner.tsName}.${typeColumn.field} is ${typeColumn.dataType} and ${target.tsName} does not fit. Accepted type: text.`);
+    }
+    resolved.push({
+      type: target.tsName,
+      table: target.tsName,
+      sql: target.sqlName,
+      keySql: key.sql
+    });
+  }
+  const first = resolved[0];
+  if (first === undefined) {
+    catalogError2("OKM1020", `Relation ${label} needs a target table.`);
+  }
+  const morph = {
+    direction: "to",
+    name,
+    typeField,
+    idField,
+    typeSql: typeColumn.sqlName,
+    idSql: idColumn.sqlName,
+    targets: resolved
+  };
+  return {
+    name: scope.name,
+    kind: "one",
+    table: first.table,
+    local: [idColumn.sqlName],
+    remote: [first.keySql],
+    morph,
+    through: {
+      table: first.table,
+      local: [idColumn.sqlName],
+      remote: [first.keySql],
+      emit: refuseTo
+    }
+  };
+}
+function resolveMorphMany(scope, table, name) {
+  const label = `${scope.owner}.${scope.name}`;
+  if (!scope.tables.includes(table)) {
+    throwNamed2("OKM1020", table, scope.tables, `Relation ${label} names ${table}, which is not in the schema. Accepted names: ${scope.tables.join(", ")}.`);
+  }
+  const owner = described(scope, table, label);
+  const here = described(scope, scope.owner, label);
+  const targets = declaredTargets(owner.relationOptions, name);
+  if (targets === undefined) {
+    catalogError2("OKM1021", `Relation ${label} needs morph("${name}", [...]) on ${owner.tsName}. ${owner.tsName} has no morph named ${name}.`);
+  }
+  if (!targets.includes(scope.owner)) {
+    catalogError2("OKM1020", `Relation ${label} is not a target of ${owner.tsName}.${name}. Accepted tables: ${targets.join(", ")}.`);
+  }
+  const typeField = `${name}Type`;
+  const idField = `${name}Id`;
+  const typeColumn = requireColumn(owner, typeField, label);
+  const idColumn = requireColumn(owner, idField, label);
+  const key = requireKey(here, label, scope.scopeFields);
+  if (idColumn.dataType !== key.dataType) {
+    catalogError2("OKM1022", `Relation ${label} id column ${owner.tsName}.${idColumn.field} is ${idColumn.dataType} and ${here.tsName}.${key.field} is ${key.dataType}. Accepted type: ${key.dataType}.`);
+  }
+  const morph = {
+    direction: "many",
+    name,
+    typeField,
+    idField,
+    typeSql: typeColumn.sqlName,
+    idSql: idColumn.sqlName,
+    typeValue: here.tsName,
+    targets: [
+      {
+        type: here.tsName,
+        table: here.tsName,
+        sql: here.sqlName,
+        keySql: key.sql
+      }
+    ]
+  };
+  return {
+    name: scope.name,
+    kind: "many",
+    table: owner.tsName,
+    local: [key.sql],
+    remote: [idColumn.sqlName],
+    morph,
+    through: {
+      table: owner.tsName,
+      local: [idColumn.sqlName],
+      remote: [key.sql],
+      emit: morphManyEmit(here.tsName)
+    }
+  };
+}
+function morphManyEmit(typeValue) {
+  return (planner, schema, relation, child, sink, parent, alias) => {
+    const pair = relation.morph;
+    const local = relation.local[0];
+    if (pair === undefined || local === undefined) {
+      throw new OkmError2("OKM1120", `Relation ${relation.name} is not a morph many.`);
+    }
+    const { quote } = planner;
+    sink.text(quote(child.model.sql));
+    sink.text(" ");
+    sink.text(alias);
+    sink.text(" where ");
+    sink.text(alias);
+    sink.text(".");
+    sink.text(quote(pair.typeSql));
+    sink.text(" = ");
+    sink.param(typeValue);
+    sink.text("::text");
+    sink.text(" and ");
+    sink.text(alias);
+    sink.text(".");
+    sink.text(quote(pair.idSql));
+    sink.text(" = ");
+    sink.text(parent);
+    sink.text(".");
+    sink.text(quote(local));
+  };
+}
+function described(scope, table, label) {
+  const found = scope.describe?.(table);
+  if (!isDescribed(found)) {
+    catalogError2("OKM1020", `Relation ${label} names ${table}, which is not in the schema.`);
+  }
+  return found;
+}
+function isDescribed(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  if (!("tsName" in value) || typeof value.tsName !== "string")
+    return false;
+  if (!("sqlName" in value) || typeof value.sqlName !== "string")
+    return false;
+  if (!("primary" in value) || !Array.isArray(value.primary))
+    return false;
+  if (!("byField" in value) || !(value.byField instanceof Map))
+    return false;
+  if (!("bySql" in value) || !(value.bySql instanceof Map))
+    return false;
+  return "relationOptions" in value;
+}
+function requireColumn(table, field, label) {
+  const column = table.byField.get(field);
+  if (column === undefined) {
+    catalogError2("OKM1021", `Relation ${label} needs column ${field} on ${table.tsName}.`);
+  }
+  return column;
+}
+function requireKey(table, label, scopeFields) {
+  const skip = scopeFields ?? [];
+  const keys = [];
+  for (const sql of table.primary) {
+    const column = table.bySql.get(sql);
+    if (column === undefined || skip.includes(column.field))
+      continue;
+    keys.push({ field: column.field, sql, dataType: column.dataType });
+  }
+  const only = keys.length === 1 ? keys[0] : undefined;
+  if (only !== undefined)
+    return only;
+  const names = keys.map((key) => key.field);
+  catalogError2("OKM1021", `Relation ${label} cannot use ${table.tsName} as a target. Its primary key is ${names.length === 0 ? "(none)" : names.join(", ")}. A morph id matches one column.`);
+}
+function declaredTargets(options, name) {
+  if (typeof options !== "object" || options === null)
+    return;
+  for (const value of Object.values(options)) {
+    if (typeof value !== "object" || value === null || !("morph" in value))
+      continue;
+    const morph = value.morph;
+    if (morph === undefined || morph.name !== name || !Array.isArray(morph.targets))
+      continue;
+    const names = [];
+    for (const target of morph.targets) {
+      if (typeof target === "string")
+        names.push(target);
+    }
+    return names;
+  }
+  return;
+}
+function assertMorphTo(name, type, id) {
+  if (name === null || type === null || typeof id !== "string" || id.length === 0) {
+    throw new OkmError2("OKM1120", "morphTo() needs a morph name, a target table, and that table's id.");
+  }
+  if (typeof name !== "string" || name.length === 0 || typeof type !== "string" || type.length === 0) {
+    throw new OkmError2("OKM1020", "morphTo() needs a morph name and a target table.");
+  }
+}
+function isTextType(dataType) {
+  return dataType === "text" || dataType === "citext" || dataType.startsWith("varchar(") || dataType.startsWith("character varying(") || dataType.startsWith("char(") || dataType.startsWith("character(");
+}
+function textLimit(dataType) {
+  const match = /^(?:varchar|character varying|char|character)\((\d+)\)$/.exec(dataType);
+  if (match?.[1] === undefined)
+    return;
+  return Number(match[1]);
+}
+
+// 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)
+  };
+}
+function morph2(name, targets) {
+  if (name.length === 0)
+    throw new OkmError2("OKM1020", "morph() needs a name.");
+  if (targets.length === 0)
+    throw new OkmError2("OKM1020", "morph() needs a target table.");
+  for (const target of targets) {
+    if (typeof target !== "string" || target.length === 0) {
+      throw new OkmError2("OKM1020", "morph() targets must be table names.");
+    }
+  }
+  const list = targets;
+  return {
+    kind: "one",
+    table: targets[0],
+    field: undefined,
+    morph: { name, targets, typeField: `${name}Type` },
+    resolve: (scope) => resolveMorph(scope, name, list)
+  };
+}
+function morphMany2(table, name) {
+  if (table.length === 0 || name.length === 0) {
+    throw new OkmError2("OKM1020", "morphMany() needs a table and a morph name.");
+  }
+  return {
+    kind: "many",
+    table,
+    field: undefined,
+    resolve: (scope) => resolveMorphMany(scope, table, name)
+  };
+}
+function morphTo2(name, type, id) {
+  assertMorphTo(name, type, id);
+  const row = {};
+  row[`${name}Type`] = type;
+  row[`${name}Id`] = id;
+  return row;
+}
+
+export { one2, many2, isRelationCall, manyThrough2, morph2, morphMany2, morphTo2 };