okmodel 0.7.0 → 0.8.0

package/dist/shared/{xhfsfkgk.js → 4vbf83xx.js}

@@ -1,3 +1,6 @@
+import {
+  emitSqlValue
+} from "./3bb7wsqt.js";
 import {
   assertOperatorFits,
   sqlType,
@@ -11,7 +14,7 @@ import {
   quote,
   isRecord,
   fail2
-} from "./67txcrcw.js";
+} from "./kgwp4jdd.js";
 import {
   isOperator,
   operatorName,
@@ -19,7 +22,11 @@ import {
 } from "./cn0n68ft.js";
 
 // src/runtime/operator-sql.ts
-function emitStructured(column, ref, name, value, sink, order) {
+function emitStructured(table, column, ref, name, value, sink, order) {
+  if (name === "sql") {
+    emitSqlValue(table, ref, value, sink);
+    return;
+  }
   if (name === "contains" || name === "containedBy" || name === "overlaps") {
     emitContainment(column, ref, name, value, sink);
     return;

package/dist/shared/{bg3rym3g.js → 63f4ksbz.js}

@@ -1,7 +1,7 @@
 import {
   touchFields,
   fieldSealed
-} from "./1w508jbr.js";
+} from "./bxas03mq.js";
 import {
   projectExpr,
   quote,
@@ -9,7 +9,7 @@ import {
   isRecord,
   registerFailFix,
   fail2
-} from "./67txcrcw.js";
+} from "./kgwp4jdd.js";
 import {
   throwNamed2
 } from "./52szzakm.js";

package/dist/shared/{pt94kz7f.js → 6m78c8ss.js}

@@ -1,6 +1,6 @@
 import {
   build3
-} from "./pbp1ss85.js";
+} from "./n0jmpgj1.js";
 export {
   build3 as build
 };

package/dist/shared/{5e3tf63j.js → 760ppr76.js}

@@ -1,14 +1,14 @@
 import {
   encodeUuid,
   decodeUuid
-} from "./hyh73qk6.js";
+} from "./ecn8mfdq.js";
 import {
   encodeText,
   decodeText
-} from "./ed0b8k4s.js";
+} from "./typ3vy7t.js";
 import {
   snakeCase
-} from "./rpycarcr.js";
+} from "./gcefca6p.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -28,19 +28,27 @@ function viewMentions(query, name) {
   pattern += '"?(?![A-Za-z0-9_])';
   return new RegExp(pattern).test(query);
 }
+function readColumns(source) {
+  return typeof source === "function" ? source() : source;
+}
+function readQuery(source) {
+  return typeof source === "function" ? source() : source;
+}
 function viewClient(name, columns, query, tenancy, refresh = "plain") {
   const field = camelCase(name);
   const marked = readGlobal(name, tenancy);
   return {
     field,
     install(model, scope, tables, casing, scoped) {
+      const listed = readColumns(columns);
+      const text = readQuery(query);
       if (Object.hasOwn(model, field)) {
         throw new OkmError2("OKM1023", `View ${name} uses the client name ${field}.`, {
           fix: { summary: "Give the view a name that no table uses." }
         });
       }
-      const exposes = exposesKey(columns, scope);
-      if (scope !== undefined && readsTenant(query, tables, casing, scoped)) {
+      const exposes = exposesKey(listed, scope);
+      if (scope !== undefined && readsTenant(text, tables, casing, scoped)) {
         if (!exposes && marked === undefined) {
           throw new OkmError2("OKM1820", `View ${name} reads a tenant table and does not expose ${scope.key}.`, {
             fix: {
@@ -58,7 +66,7 @@ function viewClient(name, columns, query, tenancy, refresh = "plain") {
         sql: name,
         primary: [],
         uniques: [],
-        columns: columnModels(columns, scope),
+        columns: columnModels(listed, scope),
         relations: []
       };
       if (marked !== undefined)

package/dist/shared/{zm0ptry0.js → 7ghwamrf.js}

@@ -3,7 +3,7 @@ import {
 } from "./cnkky55j.js";
 import {
   rejectClosed
-} from "./kb2sdhfb.js";
+} from "./ae4j5f42.js";
 
 // src/adapters/pg/reserved.ts
 var RESET_ALL = "RESET ALL";

package/dist/shared/{xnxsed62.js → 9dr2qnx7.js}

@@ -6,27 +6,33 @@ import {
   minPostgresDefinition,
   uuidv7NeedsPostgres
 } from "./ga9j92qj.js";
-import {
-  catalog,
-  enumType,
-  sameEnumLabels
-} from "./ywspezzx.js";
 import {
   isRelationCall
 } from "./exn3sd90.js";
 import {
   encodeText,
   decodeText
-} from "./ed0b8k4s.js";
+} from "./typ3vy7t.js";
 import {
   snakeCase,
   emittedTypeName,
   rejectLater
-} from "./rpycarcr.js";
+} from "./gcefca6p.js";
 import {
   ColumnBuilder2,
   formatType
-} from "./ywr8hmey.js";
+} from "./606g0nbf.js";
+import {
+  readClientGenerator
+} from "./rwmrejjz.js";
+import {
+  withLocation
+} from "./y6jdds7g.js";
+import {
+  catalog,
+  enumType,
+  sameEnumLabels
+} from "./ywspezzx.js";
 import {
   definition,
   unavailable
@@ -34,9 +40,6 @@ import {
 import {
   quoteLiteral
 } from "./94ez8kzh.js";
-import {
-  withLocation
-} from "./y6jdds7g.js";
 import {
   staticNamespace2,
   table3,
@@ -56,9 +59,6 @@ import {
   catalogError2,
   throwNamed2
 } from "./52szzakm.js";
-import {
-  readClientGenerator
-} from "./rwmrejjz.js";
 
 // src/dialects/pg/compile.ts
 function compileColumn(builder, input) {

package/dist/shared/{h15jx9bc.js → 9dvh1dr6.js}

@@ -1,6 +1,6 @@
 import {
   validationGate
-} from "./ze4hxsmy.js";
+} from "./w9ejzaqf.js";
 import {
   isOperator
 } from "./cn0n68ft.js";

package/dist/shared/{q5c6ngn3.js → a62rb2da.js}

@@ -1,6 +1,6 @@
 import {
   fail2
-} from "./67txcrcw.js";
+} from "./kgwp4jdd.js";
 
 // src/runtime/result-name.ts
 var PROTOTYPE_KEYS = ",__proto__,constructor,toString,hasOwnProperty,valueOf,isPrototypeOf,propertyIsEnumerable,toLocaleString,__defineGetter__,__defineSetter__,__lookupGetter__,__lookupSetter__,then,";

package/dist/shared/{kb2sdhfb.js → ae4j5f42.js}

@@ -31,6 +31,22 @@ var BUNSQL_CAPABILITIES = {
   prepared: "unnamed",
   describe: false
 };
+var NEON_WEBSOCKET_CAPABILITIES = {
+  transactions: "interactive",
+  stream: false,
+  listen: false,
+  cancel: false,
+  prepared: "unnamed",
+  describe: false
+};
+var NEON_HTTP_CAPABILITIES = {
+  transactions: "batch",
+  stream: false,
+  listen: false,
+  cancel: false,
+  prepared: "none",
+  describe: false
+};
 function readCapability2(flags, name) {
   return flags[name];
 }
@@ -166,4 +182,4 @@ function countFrom(value, rows) {
   return rows;
 }
 
-export { POSTGRESJS_CAPABILITIES, PGLITE_CAPABILITIES, NODE_POSTGRES_CAPABILITIES, BUNSQL_CAPABILITIES, readCapability2, hasCapability2, driverErrors, rejectClosed, rejectUncancellable, rejectCancelled, rejectTimedOut, mapFailure, nextTransactionDepth, runCall, EMPTY_NOTICES, rowsFrom, resultFrom };
+export { POSTGRESJS_CAPABILITIES, PGLITE_CAPABILITIES, NODE_POSTGRES_CAPABILITIES, BUNSQL_CAPABILITIES, NEON_WEBSOCKET_CAPABILITIES, NEON_HTTP_CAPABILITIES, readCapability2, hasCapability2, driverErrors, rejectClosed, rejectUncancellable, rejectCancelled, rejectTimedOut, mapFailure, nextTransactionDepth, runCall, EMPTY_NOTICES, rowsFrom, resultFrom };

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/{7k9grvf6.js → b6d6p0zc.js}

@@ -1,13 +1,13 @@
-import {
-  renderCatalog
-} from "./9s0ypp87.js";
 import {
   viewGlobalReason,
   viewMentions
-} from "./5e3tf63j.js";
+} from "./760ppr76.js";
+import {
+  renderCatalog
+} from "./sjk86yrx.js";
 import {
   createClient
-} from "./tbrvgw6z.js";
+} from "./bah9nbg3.js";
 import {
   OkmError2
 } from "./52szzakm.js";

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

@@ -8,7 +8,7 @@ import {
   logicalIntent,
   appliedRules,
   rejectKeys
-} from "./67txcrcw.js";
+} from "./kgwp4jdd.js";
 import {
   OkmError2,
   safe2,
@@ -86,7 +86,7 @@ function openClient(session) {
     },
     close,
     connected: session.connected,
-    tx: (...args) => import("./vczs8gd4.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
   };
@@ -121,7 +121,7 @@ function tableApi(session, table, view, uses) {
   const api = {
     find(options = {}) {
       if ("lock" in options) {
-        return lazyRead(session, () => import("./sfz1ksn6.js"), table, options, base, view);
+        return lazyRead(session, () => import("./k86n8vq3.js"), table, options, base, view);
       }
       return start(session, "find", table, options, base, view);
     },
@@ -135,10 +135,10 @@ function tableApi(session, table, view, uses) {
       return start(session, "exists", table, options, base, view);
     },
     page(options) {
-      return lazyRead(session, () => import("./pt94kz7f.js"), table, options, base, view);
+      return lazyRead(session, () => import("./6m78c8ss.js"), table, options, base, view);
     },
     aggregate(options = {}) {
-      return lazyRead(session, () => import("./1est4ezg.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);
@@ -151,9 +151,9 @@ function tableApi(session, table, view, uses) {
     }
   };
   for (const walk of ["descendants", "ancestors"]) {
-    api[walk] = (id, options) => lazyRead(session, () => import("./7mnme5tn.js"), table, { id, walk, options }, base, view);
+    api[walk] = (id, options) => lazyRead(session, () => import("./wz2a78mp.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);
+  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) {
@@ -169,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("./vb6qfyve.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("./5v3xf80k.js");
+  writers ??= import("./qd9hhd8f.js");
   return writers;
 }
 function queryHandle(run, extra) {
@@ -288,7 +289,7 @@ function lazyRead(session, load, table, options, mods, view, sync) {
   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("./dkxgzaqd.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;
@@ -301,14 +302,14 @@ function readHandle(session, table, call, mods, decode, extra) {
       call = (await import("./m7n9h2a5.js")).refine(session.schema, origin, mods.uses);
     }
     if (searched) {
-      call = (await import("./jznfax0y.js")).applyTextSearch(session.schema, call);
+      call = (await import("./zq1he88x.js")).applyTextSearch(session.schema, call);
     }
     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);
+      call = (await import("./1d9q9cv2.js")).attach(session.schema, call);
     }
     const bound = bindCall(session.schema, call, hooks);
     let plan = session.cache.get(bound.key);
@@ -371,7 +372,7 @@ function readHandle(session, table, call, mods, decode, extra) {
 }
 function streamLazy(session, call, mods, view, batch) {
   return async function* () {
-    const { streamRows } = await import("./cn957f8d.js");
+    const { streamRows } = await import("./jebgrkeq.js");
     yield* streamRows(session, call, mods, view, batch, (error) => logged(session, error));
   }();
 }
@@ -404,7 +405,7 @@ function readCall(op, table, options, all, scope, model, schema, view) {
   };
 }
 async function checkServer(pool, schema, http, requireMeta, options, source) {
-  const server = await import("./ttsqgp4p.js");
+  const server = await import("./fjpnhqan.js");
   let rows;
   try {
     const result = await pool.execute(server.versionQuery, undefined, options);
@@ -433,7 +434,7 @@ function errorFields(error) {
 var includeHooks;
 var operatorSql;
 function loadOperatorSql() {
-  operatorSql ??= import("./xhfsfkgk.js").then(() => {
+  operatorSql ??= import("./4vbf83xx.js").then(() => {
     return;
   });
   return operatorSql;
@@ -444,7 +445,7 @@ function selectHasWindow(select) {
 function hooksFor(call) {
   if (call.include === undefined)
     return Promise.resolve(undefined);
-  includeHooks ??= import("./dkxgzaqd.js").then((mod) => mod.includeHooks);
+  includeHooks ??= import("./hqpxf4a4.js").then((mod) => mod.includeHooks);
   return includeHooks;
 }
 function bindNow(schema, call) {

package/dist/shared/{5fe3kbsh.js → bnby0esn.js}

@@ -2,7 +2,7 @@ import {
   resetSession2,
   resetQueried2,
   refuseWhenLost2
-} from "./zm0ptry0.js";
+} from "./7ghwamrf.js";
 export {
   refuseWhenLost2 as refuseWhenLost,
   resetQueried2 as resetQueried,