okmodel 0.5.0 → 0.6.0

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

@@ -1,15 +1,18 @@
+import {
+  noTimeout2
+} from "./8dqhth8c.js";
 import {
   noticeBuffer,
   WireSession,
   cursorStream
-} from "./zvbjc949.js";
+} from "./4az561fn.js";
 import {
   BUNSQL_CAPABILITIES,
   driverErrors,
   rejectClosed,
   mapFailure,
   runCall
-} from "./rrstp3kb.js";
+} from "./cgbamx3e.js";
 
 // src/adapters/pg/bunsql.ts
 import { SQL } from "bun";
@@ -41,16 +44,18 @@ function open5(config) {
     counters.busy = Math.max(0, counters.busy - 1);
   });
   const held = { sql, parked, acquireMs, counters, notices, isClosed };
-  const checkout = () => closed ? rejectClosed() : import("./4ef7mmqf.js").then((mod) => mod.checkout(held));
+  const checkout = () => closed ? rejectClosed() : import("./j3rkk835.js").then((mod) => mod.checkout(held));
   return {
     capabilities: BUNSQL_CAPABILITIES,
     execute(text, params, options) {
+      noTimeout2(options);
       return runCall(closed, options, async (watch) => {
         await releaseParked(parked);
         return root.query(text, params, watch);
       });
     },
     async batch(statements, options) {
+      noTimeout2(options);
       const connection = await checkout();
       try {
         return await connection.batch(statements, options);

package/dist/shared/{t4tbsy9h.js → 358zsv4r.js}

@@ -503,7 +503,7 @@ function constraint2(input) {
   const name = input.name === undefined ? deterministicName2({
     parent: input.parent.name,
     purpose: input.constraintKind,
-    nameKey
+    nameKey: input.constraintKind === "check" ? nameKey : defaultNameKey(input.constraintKind, columns)
   }) : fitIdentifier2(input.name);
   const identity = {
     kind: "constraint",

package/dist/shared/{jdgqqx31.js → 3fqwmr09.js}

@@ -1,44 +1,62 @@
 import {
   open2
-} from "./wqem4jed.js";
-import"./8bwbwy8h.js";
+} from "./wkme6tep.js";
+import"./qq3899ht.js";
 import {
   createdOf,
   testing2
-} from "./g516zdsb.js";
+} from "./8x72s86k.js";
 import"./n442h54c.js";
 import {
-  assertTargetPolicy,
-  assertDirectConnection,
-  selectTarget,
+  projectPath,
   loadConfig,
   loadSchema
-} from "./xdpj5kkm.js";
-import"./ayz64vzj.js";
-import"./8xsbagad.js";
+} from "./t3g0k88x.js";
+import {
+  sessionFailure,
+  finishQuiet,
+  assertTargetPolicy,
+  assertDirectConnection,
+  assertStableBackend,
+  selectTarget
+} from "./ttmg09vd.js";
+import"./9s0ypp87.js";
 import {
   OkmError2
 } from "./52szzakm.js";
 
 // src/tooling/migrate/seed.ts
 import { existsSync } from "node:fs";
-import { join } from "node:path";
 import { pathToFileURL } from "node:url";
 async function seedProject(cwd, file, flags) {
   const config = await loadConfig(cwd);
   const target = selectTarget(config, flags.target);
   assertTargetPolicy(target, "seed", flags.allowProtected);
-  const path = join(cwd, file);
+  const path = projectPath(cwd, file);
   if (!existsSync(path)) {
     throw new OkmError2("invalid", `Seed file ${file} was not found.`, {
       fix: { summary: "Pass okm seed <file> a module in this project." }
     });
   }
-  assertDirectConnection(target.url, flags.allowPooler || config.allowPooler === true);
+  const allowPooler = flags.allowPooler || config.allowPooler === true;
+  assertDirectConnection(target.url, allowPooler);
   const schema = await loadSchema(cwd, config.schema);
   const pool = open2({ url: target.url, max: 1 });
-  const harness = await testing2(schema, { driver: pool, migrate: false });
+  let harness;
   try {
+    const held = await pool.reserve?.();
+    if (held !== undefined) {
+      try {
+        await assertStableBackend(async () => {
+          const result = await held.execute("select pg_backend_pid()::text");
+          const cell = result.rows[0]?.[0];
+          return cell === null || cell === undefined ? "" : String(cell);
+        }, allowPooler);
+      } finally {
+        await finishQuiet(() => held.release());
+      }
+    }
+    harness = await testing2(schema, { driver: pool, migrate: false });
     const imported = await import(`${pathToFileURL(path).href}?okm=${Date.now()}`);
     const seed = isRecord(imported) ? imported.default : undefined;
     if (typeof seed !== "function") {
@@ -48,8 +66,14 @@ async function seedProject(cwd, file, flags) {
     }
     await seed(harness);
     return formatCreated(target.name, createdOf(harness));
+  } catch (error) {
+    throw sessionFailure(error) ?? error;
   } finally {
-    await harness.close();
+    const opened = harness;
+    if (opened !== undefined)
+      await finishQuiet(() => opened.close());
+    else
+      await finishQuiet(() => pool.close());
   }
 }
 function formatCreated(target, counts) {

package/dist/shared/{922qbgnw.js → 3qnhc7w5.js}

@@ -1,9 +1,12 @@
+import {
+  mapPostgresError2
+} from "./c58secgj.js";
 import {
   withHttp
-} from "./bt9sfq0z.js";
+} from "./j60w0dvr.js";
 import {
   decodeResult
-} from "./qgvt8nx1.js";
+} from "./2z7wv5tj.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -17,13 +20,17 @@ async function* streamRows(session, call, prepare, log) {
     })));
   }
   const { plan, params } = await prepare();
-  const decode = plan.outputs.includes.length === 0 ? decodeResult : (await import("./h8ne16fq.js")).decodeIncluded;
-  for await (const chunk of session.pool.stream(plan.text, params)) {
-    const decoded = decode(plan, chunk, call.table);
-    if (!Array.isArray(decoded))
-      continue;
-    for (const row of decoded)
-      yield row;
+  const decode = plan.outputs.includes.length === 0 ? decodeResult : (await import("./ys0xzyaj.js")).decodeIncluded;
+  try {
+    for await (const chunk of session.pool.stream(plan.text, params)) {
+      const decoded = decode(plan, chunk, call.table);
+      if (!Array.isArray(decoded))
+        continue;
+      for (const row of decoded)
+        yield row;
+    }
+  } catch (error) {
+    throw log(session.http === undefined ? mapPostgresError2(error) : mapPostgresError2(error, { http: session.http }));
   }
 }
 export {

package/dist/shared/{zvbjc949.js → 4az561fn.js}

@@ -4,7 +4,7 @@ import {
   nextTransactionDepth,
   EMPTY_NOTICES,
   resultFrom
-} from "./rrstp3kb.js";
+} from "./cgbamx3e.js";
 
 // src/adapters/pg/session.ts
 function quoteIdent2(name) {

package/dist/shared/{k3ted12y.js → 54tqkxja.js}

@@ -1,4 +1,22 @@
 // src/adapters/pg/watch.ts
+var callers = new WeakMap;
+function listenOn(signal, onAbort) {
+  let set = callers.get(signal);
+  if (set === undefined) {
+    const created = new Set;
+    callers.set(signal, created);
+    signal.addEventListener("abort", () => {
+      for (const each of created)
+        each();
+    }, { once: true });
+    set = created;
+  }
+  const registered = set;
+  registered.add(onAbort);
+  return () => {
+    registered.delete(onAbort);
+  };
+}
 function openWatch(options) {
   let kind;
   const controller = new AbortController;
@@ -7,7 +25,7 @@ function openWatch(options) {
       kind = "cancelled";
     controller.abort();
   };
-  options.signal?.addEventListener("abort", onAbort, { once: true });
+  const release = options.signal === undefined ? undefined : listenOn(options.signal, onAbort);
   let timer;
   if (options.timeout !== undefined) {
     timer = setTimeout(() => {
@@ -21,7 +39,7 @@ function openWatch(options) {
     finish() {
       if (timer !== undefined)
         clearTimeout(timer);
-      options.signal?.removeEventListener("abort", onAbort);
+      release?.();
     },
     reason() {
       return kind;

package/dist/shared/{k7cc9nzk.js → 5d8t84hg.js}

@@ -1,16 +1,19 @@
+import {
+  refuseUncancellableTimeout
+} from "./b4v57v3x.js";
 import {
   isConnectionLost
-} from "./tbszx8mz.js";
+} from "./gwn6v667.js";
 import {
   openClient,
   withHttp,
   settleCall
-} from "./bt9sfq0z.js";
+} from "./j60w0dvr.js";
 import {
   rejectKeys,
   isRecord,
   fail
-} from "./qgvt8nx1.js";
+} from "./2z7wv5tj.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -92,6 +95,9 @@ class Frame {
   }
 }
 async function tx(session, args) {
+  if (typeof args[0] === "function" && args.length > 1) {
+    fail("OKM1120", "options go first: tx(options, fn).");
+  }
   const fn = typeof args[0] === "function" ? args[0] : args[1];
   const given = typeof args[0] === "function" ? {} : args[0] ?? {};
   try {
@@ -102,6 +108,7 @@ async function tx(session, args) {
     rejectKeys(given, ["isolation", "retry", "signal", "timeout"], "tx");
     const options = given;
     check(options);
+    await refuseUncancellableTimeout(session.pool, options.timeout);
     const call = fn;
     return session.tx === undefined ? await outer(session, call, options) : await nested(session, call, options);
   } catch (error) {
@@ -272,6 +279,10 @@ async function nested(session, fn, options) {
   const saved = frame.failed;
   const after = [];
   let released = false;
+  const hooks = session.pool;
+  const pending = hooks.okmScopePending?.();
+  if (pending !== undefined)
+    await pending;
   try {
     await step(session, frame, `SAVEPOINT ${name}`);
     hear?.phase(session.hookm, "start", depth + 1);
@@ -290,6 +301,7 @@ async function nested(session, fn, options) {
       await frame.conn.execute(`ROLLBACK TO SAVEPOINT ${name}`).catch(() => {
         return;
       });
+      hooks.okmForgetScope?.();
       frame.failed = saved;
       hear?.phase(session.hookm, "rollback", depth + 1);
     }

package/dist/shared/{fa9vt245.js → 5j36z8dn.js}

@@ -1,3 +1,6 @@
+import {
+  noTimeout2
+} from "./8dqhth8c.js";
 import {
   PGLITE_CAPABILITIES,
   driverErrors,
@@ -9,7 +12,7 @@ import {
   runCall,
   EMPTY_NOTICES,
   resultFrom
-} from "./rrstp3kb.js";
+} from "./cgbamx3e.js";
 
 // src/adapters/pg/pglite.ts
 import { PGlite } from "@electric-sql/pglite";
@@ -46,11 +49,17 @@ async function open3(config = {}) {
     await slot.acquire(acquireMs);
     let released = false;
     return {
-      execute: (text, params, options) => runCall(closed, options, (watch) => session.query(text, params, watch)),
-      batch: (statements, options) => runCall(closed, options, async (watch) => {
-        const { runAtomicBatch } = await import("./b066g80h.js");
-        return runAtomicBatch(session, statements, watch);
-      }),
+      execute: (text, params, options) => {
+        noTimeout2(options);
+        return runCall(closed, options, (watch) => session.query(text, params, watch));
+      },
+      batch: (statements, options) => {
+        noTimeout2(options);
+        return runCall(closed, options, async (watch) => {
+          const { runAtomicBatch } = await import("./ag4c7516.js");
+          return runAtomicBatch(session, statements, watch);
+        });
+      },
       async release() {
         if (released)
           return;
@@ -66,6 +75,7 @@ async function open3(config = {}) {
   return {
     capabilities: PGLITE_CAPABILITIES,
     execute(text, params, options) {
+      noTimeout2(options);
       return runCall(closed, options, async (watch) => {
         await slot.acquire(acquireMs);
         try {
@@ -76,6 +86,7 @@ async function open3(config = {}) {
       });
     },
     async batch(statements, options) {
+      noTimeout2(options);
       const connection = await lease();
       try {
         return await connection.batch(statements, options);

package/dist/shared/{1g0drakv.js → 5yv4k6a6.js}

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

package/dist/shared/8dqhth8c.js

@@ -0,0 +1,12 @@
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/adapters/pg/no-inflight-timeout.ts
+function noTimeout2(options) {
+  if ((options?.timeout ?? 0) <= 0)
+    return;
+  throw new OkmError2("OKM1120", "timeout");
+}
+
+export { noTimeout2 };

package/dist/shared/8etn7d8w.js

@@ -0,0 +1,62 @@
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/dialects/pg/view/refresh.ts
+async function refreshView(session, name, concurrently) {
+  const host = asHost(session);
+  await host.connected;
+  const timeout = host.timeouts?.statement;
+  const options = timeout === undefined ? undefined : { timeout };
+  const text = `refresh materialized view${concurrently ? " concurrently" : ""} ${quote(name)}`;
+  const connection = await host.pool.reserve?.();
+  if (connection === undefined) {
+    throw new OkmError2("OKM1111", "Refresh needs a driver that can reserve a connection.", {
+      fix: { summary: "Use a Postgres driver that supports interactive transactions." }
+    });
+  }
+  try {
+    if (concurrently) {
+      await connection.execute("select set_config('app.unscoped', 'on', false)");
+      try {
+        await connection.execute(text, undefined, options);
+      } finally {
+        await connection.execute("select set_config('app.unscoped', '', false)").catch(() => {
+          return;
+        });
+      }
+      return;
+    }
+    await connection.execute("begin");
+    try {
+      await connection.execute("select set_config('app.unscoped', 'on', true)");
+      await connection.execute(text, undefined, options);
+      await connection.execute("commit");
+    } catch (error) {
+      await connection.execute("rollback").catch(() => {
+        return;
+      });
+      throw error;
+    }
+  } catch (error) {
+    const { mapPostgresError } = await import("./d5azex6s.js");
+    const mapped = mapPostgresError(error, {
+      ...host.http !== undefined ? { http: host.http } : {},
+      ...host.includeValues === true ? { includeValues: true } : {},
+      ...host.schema !== undefined ? { schema: host.schema } : {}
+    });
+    host.logger?.error?.({ code: mapped.code, summary: mapped.summary });
+    throw mapped;
+  } finally {
+    await connection.release();
+  }
+}
+function asHost(session) {
+  return session;
+}
+function quote(name) {
+  return `"${name.replaceAll('"', '""')}"`;
+}
+export {
+  refreshView
+};