okmodel 0.5.1 → 0.7.0

package/dist/shared/{hf22e0wt.js → tbrvgw6z.js}

@@ -6,8 +6,9 @@ import {
   compileCall,
   decodeResult,
   logicalIntent,
-  appliedRules
-} from "./gbtcc2d7.js";
+  appliedRules,
+  rejectKeys
+} from "./67txcrcw.js";
 import {
   OkmError2,
   safe2,
@@ -85,7 +86,7 @@ function openClient(session) {
     },
     close,
     connected: session.connected,
-    tx: (...args) => import("./r2sp8hrc.js").then((mod) => mod.tx(session, args)),
+    tx: (...args) => import("./vczs8gd4.js").then((mod) => mod.tx(session, args)),
     batch: (ops, options) => batchHandle(session, ops, options),
     ...session.tx?.extras
   };
@@ -120,7 +121,7 @@ function tableApi(session, table, view, uses) {
   const api = {
     find(options = {}) {
       if ("lock" in options) {
-        return lazyRead(session, () => import("./tm5ab8we.js"), table, options, base, view);
+        return lazyRead(session, () => import("./sfz1ksn6.js"), table, options, base, view);
       }
       return start(session, "find", table, options, base, view);
     },
@@ -134,10 +135,10 @@ function tableApi(session, table, view, uses) {
       return start(session, "exists", table, options, base, view);
     },
     page(options) {
-      return lazyRead(session, () => import("./6rk2gen5.js"), table, options, base, view);
+      return lazyRead(session, () => import("./pt94kz7f.js"), table, options, base, view);
     },
     aggregate(options = {}) {
-      return lazyRead(session, () => import("./kfjp0gck.js"), table, options, base, view);
+      return lazyRead(session, () => import("./1est4ezg.js"), table, options, base, view);
     },
     insert(data, options = {}) {
       return writeHandle(session, "insert", table, data, options, mods);
@@ -149,6 +150,10 @@ function tableApi(session, table, view, uses) {
       return writeHandle(session, "delete", table, target, options, mods);
     }
   };
+  for (const walk of ["descendants", "ancestors"]) {
+    api[walk] = (id, options) => lazyRead(session, () => import("./7mnme5tn.js"), table, { id, walk, options }, base, view);
+  }
+  api.sync = (id, relation, ids, options) => lazyRead(session, () => import("./te5as7z7.js"), table, { id, relation, ids, options }, base, view, true);
   const hooks = session.schema.hooks;
   if (hooks !== undefined) {
     for (const hook of hooks) {
@@ -167,13 +172,13 @@ function tableApi(session, table, view, uses) {
   return api;
 }
 function batchHandle(session, ops, options, replica) {
-  return queryHandle(() => import("./aj2qxyhj.js").then((mod) => mod.batch(session, ops, options, replica)), {
+  return queryHandle(() => import("./vb6qfyve.js").then((mod) => mod.batch(session, ops, options, replica)), {
     replica: () => batchHandle(session, ops, options, true)
   });
 }
 var writers;
 function loadWrite() {
-  writers ??= import("./qm7cdtvr.js");
+  writers ??= import("./5v3xf80k.js");
   return writers;
 }
 function queryHandle(run, extra) {
@@ -258,41 +263,53 @@ function start(session, op, table, options, mods, view) {
       throw new OkmError2("not_found", `one() on ${table} matched no row.`, withHttp(session.http, { kind: "not_found", table }));
     }
     return value;
-  }, (prepare) => ({
+  }, () => ({
     all(reason) {
       return start(session, op, table, options, { ...mods, all: reason }, view);
     },
     required() {
       return start(session, op, table, options, { ...mods, required: true }, view);
     },
-    stream() {
-      return streamLazy(session, call, prepare);
+    stream(batch) {
+      return streamLazy(session, call, mods, view, batch);
     }
   }));
 }
-function lazyRead(session, load, table, options, mods, view) {
+function lazyRead(session, load, table, options, mods, view, sync) {
   const read = () => load().then((mod) => ({ it: mod.build(session, table, options, mods, view) }));
-  return queryHandle(() => read().then((box) => box.it), {
-    inspect: () => read().then((box) => box.it.inspect()),
-    sql: () => read().then((box) => box.it.sql()),
-    all: (reason) => lazyRead(session, load, table, options, { ...mods, all: reason }, view)
-  });
+  const sql = () => read().then((box) => box.it.sql());
+  const extra = { sql };
+  if (sync) {
+    extra.expect = (count) => lazyRead(session, load, table, options, { ...mods, expect: count }, view, true);
+  } else {
+    extra.inspect = () => read().then((box) => box.it.inspect());
+    extra.all = (reason) => lazyRead(session, load, table, options, { ...mods, all: reason }, view);
+  }
+  return queryHandle(() => read().then((box) => box.it), extra);
 }
 async function decodeRows(plan, rows, table) {
-  return plan.outputs.includes.length === 0 ? decodeResult(plan, rows, table) : (await import("./nkaxvt9q.js")).decodeIncluded(plan, rows, table);
+  return plan.outputs.includes.length === 0 ? decodeResult(plan, rows, table) : (await import("./dkxgzaqd.js")).decodeIncluded(plan, rows, table);
 }
 function readHandle(session, table, call, mods, decode, extra) {
   let prepared;
   const origin = call;
+  const searched = "search" in call;
   const prepare = async () => {
     if (prepared !== undefined)
       return prepared;
     if (mods.uses !== undefined) {
-      call = (await import("./r6nwkxnt.js")).refine(session.schema, origin, mods.uses);
+      call = (await import("./m7n9h2a5.js")).refine(session.schema, origin, mods.uses);
+    }
+    if (searched) {
+      call = (await import("./jznfax0y.js")).applyTextSearch(session.schema, call);
     }
-    if (readNeedsOperatorSql(session.schema, call))
-      await loadOperatorSql();
     const hooks = await hooksFor(call);
+    if (readNeedsOperatorSql(session.schema, call) || hooks?.needsOperator(session.schema, call)) {
+      await loadOperatorSql();
+    }
+    if (call.build === undefined && selectHasWindow(call.select)) {
+      call = (await import("./gzaveazc.js")).attach(session.schema, call);
+    }
     const bound = bindCall(session.schema, call, hooks);
     let plan = session.cache.get(bound.key);
     if (plan === undefined) {
@@ -307,7 +324,7 @@ function readHandle(session, table, call, mods, decode, extra) {
     prepared = { plan, params: bound.params };
     return prepared;
   };
-  const sync = () => call.include === undefined && mods.uses === undefined && !readNeedsOperatorSql(session.schema, call);
+  const sync = () => !searched && call.include === undefined && mods.uses === undefined && !selectHasWindow(call.select) && !readNeedsOperatorSql(session.schema, call);
   const run = async () => {
     await session.connected;
     const { plan, params } = await prepare();
@@ -352,10 +369,10 @@ function readHandle(session, table, call, mods, decode, extra) {
     ...extra?.(prepare)
   });
 }
-function streamLazy(session, call, prepare) {
+function streamLazy(session, call, mods, view, batch) {
   return async function* () {
-    const { streamRows } = await import("./zqrnhwsq.js");
-    yield* streamRows(session, call, prepare, (error) => logged(session, error));
+    const { streamRows } = await import("./cn957f8d.js");
+    yield* streamRows(session, call, mods, view, batch, (error) => logged(session, error));
   }();
 }
 function archiveRecord(model, view) {
@@ -368,12 +385,7 @@ function archiveRecord(model, view) {
 }
 function readCall(op, table, options, all, scope, model, schema, view) {
   const record = options;
-  const accepted = readOptionNames(op);
-  for (const key of Object.keys(record)) {
-    if (!accepted.includes(key)) {
-      throwNamed2("OKM1120", key, accepted, `Option ${key} is not accepted by ${op}. Accepted options: ${accepted.join(", ")}.`);
-    }
-  }
+  rejectKeys(record, readOptionNames(op), op, true);
   return {
     op,
     table,
@@ -382,6 +394,7 @@ function readCall(op, table, options, all, scope, model, schema, view) {
     ...record.orderBy !== undefined ? { orderBy: record.orderBy } : {},
     ...record.limit !== undefined ? { limit: record.limit } : {},
     ...record.include !== undefined ? { include: record.include } : {},
+    ..."search" in record ? { search: record.search } : {},
     ...callOptions(record),
     ...all !== undefined ? { all } : {},
     ...scope !== undefined ? { scope } : {},
@@ -391,14 +404,14 @@ function readCall(op, table, options, all, scope, model, schema, view) {
   };
 }
 async function checkServer(pool, schema, http, requireMeta, options, source) {
-  const server = await import("./47x8x9ze.js");
+  const server = await import("./ttsqgp4p.js");
   let rows;
   try {
     const result = await pool.execute(server.versionQuery, undefined, options);
     rows = result.rows;
   } catch (error) {
-    const { mapPostgresError } = await import("./51mvgj8w.js");
-    throw mapPostgresError(error, mapOptions(http, false));
+    const { mapPostgresError } = await import("./63qtkrca.js");
+    throw mapPostgresError(error, mapOptions(http, false, schema));
   }
   await server.acceptServer(pool, schema, rows, http, requireMeta, options, source);
 }
@@ -406,8 +419,8 @@ async function mapError(session, error) {
   if (error instanceof OkmError2) {
     return session.http === undefined ? error : new OkmError2(error.code, error.message, { ...errorFields(error), http: session.http });
   }
-  const { mapPostgresError } = await import("./51mvgj8w.js");
-  return mapPostgresError(error, mapOptions(session.http, session.includeValues));
+  const { mapPostgresError } = await import("./63qtkrca.js");
+  return mapPostgresError(error, mapOptions(session.http, session.includeValues, session.schema));
 }
 function errorFields(error) {
   return {
@@ -420,15 +433,18 @@ function errorFields(error) {
 var includeHooks;
 var operatorSql;
 function loadOperatorSql() {
-  operatorSql ??= import("./cr74e96e.js").then(() => {
+  operatorSql ??= import("./xhfsfkgk.js").then(() => {
     return;
   });
   return operatorSql;
 }
+function selectHasWindow(select) {
+  return Array.isArray(select) && select.some((item) => typeof item !== "string");
+}
 function hooksFor(call) {
   if (call.include === undefined)
     return Promise.resolve(undefined);
-  includeHooks ??= import("./nkaxvt9q.js").then((mod) => mod.includeHooks);
+  includeHooks ??= import("./dkxgzaqd.js").then((mod) => mod.includeHooks);
   return includeHooks;
 }
 function bindNow(schema, call) {
@@ -461,18 +477,22 @@ function attachHttp(http, error) {
 function callOptions(input, statement) {
   const timeout = input.timeout ?? statement;
   const route = input.route;
-  if (input.signal === undefined && timeout === undefined && route === undefined)
+  const pin = input.pin;
+  if (input.signal === undefined && timeout === undefined && route === undefined && pin === undefined) {
     return;
+  }
   return {
     ...input.signal !== undefined ? { signal: input.signal } : {},
     ...timeout !== undefined ? { timeout } : {},
-    ...route !== undefined ? { route } : {}
+    ...route !== undefined ? { route } : {},
+    ...pin !== undefined ? { pin } : {}
   };
 }
-function mapOptions(http, includeValues) {
+function mapOptions(http, includeValues, schema) {
   return {
     ...http !== undefined ? { http } : {},
-    ...includeValues ? { includeValues: true } : {}
+    ...includeValues ? { includeValues: true } : {},
+    schema
   };
 }
 async function settleCall(session, error) {