okmodel 0.0.0 → 0.1.1

package/dist/shared/523ft3e8.js

@@ -0,0 +1,171 @@
+import {
+  open2
+} from "./dkn3y60a.js";
+import"./y9m15dfv.js";
+import {
+  loadMigrations
+} from "./jjb7yht9.js";
+import {
+  assertTargetPolicy,
+  listTargets,
+  loadConfig
+} from "./05w44d8g.js";
+import {
+  OkmError2
+} from "./ycwz42az.js";
+
+// src/tooling/migrate/status.ts
+import { join } from "node:path";
+function describeStatus(migrations, history, recorded) {
+  const done = new Set(history.map((row) => `${row.migrationId}:${String(row.stepIndex)}`));
+  const known = new Set(migrations.map((migration) => migration.id));
+  for (const migration of migrations) {
+    let have = 0;
+    let missing = -1;
+    for (let index = 0;index < migration.steps.length; index += 1) {
+      if (done.has(`${migration.id}:${String(index)}`))
+        have += 1;
+      else if (missing < 0)
+        missing = index;
+    }
+    if (have > 0 && missing >= 0) {
+      return {
+        version: migration.id,
+        catalogHash: recorded?.hash ?? "-",
+        state: `failed at step ${String(missing)}`
+      };
+    }
+  }
+  const extra = history.some((row) => !known.has(row.migrationId));
+  const pending = migrations.filter((migration) => migration.steps.some((_, index) => !done.has(`${migration.id}:${String(index)}`)));
+  const finished = lastComplete(migrations, done);
+  const version = recorded?.version ?? finished ?? "-";
+  const catalogHash = recorded?.hash ?? "-";
+  if (extra)
+    return { version, catalogHash, state: "ahead" };
+  if (pending.length > 0) {
+    const contract = pending.some((migration) => migration.steps.some((step) => step.class !== "expand"));
+    return {
+      version,
+      catalogHash,
+      state: contract ? "behind by contract" : "behind by expand"
+    };
+  }
+  const last = migrations.at(-1);
+  if (last !== undefined && recorded !== undefined && recorded.hash !== last.catalogHash) {
+    return { version, catalogHash, state: "ahead" };
+  }
+  return {
+    version: recorded?.version ?? last?.id ?? "-",
+    catalogHash: recorded?.hash ?? last?.catalogHash ?? "-",
+    state: "current"
+  };
+}
+async function readTargetStatus(input) {
+  assertTargetPolicy({ name: input.target, protected: input.protected }, "status");
+  const pool = open2({
+    url: input.url,
+    max: 1,
+    ...input.searchPath !== undefined ? { searchPath: input.searchPath } : {}
+  });
+  try {
+    const present = await pool.execute("select (to_regclass('okm_meta') is not null), (to_regclass('okm_history') is not null)");
+    const meta = wireTrue(present.rows[0]?.[0] ?? null);
+    const history = wireTrue(present.rows[0]?.[1] ?? null);
+    const recorded = meta ? await readMeta(pool) : undefined;
+    const rows = history ? await readHistory(pool) : [];
+    const described = describeStatus(input.migrations, rows, recorded);
+    return {
+      target: input.target,
+      version: described.version,
+      catalogHash: described.catalogHash,
+      state: described.state,
+      protected: input.protected
+    };
+  } finally {
+    await pool.close();
+  }
+}
+async function statusProject(cwd, flags) {
+  const config = await loadConfig(cwd);
+  const targets = chosen(listTargets(config), flags.target);
+  const migrations = loadMigrations(join(cwd, config.migrations ?? "migrations"));
+  const rows = [];
+  for (const target of targets) {
+    rows.push(await readTargetStatus({
+      url: target.url,
+      target: target.name,
+      protected: target.protected,
+      migrations
+    }));
+  }
+  return formatStatus(rows);
+}
+function formatStatus(rows) {
+  const lines = ["target\tversion\tcatalog\tstate\tprotected"];
+  for (const row of rows) {
+    lines.push([row.target, row.version, row.catalogHash, row.state, row.protected ? "true" : "false"].join("\t"));
+  }
+  return `${lines.join(`
+`)}
+`;
+}
+function chosen(targets, name) {
+  if (targets.length === 0) {
+    throw new OkmError2("OKM1845", "No target is configured.", {
+      fix: { summary: "Set database or targets in okmodel.config.ts." }
+    });
+  }
+  if (name === undefined)
+    return targets;
+  const found = targets.find((target) => target.name === name);
+  if (found === undefined) {
+    throw new OkmError2("OKM1845", `Target ${name} is not configured.`, {
+      fix: { summary: "Pass a name from targets." }
+    });
+  }
+  return [found];
+}
+function lastComplete(migrations, done) {
+  let version;
+  for (const migration of migrations) {
+    if (migration.steps.length === 0)
+      continue;
+    const complete = migration.steps.every((_, index) => done.has(`${migration.id}:${String(index)}`));
+    if (!complete)
+      break;
+    version = migration.id;
+  }
+  return version;
+}
+async function readMeta(pool) {
+  const result = await pool.execute("select catalog_hash, migration_id from okm_meta where id = 'head'");
+  const hash = result.rows[0]?.[0];
+  const version = result.rows[0]?.[1];
+  if (hash === null || hash === undefined || version === null || version === undefined)
+    return;
+  return { hash, version };
+}
+async function readHistory(pool) {
+  const result = await pool.execute("select migration_id, step_index::text, class from okm_history order by migration_id, step_index");
+  const rows = [];
+  for (const row of result.rows) {
+    const migrationId = row[0];
+    const step = row[1];
+    const stepClass = row[2];
+    if (migrationId == null || step == null || stepClass == null)
+      continue;
+    rows.push({
+      migrationId,
+      stepIndex: Number(step),
+      class: stepClass === "contract" || stepClass === "unclassified" ? stepClass : "expand"
+    });
+  }
+  return rows;
+}
+function wireTrue(value) {
+  return value === "t" || value === "true";
+}
+export {
+  statusProject
+};

package/dist/shared/8b04d28c.js

@@ -0,0 +1,14 @@
+import {
+  open3
+} from "./fgqgsb5z.js";
+import {
+  PGLITE_CAPABILITIES,
+  readCapability2,
+  hasCapability2
+} from "./xy79j5hq.js";
+export {
+  PGLITE_CAPABILITIES as capabilities,
+  hasCapability2 as hasCapability,
+  open3 as open,
+  readCapability2 as readCapability
+};

package/dist/shared/cn0n68ft.js

@@ -0,0 +1,16 @@
+// src/dialects/pg/operators.ts
+var RUNTIME = Symbol("okmodel.operator");
+function isOperator(value) {
+  return typeof value === "object" && value !== null && RUNTIME in value;
+}
+function operatorName(value) {
+  return value[RUNTIME];
+}
+function operatorValue(value) {
+  return value.value;
+}
+function tag(name, value) {
+  return { [RUNTIME]: name, value };
+}
+
+export { isOperator, operatorName, operatorValue, tag };

package/dist/shared/dkn3y60a.js

@@ -0,0 +1,374 @@
+import {
+  POSTGRESJS_CAPABILITIES,
+  driverErrors,
+  rejectClosed,
+  mapFailure,
+  nextTransactionDepth,
+  runCall,
+  EMPTY_NOTICES,
+  resultFrom
+} from "./xy79j5hq.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();
+    });
+  }
+  async hold(checkout) {
+    this.busy += 1;
+    this.wake();
+    try {
+      const connection = await checkout();
+      let released = false;
+      const release = connection.release.bind(connection);
+      connection.release = () => {
+        if (released)
+          return Promise.resolve();
+        released = true;
+        return release().finally(() => {
+          this.busy -= 1;
+          this.park();
+        });
+      };
+      return connection;
+    } catch (error) {
+      this.busy -= 1;
+      this.park();
+      throw error;
+    }
+  }
+  async* stream(open) {
+    this.busy += 1;
+    this.wake();
+    try {
+      yield* open();
+    } finally {
+      this.busy -= 1;
+      this.park();
+    }
+  }
+  async listen(start) {
+    this.listeners += 1;
+    this.wake();
+    try {
+      const stop = await start();
+      let stopped = false;
+      return async () => {
+        if (stopped)
+          return;
+        stopped = true;
+        try {
+          await stop();
+        } finally {
+          this.listeners -= 1;
+          this.park();
+        }
+      };
+    } catch (error) {
+      this.listeners -= 1;
+      this.park();
+      throw error;
+    }
+  }
+  wake() {
+    for (const socket of this.held)
+      socket.ref();
+  }
+  park() {
+    if (this.busy > 0 || this.listeners > 0)
+      return;
+    for (const socket of this.held)
+      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 open2(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 PgSession(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)));
+    },
+    async batch(statements, options) {
+      return sockets.occupy(async () => {
+        const { checkout } = await import("./xqbhg6cn.js");
+        const connection = await checkout(held);
+        try {
+          return await connection.batch(statements, options);
+        } finally {
+          await connection.release();
+        }
+      });
+    },
+    reserve() {
+      return sockets.hold(async () => {
+        const mod = await import("./xqbhg6cn.js");
+        return mod.checkout(held);
+      });
+    },
+    describe: (text, params) => sockets.occupy(() => import("./xqbhg6cn.js").then((mod) => mod.describe(sql, text, params))),
+    stream(text, params) {
+      return sockets.stream(() => loadStream(sql, text, params));
+    },
+    listen(channel, onNotify) {
+      return sockets.listen(async () => {
+        const listening = await sql.listen(channel, onNotify);
+        return async () => {
+          await listening.unlisten();
+        };
+      });
+    },
+    cancel() {
+      for (const pending of poolInflight)
+        pending.cancel();
+    },
+    stats: () => statsOf(counters, max),
+    async close() {
+      closed = true;
+      await sql.end({ timeout: 5 });
+    }
+  };
+}
+
+class PgSession {
+  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;
+        });
+      });
+    }
+    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);
+  }
+  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);
+  }
+  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.leave();
+    this.untrack(pending);
+    watch.signal.removeEventListener("abort", onAbort);
+  }
+}
+async function* loadStream(sql, text, params) {
+  const { stream } = await import("./xqbhg6cn.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;
+}
+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");
+  if (why === "cancelled" || code === "57014") {
+    return Promise.reject(errors.cancelled(typeof error === "string" ? undefined : error));
+  }
+  return Promise.reject(errors.mapDriverError(error));
+}
+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 { open2, PgSession };

package/dist/shared/dynq16vb.js

@@ -0,0 +1,81 @@
+import {
+  DriverError2,
+  outcomeUnknown2,
+  mapDriverError2
+} from "./hd293j9g.js";
+import {
+  isConnectionFailure
+} from "./ngk8gj61.js";
+
+// src/adapters/pg/batch.ts
+var savepointIds = 0;
+async function runAtomicBatch(session, statements, watch) {
+  if (session.inTransaction())
+    return savepoint(session, statements, watch);
+  return transaction(session, statements, watch);
+}
+async function transaction(session, statements, watch) {
+  try {
+    await control(session, "BEGIN", watch);
+    const results = await statementsOf(session, statements, watch);
+    try {
+      await control(session, "COMMIT", watch);
+    } catch (error) {
+      if (isConnectionFailure(error))
+        throw outcomeUnknown2(error);
+      throw stamp(error, null);
+    }
+    return results;
+  } catch (error) {
+    await rollback(session);
+    throw error;
+  }
+}
+async function savepoint(session, statements, watch) {
+  savepointIds += 1;
+  const name = `okm_b${String(savepointIds)}`;
+  try {
+    await control(session, `SAVEPOINT ${name}`, watch);
+    const results = await statementsOf(session, statements, watch);
+    await control(session, `RELEASE SAVEPOINT ${name}`, watch);
+    return results;
+  } catch (error) {
+    await rollback(session, `ROLLBACK TO SAVEPOINT ${name}`);
+    throw error;
+  }
+}
+function control(session, text, watch) {
+  return session.query(text, undefined, watch).then(() => {
+    return;
+  });
+}
+async function rollback(session, text = "ROLLBACK") {
+  try {
+    await session.query(text, undefined, undefined);
+  } catch {
+    session.abandon();
+  }
+}
+async function statementsOf(session, statements, watch) {
+  const results = Array.from({ length: statements.length });
+  for (let index = 0;index < statements.length; index += 1) {
+    const statement = statements[index];
+    if (statement === undefined)
+      continue;
+    try {
+      results[index] = await session.query(statement.text, statement.params, watch);
+    } catch (error) {
+      throw stamp(error, index);
+    }
+  }
+  return results;
+}
+function stamp(error, batchIndex) {
+  const mapped = mapDriverError2(error, batchIndex);
+  if (mapped instanceof DriverError2)
+    return mapped;
+  return error;
+}
+export {
+  runAtomicBatch
+};