okmodel 0.6.0 → 0.7.0

package/dist/shared/{32cnm7kn.js → x933k9a3.js}

@@ -1,21 +1,27 @@
 import {
-  noTimeout2
-} from "./8dqhth8c.js";
+  DriverError2
+} from "./cm3w0ywp.js";
+import {
+  noTimeout
+} from "./79dt02vc.js";
 import {
   noticeBuffer,
-  WireSession,
-  cursorStream
-} from "./4az561fn.js";
+  WireSession
+} from "./1qa0qajz.js";
 import {
   BUNSQL_CAPABILITIES,
   driverErrors,
   rejectClosed,
   mapFailure,
   runCall
-} from "./cgbamx3e.js";
+} from "./kb2sdhfb.js";
 
 // src/adapters/pg/bunsql.ts
 import { SQL } from "bun";
+var clientPools = new WeakSet;
+function markClientPool(pool) {
+  clientPools.add(pool);
+}
 function open5(config) {
   const max = config.max ?? 10;
   const acquireMs = config.timeouts?.acquire;
@@ -25,6 +31,8 @@ function open5(config) {
   const isClosed = () => closed;
   const named = config.prepared === "named";
   const parked = [];
+  let dropped = 0;
+  let closures = 0;
   const sql = new SQL(config.url, {
     max,
     idleTimeout: 0,
@@ -36,26 +44,53 @@ function open5(config) {
       application_name: "okmodel",
       ...config.searchPath !== undefined ? { search_path: config.searchPath } : {}
     },
-    ...config.ssl !== undefined ? { tls: config.ssl } : {}
+    ...config.ssl !== undefined ? { tls: config.ssl } : {},
+    onclose() {
+      dropped += 1;
+      closures += 1;
+    }
   });
   const root = new WireSession((text, params) => send2(sql, text, params), notices, isClosed, false, () => {
     counters.busy += 1;
   }, () => {
     counters.busy = Math.max(0, counters.busy - 1);
   });
-  const held = { sql, parked, acquireMs, counters, notices, isClosed };
-  const checkout = () => closed ? rejectClosed() : import("./j3rkk835.js").then((mod) => mod.checkout(held));
-  return {
+  const held = {
+    sql,
+    parked,
+    acquireMs,
+    counters,
+    notices,
+    isClosed,
+    closures: () => closures
+  };
+  const run = (text, params, watch) => {
+    const sent = dropped;
+    return root.query(text, params, watch).catch((error) => import("./ab9gmbwy.js").then((mod) => mod.recover(sql, error, text, root.depth(), clientPools.has(pool), dropped > sent, () => root.query(text, params, watch))));
+  };
+  const afterDrop = (text, params, watch) => {
+    if (dropped === 0)
+      return run(text, params, watch);
+    const seen = dropped;
+    return import("./ab9gmbwy.js").then((mod) => mod.drainClosed(sql).then(() => {
+      if (dropped === seen)
+        dropped = 0;
+      return run(text, params, watch);
+    }));
+  };
+  const checkout = () => closed ? rejectClosed() : import("./ab9gmbwy.js").then((mod) => mod.checkout(held));
+  const pool = {
     capabilities: BUNSQL_CAPABILITIES,
     execute(text, params, options) {
-      noTimeout2(options);
-      return runCall(closed, options, async (watch) => {
-        await releaseParked(parked);
-        return root.query(text, params, watch);
-      });
+      const refused = noTimeout(options);
+      if (refused !== undefined)
+        return refused;
+      return runCall(closed, options, (watch) => releaseParked(parked).then(() => afterDrop(text, params, watch)));
     },
     async batch(statements, options) {
-      noTimeout2(options);
+      const refused = noTimeout(options);
+      if (refused !== undefined)
+        return refused;
       const connection = await checkout();
       try {
         return await connection.batch(statements, options);
@@ -65,10 +100,13 @@ function open5(config) {
     },
     reserve: () => checkout(),
     stream(text, params) {
-      return stream(text, params);
+      return async function* () {
+        const { streamRows } = await import("./ab9gmbwy.js");
+        yield* streamRows(checkout, text, params);
+      }();
     },
     listen(channel, onNotify) {
-      return listen(channel, onNotify);
+      return import("./ab9gmbwy.js").then((mod) => mod.listen(sql, parked, closed, channel, onNotify));
     },
     stats: () => statsOf(counters, max),
     async close() {
@@ -77,31 +115,29 @@ function open5(config) {
       await sql.close();
     }
   };
-  function stream(text, params) {
-    return async function* () {
-      const connection = await checkout();
-      try {
-        yield* cursorStream((statement, values) => connection.execute(statement, values), text, params);
-      } finally {
-        await connection.release();
-      }
-    }();
-  }
-  async function listen(channel, onNotify) {
-    if (closed)
-      return rejectClosed();
-    await releaseParked(parked);
-    const subscription = await sql.listen(channel, onNotify);
-    return async () => {
-      await subscription.unlisten();
-    };
-  }
+  return pool;
 }
 function send2(sql, text, params) {
+  const refused = refuseInt8(params);
+  if (refused !== undefined)
+    return refused;
   if (params === undefined || params.length === 0)
     return sql.unsafe(text).raw();
   return sql.unsafe(text, [...params]).raw();
 }
+function refuseInt8(params) {
+  if (params === undefined)
+    return;
+  for (const value of params) {
+    if (value === null || value.length < 19 || !/^-?(?:0|[1-9]\d*)$/.test(value))
+      continue;
+    const parsed = BigInt(value);
+    if (parsed > 9223372036854775807n || parsed < -9223372036854775808n) {
+      return Promise.reject(new DriverError2("bigint out of range", { sqlstate: "22003" }));
+    }
+  }
+  return;
+}
 async function reserve(sql, acquireMs, counters) {
   counters.waiting += 1;
   try {
@@ -151,4 +187,4 @@ function statsOf(counters, size) {
   };
 }
 
-export { open5, send2, reserve, park };
+export { markClientPool, open5, send2, reserve, park };

package/dist/shared/{n076ydsc.js → xhfsfkgk.js}

@@ -5,13 +5,13 @@ import {
   assertBoundText,
   assertRegconfig,
   textArray
-} from "./n7mcc1gk.js";
+} from "./zchaghkf.js";
 import {
   installOperatorSql,
   quote,
   isRecord,
-  fail
-} from "./2z7wv5tj.js";
+  fail2
+} from "./67txcrcw.js";
 import {
   isOperator,
   operatorName,
@@ -19,7 +19,7 @@ import {
 } from "./cn0n68ft.js";
 
 // src/runtime/operator-sql.ts
-function emitStructured(column, ref, name, value, sink) {
+function emitStructured(column, ref, name, value, sink, order) {
   if (name === "contains" || name === "containedBy" || name === "overlaps") {
     emitContainment(column, ref, name, value, sink);
     return;
@@ -36,12 +36,20 @@ function emitStructured(column, ref, name, value, sink) {
     emitMatches(column, ref, value, sink);
     return;
   }
+  if (name === "relevance") {
+    if (order !== true)
+      fail2("OKM1121", `relevance on ${column.field} belongs in orderBy.`);
+    emitRelevance(column, ref, value, sink);
+    sink.text(" desc");
+    sink.mark(`o:${column.field}:relevance`);
+    return;
+  }
   if (name === "similar" || name === "wordSimilar") {
     emitTrigram(column, ref, name, value, sink);
     return;
   }
   assertOperatorFits(column, name);
-  fail("OKM1121", `${name} is not a value operator on ${column.field}. Use has, none, or every on a relation.`);
+  fail2("OKM1121", `${name} is not a value operator on ${column.field}. Use has, none, or every on a relation.`);
 }
 function emitContainment(column, ref, name, value, sink) {
   assertOperatorFits(column, name);
@@ -56,7 +64,7 @@ function emitJsonKey(column, ref, name, value, sink) {
   assertOperatorFits(column, name);
   if (name === "hasKey") {
     if (typeof value !== "string")
-      fail("OKM1121", `hasKey on ${column.field} needs a key.`);
+      fail2("OKM1121", `hasKey on ${column.field} needs a key.`);
     assertBoundText(value, `key on ${column.field}`);
     sink.text("jsonb_exists(");
     sink.text(ref);
@@ -66,7 +74,7 @@ function emitJsonKey(column, ref, name, value, sink) {
     return;
   }
   if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
-    fail("OKM1121", `hasAnyKey on ${column.field} needs a list of keys.`);
+    fail2("OKM1121", `hasAnyKey on ${column.field} needs a list of keys.`);
   }
   sink.text("jsonb_exists_any(");
   sink.text(ref);
@@ -77,15 +85,15 @@ function emitJsonKey(column, ref, name, value, sink) {
 function emitPath(column, ref, value, sink) {
   assertOperatorFits(column, "path");
   if (!isRecord(value) || !Array.isArray(value.segments) || !isOperator(value.op)) {
-    fail("OKM1121", `path on ${column.field} needs segments and a comparison.`);
+    fail2("OKM1121", `path on ${column.field} needs segments and a comparison.`);
   }
   const segments = value.segments;
   if (segments.length === 0 || segments.some((item) => typeof item !== "string")) {
-    fail("OKM1121", `path on ${column.field} needs a list of segments.`);
+    fail2("OKM1121", `path on ${column.field} needs a list of segments.`);
   }
   const opName = operatorName(value.op);
   if (opName !== "eq" && opName !== "lt" && opName !== "lte" && opName !== "gt" && opName !== "gte") {
-    fail("OKM1121", `path on ${column.field} compares with eq, lt, lte, gt, or gte.`);
+    fail2("OKM1121", `path on ${column.field} compares with eq, lt, lte, gt, or gte.`);
   }
   const operand = operatorValue(value.op);
   const cast = pathCast(column, operand);
@@ -106,7 +114,7 @@ function pathCast(column, operand) {
     return "boolean";
   if (typeof operand === "string")
     return "text";
-  fail("OKM1121", `path on ${column.field} compares a string, number, or boolean.`);
+  fail2("OKM1121", `path on ${column.field} compares a string, number, or boolean.`);
 }
 function pathParam(operand) {
   if (typeof operand === "number")
@@ -117,35 +125,61 @@ function pathParam(operand) {
     return operand;
   return "";
 }
-function emitMatches(column, ref, value, sink) {
-  assertOperatorFits(column, "matches");
-  if (!isRecord(value) || typeof value.query !== "string") {
-    fail("OKM1121", `matches on ${column.field} needs search text.`);
+var MATCH_FN = {
+  natural: "websearch_to_tsquery",
+  "all-words": "plainto_tsquery",
+  phrase: "phraseto_tsquery",
+  advanced: "to_tsquery"
+};
+function readMatch(column, value, label) {
+  if (!isRecord(value) || typeof value.query !== "string" || value.query.length === 0) {
+    fail2("OKM1121", `${label} on ${column.field} needs text to look for.`);
   }
-  assertNoControl(value.query, `matches on ${column.field}`);
-  const mode = value.mode ?? "websearch";
-  const fn = mode === "websearch" ? "websearch_to_tsquery" : mode === "plain" ? "plainto_tsquery" : mode === "phrase" ? "phraseto_tsquery" : undefined;
+  assertNoControl(value.query, `${label} on ${column.field}`);
+  const match = value.match ?? "natural";
+  const fn = typeof match === "string" ? MATCH_FN[match] : undefined;
   if (fn === undefined) {
-    fail("OKM1121", `matches on ${column.field} mode must be websearch, plain, or phrase.`);
+    fail2("OKM1121", `${label} on ${column.field} match must be natural, all-words, phrase, or advanced.`);
   }
-  sink.text(ref);
-  sink.text(" @@ ");
-  sink.text(fn);
+  if (value.language === undefined)
+    return { fn, language: undefined, query: value.query };
+  if (typeof value.language !== "string") {
+    fail2("OKM1121", `${label} on ${column.field} language must be a name such as english.`);
+  }
+  assertRegconfig(value.language);
+  return { fn, language: value.language, query: value.query };
+}
+function emitTsquery(sink, query) {
+  sink.mark(query.language === undefined ? `:${query.fn}` : `:${query.fn}:lang`);
+  sink.text(query.fn);
   sink.text("(");
-  if (typeof value.config === "string") {
-    assertRegconfig(value.config);
-    sink.param(value.config);
+  if (query.language !== undefined) {
+    sink.param(query.language);
     sink.text("::regconfig, ");
   }
-  sink.param(value.query);
+  sink.param(query.query);
+  sink.text(")");
+}
+function emitMatches(column, ref, value, sink) {
+  assertOperatorFits(column, "matches");
+  sink.text(ref);
+  sink.text(" @@ ");
+  emitTsquery(sink, readMatch(column, value, "matches"));
+}
+function emitRelevance(column, ref, value, sink) {
+  assertOperatorFits(column, "relevance");
+  sink.text("ts_rank(");
+  sink.text(ref);
+  sink.text(", ");
+  emitTsquery(sink, readMatch(column, value, "relevance"));
   sink.text(")");
 }
 function emitTrigram(column, ref, name, value, sink) {
   if (!isRecord(value) || typeof value.query !== "string" || typeof value.schema !== "string") {
-    fail("OKM1121", `${name} on ${column.field} needs query text.`);
+    fail2("OKM1121", `${name} on ${column.field} needs query text.`);
   }
   if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(value.schema)) {
-    fail("OKM1121", `${name} on ${column.field} needs an extension schema name.`);
+    fail2("OKM1121", `${name} on ${column.field} needs an extension schema name.`);
   }
   sink.text(ref);
   sink.text(" operator(");

package/dist/shared/xjk7hnn5.js

@@ -0,0 +1,272 @@
+import {
+  readHandle,
+  readCall,
+  attachHttp
+} from "./tbrvgw6z.js";
+import {
+  decodeResult,
+  emitWhere,
+  emitOrder,
+  selectedColumns,
+  rejectKeys,
+  projectExpr,
+  indexes,
+  quote,
+  list,
+  isRecord,
+  fail2
+} from "./67txcrcw.js";
+import {
+  OkmError2,
+  throwNamed2
+} from "./52szzakm.js";
+
+// src/runtime/tree.ts
+var OPTIONS = [
+  "where",
+  "select",
+  "orderBy",
+  "depth",
+  "self",
+  "relation",
+  "route",
+  "signal",
+  "timeout"
+];
+function build2(session, table, options, mods, view) {
+  try {
+    return open(session, table, options, mods, view);
+  } catch (error) {
+    throw error instanceof OkmError2 ? attachHttp(session.http, error) : error;
+  }
+}
+function open(session, table, options, mods, view) {
+  const packed = readPacked(options);
+  const user = packed.user;
+  rejectKeys(user, OPTIONS, packed.walk);
+  const indexed = indexes(session.schema).get(table);
+  if (indexed === undefined)
+    fail2("OKM1120", `Table ${table} is not in the schema.`);
+  const edge = pickEdge(indexed, user.relation);
+  const identity = identityColumn2(session, indexed);
+  const depth = readDepth(user.depth);
+  const self = readSelf(user.self);
+  const id = userId(identity, packed.id);
+  const shared = {
+    ...user.where !== undefined ? { where: user.where } : {},
+    ...user.select !== undefined ? { select: user.select } : {},
+    ...user.orderBy !== undefined ? { orderBy: user.orderBy } : {},
+    ...user.signal !== undefined ? { signal: user.signal } : {},
+    ...user.timeout !== undefined ? { timeout: user.timeout } : {},
+    ...user.route !== undefined ? { route: user.route } : {}
+  };
+  const base = readCall("find", table, shared, mods.all, session.scope, session.schema.model[table], session.schema, view);
+  const spec = { direction: packed.walk, edge, identity, depth, self, id };
+  const call = {
+    ...base,
+    op: packed.walk,
+    build: (schema, planned, sink, outputs, source) => {
+      emitTree(schema, planned, sink, outputs, source, spec);
+    }
+  };
+  return readHandle(session, table, call, mods, (compiled, rows) => decodeResult(compiled, rows, table));
+}
+function emitTree(schema, table, sink, outputs, call, spec) {
+  const { direction, edge, identity, depth, self, id } = spec;
+  sink.mark(`walk:${direction}|rel:${edge.name}|self:${self ? "1" : "0"}|depth:${depth === undefined ? "all" : String(depth)}|`);
+  const selected = selectedColumns(table, call.select);
+  sink.text("with recursive walk as (select ");
+  emitKeyList(sink, "s", edge.parent, "k");
+  emitKeyList(sink, "s", edge.child, "f");
+  sink.text(", 0 as depth, array[s.");
+  sink.text(quote(identity.sql));
+  sink.text("] as seen from ");
+  sink.text(quote(table.model.sql));
+  sink.text(" s where s.");
+  sink.text(quote(identity.sql));
+  sink.text(" = ");
+  sink.param(identity.encode(id));
+  emitWhere(schema, table, undefined, sink, "s", 0, true);
+  sink.text(" union all select ");
+  let started = emitBare(sink, "c", edge.parent, false);
+  emitBare(sink, "c", edge.child, started);
+  sink.text(", w.depth + 1, w.seen || c.");
+  sink.text(quote(identity.sql));
+  sink.text(" from ");
+  sink.text(quote(table.model.sql));
+  sink.text(" c join walk w on ");
+  if (direction === "descendants")
+    emitStep(sink, "c", edge.child, edge.parent, "k");
+  else
+    emitStep(sink, "c", edge.parent, edge.child, "f");
+  sink.text(" where c.");
+  sink.text(quote(identity.sql));
+  sink.text(" <> all(w.seen)");
+  if (depth !== undefined) {
+    sink.text(" and w.depth < ");
+    sink.text(String(depth));
+  }
+  emitWhere(schema, table, undefined, sink, "c", 0, true);
+  sink.text(") select ");
+  let column = 0;
+  for (let index = 0;index < selected.length; index += 1) {
+    const item = selected[index];
+    if (item === undefined)
+      continue;
+    if (column > 0)
+      sink.text(", ");
+    sink.text(projectExpr(`t.${quote(item.sql)}`, item.dataType));
+    sink.mark(`s:${item.field}`);
+    outputs?.fields.push({ key: item.field, at: column, decode: item.decode });
+    column += 1;
+  }
+  if (column === 0)
+    sink.text("1");
+  sink.text(" from ");
+  sink.text(quote(table.model.sql));
+  sink.text(" t join walk w on ");
+  emitStep(sink, "t", edge.parent, edge.parent, "k");
+  if (self)
+    emitWhere(schema, table, call.where, sink, "t", 0, false);
+  else {
+    sink.text(" where w.depth > 0");
+    emitWhere(schema, table, call.where, sink, "t", 0, true);
+  }
+  if (call.orderBy !== undefined) {
+    emitOrder(table, call.orderBy, sink, "t");
+    return;
+  }
+  sink.text(" order by w.depth asc");
+  sink.mark("order:depth");
+  for (const field of table.model.primary) {
+    const item = table.columns.get(field);
+    if (item === undefined)
+      continue;
+    sink.text(", t.");
+    sink.text(quote(item.sql));
+    sink.text(" asc");
+  }
+}
+function emitKeyList(sink, alias, columns, prefix) {
+  for (let index = 0;index < columns.length; index += 1) {
+    const name = columns[index];
+    if (name === undefined)
+      continue;
+    if (index > 0 || prefix === "f")
+      sink.text(", ");
+    sink.text(alias);
+    sink.text(".");
+    sink.text(quote(name));
+    sink.text(" as ");
+    sink.text(prefix);
+    sink.text(String(index));
+  }
+}
+function emitBare(sink, alias, columns, lead) {
+  let started = lead;
+  for (const name of columns) {
+    if (started)
+      sink.text(", ");
+    started = true;
+    sink.text(alias);
+    sink.text(".");
+    sink.text(quote(name));
+  }
+  return started;
+}
+function emitStep(sink, alias, columns, against, prefix) {
+  for (let index = 0;index < columns.length; index += 1) {
+    const name = columns[index];
+    if (name === undefined || against[index] === undefined)
+      continue;
+    if (index > 0)
+      sink.text(" and ");
+    sink.text(alias);
+    sink.text(".");
+    sink.text(quote(name));
+    sink.text(" = w.");
+    sink.text(prefix);
+    sink.text(String(index));
+  }
+}
+function readPacked(options) {
+  if (!isRecord(options) || options.walk !== "descendants" && options.walk !== "ancestors") {
+    fail2("OKM1120", "descendants and ancestors are table methods.");
+  }
+  const user = options.options;
+  if (user === undefined)
+    return { id: options.id, walk: options.walk, user: {} };
+  if (!isRecord(user))
+    fail2("OKM1120", `${options.walk} options must be an object.`);
+  return { id: options.id, walk: options.walk, user };
+}
+function pickEdge(table, relation) {
+  const edges = selfEdges(table);
+  if (edges.length === 0) {
+    fail2("OKM1120", `${table.model.name} has no relation to itself.`, `Declare children: many("${table.model.name}") or parent: one("${table.model.name}").`);
+  }
+  const groups = new Set(edges.map((edge) => edge.child.join("\x00")));
+  if (relation === undefined) {
+    if (groups.size !== 1) {
+      fail2("OKM1120", `${table.model.name} has more than one relation to itself. Pass relation.`, `Accepted names: ${edges.map((edge) => edge.name).join(", ")}.`);
+    }
+    const only = edges[0];
+    if (only === undefined)
+      fail2("OKM1120", `${table.model.name} has no relation to itself.`);
+    return only;
+  }
+  if (typeof relation !== "string" || relation.length === 0) {
+    fail2("OKM1120", "relation must be a name.");
+  }
+  const found = edges.find((edge) => edge.name === relation);
+  if (found === undefined) {
+    throwNamed2("OKM1120", relation, edges.map((edge) => edge.name), `Relation ${relation} is not a self-relation of ${table.model.name}. Accepted names: ${list(edges.map((edge) => edge.name))}.`);
+  }
+  return found;
+}
+function selfEdges(table) {
+  const edges = [];
+  for (const relation of table.model.relations) {
+    if (relation.table !== table.model.name || relation.through !== undefined)
+      continue;
+    edges.push(relation.kind === "many" ? { name: relation.name, parent: relation.local, child: relation.remote } : { name: relation.name, parent: relation.remote, child: relation.local });
+  }
+  return edges;
+}
+function identityColumn2(session, table) {
+  const tenancy = session.schema.tenancy;
+  const keys = tenancy === undefined ? [] : tenancy.keys ?? [tenancy.key];
+  const fields = table.model.primary.filter((field) => !keys.includes(field));
+  if (fields.length !== 1) {
+    fail2("OKM1120", `${table.model.name} needs one primary key column besides the tenant key.`, "Use a single-column primary key.");
+  }
+  const field = fields[0];
+  const column = field === undefined ? undefined : table.columns.get(field);
+  if (column === undefined) {
+    fail2("OKM1120", `${table.model.name} needs one primary key column besides the tenant key.`);
+  }
+  return column;
+}
+function readDepth(value) {
+  if (value === undefined)
+    return;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    fail2("OKM1120", "depth must be an integer from 0 up.");
+  }
+  return value;
+}
+function readSelf(value) {
+  if (value === undefined)
+    return false;
+  if (typeof value !== "boolean")
+    fail2("OKM1120", "self must be true or false.");
+  return value;
+}
+function userId(column, id) {
+  if (id === undefined || id === null) {
+    fail2("OKM1121", `${column.field} needs a value.`);
+  }
+  return id;
+}
+
+export { build2, identityColumn2 };