okmodel 0.7.0 → 0.9.0

package/dist/tooling/shared/5x3pf400.js

@@ -0,0 +1,185 @@
+// src/adapters/capabilities.ts
+var POSTGRESJS_CAPABILITIES = {
+  transactions: "interactive",
+  stream: true,
+  listen: true,
+  cancel: true,
+  prepared: "unnamed",
+  describe: true
+};
+var PGLITE_CAPABILITIES = {
+  transactions: "interactive",
+  stream: false,
+  listen: true,
+  cancel: false,
+  prepared: "unnamed",
+  describe: true
+};
+var NODE_POSTGRES_CAPABILITIES = {
+  transactions: "interactive",
+  stream: true,
+  listen: true,
+  cancel: true,
+  prepared: "unnamed",
+  describe: false
+};
+var BUNSQL_CAPABILITIES = {
+  transactions: "interactive",
+  stream: true,
+  listen: true,
+  cancel: false,
+  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];
+}
+function hasCapability2(flags, name) {
+  return flags[name];
+}
+
+// src/adapters/failure.ts
+var loading;
+function driverErrors() {
+  loading ??= import("./a2xe04bm.js");
+  return loading;
+}
+function rejectClosed() {
+  return import("./sjwkt1pg.js").then((mod) => mod.closed());
+}
+function rejectUncancellable() {
+  return import("./sjwkt1pg.js").then((mod) => mod.refused());
+}
+function rejectCancelled() {
+  return driverErrors().then((mod) => Promise.reject(mod.cancelled()));
+}
+function rejectTimedOut() {
+  return driverErrors().then((mod) => Promise.reject(mod.timedOut()));
+}
+async function mapFailure(error) {
+  const mod = await driverErrors();
+  return mod.mapDriverError(error);
+}
+
+// src/adapters/pg/call.ts
+function needsWatch(options) {
+  return options?.signal !== undefined || options?.timeout !== undefined;
+}
+function nextTransactionDepth(depth, text) {
+  const command = text.trim().replace(/;\s*$/, "").trim().toLowerCase();
+  if (/^(?:begin|start transaction)(?:\s|$)/.test(command))
+    return depth + 1;
+  if (command === "commit" || command === "commit work" || command === "end") {
+    return Math.max(0, depth - 1);
+  }
+  if (command === "rollback" || command === "rollback work")
+    return 0;
+  return depth;
+}
+function runCall(closed, options, fn) {
+  if (closed)
+    return rejectClosed();
+  if (options?.signal?.aborted === true)
+    return rejectCancelled();
+  if (options?.timeout !== undefined && options.timeout <= 0)
+    return rejectTimedOut();
+  if (options === undefined || !needsWatch(options))
+    return fn(undefined);
+  const watched = options;
+  return import("./54tqkxja.js").then(({ openWatch }) => {
+    const watch = openWatch(watched);
+    return fn(watch).finally(() => {
+      watch.finish();
+    });
+  });
+}
+
+// src/adapters/pg/result.ts
+var EMPTY_NOTICES = [];
+function cell(value) {
+  if (value === null || value === undefined)
+    return null;
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "bigint")
+    return value.toString();
+  if (value instanceof Uint8Array)
+    return new TextDecoder().decode(value);
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  return null;
+}
+function rowsFrom(value) {
+  const list = rowList(value);
+  const rows = Array.from({ length: list.length });
+  for (let index = 0;index < list.length; index += 1) {
+    rows[index] = rowCells(list[index]);
+  }
+  return rows;
+}
+function resultFrom(value, notices) {
+  const rows = rowsFrom(value);
+  return {
+    rows,
+    count: countFrom(value, rows.length),
+    notices
+  };
+}
+function rowList(value) {
+  if (Array.isArray(value))
+    return value;
+  if (typeof value === "object" && value !== null && "rows" in value) {
+    const rows = Reflect.get(value, "rows");
+    if (Array.isArray(rows))
+      return rows;
+  }
+  return [];
+}
+function rowCells(row) {
+  if (Array.isArray(row)) {
+    const cells = Array.from({ length: row.length });
+    for (let index = 0;index < row.length; index += 1)
+      cells[index] = cell(row[index]);
+    return cells;
+  }
+  if (typeof row === "object" && row !== null) {
+    const values = Object.values(row);
+    const cells = Array.from({ length: values.length });
+    for (let index = 0;index < values.length; index += 1)
+      cells[index] = cell(values[index]);
+    return cells;
+  }
+  return [cell(row)];
+}
+function countFrom(value, rows) {
+  if (typeof value !== "object" || value === null)
+    return rows;
+  const count = Reflect.get(value, "count");
+  if (typeof count === "number" && !Number.isNaN(count))
+    return count;
+  const rowCount = Reflect.get(value, "rowCount");
+  if (typeof rowCount === "number" && !Number.isNaN(rowCount))
+    return rowCount;
+  const affected = Reflect.get(value, "affectedRows");
+  if (typeof affected === "number" && !Number.isNaN(affected))
+    return affected;
+  return rows;
+}
+
+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/tooling/shared/5zrzffnk.js

@@ -0,0 +1,6 @@
+import {
+  stack2
+} from "./35zemrmf.js";
+export {
+  stack2 as stack
+};

package/dist/tooling/shared/62fxpc1p.js

@@ -0,0 +1,332 @@
+import {
+  POSTGRESJS_CAPABILITIES,
+  rejectClosed,
+  mapFailure,
+  nextTransactionDepth,
+  runCall,
+  EMPTY_NOTICES,
+  resultFrom
+} from "./5x3pf400.js";
+
+// src/adapters/pg/postgresjs.ts
+import net from "node:net";
+import postgres from "postgres";
+class PoolSockets {
+  held = [];
+  busy = 0;
+  listeners = 0;
+  hostCursor = 0;
+  connect(target) {
+    const path = typeof target.path === "string" ? target.path : undefined;
+    const hosts = target.host;
+    const ports = target.port;
+    const index = hosts.length === 0 ? 0 : this.hostCursor % hosts.length;
+    this.hostCursor += 1;
+    const host = hosts[index] ?? "localhost";
+    const port = ports[index] ?? ports[0] ?? 5432;
+    const socket = path !== undefined ? net.connect(path) : net.connect(port, host);
+    this.held.push(socket);
+    return socket;
+  }
+  occupy(run) {
+    this.busy += 1;
+    this.wake();
+    return run().finally(() => {
+      this.busy -= 1;
+      this.park();
+    });
+  }
+  busyGate() {
+    return {
+      enter: () => {
+        this.busy += 1;
+        this.wake();
+      },
+      leave: () => {
+        this.busy -= 1;
+        this.park();
+      }
+    };
+  }
+  listenerGate() {
+    return {
+      enter: () => {
+        this.listeners += 1;
+        this.wake();
+      },
+      leave: () => {
+        this.listeners -= 1;
+        this.park();
+      }
+    };
+  }
+  wake() {
+    for (const socket of this.held)
+      if (socket.writable)
+        socket.ref();
+  }
+  park() {
+    if (this.busy > 0 || this.listeners > 0)
+      return;
+    for (const socket of this.held)
+      if (socket.writable)
+        socket.unref();
+  }
+}
+function driverOptions(config, state) {
+  return {
+    max: state.max,
+    prepare: state.named,
+    idle_timeout: state.plain ? 0 : 30,
+    ...state.plain ? { max_lifetime: null } : {},
+    connect_timeout: 5,
+    types: WIRE_TYPES,
+    ...state.plain ? { socket: (options) => state.sockets.connect(options) } : {},
+    ...config.ssl !== undefined ? { ssl: config.ssl } : {},
+    connection: {
+      application_name: "okmodel",
+      ...config.searchPath !== undefined ? { search_path: config.searchPath } : {}
+    },
+    onnotice(notice) {
+      state.notices.push(notice);
+    }
+  };
+}
+function open3(config) {
+  const max = config.max ?? 10;
+  const acquireMs = config.timeouts?.acquire;
+  const counters = { reserved: 0, busy: 0, reservedBusy: 0, waiting: 0 };
+  const poolInflight = new Set;
+  const notices = noticeBuffer();
+  let closed = false;
+  const isClosed = () => closed;
+  const named = config.prepared === "named";
+  const plain = config.ssl === undefined;
+  const sockets = new PoolSockets;
+  const sql = postgres(config.url, driverOptions(config, {
+    max,
+    named,
+    plain,
+    notices,
+    sockets
+  }));
+  const root = new PgSession2(sql, counters, "pool", poolInflight, isClosed, undefined, notices, named);
+  const held = { sql, acquireMs, counters, isClosed, notices, named, poolInflight };
+  return {
+    capabilities: POSTGRESJS_CAPABILITIES,
+    execute(text, params, options) {
+      return sockets.occupy(() => runCall(closed, options, (watch) => root.query(text, params, watch)));
+    },
+    batch(statements, options) {
+      return sockets.occupy(() => import("./04svnxxj.js").then((mod) => mod.runBatch(held, statements, options)));
+    },
+    reserve() {
+      const gate = sockets.busyGate();
+      gate.enter();
+      return import("./04svnxxj.js").then((mod) => mod.holdCheckout(gate, () => mod.checkout(held)), (error) => {
+        gate.leave();
+        throw error;
+      });
+    },
+    describe: (text, params) => sockets.occupy(() => import("./04svnxxj.js").then((mod) => mod.describe(sql, text, params))),
+    stream(text, params) {
+      const gate = sockets.busyGate();
+      return async function* () {
+        gate.enter();
+        try {
+          yield* loadStream(sql, text, params);
+        } finally {
+          gate.leave();
+        }
+      }();
+    },
+    listen(channel, onNotify) {
+      const gate = sockets.listenerGate();
+      gate.enter();
+      return import("./04svnxxj.js").then((mod) => mod.holdListener(gate, async () => {
+        const listening = await sql.listen(channel, onNotify);
+        return async () => {
+          await listening.unlisten();
+        };
+      }), (error) => {
+        gate.leave();
+        throw error;
+      });
+    },
+    cancel() {
+      for (const pending of poolInflight)
+        pending.cancel();
+    },
+    stats: () => statsOf(counters, max),
+    async close() {
+      closed = true;
+      await sql.end({ timeout: 5 });
+    }
+  };
+}
+
+class PgSession2 {
+  canCancel = true;
+  transactionDepth = 0;
+  sql;
+  counters;
+  scope;
+  local;
+  isClosed;
+  shared;
+  notices;
+  named;
+  constructor(sql, counters, scope, local, isClosed, shared, notices, named) {
+    this.sql = sql;
+    this.counters = counters;
+    this.scope = scope;
+    this.local = local;
+    this.isClosed = isClosed;
+    this.shared = shared;
+    this.notices = notices;
+    this.named = named;
+  }
+  query(text, params, watch) {
+    if (this.isClosed())
+      return rejectClosed();
+    const start = this.notices.start();
+    this.enter();
+    const pending = send(this.sql, text, params, this.named);
+    if (watch === undefined) {
+      return pending.then((result) => {
+        this.leave();
+        this.note(text);
+        return resultFrom(result, this.notices.since(start));
+      }, (error) => {
+        this.leave();
+        return mapFailure(error).then((mapped) => {
+          throw mapped;
+        });
+      });
+    }
+    this.local.add(pending);
+    this.shared?.add(pending);
+    const onAbort = () => {
+      pending.cancel();
+    };
+    if (watch.signal.aborted)
+      onAbort();
+    else
+      watch.signal.addEventListener("abort", onAbort, { once: true });
+    return import("./04svnxxj.js").then((mod) => mod.watchQuery(pending, watch, onAbort, {
+      start,
+      text,
+      notices: this.notices,
+      leave: () => {
+        this.leave();
+      },
+      note: (sqlText) => {
+        this.note(sqlText);
+      },
+      untrack: (item) => {
+        this.local.delete(item);
+        this.shared?.delete(item);
+      }
+    }), (error) => {
+      this.leave();
+      this.local.delete(pending);
+      this.shared?.delete(pending);
+      watch.signal.removeEventListener("abort", onAbort);
+      throw error;
+    });
+  }
+  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);
+  }
+  enter() {
+    if (this.scope === "pool")
+      this.counters.busy += 1;
+    else
+      this.counters.reservedBusy += 1;
+  }
+  leave() {
+    if (this.scope === "pool")
+      this.counters.busy = Math.max(0, this.counters.busy - 1);
+    else
+      this.counters.reservedBusy = Math.max(0, this.counters.reservedBusy - 1);
+  }
+}
+async function* loadStream(sql, text, params) {
+  const { stream } = await import("./04svnxxj.js");
+  yield* stream(sql, text, params);
+}
+function send(sql, text, params, named) {
+  if (!named && (params === undefined || params.length === 0))
+    return sql.unsafe(text).raw();
+  return sql.unsafe(text, asParams(params), { prepare: named }).raw();
+}
+function asParams(params) {
+  if (params === undefined)
+    return [];
+  return params;
+}
+function statsOf(counters, size) {
+  return {
+    size,
+    idle: Math.max(0, size - counters.reserved - counters.busy),
+    inflight: counters.busy + counters.reservedBusy,
+    waiting: counters.waiting
+  };
+}
+function noticeBuffer() {
+  let notices;
+  return {
+    push(notice) {
+      const severity = typeof notice.severity === "string" ? notice.severity : "";
+      const message = typeof notice.message === "string" ? notice.message : "";
+      const code = typeof notice.code === "string" && 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);
+    }
+  };
+}
+function wire(to, from) {
+  return {
+    to,
+    from: [...from],
+    serialize: (value) => value,
+    parse: (value) => value
+  };
+}
+var WIRE_TYPES = {
+  number: wire(0, [21, 23, 26, 700, 701]),
+  boolean: wire(16, [16]),
+  bytea: wire(17, [17]),
+  json: wire(114, [114, 3802]),
+  date: wire(1184, [1082, 1114, 1184]),
+  boolArray: wire(1000, [1000]),
+  int2Array: wire(1005, [1005]),
+  int4Array: wire(1007, [1007]),
+  textArray: wire(1009, [1009]),
+  int8Array: wire(1016, [1016]),
+  numericArray: wire(1231, [1231]),
+  jsonbArray: wire(3807, [3807])
+};
+
+export { open3, PgSession2 };

package/dist/tooling/shared/68tf18v4.js

@@ -0,0 +1,20 @@
+import {
+  open5,
+  connectClient3,
+  send4
+} from "./am04v8na.js";
+import {
+  NEON_WEBSOCKET_CAPABILITIES,
+  NEON_HTTP_CAPABILITIES,
+  readCapability2,
+  hasCapability2
+} from "./5x3pf400.js";
+export {
+  NEON_WEBSOCKET_CAPABILITIES as capabilities,
+  connectClient3 as connectClient,
+  hasCapability2 as hasCapability,
+  NEON_HTTP_CAPABILITIES as httpCapabilities,
+  open5 as open,
+  readCapability2 as readCapability,
+  send4 as send
+};

package/dist/tooling/shared/6vk28rjp.js

@@ -0,0 +1,98 @@
+import {
+  historySql2
+} from "./dhatassp.js";
+import"./jr2nmr81.js";
+import {
+  OkmError
+} from "./hfq3n3bd.js";
+
+// src/runtime/compat-words.ts
+var BEHIND_EXPAND = "behind by expand";
+var BEHIND_CONTRACT = "behind by contract";
+var AHEAD_CONTRACT = "ahead by contract";
+
+// src/runtime/drift-detail.ts
+function driftVerdict(codeHash, recordedHash, migrations) {
+  const codeAt = indexOfHash(migrations, codeHash);
+  const recordedAt = indexOfHash(migrations, recordedHash);
+  if (codeAt >= 0 && recordedAt >= codeAt) {
+    for (let index = codeAt + 1;index <= recordedAt; index += 1) {
+      const migration = migrations[index];
+      if (migration !== undefined && migration.expand !== true) {
+        return { state: "ahead by contract", migrationId: migration.id };
+      }
+    }
+    return { state: "ok" };
+  }
+  if (codeAt >= 0 && recordedAt >= 0 && recordedAt < codeAt) {
+    const next = migrations[recordedAt + 1];
+    if (next !== undefined) {
+      return {
+        state: next.expand ? "behind by expand" : "behind by contract",
+        migrationId: next.id
+      };
+    }
+  }
+  if (recordedAt >= 0) {
+    const at = migrations[recordedAt];
+    if (at !== undefined)
+      return { state: "behind", migrationId: at.id };
+  }
+  const last = migrations.at(-1);
+  return { state: "behind", migrationId: last?.id ?? "" };
+}
+async function assertDrift(pool, codeHash, recordedHash, options, namespace = "public") {
+  let rows;
+  try {
+    const result = await pool.execute(await historySql2(namespace), undefined, options);
+    rows = result.rows;
+  } catch (error) {
+    throw gapError({ state: "behind", migrationId: "" }, error);
+  }
+  const verdict = driftVerdict(codeHash, recordedHash, groupMigrations(rows));
+  if (verdict.state === "ok")
+    return;
+  throw gapError(verdict);
+}
+function indexOfHash(migrations, hash) {
+  let found = -1;
+  for (let index = 0;index < migrations.length; index += 1) {
+    if (migrations[index]?.catalogHash === hash)
+      found = index;
+  }
+  return found;
+}
+function groupMigrations(rows) {
+  const grouped = [];
+  for (const row of rows) {
+    const id = row[0];
+    const stepClass = row[1];
+    const hash = row[2];
+    if (id == null || stepClass == null || hash == null)
+      continue;
+    const expand = stepClass === "expand";
+    const last = grouped.at(-1);
+    if (last !== undefined && last.id === id) {
+      grouped[grouped.length - 1] = {
+        id,
+        catalogHash: hash,
+        expand: last.expand && expand
+      };
+      continue;
+    }
+    grouped.push({ id, catalogHash: hash, expand });
+  }
+  return grouped;
+}
+function gapError(verdict, cause) {
+  const named = verdict.migrationId;
+  const phrase = verdict.state === "ahead by contract" ? `${AHEAD_CONTRACT} migration ${named}` : verdict.state === "behind by expand" ? `${BEHIND_EXPAND} migration ${named}` : verdict.state === "behind by contract" ? `${BEHIND_CONTRACT} migration ${named}` : named.length > 0 ? `behind the app at migration ${named}` : "behind the app";
+  const fix = named.length > 0 ? `Apply ${named}, or change the deploy order.` : "Apply migrations, or change the deploy order.";
+  return new OkmError("OKM1520", `The database is ${phrase}.`, {
+    ...cause === undefined ? {} : { cause },
+    fix: { summary: fix }
+  });
+}
+export {
+  assertDrift
+};

package/dist/tooling/shared/76pv6qff.js

@@ -0,0 +1,9 @@
+import {
+  historySql2,
+  acceptServer2
+} from "./dhatassp.js";
+import"./jr2nmr81.js";
+export {
+  acceptServer2 as acceptServer,
+  historySql2 as historySql
+};