okmodel 0.7.0 → 0.8.0

package/dist/tooling/shared/fb9k2qwd.js

@@ -0,0 +1,89 @@
+import {
+  OkmError,
+  catalogFileText2
+} from "./f9mphxej.js";
+
+// src/runtime/drift.ts
+async function assertCompatible(pool, schema, recordedHash, source, options) {
+  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("./5bvw2nev.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("./5bvw2nev.js");
+      loadTrustedCatalog(text, code.hash);
+    });
+  }
+  const { assertDrift } = await import("./rf83gr2d.js");
+  await assertDrift(pool, code.hash, recordedHash, options);
+}
+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("./5bvw2nev.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;
+}
+function artifactDir(catalogDir) {
+  if (catalogDir !== undefined)
+    return catalogDir.replace(/[/\\]+$/, "");
+  const cwd = globalThis.process?.cwd?.() ?? ".";
+  return `${cwd}/.okm`;
+}
+async function readText(path) {
+  const bun = globalThis.Bun;
+  if (bun !== undefined) {
+    const file = bun.file(path);
+    if (!await file.exists())
+      return;
+    return file.text();
+  }
+  const loader = globalThis.process?.getBuiltinModule;
+  if (loader === undefined)
+    return;
+  try {
+    return await loader("node:fs/promises").readFile(path, "utf8");
+  } catch {
+    return;
+  }
+}
+export {
+  assertCompatible
+};

package/dist/tooling/shared/g9ad4n80.js

@@ -0,0 +1,211 @@
+import {
+  DriverError2,
+  isConnectionFailure
+} from "./f9mphxej.js";
+import {
+  send2,
+  reserve2,
+  park2
+} from "./xjs6zqtc.js";
+import {
+  resetSession2,
+  refuseWhenLost2
+} from "./4d2w25vw.js";
+import {
+  cursorStream
+} from "./7kms6fvj.js";
+import {
+  WireSession
+} from "./yw30vnq2.js";
+import {
+  noTimeout
+} from "./rs1jb051.js";
+import {
+  rejectClosed,
+  runCall
+} from "./xhrnjch9.js";
+
+// src/adapters/pg/bunsql-extra.ts
+async function recover(sql, error, text, depth, clientRead, closedDuring, again) {
+  if (!lostQuery(error))
+    throw error;
+  await flushClosed(sql);
+  const alreadyDead = closedDuring || socketClosed(error);
+  if (!clientRead && !alreadyDead || depth !== 0 || !readStatement(text))
+    throw error;
+  try {
+    return await again();
+  } catch (next) {
+    if (lostQuery(next))
+      await flushClosed(sql);
+    throw next;
+  }
+}
+function drainClosed(sql) {
+  return flushClosed(sql).then(() => {
+    return;
+  });
+}
+function readStatement(text) {
+  const head = text.trimStart().toLowerCase().replace(/\s+/g, " ");
+  if (head.length === 0 || head.includes("pg_advisory"))
+    return false;
+  if (/\sfor (?:no key update|key share|update|share)\b/.test(head))
+    return false;
+  return !/^(?:insert|update|delete|refresh|with|create|alter|drop|truncate|grant|revoke|comment|vacuum|analyze|reindex|copy|begin|start|commit|rollback|savepoint|release|set|reset)\b/.test(head);
+}
+function lostQuery(error) {
+  return isConnectionFailure(error) || socketClosed(error);
+}
+function socketClosed(error) {
+  if (!(error instanceof Error))
+    return false;
+  if (error.message === "Connection closed")
+    return true;
+  return error.cause instanceof Error && error.cause.message === "Connection closed";
+}
+async function listen(sql, parked, closed, channel, onNotify) {
+  if (closed)
+    return rejectClosed();
+  const pending = parked.splice(0);
+  for (const reserved of pending) {
+    const done = reserved.release();
+    if (done instanceof Promise)
+      await done;
+  }
+  const subscription = await sql.listen(channel, onNotify);
+  return async () => {
+    await subscription.unlisten();
+  };
+}
+async function checkout(held) {
+  const { counters, isClosed } = held;
+  if (isClosed())
+    return rejectClosed();
+  const reserved = await takeOpen(held) ?? await reserve2(held.sql, held.acquireMs, counters);
+  counters.reserved += 1;
+  const session = new WireSession((text, params) => send2(reserved, text, params), held.notices, isClosed, false, () => {
+    counters.reservedBusy += 1;
+  }, () => {
+    counters.reservedBusy = Math.max(0, counters.reservedBusy - 1);
+  });
+  let lost = { on: false };
+  const opened = held.closures();
+  const reconnected = () => {
+    if (held.closures() === opened)
+      return;
+    lost.on = true;
+    return Promise.reject(new DriverError2("Connection closed", { sqlstate: "08006" }));
+  };
+  const guard = (run) => refuseWhenLost2(lost, () => run().catch((error) => {
+    if (error instanceof Error && bunClosed(error.message)) {
+      throw new DriverError2(error.message, { cause: error, sqlstate: "08006" });
+    }
+    throw error;
+  }));
+  let released = false;
+  return {
+    execute: (text, params, options) => {
+      const refused = noTimeout(options);
+      if (refused !== undefined)
+        return refused;
+      const gone = reconnected();
+      if (gone !== undefined)
+        return gone;
+      return guard(() => runCall(isClosed(), options, (watch) => session.query(text, params, watch)));
+    },
+    batch: (statements, options) => {
+      const refused = noTimeout(options);
+      if (refused !== undefined)
+        return refused;
+      const gone = reconnected();
+      if (gone !== undefined)
+        return gone;
+      return guard(() => runCall(isClosed(), options, async (watch) => {
+        const { runAtomicBatch } = await import("./3rrw5w8f.js");
+        return runAtomicBatch(session, statements, watch);
+      }));
+    },
+    evict() {
+      lost.on = true;
+    },
+    async release() {
+      if (released)
+        return;
+      released = true;
+      if (!lost.on && reportsClosed(reserved))
+        lost.on = true;
+      try {
+        if (!lost.on)
+          await reset(session, reserved);
+      } catch (error) {
+        if (lostQuery(error) || reportsClosed(reserved))
+          lost.on = true;
+        else
+          throw error;
+      } finally {
+        counters.reserved = Math.max(0, counters.reserved - 1);
+        if (lost.on) {
+          try {
+            reserved.release();
+          } catch {}
+          await flushClosed(held.sql);
+        } else
+          await park2(held.parked, reserved);
+      }
+    }
+  };
+}
+function reportsClosed(reserved) {
+  return Reflect.get(reserved, "closed") === true;
+}
+async function takeOpen(held) {
+  while (held.parked.length > 0) {
+    const next = held.parked.pop();
+    if (next === undefined)
+      return;
+    if (!reportsClosed(next))
+      return next;
+    try {
+      next.release();
+    } catch {}
+    await flushClosed(held.sql);
+  }
+  return;
+}
+async function flushClosed(sql) {
+  for (let attempt = 0;attempt < 3; attempt += 1) {
+    try {
+      await sql.unsafe("select 1");
+      return true;
+    } catch {}
+  }
+  return false;
+}
+function bunClosed(message) {
+  return message === "Connection closed" || message === "connection must be a PostgresSQLConnection";
+}
+async function reset(session, sql) {
+  const run = (text) => sql.unsafe(text);
+  await resetSession2(session.depth(), run);
+}
+function streamRows(checkout, text, params) {
+  return async function* () {
+    const connection = await checkout();
+    try {
+      yield* cursorStream((statement, values) => connection.execute(statement, values), text, params);
+    } catch (error) {
+      connection.evict?.();
+      throw error;
+    } finally {
+      await connection.release();
+    }
+  }();
+}
+export {
+  checkout,
+  drainClosed,
+  listen,
+  recover,
+  streamRows
+};

package/dist/tooling/shared/gfvtj6d0.js

@@ -0,0 +1,94 @@
+import {
+  DriverError2,
+  isConnectionLost
+} from "./f9mphxej.js";
+import {
+  connectClient3,
+  send4
+} from "./y5656f0e.js";
+import {
+  resetSession2
+} from "./4d2w25vw.js";
+import {
+  WireSession
+} from "./yw30vnq2.js";
+import {
+  noTimeout
+} from "./rs1jb051.js";
+import {
+  rejectClosed,
+  runCall
+} from "./xhrnjch9.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("./3rrw5w8f.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/gmcf9cxf.js

@@ -0,0 +1,294 @@
+import {
+  assertNoControl
+} from "./3tq8pnb8.js";
+import {
+  OkmError,
+  throwNamed,
+  isOperator,
+  operatorName,
+  operatorValue,
+  tag,
+  refuseHidden,
+  quote,
+  list,
+  fail2
+} from "./f9mphxej.js";
+
+// src/dialects/pg/ops/fragment.ts
+var IDENT = Symbol("okmodel.sql.ident");
+var COLUMN = Symbol("okmodel.sql.column");
+function fragmentError(message, fix) {
+  throw new OkmError("OKM1125", message, { fix: { summary: fix } });
+}
+function isFragmentParts(value) {
+  return Array.isArray(value) && value.every(isPart);
+}
+function isPart(value) {
+  if (typeof value !== "object" || value === null || !("k" in value))
+    return false;
+  const kind = value.k;
+  if (kind === "t")
+    return "s" in value && typeof value.s === "string";
+  if (kind === "p")
+    return "v" in value && typeof value.v === "string";
+  if (kind === "n" || kind === "c")
+    return true;
+  if (kind === "i")
+    return "n" in value && typeof value.n === "string";
+  if (kind === "f")
+    return "parts" in value && isFragmentParts(value.parts);
+  return false;
+}
+function readSelectFragment(value) {
+  if (!isOperator(value) || operatorName(value) !== "sql")
+    return;
+  const named = value;
+  if (typeof named.as !== "string") {
+    fragmentError("A select fragment needs as(name).", 'Call .as("len") and pass that value in select.');
+  }
+  const stored = operatorValue(value);
+  if (!isFragmentParts(stored)) {
+    fragmentError("A fragment was not created by fragment``.", "Call fragment`...`.");
+  }
+  const textual = named.text === true;
+  return textual ? { as: named.as, parts: stored, textual: true } : { as: named.as, parts: stored };
+}
+function scanLiteral(literal, state) {
+  for (let index = 0;index < literal.length; index += 1) {
+    const char = literal[index] ?? "";
+    const code = literal.charCodeAt(index);
+    if (state.quote !== undefined) {
+      if (char !== state.quote)
+        continue;
+      if (literal[index + 1] === state.quote) {
+        index += 1;
+        continue;
+      }
+      state.quote = undefined;
+      continue;
+    }
+    if (code <= 31 && code !== 9 && code !== 10 && code !== 13 || code === 127) {
+      fragmentError("A fragment literal contains a control character.", "Remove NUL and other control characters. A newline, tab, or return is allowed.");
+    }
+    if (char === "'" || char === '"') {
+      state.quote = char;
+      continue;
+    }
+    if (char === "(") {
+      state.paren += 1;
+      continue;
+    }
+    if (char === ")") {
+      state.paren -= 1;
+      if (state.paren < 0) {
+        fragmentError("A fragment has unbalanced SQL.", "Keep parentheses and quotes balanced. A fragment cannot close the surrounding predicate.");
+      }
+      continue;
+    }
+    if (char === ";") {
+      fragmentError("A fragment cannot include a semicolon.", "Pass the value as an interpolation. The fragment is one expression.");
+    }
+    if (char === "$") {
+      fragmentError("A fragment cannot include a dollar quote or a parameter marker.", "Interpolate the value. The planner numbers parameters.");
+    }
+    if (char === "-" && literal[index + 1] === "-" || char === "/" && literal[index + 1] === "*") {
+      fragmentError("A fragment cannot include a comment.", "Remove the comment. A comment can hide the rest of the predicate.");
+    }
+  }
+}
+function appendText(parts, literal) {
+  if (literal.length === 0)
+    return;
+  parts.push({ k: "t", s: literal });
+}
+function appendValue(parts, value) {
+  if (value === null) {
+    parts.push({ k: "n" });
+    return;
+  }
+  if (typeof value === "string") {
+    parts.push({ k: "p", v: value });
+    return;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      fragmentError("A fragment needs a finite number.", "Pass a finite number, or leave it out.");
+    }
+    parts.push({ k: "p", v: String(value) });
+    return;
+  }
+  if (typeof value === "boolean") {
+    parts.push({ k: "p", v: value ? "true" : "false" });
+    return;
+  }
+  if (typeof value === "bigint") {
+    parts.push({ k: "p", v: String(value) });
+    return;
+  }
+  if (typeof value === "object") {
+    if (COLUMN in value) {
+      parts.push({ k: "c" });
+      return;
+    }
+    if (IDENT in value) {
+      const name = value[IDENT];
+      if (typeof name === "string") {
+        parts.push({ k: "i", n: name });
+        return;
+      }
+    }
+    if (isOperator(value) && operatorName(value) === "sql") {
+      const nested = operatorValue(value);
+      if (!isFragmentParts(nested)) {
+        fragmentError("A fragment was not created by fragment``.", "Call fragment`...`.");
+      }
+      parts.push({ k: "f", parts: nested });
+      return;
+    }
+  }
+  fragmentError("A fragment cannot interpolate that value.", "Interpolate a string, number, boolean, null, ident(name), fragment.column, or another fragment.");
+}
+function hasSql(parts) {
+  for (const part of parts) {
+    if (part.k === "t") {
+      if (part.s.trim().length > 0)
+        return true;
+      continue;
+    }
+    return true;
+  }
+  return false;
+}
+function compile(strings, values) {
+  const state = { quote: undefined, paren: 0 };
+  const parts = [];
+  for (let index = 0;index < values.length + 1; index += 1) {
+    const literal = strings[index] ?? "";
+    scanLiteral(literal, state);
+    appendText(parts, literal);
+    if (index === values.length)
+      continue;
+    if (state.quote !== undefined) {
+      fragmentError("A fragment cannot interpolate inside quotes.", "Do not put an interpolation inside quotes. Write title = ${name}.");
+    }
+    appendValue(parts, values[index]);
+  }
+  if (state.quote !== undefined || state.paren !== 0) {
+    fragmentError("A fragment has unbalanced SQL.", "Keep parentheses and quotes balanced. A fragment cannot close the surrounding predicate.");
+  }
+  if (!hasSql(parts)) {
+    fragmentError("A fragment needs SQL text.", "Write an expression, or interpolate a value.");
+  }
+  return parts;
+}
+function isTemplate(value) {
+  return Array.isArray(value) && "raw" in value;
+}
+function bind(parts, textual = false) {
+  const tagged = tag("sql", parts);
+  return Object.assign(tagged, {
+    as(name) {
+      if (typeof name !== "string" || name.length === 0) {
+        fragmentError("as(name) needs a result name.", 'Call .as("len") with a name that is not a column.');
+      }
+      assertNoControl(name, "fragment as");
+      const selected = Object.assign(tag("sql", parts), { as: name });
+      return textual ? Object.assign(selected, { text: true }) : selected;
+    }
+  });
+}
+function fragmentTag(strings, ...values) {
+  if (!isTemplate(strings)) {
+    fragmentError("Call fragment as a template: fragment`...`.", "Write fragment`length(${fragment.column}) > ${1}`.");
+  }
+  return bind(compile(strings, values));
+}
+var fragment = Object.assign(fragmentTag, {
+  column: { [COLUMN]: true }
+});
+
+// src/runtime/sql-fragment.ts
+function emitSqlValue(table, ref, value, sink) {
+  const dot = ref.indexOf(".");
+  const alias = dot < 0 ? ref : ref.slice(0, dot);
+  writeFragment(requireParts(value), sink, alias, ref, table, "where");
+}
+function emitSqlSelect(table, parts, sink, alias) {
+  writeFragment(parts, sink, alias, undefined, table, "select");
+}
+function decodeSqlNumber(wire) {
+  const parsed = Number(wire);
+  if (!Number.isFinite(parsed)) {
+    throw new OkmError("OKM1125", "A select fragment must be a number.", {
+      fix: { summary: "Use a numeric expression, such as length(title). Text stays in where." }
+    });
+  }
+  return parsed;
+}
+function requireParts(value) {
+  if (!isFragmentParts(value)) {
+    throw new OkmError("OKM1125", "A fragment was not created by fragment``.", {
+      fix: { summary: "Call fragment`...`." }
+    });
+  }
+  return value;
+}
+function writeFragment(parts, sink, alias, ref, table, place) {
+  sink.mark(":g");
+  sink.text("(");
+  for (const part of parts)
+    writePart(part, sink, alias, ref, table, place);
+  sink.mark(":g");
+  sink.text(")");
+}
+function writePart(part, sink, alias, ref, table, place) {
+  if (part.k === "t") {
+    sink.mark(`:t:${String(part.s.length)}:${part.s}`);
+    sink.text(part.s);
+    return;
+  }
+  if (part.k === "p") {
+    sink.mark(":p");
+    sink.param(part.v);
+    return;
+  }
+  if (part.k === "n") {
+    sink.mark(":n");
+    sink.text("null");
+    return;
+  }
+  if (part.k === "i") {
+    writeIdent(part.n, table, sink, alias, place);
+    return;
+  }
+  if (part.k === "c") {
+    if (ref === undefined) {
+      throw new OkmError("OKM1125", "fragment.column belongs on a where field.", {
+        fix: { summary: "Use ident(name) in select, or put fragment.column on a where field." }
+      });
+    }
+    sink.mark(":c");
+    sink.text(ref);
+    return;
+  }
+  writeFragment(part.parts, sink, alias, ref, table, place);
+}
+function writeIdent(name, table, sink, alias, place) {
+  const column = table.columns.get(name);
+  if (column === undefined) {
+    throwNamed("OKM1120", name, table.names, `Field ${name} is not on ${table.model.name}. Accepted names: ${list(table.names)}.`);
+  }
+  if (place === "select") {
+    if (column.hidden) {
+      fail2("OKM1120", `Field ${column.field} is hidden.`, "A select fragment cannot name a hidden field.");
+    }
+  } else {
+    refuseHidden(column);
+  }
+  sink.mark(`:i:${String(column.field.length)}:${column.field}`);
+  sink.text(alias);
+  sink.text(".");
+  sink.text(quote(column.sql));
+}
+
+export { readSelectFragment, emitSqlValue, emitSqlSelect, decodeSqlNumber };

package/dist/tooling/shared/htnaj77v.js

@@ -0,0 +1,17 @@
+// src/runtime/catalog-cache.ts
+var inflight = new Map;
+function loadOnce(key, load) {
+  const found = inflight.get(key);
+  if (found !== undefined)
+    return found;
+  const pending = Promise.resolve().then(load);
+  inflight.set(key, pending);
+  pending.catch(() => {
+    if (inflight.get(key) === pending)
+      inflight.delete(key);
+  });
+  return pending;
+}
+export {
+  loadOnce
+};