okmodel 0.1.1 → 0.3.0

package/dist/shared/01yr20s5.js

@@ -0,0 +1,149 @@
+import {
+  noticeBuffer,
+  WireSession,
+  cursorStream
+} from "./0jc3ffzf.js";
+import {
+  BUNSQL_CAPABILITIES,
+  driverErrors,
+  rejectClosed,
+  mapFailure,
+  runCall
+} from "./rrstp3kb.js";
+
+// src/adapters/pg/bunsql.ts
+import { SQL } from "bun";
+function open5(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 = [];
+  const sql = new SQL(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 } : {}
+  });
+  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 };
+  const checkout = () => closed ? rejectClosed() : import("./fs0ex00p.js").then((mod) => mod.checkout(held));
+  return {
+    capabilities: BUNSQL_CAPABILITIES,
+    execute(text, params, options) {
+      return runCall(closed, options, async (watch) => {
+        await releaseParked(parked);
+        return root.query(text, params, watch);
+      });
+    },
+    async batch(statements, options) {
+      const connection = await checkout();
+      try {
+        return await connection.batch(statements, options);
+      } finally {
+        await connection.release();
+      }
+    },
+    reserve: () => checkout(),
+    stream(text, params) {
+      return stream(text, params);
+    },
+    listen(channel, onNotify) {
+      return listen(channel, onNotify);
+    },
+    stats: () => statsOf(counters, max),
+    async close() {
+      closed = true;
+      await releaseParked(parked);
+      await sql.close();
+    }
+  };
+  function stream(text, params) {
+    return async function* () {
+      const connection = await checkout();
+      try {
+        yield* cursorStream((statement, values) => connection.execute(statement, values), text, params);
+      } finally {
+        await connection.release();
+      }
+    }();
+  }
+  async function listen(channel, onNotify) {
+    if (closed)
+      return rejectClosed();
+    await releaseParked(parked);
+    const subscription = await sql.listen(channel, onNotify);
+    return async () => {
+      await subscription.unlisten();
+    };
+  }
+}
+function send2(sql, text, params) {
+  if (params === undefined || params.length === 0)
+    return sql.unsafe(text).raw();
+  return sql.unsafe(text, [...params]).raw();
+}
+async function reserve(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 park(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 { open5, send2, reserve, park };

package/dist/shared/0jc3ffzf.js

@@ -0,0 +1,154 @@
+import {
+  driverErrors,
+  rejectClosed,
+  nextTransactionDepth,
+  EMPTY_NOTICES,
+  resultFrom
+} from "./rrstp3kb.js";
+
+// src/adapters/pg/session.ts
+function quoteIdent2(name) {
+  return `"${name.replaceAll('"', '""')}"`;
+}
+function noticeBuffer() {
+  let notices;
+  return {
+    push(notice) {
+      const severity = notice.severity ?? "";
+      const message = notice.message ?? "";
+      const code = notice.code !== undefined && notice.code.length > 0 ? notice.code : undefined;
+      const entry = code === undefined ? { severity, message } : { severity, message, code };
+      (notices ??= []).push(entry);
+    },
+    start() {
+      return notices?.length ?? 0;
+    },
+    since(start) {
+      if (notices === undefined || notices.length === start)
+        return EMPTY_NOTICES;
+      return notices.slice(start);
+    }
+  };
+}
+
+class WireSession {
+  canCancel;
+  transactionDepth = 0;
+  local = new Set;
+  send;
+  notices;
+  isClosed;
+  onEnter;
+  onLeave;
+  shared;
+  constructor(send, notices, isClosed, canCancel, onEnter, onLeave, shared) {
+    this.send = send;
+    this.notices = notices;
+    this.isClosed = isClosed;
+    this.canCancel = canCancel;
+    this.onEnter = onEnter;
+    this.onLeave = onLeave;
+    this.shared = shared;
+  }
+  query(text, params, watch) {
+    if (this.isClosed())
+      return rejectClosed();
+    const start = this.notices.start();
+    this.onEnter();
+    const pending = this.send(text, params);
+    if (watch === undefined) {
+      return pending.then((result) => {
+        this.onLeave();
+        this.note(text);
+        return resultFrom(result, this.notices.since(start));
+      }, (error) => {
+        this.onLeave();
+        return driverErrors().then((errors) => Promise.reject(errors.mapDriverError(error)));
+      });
+    }
+    return this.watched(pending, watch, start, text);
+  }
+  inTransaction() {
+    return this.transactionDepth > 0;
+  }
+  abandon() {
+    this.transactionDepth = 0;
+  }
+  depth() {
+    return this.transactionDepth;
+  }
+  cancel() {
+    for (const pending of this.local)
+      pending.cancel?.();
+  }
+  note(text) {
+    this.transactionDepth = nextTransactionDepth(this.transactionDepth, text);
+  }
+  track(pending) {
+    this.local.add(pending);
+    this.shared?.add(pending);
+  }
+  untrack(pending) {
+    this.local.delete(pending);
+    this.shared?.delete(pending);
+  }
+  watched(pending, watch, start, text) {
+    this.track(pending);
+    const onAbort = () => {
+      pending.cancel?.();
+    };
+    if (watch.signal.aborted)
+      onAbort();
+    else
+      watch.signal.addEventListener("abort", onAbort, { once: true });
+    return pending.then((result) => {
+      this.finishWatched(pending, watch, onAbort);
+      const why = watch.reason();
+      if (why === "timeout" || why === "cancelled")
+        return classify(why, watch);
+      this.note(text);
+      return resultFrom(result, this.notices.since(start));
+    }, (error) => {
+      this.finishWatched(pending, watch, onAbort);
+      return classify(error, watch);
+    });
+  }
+  finishWatched(pending, watch, onAbort) {
+    this.onLeave();
+    this.untrack(pending);
+    watch.signal.removeEventListener("abort", onAbort);
+  }
+}
+async function* cursorStream(run, text, params) {
+  const name = "okm_stream";
+  await run("BEGIN");
+  try {
+    await run(`DECLARE ${name} NO SCROLL CURSOR FOR ${text}`, params);
+    for (;; ) {
+      const chunk = await run(`FETCH 64 FROM ${name}`);
+      if (chunk.rows.length === 0)
+        break;
+      yield chunk.rows;
+    }
+  } finally {
+    await run("ROLLBACK").catch(() => {
+      return;
+    });
+  }
+}
+async function classify(error, watch) {
+  const errors = await driverErrors();
+  if (error instanceof errors.DriverError)
+    return Promise.reject(error);
+  const why = typeof error === "string" ? error : watch.reason();
+  if (why === "timeout") {
+    return Promise.reject(errors.timedOut(typeof error === "string" ? undefined : error));
+  }
+  const code = errors.errorField(error, "code") ?? errors.errorField(error, "errno");
+  if (why === "cancelled" || code === "57014") {
+    return Promise.reject(errors.cancelled(typeof error === "string" ? undefined : error));
+  }
+  return Promise.reject(errors.mapDriverError(error));
+}
+
+export { quoteIdent2, noticeBuffer, WireSession, cursorStream };

package/dist/shared/0v1g424p.js

@@ -0,0 +1,26 @@
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/dialects/pg/filter-parse.ts
+function parseQuery(allow, sort, query) {
+  if (typeof query !== "object" || query === null || Array.isArray(query)) {
+    throw new OkmError2("OKM1121", "filters parse expects an object of fields.");
+  }
+  const where = {};
+  let orderBy;
+  for (const key of Object.keys(query)) {
+    const value = query[key];
+    if (key === "sort" && typeof value === "string" && sort.includes(value)) {
+      orderBy = { [value]: "asc" };
+      continue;
+    }
+    if (allow[key]?.includes("eq") === true && (value === null || typeof value !== "object")) {
+      where[key] = value;
+    }
+  }
+  return orderBy === undefined ? { where } : { where, orderBy };
+}
+export {
+  parseQuery
+};

package/dist/shared/1g0drakv.js

@@ -0,0 +1,225 @@
+import {
+  required
+} from "./c9z5g0fm.js";
+import {
+  definition,
+  rejected
+} from "./tmbdywx0.js";
+
+// src/dialects/pg/temporal.ts
+var TEMPORAL_MISSING = "Date and time codecs need the Temporal global. okmodel does not ship a polyfill. Use a runtime that provides Temporal, or assign a polyfill to globalThis.Temporal before using these columns.";
+function requireTemporal() {
+  const temporal = globalThis.Temporal;
+  if (typeof temporal !== "object" || temporal === null || !("Instant" in temporal)) {
+    rejected(TEMPORAL_MISSING);
+  }
+}
+function timePrecision(precision, role) {
+  if (precision === undefined) {
+    return;
+  }
+  if (!Number.isInteger(precision) || precision < 0 || precision > 6) {
+    definition(`${role} precision ${String(precision)} must be an integer from 0 to 6.`);
+  }
+  return precision;
+}
+function encodeInstant(value, precision) {
+  requireTemporal();
+  if (precision === undefined) {
+    return value.toString();
+  }
+  return value.toString({ fractionalSecondDigits: precision });
+}
+function decodeInstant(wire) {
+  requireTemporal();
+  try {
+    return Temporal.Instant.from(wire);
+  } catch {
+    rejected(`timestamptz ${wire} must be an ISO-8601 instant, for example 2020-01-01T00:00:00Z.`);
+  }
+}
+function encodeDateTime(value, precision) {
+  requireTemporal();
+  if (precision === undefined) {
+    return value.toString();
+  }
+  return value.toString({ fractionalSecondDigits: precision });
+}
+function decodeDateTime(wire) {
+  requireTemporal();
+  try {
+    return Temporal.PlainDateTime.from(wire);
+  } catch {
+    rejected(`timestamp ${wire} must be an ISO-8601 date-time without a zone, for example 2020-01-01T00:00:00.`);
+  }
+}
+function encodeDate(value) {
+  requireTemporal();
+  return value.toString();
+}
+function decodeDate(wire) {
+  requireTemporal();
+  try {
+    return Temporal.PlainDate.from(wire);
+  } catch {
+    rejected(`date ${wire} must be YYYY-MM-DD.`);
+  }
+}
+function encodeTime(value, precision) {
+  requireTemporal();
+  if (precision === undefined) {
+    return value.toString();
+  }
+  return value.toString({ fractionalSecondDigits: precision });
+}
+function decodeTime(wire) {
+  requireTemporal();
+  try {
+    return Temporal.PlainTime.from(wire);
+  } catch {
+    rejected(`time ${wire} must be a time of day, for example 00:00:00.`);
+  }
+}
+function encodeTimeZone(value, precision) {
+  requireTemporal();
+  if (!offsetText().test(value.offset)) {
+    rejected(`timetz offset ${value.offset} must be ±HH:MM.`);
+  }
+  return `${encodeTime(value.time, precision)}${value.offset}`;
+}
+function decodeTimeZone(wire) {
+  const match = timeZoneText().exec(wire);
+  const time = match?.[1];
+  const hours = match?.[2];
+  if (time === undefined || hours === undefined) {
+    rejected(`timetz ${wire} must be a time of day plus ±HH or ±HH:MM, for example 00:00:00+00.`);
+  }
+  return { time: decodeTime(time), offset: `${hours}:${match?.[3] ?? "00"}` };
+}
+function encodeDuration(value) {
+  requireTemporal();
+  const text = value.toString();
+  return text.startsWith("-") ? text.slice(1).replace(/\d+(?:\.\d+)?(?=[A-Z])/g, "-$&") : text;
+}
+function decodeDuration(wire) {
+  requireTemporal();
+  const fields = {};
+  const rest = wire.replace(/([+-]?\d+) (year|mon|day)s?|([+-]?)(\d+):(\d{2}):(\d{2})(?:\.(\d{1,6}))?/g, (_part, count, unit, sign, h = "", m = "", s = "", f = "") => {
+    if (count !== undefined && unit !== undefined) {
+      fields[`${unit === "mon" ? "month" : unit}s`] = Number(count);
+      return "";
+    }
+    const micros = Number(f.padEnd(6, "0"));
+    const flip = sign === "-" ? -1 : 1;
+    fields.hours = flip * Number(h);
+    fields.minutes = flip * Number(m);
+    fields.seconds = flip * Number(s);
+    fields.milliseconds = flip * Math.trunc(micros / 1000);
+    fields.microseconds = flip * (micros % 1000);
+    return "";
+  });
+  try {
+    return Temporal.Duration.from(rest.trim() === "" && wire !== "" ? fields : wire);
+  } catch {
+    rejected(`interval ${wire} must be what Postgres sends (for example 01:30:00 or 1 day 02:03:04) or an ISO-8601 duration (PT1H). Parts of different signs are not one Temporal.Duration.`);
+  }
+}
+function intervalFields(fields) {
+  switch (fields) {
+    case "year":
+    case "month":
+    case "day":
+    case "hour":
+    case "minute":
+    case "second":
+    case "year to month":
+    case "day to hour":
+    case "day to minute":
+    case "day to second":
+    case "hour to minute":
+    case "hour to second":
+    case "minute to second":
+      return fields;
+    default:
+      definition(`interval fields ${fields} must be one of: year, month, day, hour, minute, second, year to month, day to hour, day to minute, day to second, hour to minute, hour to second, minute to second.`);
+  }
+}
+function offsetText() {
+  offsetPattern ??= /^[+-]\d{2}:\d{2}$/;
+  return offsetPattern;
+}
+function timeZoneText() {
+  timeZonePattern ??= /^(.+?)([+-]\d{2})(?::(\d{2}))?$/;
+  return timeZonePattern;
+}
+var offsetPattern;
+var timeZonePattern;
+
+// src/dialects/pg/time.ts
+function timestamptz2(precision) {
+  const digits = timePrecision(precision, "timestamptz");
+  return required({
+    baseType: timed("timestamptz", digits),
+    encode: (value) => encodeInstant(value, digits),
+    decode: decodeInstant,
+    accepts: ["Temporal.Instant"],
+    sqlForm: "quote"
+  });
+}
+function timestamp2(precision) {
+  const digits = timePrecision(precision, "timestamp");
+  return required({
+    baseType: timed("timestamp", digits),
+    encode: (value) => encodeDateTime(value, digits),
+    decode: decodeDateTime,
+    accepts: ["Temporal.PlainDateTime"],
+    sqlForm: "quote"
+  });
+}
+function date2() {
+  return required({
+    baseType: "date",
+    encode: encodeDate,
+    decode: decodeDate,
+    accepts: ["Temporal.PlainDate"],
+    sqlForm: "quote"
+  });
+}
+function time2(precision) {
+  const digits = timePrecision(precision, "time");
+  return required({
+    baseType: timed("time", digits),
+    encode: (value) => encodeTime(value, digits),
+    decode: decodeTime,
+    accepts: ["Temporal.PlainTime"],
+    sqlForm: "quote"
+  });
+}
+function timetz2(precision) {
+  const digits = timePrecision(precision, "timetz");
+  return required({
+    baseType: timed("timetz", digits),
+    encode: (value) => encodeTimeZone(value, digits),
+    decode: decodeTimeZone,
+    accepts: ["Object"],
+    sqlForm: "quote"
+  });
+}
+function interval2(fields) {
+  const qualifier = fields === undefined ? undefined : intervalFields(fields);
+  return required({
+    baseType: qualifier === undefined ? "interval" : `interval ${qualifier}`,
+    encode: encodeDuration,
+    decode: decodeDuration,
+    accepts: ["Temporal.Duration"],
+    sqlForm: "quote"
+  });
+}
+function timed(name, precision) {
+  if (precision === undefined) {
+    return name;
+  }
+  return `${name}(${String(precision)})`;
+}
+
+export { encodeInstant, decodeInstant, encodeDate, decodeDate, timestamptz2, timestamp2, date2, time2, timetz2, interval2 };

package/dist/shared/{kprcwaha.js → 1tfdfvhh.js}

@@ -1,8 +1,10 @@
-import"./y9m15dfv.js";
+import"./t616ynfn.js";
+import"./n442h54c.js";
 import {
   listTargets,
   loadConfig
-} from "./05w44d8g.js";
+} from "./5nmdenb6.js";
+import"./2ssqrv66.js";
 
 // src/tooling/migrate/dev.ts
 import { mkdirSync } from "node:fs";
@@ -15,7 +17,7 @@ async function devProject(cwd) {
 `;
   const directory = join(cwd, config.out ?? ".okm", "dev-db");
   mkdirSync(directory, { recursive: true });
-  const { open } = await import("./8b04d28c.js");
+  const { open } = await import("./kgnc8grt.js");
   const pool = await open({ dataDir: directory });
   try {
     await pool.execute("select 1");