okmodel 0.5.1 → 0.7.0

package/dist/shared/{pf0d8f77.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("CONNECTION_CLOSED") || 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/{5fqx9yh4.js → dk8v79p3.js}

@@ -7,9 +7,11 @@ import {
   startupCatalog2,
   startupHash2,
   loadTrustedCatalog2,
+  catalogFileText2,
   parseCatalog2
-} from "./8bwbwy8h.js";
+} from "./qq3899ht.js";
 export {
+  catalogFileText2 as catalogFileText,
   catalogHash2 as catalogHash,
   creationOrder2 as creationOrder,
   loadTrustedCatalog2 as loadTrustedCatalog,

package/dist/shared/{nkaxvt9q.js → dkxgzaqd.js}

@@ -1,10 +1,13 @@
 import {
+  orderHasRelevance,
   emitRelationFrom,
+  needsOperatorSql,
   decodeResult,
   emitJoin,
   emitWhere,
   emitOrder,
   emitPrimaryOrder,
+  refuseHidden,
   selectedColumns,
   rejectKeys,
   readLimit,
@@ -16,8 +19,8 @@ import {
   list,
   isRecord,
   registerFailFix,
-  fail
-} from "./gbtcc2d7.js";
+  fail2
+} from "./67txcrcw.js";
 import {
   throwNamed2
 } from "./52szzakm.js";
@@ -26,6 +29,32 @@ import {
 registerFailFix("OKM1105", "Pass limit on the include, or call .all(reason).");
 var INCLUDE_OPTIONS = ["all", "include", "limit", "orderBy", "select", "where"];
 function emitIncludeSelect(include, alias, sink, outputs, column) {
+  const morph = include.morphTo;
+  if (morph !== undefined) {
+    if (column > 0 || outputs?.fields.length)
+      sink.text(", ");
+    sink.text(alias);
+    sink.text(".payload");
+    outputs?.includes.push({
+      name: include.name,
+      kind: "one",
+      at: column,
+      fields: [],
+      nested: [],
+      morph: {
+        typeKey: morph.typeKey,
+        targets: morph.targets.map((target) => ({
+          type: target.type,
+          fields: target.columns.map((item, at) => ({
+            key: item.field,
+            at,
+            decode: item.decode
+          }))
+        }))
+      }
+    });
+    return column + 1;
+  }
   const selected = include.columns;
   sink.mark(`i:${include.name}:${include.relation.kind}`);
   if (include.relation.kind === "many") {
@@ -109,9 +138,13 @@ function emitIncludeSelect(include, alias, sink, outputs, column) {
   return cursor;
 }
 function emitIncludeJoin(schema, include, sink, parentAlias, alias, depth) {
+  if (include.morphTo !== undefined) {
+    emitMorphJoin(schema, include, sink, parentAlias, alias, depth);
+    return;
+  }
   const child = indexes(schema).get(include.relation.table);
   if (child === undefined) {
-    fail("OKM1120", `Relation ${include.name} names ${include.relation.table}, which is not in the schema.`);
+    fail2("OKM1120", `Relation ${include.name} names ${include.relation.table}, which is not in the schema.`);
   }
   const childAlias = `r${String(depth)}_${include.name}`;
   sink.text(" left join lateral (");
@@ -135,10 +168,7 @@ function emitIncludeJoin(schema, include, sink, parentAlias, alias, depth) {
     sink.text(") as item from ");
     emitRelationFrom(schema, include.relation, child, sink, parentAlias, childAlias, depth + 1);
     emitWhere(schema, child, include.where, sink, childAlias, depth + 1, true);
-    emitOrder(child, include.orderBy, sink, childAlias);
-    if (include.orderBy === undefined && child.model.primary.length > 0) {
-      emitPrimaryOrder(child, sink, childAlias);
-    }
+    emitIncludeOrder(child, include.orderBy, sink, childAlias);
     if (include.limit !== undefined) {
       sink.text(" limit ");
       sink.param(String(include.limit));
@@ -207,9 +237,12 @@ function emitIncludeJoin(schema, include, sink, parentAlias, alias, depth) {
   sink.text(" on true");
 }
 function emitNestedAggregate(schema, include, sink, alias, depth) {
+  if (include.relation.morph?.direction === "to") {
+    fail2("OKM1120", `Include ${include.name} is a morph and cannot be nested in this version.`);
+  }
   const child = indexes(schema).get(include.relation.table);
   if (child === undefined) {
-    fail("OKM1120", `Relation ${include.name} names ${include.relation.table}, which is not in the schema.`);
+    fail2("OKM1120", `Relation ${include.name} names ${include.relation.table}, which is not in the schema.`);
   }
   const childAlias = `n${String(depth)}_${include.name}`;
   sink.text("(select coalesce(json_agg(item order by ord), '[]'::json) from (select item, row_number() over () as ord from (select json_build_array(");
@@ -226,10 +259,7 @@ function emitNestedAggregate(schema, include, sink, alias, depth) {
   sink.text(") as item from ");
   emitRelationFrom(schema, include.relation, child, sink, alias, childAlias, depth);
   emitWhere(schema, child, include.where, sink, childAlias, depth, true);
-  emitOrder(child, include.orderBy, sink, childAlias);
-  if (include.orderBy === undefined && child.model.primary.length > 0) {
-    emitPrimaryOrder(child, sink, childAlias);
-  }
+  emitIncludeOrder(child, include.orderBy, sink, childAlias);
   if (include.limit !== undefined) {
     sink.text(" limit ");
     sink.param(String(include.limit));
@@ -237,6 +267,14 @@ function emitNestedAggregate(schema, include, sink, alias, depth) {
   }
   sink.text(") limited) ordered)");
 }
+function includeColumns(table, select) {
+  const columns = selectedColumns(table, select);
+  if (select === undefined)
+    return omitHidden(columns);
+  for (const column of columns)
+    refuseHidden(column);
+  return columns;
+}
 function omitHidden(columns) {
   for (const column of columns) {
     if (!column.hidden)
@@ -249,7 +287,7 @@ function readIncludes(schema, table, include, all) {
   if (include === undefined)
     return [];
   if (!isRecord(include)) {
-    fail("OKM1120", "include must be an object of relations.");
+    fail2("OKM1120", "include must be an object of relations.");
   }
   const parsed = [];
   for (const name of Object.keys(include)) {
@@ -262,9 +300,11 @@ function readIncludes(schema, table, include, all) {
   return parsed;
 }
 function parseInclude(schema, name, relation, value, all) {
+  if (relation.morph?.direction === "to")
+    return parseMorph(schema, name, relation, value);
   if (value === true) {
     if (relation.kind === "many" && all === undefined) {
-      fail("OKM1105", `Include ${name} is to-many and has no limit. Pass limit, or call .all(reason).`);
+      fail2("OKM1105", `Include ${name} is to-many and has no limit. Pass limit, or call .all(reason).`);
     }
     const child = childIndex(schema, relation);
     const columns = omitHidden(selectedColumns(child, undefined));
@@ -280,7 +320,7 @@ function parseInclude(schema, name, relation, value, all) {
     };
   }
   if (!isRecord(value)) {
-    fail("OKM1120", `Include ${name} must be true or an object.`);
+    fail2("OKM1120", `Include ${name} must be true or an object.`);
   }
   rejectKeys(value, INCLUDE_OPTIONS, `include ${name}`);
   const reason = typeof value.all === "string" ? value.all : all;
@@ -288,10 +328,10 @@ function parseInclude(schema, name, relation, value, all) {
   if (value.limit !== undefined)
     limit = readLimit(value.limit);
   if (relation.kind === "many" && limit === undefined && reason === undefined) {
-    fail("OKM1105", `Include ${name} is to-many and has no limit. Pass limit, or call .all(reason).`);
+    fail2("OKM1105", `Include ${name} is to-many and has no limit. Pass limit, or call .all(reason).`);
   }
   const child = childIndex(schema, relation);
-  const columns = omitHidden(selectedColumns(child, value.select));
+  const columns = includeColumns(child, value.select);
   const nestedValue = value.include;
   const nested = nestedValue === undefined ? [] : readIncludes(schema, child, nestedValue, reason);
   return {
@@ -317,10 +357,125 @@ function anchored(table, columns) {
 function childIndex(schema, relation) {
   const child = indexes(schema).get(relation.table);
   if (child === undefined) {
-    fail("OKM1120", `Relation ${relation.name} names ${relation.table}, which is not in the schema.`);
+    fail2("OKM1120", `Relation ${relation.name} names ${relation.table}, which is not in the schema.`);
   }
   return child;
 }
+function parseMorph(schema, name, relation, value) {
+  if (value !== true) {
+    fail2("OKM1120", `Include ${name} is a morph. Pass true. select, where, orderBy, and limit are not available on it.`);
+  }
+  const morph = relation.morph;
+  if (morph === undefined)
+    fail2("OKM1120", `Include ${name} is not a morph.`);
+  const planned = [];
+  for (const target of morph.targets) {
+    const child = indexes(schema).get(target.table);
+    if (child === undefined) {
+      fail2("OKM1120", `Relation ${name} names ${target.table}, which is not in the schema.`);
+    }
+    planned.push({
+      type: target.type,
+      table: target.table,
+      sql: target.sql,
+      keySql: target.keySql,
+      columns: omitHidden(selectedColumns(child, undefined))
+    });
+  }
+  return {
+    name,
+    relation,
+    where: undefined,
+    orderBy: undefined,
+    limit: undefined,
+    columns: [],
+    presence: undefined,
+    anchor: 0,
+    nested: [],
+    morphTo: {
+      typeKey: morph.typeField,
+      typeSql: morph.typeSql,
+      idSql: morph.idSql,
+      targets: planned
+    }
+  };
+}
+function emitMorphJoin(schema, include, sink, parentAlias, alias, depth) {
+  const morph = include.morphTo;
+  if (morph === undefined)
+    fail2("OKM1120", `Include ${include.name} is not a morph.`);
+  sink.text(" left join lateral (select payload from (");
+  for (let index = 0;index < morph.targets.length; index += 1) {
+    const target = morph.targets[index];
+    if (target === undefined)
+      continue;
+    if (index > 0)
+      sink.text(" union all ");
+    const childAlias = `m${String(depth)}_${include.name}_${String(index)}`;
+    const child = indexes(schema).get(target.table);
+    if (child === undefined) {
+      fail2("OKM1120", `Relation ${include.name} names ${target.table}, which is not in the schema.`);
+    }
+    sink.text("select json_build_array(");
+    sink.param(target.type);
+    sink.text("::text");
+    sink.mark(`mt:${target.type}`);
+    for (const column of target.columns) {
+      sink.text(", ");
+      sink.text(jsonExpr(`${childAlias}.${quote(column.sql)}`, column.dataType));
+    }
+    sink.text(") as payload from ");
+    sink.text(quote(target.sql));
+    sink.text(" ");
+    sink.text(childAlias);
+    sink.text(" where ");
+    sink.text(parentAlias);
+    sink.text(".");
+    sink.text(quote(morph.typeSql));
+    sink.text(" = ");
+    sink.param(target.type);
+    sink.text("::text");
+    sink.text(" and ");
+    sink.text(childAlias);
+    sink.text(".");
+    sink.text(quote(target.keySql));
+    sink.text(" = ");
+    sink.text(parentAlias);
+    sink.text(".");
+    sink.text(quote(morph.idSql));
+    emitWhere(schema, child, undefined, sink, childAlias, depth + 1, true);
+  }
+  sink.text(") matched limit 1) ");
+  sink.text(alias);
+  sink.text(" on true");
+}
+function decodeMorph(include, row) {
+  const morph = include.morph;
+  if (morph === undefined)
+    return null;
+  const raw = row[include.at];
+  if (raw === null || raw === undefined)
+    return null;
+  const parsed = JSON.parse(raw);
+  if (!Array.isArray(parsed))
+    return null;
+  const type = parsed[0];
+  if (typeof type !== "string")
+    return null;
+  let target;
+  for (const item of morph.targets) {
+    if (item.type === type)
+      target = item;
+  }
+  if (target === undefined)
+    return null;
+  const child = {};
+  for (const field of target.fields) {
+    child[field.key] = jsonCell(parsed[field.at + 1], field.decode);
+  }
+  child[morph.typeKey] = type;
+  return child;
+}
 function decodeIncluded(plan, rows, table) {
   return decodeResult(plan, rows, table, decodeRowIncluded);
 }
@@ -335,6 +490,8 @@ function decodeRowIncluded(outputs, row) {
   return result;
 }
 function decodeInclude(include, row) {
+  if (include.morph !== undefined)
+    return decodeMorph(include, row);
   if (include.kind === "many") {
     const raw = row[include.at];
     if (raw === null || raw === undefined)
@@ -390,10 +547,58 @@ function jsonCell(value, decode) {
   const wire = typeof value === "string" ? value : JSON.stringify(value);
   return decode === undefined ? wire : decode(wire);
 }
+function emitIncludeOrder(child, orderBy, sink, alias) {
+  emitOrder(child, orderBy, sink, alias);
+  const named = isRecord(orderBy) ? Object.keys(orderBy) : [];
+  if (named.length === 0) {
+    if (child.model.primary.length > 0)
+      emitPrimaryOrder(child, sink, alias);
+    return;
+  }
+  for (const field of child.model.primary) {
+    if (named.includes(field))
+      continue;
+    const column = child.columns.get(field);
+    if (column === undefined)
+      continue;
+    sink.text(", ");
+    sink.text(alias);
+    sink.text(".");
+    sink.text(quote(column.sql));
+    sink.text(" asc");
+  }
+}
+function needsOperator(schema, call) {
+  const table = indexes(schema).get(call.table);
+  if (table === undefined)
+    return false;
+  return walkOperators(schema, table, call.include);
+}
+function walkOperators(schema, table, include) {
+  if (!isRecord(include))
+    return false;
+  for (const name of Object.keys(include)) {
+    const value = include[name];
+    if (!isRecord(value))
+      continue;
+    const relation = table.relations.get(name);
+    if (relation === undefined)
+      continue;
+    const child = indexes(schema).get(relation.table);
+    if (child === undefined)
+      continue;
+    if (needsOperatorSql(child, value.where) || orderHasRelevance(value.orderBy))
+      return true;
+    if (walkOperators(schema, child, value.include))
+      return true;
+  }
+  return false;
+}
 var includeHooks = {
   read: readIncludes,
   select: emitIncludeSelect,
-  join: emitIncludeJoin
+  join: emitIncludeJoin,
+  needsOperator
 };
 export {
   decodeIncluded,

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/{4m9fn52z.js → ed0b8k4s.js}

@@ -1,6 +1,6 @@
 import {
   required
-} from "./c9z5g0fm.js";
+} from "./ywr8hmey.js";
 import {
   definition,
   rejected

package/dist/shared/{z2rnngj4.js → ek2wt2dz.js}

@@ -1,3 +1,6 @@
+import {
+  catalogFileText2
+} from "./qq3899ht.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -11,7 +14,7 @@ async function assertCompatible(pool, schema, recordedHash, source, options) {
   if (code.artifact !== undefined) {
     const artifact = code.artifact;
     await loadOnce(`text\x00${artifact.hash}`, async () => {
-      const { loadTrustedCatalog } = await import("./5fqx9yh4.js");
+      const { loadTrustedCatalog } = await import("./dk8v79p3.js");
       loadTrustedCatalog(artifact.text, artifact.hash);
     });
   } else if (code.fromFile) {
@@ -25,7 +28,7 @@ async function assertCompatible(pool, schema, recordedHash, source, options) {
           }
         });
       }
-      const { loadTrustedCatalog } = await import("./5fqx9yh4.js");
+      const { loadTrustedCatalog } = await import("./dk8v79p3.js");
       loadTrustedCatalog(text, code.hash);
     });
   }
@@ -39,7 +42,7 @@ async function codeHash(schema, source) {
   const listed = await readHashFile(source.catalogDir);
   if (listed !== undefined)
     return { hash: listed, fromFile: true };
-  const { catalogHash } = await import("./5fqx9yh4.js");
+  const { catalogHash } = await import("./dk8v79p3.js");
   return { hash: catalogHash(schemaCatalog(schema)), fromFile: false };
 }
 function schemaCatalog(schema) {
@@ -57,12 +60,12 @@ async function readHashFile(catalogDir) {
   const text = await readText(`${artifactDir(catalogDir)}/catalog.hash`);
   if (text === undefined)
     return;
-  const hash = text.trim();
+  const hash = catalogFileText2(text, "catalog.hash").trim();
   return hash.length === 0 ? undefined : hash;
 }
 function artifactDir(catalogDir) {
   if (catalogDir !== undefined)
-    return catalogDir.replace(/\/$/, "");
+    return catalogDir.replace(/[/\\]+$/, "");
   const cwd = globalThis.process?.cwd?.() ?? ".";
   return `${cwd}/.okm`;
 }