okmodel 0.6.0 → 0.8.0

package/dist/shared/agsfb86s.js

@@ -0,0 +1,233 @@
+import {
+  outcomeUnknown2
+} from "./cm3w0ywp.js";
+import {
+  noTimeout
+} from "./q0cqt2sp.js";
+import {
+  noticeBuffer,
+  WireSession
+} from "./mtw6jz76.js";
+import {
+  NEON_WEBSOCKET_CAPABILITIES,
+  NEON_HTTP_CAPABILITIES,
+  driverErrors,
+  rejectClosed,
+  mapFailure,
+  runCall,
+  EMPTY_NOTICES,
+  resultFrom
+} from "./ae4j5f42.js";
+
+// src/adapters/pg/neon.ts
+import {
+  Pool,
+  neon,
+  neonConfig
+} from "@neondatabase/serverless";
+var CONNECT_MS = 30000;
+var WIRE = {
+  getTypeParser() {
+    return (value) => value;
+  }
+};
+var names = new Map;
+async function open6(config) {
+  if (config.mode === "http")
+    return openHttp(config);
+  return openWebSocket(config);
+}
+function connectClient2(pool, acquireMs, counters) {
+  counters.waiting += 1;
+  let settled = false;
+  return new Promise((resolve, reject) => {
+    let timer;
+    if (acquireMs !== undefined) {
+      timer = setTimeout(() => {
+        settled = true;
+        counters.waiting = Math.max(0, counters.waiting - 1);
+        driverErrors().then((errors) => {
+          reject(errors.acquireTimeout());
+        });
+      }, acquireMs);
+    }
+    take(pool).then((client) => {
+      if (settled) {
+        client.release();
+        return;
+      }
+      if (timer !== undefined)
+        clearTimeout(timer);
+      counters.waiting = Math.max(0, counters.waiting - 1);
+      resolve(client);
+    }, (error) => {
+      if (settled)
+        return;
+      if (timer !== undefined)
+        clearTimeout(timer);
+      counters.waiting = Math.max(0, counters.waiting - 1);
+      mapFailure(error).then(reject);
+    });
+  });
+}
+function send3(runner, text, params, named) {
+  const query = {
+    text,
+    rowMode: "array",
+    types: WIRE,
+    ...params !== undefined && params.length > 0 ? { values: params } : {},
+    ...named ? { name: statementName(text) } : {}
+  };
+  return runner.query(query);
+}
+async function openWebSocket(config) {
+  ensureWebSocket();
+  const max = config.max ?? 10;
+  const acquireMs = config.timeouts?.acquire;
+  const counters = { reserved: 0, busy: 0, reservedBusy: 0, waiting: 0 };
+  const notices = noticeBuffer();
+  let closed = false;
+  const isClosed = () => closed;
+  const named = config.prepared === "named";
+  const pool = new Pool({
+    connectionString: config.url,
+    max,
+    idleTimeoutMillis: 0,
+    allowExitOnIdle: true,
+    connectionTimeoutMillis: CONNECT_MS,
+    application_name: "okmodel",
+    types: WIRE,
+    ...config.searchPath !== undefined ? { options: `-c search_path=${config.searchPath}` } : {}
+  });
+  pool.on("error", () => {
+    return;
+  });
+  try {
+    const warmed = await take(pool);
+    warmed.release();
+  } catch (error) {
+    await pool.end().catch(() => {
+      return;
+    });
+    throw await mapFailure(error);
+  }
+  const root = new WireSession((text, params) => send3(pool, text, params, named), notices, isClosed, false, () => {
+    counters.busy += 1;
+  }, () => {
+    counters.busy = Math.max(0, counters.busy - 1);
+  });
+  const held = { pool, acquireMs, counters, notices, named, isClosed };
+  const checkout = () => closed ? rejectClosed() : import("./jx2m62cs.js").then((mod) => mod.checkout(held));
+  return {
+    capabilities: NEON_WEBSOCKET_CAPABILITIES,
+    execute(text, params, options) {
+      const refused = noTimeout(options);
+      if (refused !== undefined)
+        return refused;
+      return runCall(closed, options, (watch) => root.query(text, params, watch));
+    },
+    async batch(statements, options) {
+      const refused = noTimeout(options);
+      if (refused !== undefined)
+        return refused;
+      const connection = await checkout();
+      try {
+        return await connection.batch(statements, options);
+      } finally {
+        await connection.release();
+      }
+    },
+    reserve: () => checkout(),
+    stats: () => statsOf(counters, max),
+    async close() {
+      closed = true;
+      await pool.end();
+    }
+  };
+}
+function openHttp(config) {
+  const max = config.max ?? 10;
+  const counters = { reserved: 0, busy: 0, reservedBusy: 0, waiting: 0 };
+  let closed = false;
+  const sql = neon(config.url, { arrayMode: true, fullResults: true });
+  const run = async (text, params) => {
+    counters.busy += 1;
+    try {
+      const result = await sql.query(text, params === undefined ? [] : [...params]);
+      return resultFrom(result, EMPTY_NOTICES);
+    } finally {
+      counters.busy = Math.max(0, counters.busy - 1);
+    }
+  };
+  return {
+    capabilities: NEON_HTTP_CAPABILITIES,
+    execute(text, params, options) {
+      const refused = noTimeout(options);
+      if (refused !== undefined)
+        return refused;
+      if (closed)
+        return rejectClosed();
+      return runCall(closed, options, () => run(text, params).catch((error) => mapFailure(error).then((mapped) => Promise.reject(mapped))));
+    },
+    async batch(statements, options) {
+      const refused = noTimeout(options);
+      if (refused !== undefined)
+        return refused;
+      if (closed)
+        return rejectClosed();
+      counters.busy += 1;
+      try {
+        const queries = statements.map((statement) => sql.query(statement.text, statement.params === undefined ? [] : [...statement.params]));
+        const results = await sql.transaction(queries, httpOptions());
+        return results.map((result) => resultFrom(result, EMPTY_NOTICES));
+      } catch (error) {
+        if (!isDatabaseError(error))
+          throw outcomeUnknown2(error);
+        throw await mapFailure(error);
+      } finally {
+        counters.busy = Math.max(0, counters.busy - 1);
+      }
+    },
+    stats: () => statsOf(counters, max),
+    close() {
+      closed = true;
+      return Promise.resolve();
+    }
+  };
+}
+function httpOptions() {
+  return { arrayMode: true, fullResults: true };
+}
+function isDatabaseError(error) {
+  if (typeof error !== "object" || error === null)
+    return false;
+  const code = Reflect.get(error, "code");
+  return typeof code === "string" && /^[0-9A-Z]{5}$/.test(code);
+}
+function take(pool) {
+  const connect = pool.connect.bind(pool);
+  return connect();
+}
+function ensureWebSocket() {
+  if (neonConfig.webSocketConstructor === undefined && typeof WebSocket === "function") {
+    neonConfig.webSocketConstructor = WebSocket;
+  }
+}
+function statementName(text) {
+  const existing = names.get(text);
+  if (existing !== undefined)
+    return existing;
+  const name = `okm_${String(names.size)}`;
+  names.set(text, name);
+  return name;
+}
+function statsOf(counters, size) {
+  return {
+    size,
+    idle: Math.max(0, size - counters.reserved - counters.busy),
+    inflight: counters.busy + counters.reservedBusy,
+    waiting: counters.waiting
+  };
+}
+
+export { open6, connectClient2, send3 };

package/dist/shared/{8x72s86k.js → b6d6p0zc.js}

@@ -1,13 +1,13 @@
-import {
-  renderCatalog
-} from "./9s0ypp87.js";
 import {
   viewGlobalReason,
   viewMentions
-} from "./x3jc53kg.js";
+} from "./760ppr76.js";
+import {
+  renderCatalog
+} from "./sjk86yrx.js";
 import {
   createClient
-} from "./j60w0dvr.js";
+} from "./bah9nbg3.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -641,7 +641,10 @@ async function readTenant(facts, handle, where) {
           leak(facts.name, "stream", item);
       }
     } catch (error) {
-      if (!(error instanceof OkmError2) || error.code !== "OKM1111")
+      if (!(error instanceof OkmError2))
+        throw error;
+      const refused = error.code === "OKM1111" || error.code === "OKM1120" && error.message.includes("primary key");
+      if (!refused)
         throw error;
     }
   }
@@ -988,7 +991,10 @@ async function readFiltered(name, handle, where) {
           leak(name, "stream", item);
       }
     } catch (error) {
-      if (!(error instanceof OkmError2) || error.code !== "OKM1111")
+      if (!(error instanceof OkmError2))
+        throw error;
+      const refused = error.code === "OKM1111" || error.code === "OKM1120" && error.message.includes("primary key");
+      if (!refused)
         throw error;
     }
   }

package/dist/shared/{ag4c7516.js → b76b8d95.js}

@@ -2,10 +2,10 @@ import {
   DriverError2,
   outcomeUnknown2,
   mapDriverError2
-} from "./31vm914h.js";
+} from "./cm3w0ywp.js";
 import {
   isConnectionLost
-} from "./gwn6v667.js";
+} from "./cnkky55j.js";
 
 // src/adapters/pg/batch.ts
 var savepointIds = 0;

package/dist/shared/{j60w0dvr.js → bah9nbg3.js}

@@ -6,8 +6,9 @@ import {
   compileCall,
   decodeResult,
   logicalIntent,
-  appliedRules
-} from "./2z7wv5tj.js";
+  appliedRules,
+  rejectKeys
+} from "./kgwp4jdd.js";
 import {
   OkmError2,
   safe2,
@@ -85,7 +86,7 @@ function openClient(session) {
     },
     close,
     connected: session.connected,
-    tx: (...args) => import("./5d8t84hg.js").then((mod) => mod.tx(session, args)),
+    tx: (...args) => import("./v1wad97q.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("./r11n8grd.js"), table, options, base, view);
+        return lazyRead(session, () => import("./k86n8vq3.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("./pjr6xrm5.js"), table, options, base, view);
+      return lazyRead(session, () => import("./6m78c8ss.js"), table, options, base, view);
     },
     aggregate(options = {}) {
-      return lazyRead(session, () => import("./venqrjna.js"), table, options, base, view);
+      return lazyRead(session, () => import("./n05z9nwz.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("./wz2a78mp.js"), table, { id, walk, options }, base, view);
+  }
+  api.sync = (id, relation, ids, options) => lazyRead(session, () => import("./p5nh3r8q.js"), table, { id, relation, ids, options }, base, view, true);
   const hooks = session.schema.hooks;
   if (hooks !== undefined) {
     for (const hook of hooks) {
@@ -164,16 +169,17 @@ function tableApi(session, table, view, uses) {
   for (const name in session.schema.model[table]?.presets) {
     api[name] = (...args) => tableApi(session, table, view, [uses, name, args]);
   }
+  api[Symbol.for("okm.lane")] = [session, table, mapError];
   return api;
 }
 function batchHandle(session, ops, options, replica) {
-  return queryHandle(() => import("./sbdme3vy.js").then((mod) => mod.batch(session, ops, options, replica)), {
+  return queryHandle(() => import("./e8zyaqvj.js").then((mod) => mod.batch(session, ops, options, replica)), {
     replica: () => batchHandle(session, ops, options, true)
   });
 }
 var writers;
 function loadWrite() {
-  writers ??= import("./2cg3wnxc.js");
+  writers ??= import("./qd9hhd8f.js");
   return writers;
 }
 function queryHandle(run, extra) {
@@ -258,41 +264,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("./ys0xzyaj.js")).decodeIncluded(plan, rows, table);
+  return plan.outputs.includes.length === 0 ? decodeResult(plan, rows, table) : (await import("./hqpxf4a4.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("./zq1he88x.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("./1d9q9cv2.js")).attach(session.schema, call);
+    }
     const bound = bindCall(session.schema, call, hooks);
     let plan = session.cache.get(bound.key);
     if (plan === undefined) {
@@ -307,7 +325,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 +370,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("./3qnhc7w5.js");
-    yield* streamRows(session, call, prepare, (error) => logged(session, error));
+    const { streamRows } = await import("./jebgrkeq.js");
+    yield* streamRows(session, call, mods, view, batch, (error) => logged(session, error));
   }();
 }
 function archiveRecord(model, view) {
@@ -368,12 +386,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 +395,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,13 +405,13 @@ function readCall(op, table, options, all, scope, model, schema, view) {
   };
 }
 async function checkServer(pool, schema, http, requireMeta, options, source) {
-  const server = await import("./y2t3jktd.js");
+  const server = await import("./fjpnhqan.js");
   let rows;
   try {
     const result = await pool.execute(server.versionQuery, undefined, options);
     rows = result.rows;
   } catch (error) {
-    const { mapPostgresError } = await import("./d5azex6s.js");
+    const { mapPostgresError } = await import("./63qtkrca.js");
     throw mapPostgresError(error, mapOptions(http, false, schema));
   }
   await server.acceptServer(pool, schema, rows, http, requireMeta, options, source);
@@ -406,7 +420,7 @@ 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("./d5azex6s.js");
+  const { mapPostgresError } = await import("./63qtkrca.js");
   return mapPostgresError(error, mapOptions(session.http, session.includeValues, session.schema));
 }
 function errorFields(error) {
@@ -420,15 +434,18 @@ function errorFields(error) {
 var includeHooks;
 var operatorSql;
 function loadOperatorSql() {
-  operatorSql ??= import("./n076ydsc.js").then(() => {
+  operatorSql ??= import("./4vbf83xx.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("./ys0xzyaj.js").then((mod) => mod.includeHooks);
+  includeHooks ??= import("./hqpxf4a4.js").then((mod) => mod.includeHooks);
   return includeHooks;
 }
 function bindNow(schema, call) {
@@ -461,12 +478,15 @@ 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, schema) {

package/dist/shared/bnby0esn.js

@@ -0,0 +1,10 @@
+import {
+  resetSession2,
+  resetQueried2,
+  refuseWhenLost2
+} from "./7ghwamrf.js";
+export {
+  refuseWhenLost2 as refuseWhenLost,
+  resetQueried2 as resetQueried,
+  resetSession2 as resetSession
+};