okmodel 0.7.0 → 0.9.0

package/dist/tooling/shared/kz715295.js

@@ -0,0 +1,94 @@
+import {
+  DriverError2,
+  isConnectionLost
+} from "./hfq3n3bd.js";
+import {
+  connectClient3,
+  send4
+} from "./am04v8na.js";
+import {
+  resetSession2
+} from "./7pxncnzs.js";
+import {
+  WireSession
+} from "./jsjjz875.js";
+import {
+  noTimeout
+} from "./3yn79q5m.js";
+import {
+  rejectClosed,
+  runCall
+} from "./5x3pf400.js";
+
+// src/adapters/pg/neon-extra.ts
+async function checkout(held) {
+  const { pool, counters, named, isClosed } = held;
+  if (isClosed())
+    return rejectClosed();
+  const client = await connectClient3(pool, held.acquireMs, counters);
+  counters.reserved += 1;
+  let lost = false;
+  const onError = () => {
+    lost = true;
+  };
+  const events = client;
+  events.on("error", onError);
+  const local = new Set;
+  const session = new WireSession((text, params) => {
+    const pending = send4(client, text, params, named);
+    const guarded = pending.catch((error) => {
+      if (isConnectionLost(error) || lost) {
+        lost = true;
+        if (isConnectionLost(error))
+          throw error;
+        throw Object.assign(new DriverError2("CONNECTION_CLOSED", { cause: error }), {
+          code: "CONNECTION_CLOSED"
+        });
+      }
+      throw error;
+    });
+    return guarded;
+  }, held.notices, isClosed, false, () => {
+    counters.reservedBusy += 1;
+  }, () => {
+    counters.reservedBusy = Math.max(0, counters.reservedBusy - 1);
+  }, local);
+  const guard = (run) => lost ? rejectClosed() : run();
+  let released = false;
+  return {
+    execute: (text, params, options) => {
+      const refused = noTimeout(options);
+      if (refused !== undefined)
+        return refused;
+      return guard(() => runCall(isClosed(), options, (watch) => session.query(text, params, watch)));
+    },
+    batch: (statements, options) => {
+      const refused = noTimeout(options);
+      if (refused !== undefined)
+        return refused;
+      return guard(() => runCall(isClosed(), options, async (watch) => {
+        const { runAtomicBatch } = await import("./gqwevek4.js");
+        return runAtomicBatch(session, statements, watch);
+      }));
+    },
+    async release() {
+      if (released)
+        return;
+      released = true;
+      try {
+        if (!lost)
+          await reset(session, client);
+      } finally {
+        counters.reserved = Math.max(0, counters.reserved - 1);
+        events.removeListener("error", onError);
+        client.release(lost);
+      }
+    }
+  };
+}
+async function reset(session, client) {
+  await resetSession2(session.depth(), (text) => client.query(text));
+}
+export {
+  checkout
+};

package/dist/tooling/shared/m3xt8b1h.js

@@ -0,0 +1,22 @@
+import {
+  markClientPool2,
+  open2,
+  send2,
+  reserve2,
+  park2
+} from "./rcywj2w8.js";
+import {
+  BUNSQL_CAPABILITIES,
+  readCapability2,
+  hasCapability2
+} from "./5x3pf400.js";
+export {
+  BUNSQL_CAPABILITIES as capabilities,
+  hasCapability2 as hasCapability,
+  markClientPool2 as markClientPool,
+  open2 as open,
+  park2 as park,
+  readCapability2 as readCapability,
+  reserve2 as reserve,
+  send2 as send
+};

package/dist/tooling/shared/m4hhb8aa.js

@@ -0,0 +1,9 @@
+import {
+  build2,
+  identityColumn2
+} from "./vwr2y833.js";
+import"./jr2nmr81.js";
+export {
+  build2 as build,
+  identityColumn2 as identityColumn
+};

package/dist/tooling/shared/mw5npye0.js

@@ -0,0 +1,16 @@
+import {
+  open3,
+  PgSession2
+} from "./62fxpc1p.js";
+import {
+  POSTGRESJS_CAPABILITIES,
+  readCapability2,
+  hasCapability2
+} from "./5x3pf400.js";
+export {
+  PgSession2 as PgSession,
+  POSTGRESJS_CAPABILITIES as capabilities,
+  hasCapability2 as hasCapability,
+  open3 as open,
+  readCapability2 as readCapability
+};

package/dist/tooling/shared/n4jqhpqz.js

@@ -0,0 +1,27 @@
+// src/runtime/tx.ts
+async function runWrite(host, statements, options, atomic) {
+  if (statements.length === 0)
+    return [];
+  const first = statements[0];
+  const limit = options?.timeout ?? host.timeouts?.statement;
+  const call = limit === undefined || limit === options?.timeout ? options : { ...options, timeout: limit };
+  const single = statements.length === 1 && first !== undefined && atomic === undefined;
+  const watched = host.hookm !== undefined && !single && host.tx === undefined ? await import("./96ps4g1z.js") : undefined;
+  watched?.phase(host.hookm, "start", 0);
+  let results;
+  try {
+    results = single ? [await host.pool.execute(first.text, first.params, call)] : await host.pool.batch(statements, call);
+  } catch (error) {
+    watched?.phase(host.hookm, "rollback", 0);
+    throw error;
+  }
+  watched?.phase(host.hookm, "commit", 0);
+  if (host.hookm !== undefined) {
+    const heard = results.flatMap((result) => result.notices);
+    if (heard.length > 0)
+      (await import("./96ps4g1z.js")).notices(host.hookm, heard);
+  }
+  return results;
+}
+
+export { runWrite };

package/dist/tooling/shared/nxq95eb6.js

@@ -0,0 +1,42 @@
+import {
+  open3
+} from "./62fxpc1p.js";
+import {
+  createClient
+} from "./jr2nmr81.js";
+
+// src/runtime/pg/postgresjs.ts
+function connect(target, options) {
+  if (typeof target === "object" && !isPool(target)) {
+    return import("./kbqnrs1x.js").then((mod) => mod.default(target, options, open3));
+  }
+  const owned = !isPool(target);
+  const pool = isPool(target) ? target : open3({
+    url: target,
+    ...options.max !== undefined ? { max: options.max } : {},
+    ...options.timeouts !== undefined ? { timeouts: options.timeouts } : {},
+    ...options.prepared !== undefined ? { prepared: options.prepared } : {},
+    ...options.searchPath !== undefined ? { searchPath: options.searchPath } : {},
+    ...options.ssl !== undefined ? { ssl: options.ssl } : {}
+  });
+  return createClient(options.schema, pool, {
+    ownsPool: owned,
+    http: options.errors?.http,
+    includeValues: options.errors?.includeValues,
+    logger: options.logger,
+    signal: options.signal,
+    timeout: options.timeout,
+    timeouts: options.timeouts,
+    hookm: options.hookm,
+    catalog: options.catalog,
+    catalogDir: options.catalogDir,
+    requireMeta: options.requireMeta,
+    generators: options.generators
+  });
+}
+function isPool(target) {
+  return typeof target === "object" && "execute" in target && "capabilities" in target;
+}
+export {
+  connect
+};

package/dist/tooling/shared/qartgazh.js

@@ -0,0 +1,70 @@
+import {
+  OkmError,
+  catalogFileText2
+} from "./hfq3n3bd.js";
+import {
+  artifactDir,
+  readText
+} from "./dhatassp.js";
+
+// src/runtime/drift.ts
+async function assertCompatible(pool, schema, recordedHash, source, options, namespace = "public") {
+  const code = await codeHash(schema, source);
+  if (code.hash === recordedHash)
+    return;
+  const { loadOnce } = await import("./htnaj77v.js");
+  if (code.artifact !== undefined) {
+    const artifact = code.artifact;
+    await loadOnce(`text\x00${artifact.hash}`, async () => {
+      const { loadTrustedCatalog } = await import("./yb4kd19s.js");
+      loadTrustedCatalog(artifact.text, artifact.hash);
+    });
+  } else if (code.fromFile) {
+    const dir = artifactDir(source.catalogDir);
+    await loadOnce(`file\x00${dir}\x00${code.hash}`, async () => {
+      const text = await readText(`${dir}/catalog.json`);
+      if (text === undefined) {
+        throw new OkmError("OKM1027", `${dir}/catalog.json is missing.`, {
+          fix: {
+            summary: "Run okm build so catalog.json matches catalog.hash. connect does not rebuild the catalog from the schema."
+          }
+        });
+      }
+      const { loadTrustedCatalog } = await import("./yb4kd19s.js");
+      loadTrustedCatalog(text, code.hash);
+    });
+  }
+  const { assertDrift } = await import("./6vk28rjp.js");
+  await assertDrift(pool, code.hash, recordedHash, options, namespace);
+}
+async function codeHash(schema, source) {
+  if (source.catalog !== undefined) {
+    return { hash: source.catalog.hash, artifact: source.catalog, fromFile: false };
+  }
+  const listed = await readHashFile(source.catalogDir);
+  if (listed !== undefined)
+    return { hash: listed, fromFile: true };
+  const { catalogHash } = await import("./yb4kd19s.js");
+  return { hash: catalogHash(schemaCatalog(schema)), fromFile: false };
+}
+function schemaCatalog(schema) {
+  const value = Reflect.get(schema, "catalog");
+  if (typeof value !== "object" || value === null || !("objects" in value)) {
+    throw new OkmError("OKM1520", "The schema has no catalog to compare.", {
+      fix: {
+        summary: "Pass the schema() result to connect, or a catalog artifact from okm build."
+      }
+    });
+  }
+  return value;
+}
+async function readHashFile(catalogDir) {
+  const text = await readText(`${artifactDir(catalogDir)}/catalog.hash`);
+  if (text === undefined)
+    return;
+  const hash = catalogFileText2(text, "catalog.hash").trim();
+  return hash.length === 0 ? undefined : hash;
+}
+export {
+  assertCompatible
+};

package/dist/tooling/shared/rcywj2w8.js

@@ -0,0 +1,190 @@
+import {
+  DriverError2
+} from "./hfq3n3bd.js";
+import {
+  noticeBuffer,
+  WireSession
+} from "./jsjjz875.js";
+import {
+  noTimeout
+} from "./3yn79q5m.js";
+import {
+  BUNSQL_CAPABILITIES,
+  driverErrors,
+  rejectClosed,
+  mapFailure,
+  runCall
+} from "./5x3pf400.js";
+
+// src/adapters/pg/bunsql.ts
+import { SQL as BunSQL } from "bun";
+var clientPools = new WeakSet;
+function markClientPool2(pool) {
+  clientPools.add(pool);
+}
+function open2(config) {
+  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 parked = [];
+  let dropped = 0;
+  let closures = 0;
+  const sql = new BunSQL(config.url, {
+    max,
+    idleTimeout: 0,
+    maxLifetime: 0,
+    prepare: named,
+    bigint: false,
+    connectionTimeout: 5,
+    connection: {
+      application_name: "okmodel",
+      ...config.searchPath !== undefined ? { search_path: config.searchPath } : {}
+    },
+    ...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,
+    closures: () => closures
+  };
+  const run = (text, params, watch) => {
+    const sent = dropped;
+    return root.query(text, params, watch).catch((error) => import("./8yr7ges1.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("./8yr7ges1.js").then((mod) => mod.drainClosed(sql).then(() => {
+      if (dropped === seen)
+        dropped = 0;
+      return run(text, params, watch);
+    }));
+  };
+  const checkout = () => closed ? rejectClosed() : import("./8yr7ges1.js").then((mod) => mod.checkout(held));
+  const pool = {
+    capabilities: BUNSQL_CAPABILITIES,
+    execute(text, params, options) {
+      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) {
+      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(),
+    stream(text, params) {
+      return async function* () {
+        const { streamRows } = await import("./8yr7ges1.js");
+        yield* streamRows(checkout, text, params);
+      }();
+    },
+    listen(channel, onNotify) {
+      return import("./8yr7ges1.js").then((mod) => mod.listen(sql, parked, closed, channel, onNotify));
+    },
+    stats: () => statsOf(counters, max),
+    async close() {
+      closed = true;
+      await releaseParked(parked);
+      await sql.close();
+    }
+  };
+  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 reserve2(sql, acquireMs, counters) {
+  counters.waiting += 1;
+  try {
+    if (acquireMs === undefined)
+      return await sql.reserve();
+    return await sql.reserve({ signal: AbortSignal.timeout(acquireMs) });
+  } catch (error) {
+    if (isAbort(error)) {
+      const errors = await driverErrors();
+      throw errors.acquireTimeout();
+    }
+    throw await mapFailure(error);
+  } finally {
+    counters.waiting = Math.max(0, counters.waiting - 1);
+  }
+}
+async function park2(parked, reserved) {
+  parked.push(reserved);
+  while (parked.length > 1) {
+    const extra = parked.shift();
+    if (extra !== undefined)
+      await releaseReserved(extra);
+  }
+}
+async function releaseParked(parked) {
+  const pending = parked.splice(0);
+  for (const reserved of pending)
+    await releaseReserved(reserved);
+}
+function releaseReserved(reserved) {
+  const done = reserved.release();
+  return done instanceof Promise ? done.then(() => {
+    return;
+  }) : Promise.resolve();
+}
+function isAbort(error) {
+  if (!(error instanceof Error))
+    return false;
+  return error.name === "AbortError" || error.name === "TimeoutError";
+}
+function statsOf(counters, size) {
+  return {
+    size,
+    idle: Math.max(0, size - counters.reserved - counters.busy),
+    inflight: counters.busy + counters.reservedBusy,
+    waiting: counters.waiting
+  };
+}
+
+export { markClientPool2, open2, send2, reserve2, park2 };

package/dist/tooling/shared/s6qha57m.js

@@ -0,0 +1,16 @@
+import {
+  open6,
+  seal2
+} from "./t6zjeake.js";
+import {
+  PGLITE_CAPABILITIES,
+  readCapability2,
+  hasCapability2
+} from "./5x3pf400.js";
+export {
+  PGLITE_CAPABILITIES as capabilities,
+  hasCapability2 as hasCapability,
+  open6 as open,
+  readCapability2 as readCapability,
+  seal2 as seal
+};

package/dist/tooling/shared/shjs0379.js

@@ -0,0 +1,150 @@
+import {
+  runWrite
+} from "./n4jqhpqz.js";
+import {
+  refuseUncancellableTimeout
+} from "./tcwpjvxe.js";
+import {
+  withHttp,
+  settleCall
+} from "./jr2nmr81.js";
+import {
+  OkmError,
+  rejectKeys,
+  isRecord,
+  fail2
+} from "./hfq3n3bd.js";
+
+// src/runtime/batch.ts
+async function batch(session, ops, options, replica) {
+  try {
+    if (replica !== undefined) {
+      throw new OkmError("OKM1840", "batch() needs the primary. .replica() is not allowed on a batch.", withHttp(session.http, {
+        fix: { summary: "Remove .replica(). A batch always runs on the primary." }
+      }));
+    }
+    if (!Array.isArray(ops))
+      fail2("OKM1121", "batch expects a list of write operations.");
+    const record = options ?? {};
+    if (!isRecord(record))
+      fail2("OKM1121", "batch options must be an object.");
+    rejectKeys(record, ["signal", "timeout"], "batch");
+    await refuseUncancellableTimeout(session.pool, typeof record["timeout"] === "number" ? record["timeout"] : undefined);
+    for (const op of ops) {
+      if (typeof op === "object" && op !== null && op["~refresh"] === true) {
+        fail2("OKM1121", "batch does not take refresh(). Await refresh() on its own. It is one statement and cannot share the batch.");
+      }
+    }
+    const prepared = [];
+    for (const op of ops) {
+      const plan = typeof op === "object" && op !== null ? op["~plan"] : undefined;
+      if (plan === undefined) {
+        fail2("OKM1121", "batch takes write operations: insert, update, delete, and archive. Pass them without awaiting.");
+      }
+      const item = await plan();
+      if (item.checked === "parent") {
+        throw new OkmError("OKM1705", "batch does not take an update that sets a path column. The parent is checked in the statement, and a batch cannot report that after it commits. Use update({ where, set }) inside tx().", { fix: { summary: "Use update({ where, set }) inside tx()." } });
+      }
+      if (item.checked !== undefined) {
+        fail2("OKM1121", item.checked === "restore" ? "batch does not take restore: it is refused while its parent is archived, and a batch cannot report that after it commits. Use tx()." : "batch does not take a write with expect: the count is checked after the statement ran, and a batch cannot report that after it commits. Use tx().");
+      }
+      prepared.push(item);
+    }
+    return await run(session, prepared, record);
+  } catch (error) {
+    return settleCall(session, error);
+  }
+}
+async function run(session, prepared, options) {
+  await session.connected;
+  const statements = [];
+  const starts = [];
+  for (const item of prepared) {
+    starts.push(statements.length);
+    statements.push(...item.statements);
+  }
+  if (statements.length === 0)
+    return prepared.map((item) => item.finish([]));
+  let results;
+  try {
+    results = await runWrite(session, statements, call(options), true);
+  } catch (error) {
+    throw at(error, starts);
+  }
+  const extra = await recover(session, prepared, results, starts, options);
+  return prepared.map((item, index) => {
+    const from = starts[index] ?? 0;
+    const slice = results.slice(from, from + item.statements.length);
+    const more = extra.get(index);
+    return item.finish(more === undefined ? slice : slice.concat(more));
+  });
+}
+async function recover(session, prepared, results, starts, options) {
+  const pending = [];
+  for (let index = 0;index < prepared.length; index += 1) {
+    const item = prepared[index];
+    if (item?.follow === undefined)
+      continue;
+    const from = starts[index] ?? 0;
+    const more = item.follow(results.slice(from, from + item.statements.length));
+    if (more.length === 0)
+      continue;
+    pending.push({ index, statements: more });
+  }
+  const found = new Map;
+  if (pending.length === 0)
+    return found;
+  const flat = [];
+  const extraStarts = [];
+  for (const item of pending) {
+    extraStarts.push(flat.length);
+    flat.push(...item.statements);
+  }
+  let ran;
+  try {
+    ran = await runWrite(session, flat, call(options), true);
+  } catch (error) {
+    throw mapExtra(error, pending, extraStarts);
+  }
+  for (let index = 0;index < pending.length; index += 1) {
+    const item = pending[index];
+    if (item === undefined)
+      continue;
+    const from = extraStarts[index] ?? 0;
+    found.set(item.index, ran.slice(from, extraStarts[index + 1] ?? ran.length));
+  }
+  return found;
+}
+function mapExtra(error, pending, extraStarts) {
+  const failed = error?.batchIndex;
+  const move = error?.at;
+  if (typeof failed !== "number" || typeof move !== "function")
+    return error;
+  let slot = 0;
+  while (slot + 1 < extraStarts.length && (extraStarts[slot + 1] ?? Infinity) <= failed)
+    slot += 1;
+  const op = pending[slot]?.index ?? slot;
+  return op === failed ? error : move.call(error, op);
+}
+function call(options) {
+  const { signal, timeout } = options;
+  if (signal === undefined && timeout === undefined)
+    return;
+  return {
+    ...signal !== undefined ? { signal } : {},
+    ...typeof timeout === "number" ? { timeout } : {}
+  };
+}
+function at(error, starts) {
+  const failed = error?.batchIndex;
+  const move = error?.at;
+  if (typeof failed !== "number" || typeof move !== "function")
+    return error;
+  let index = 0;
+  while (index + 1 < starts.length && (starts[index + 1] ?? Infinity) <= failed)
+    index += 1;
+  return index === failed ? error : move.call(error, index);
+}
+export {
+  batch
+};

package/dist/tooling/shared/sjwkt1pg.js

@@ -0,0 +1,16 @@
+import {
+  OkmError,
+  DriverError2
+} from "./hfq3n3bd.js";
+
+// src/adapters/lazy-errors.ts
+function refused() {
+  return Promise.reject(new OkmError("OKM1120", "timeout"));
+}
+function closed() {
+  return Promise.reject(new DriverError2("The pool is closed.", { sqlstate: "08006" }));
+}
+export {
+  closed,
+  refused
+};