okmodel 0.0.0 → 0.1.0

package/dist/shared/fgqgsb5z.js

@@ -0,0 +1,281 @@
+import {
+  PGLITE_CAPABILITIES,
+  driverErrors,
+  rejectClosed,
+  rejectCancelled,
+  rejectTimedOut,
+  mapFailure,
+  nextTransactionDepth,
+  runCall,
+  EMPTY_NOTICES,
+  resultFrom
+} from "./xy79j5hq.js";
+
+// src/adapters/pg/pglite.ts
+import { PGlite } from "@electric-sql/pglite";
+var RESET_ALL = "RESET ALL";
+var UNLOCK = "SELECT pg_advisory_unlock_all()";
+async function open3(config = {}) {
+  const db = new PGlite({
+    dataDir: config.dataDir ?? "memory://",
+    parsers: WIRE,
+    serializers: WIRE
+  });
+  await db.waitReady;
+  const acquireMs = config.timeouts?.acquire;
+  const slot = new Slot;
+  const notices = noticeBuffer();
+  const queryOptions = {
+    rowMode: "array",
+    parsers: WIRE,
+    serializers: WIRE,
+    onNotice(notice) {
+      notices.push(notice);
+    }
+  };
+  let closed = false;
+  let inflight = 0;
+  const session = new PgliteSession(db, queryOptions, notices, () => {
+    inflight += 1;
+  }, () => {
+    inflight = Math.max(0, inflight - 1);
+  });
+  async function lease() {
+    if (closed)
+      return rejectClosed();
+    await slot.acquire(acquireMs);
+    let released = false;
+    return {
+      execute: (text, params, options) => runCall(closed, options, (watch) => session.query(text, params, watch)),
+      batch: (statements, options) => runCall(closed, options, async (watch) => {
+        const { runAtomicBatch } = await import("./dynq16vb.js");
+        return runAtomicBatch(session, statements, watch);
+      }),
+      async release() {
+        if (released)
+          return;
+        released = true;
+        try {
+          await reset(session);
+        } finally {
+          slot.release();
+        }
+      }
+    };
+  }
+  return {
+    capabilities: PGLITE_CAPABILITIES,
+    execute(text, params, options) {
+      return runCall(closed, options, async (watch) => {
+        await slot.acquire(acquireMs);
+        try {
+          return await session.query(text, params, watch);
+        } finally {
+          slot.release();
+        }
+      });
+    },
+    async batch(statements, options) {
+      const connection = await lease();
+      try {
+        return await connection.batch(statements, options);
+      } finally {
+        await connection.release();
+      }
+    },
+    reserve: () => lease(),
+    async describe(text) {
+      await slot.acquire(acquireMs);
+      try {
+        const described = await db.describeQuery(text);
+        return {
+          columns: described.resultFields.map((field) => field.name),
+          parameterCount: described.queryParams.length
+        };
+      } finally {
+        slot.release();
+      }
+    },
+    async listen(channel, onNotify) {
+      const unlisten = await db.listen(channel, onNotify);
+      return async () => {
+        await unlisten();
+      };
+    },
+    stats() {
+      return { size: 1, idle: slot.idle, inflight, waiting: slot.waiting };
+    },
+    async close() {
+      closed = true;
+      await db.close();
+    }
+  };
+}
+
+class PgliteSession {
+  canCancel = false;
+  transactionDepth = 0;
+  db;
+  options;
+  notices;
+  enter;
+  leave;
+  constructor(db, options, notices, enter, leave) {
+    this.db = db;
+    this.options = options;
+    this.notices = notices;
+    this.enter = enter;
+    this.leave = leave;
+  }
+  query(text, params, watch) {
+    const why = watch?.reason();
+    if (why === "timeout")
+      return rejectTimedOut();
+    if (why === "cancelled" || watch?.signal.aborted === true)
+      return rejectCancelled();
+    this.enter();
+    const pending = params === undefined || params.length === 0 ? this.db.query(text, undefined, this.options) : this.db.query(text, params, this.options);
+    return pending.then((result) => {
+      this.leave();
+      this.note(text);
+      return resultFrom(result, this.notices.take());
+    }, (error) => {
+      this.leave();
+      this.notices.take();
+      return mapFailure(error).then((mapped) => {
+        throw mapped;
+      });
+    });
+  }
+  inTransaction() {
+    return this.transactionDepth > 0;
+  }
+  abandon() {
+    this.transactionDepth = 0;
+  }
+  rollback() {
+    return this.query("ROLLBACK", undefined, undefined).then(() => {
+      this.transactionDepth = 0;
+    }, (error) => {
+      this.transactionDepth = 0;
+      throw error;
+    });
+  }
+  note(text) {
+    this.transactionDepth = nextTransactionDepth(this.transactionDepth, text);
+  }
+}
+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);
+    },
+    take() {
+      const taken = notices ?? EMPTY_NOTICES;
+      notices = undefined;
+      return taken;
+    }
+  };
+}
+
+class Slot {
+  held = false;
+  waiters = [];
+  acquire(acquireMs) {
+    if (!this.held) {
+      this.held = true;
+      return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+      const waiter = {
+        resolve,
+        timer: undefined
+      };
+      if (acquireMs !== undefined) {
+        waiter.timer = setTimeout(() => {
+          const index = this.waiters.indexOf(waiter);
+          if (index !== -1)
+            this.waiters.splice(index, 1);
+          driverErrors().then((errors) => {
+            reject(errors.acquireTimeout());
+          });
+        }, acquireMs);
+      }
+      this.waiters.push(waiter);
+    });
+  }
+  release() {
+    const next = this.waiters.shift();
+    if (next === undefined) {
+      this.held = false;
+      return;
+    }
+    if (next.timer !== undefined)
+      clearTimeout(next.timer);
+    next.resolve();
+  }
+  get idle() {
+    return this.held ? 0 : 1;
+  }
+  get waiting() {
+    return this.waiters.length;
+  }
+}
+async function reset(session) {
+  if (session.inTransaction())
+    await session.rollback().catch(() => {
+      return;
+    });
+  try {
+    await session.query(RESET_ALL, undefined, undefined);
+    await session.query(UNLOCK, undefined, undefined);
+  } catch {
+    await session.rollback().catch(() => {
+      return;
+    });
+    await session.query(RESET_ALL, undefined, undefined);
+    await session.query(UNLOCK, undefined, undefined);
+  }
+}
+function wireMap(oids) {
+  const parsers = {};
+  for (const oid of oids)
+    parsers[oid] = (value) => value;
+  return parsers;
+}
+var WIRE = wireMap([
+  16,
+  17,
+  20,
+  21,
+  23,
+  25,
+  114,
+  700,
+  701,
+  1043,
+  1082,
+  1114,
+  1184,
+  1700,
+  2950,
+  3802,
+  1000,
+  1005,
+  1007,
+  1009,
+  1016,
+  1115,
+  1182,
+  1185,
+  1231,
+  199,
+  3807
+]);
+
+export { open3 };

package/dist/shared/g2v6gnc8.js

@@ -0,0 +1,347 @@
+import {
+  open2
+} from "./7ck0dtry.js";
+import {
+  catalogHash2
+} from "./y9m15dfv.js";
+import {
+  loadMigrations
+} from "./4j72449d.js";
+import {
+  quoteIdent,
+  planMigration,
+  assertTargetPolicy,
+  assertDirectConnection,
+  selectTarget,
+  projectHead,
+  loadConfig
+} from "./kynx7vbm.js";
+import {
+  OkmError2
+} from "./ycwz42az.js";
+
+// src/tooling/migrate/apply.ts
+import { join } from "node:path";
+var DEFAULT_LOCK_MS = 5000;
+var DEFAULT_STATEMENT_MS = 30000;
+var DEFAULT_RETRIES = 3;
+var BACKOFF_MS = 50;
+var META = `create table if not exists okm_meta (
+  id text primary key,
+  catalog_hash text not null,
+  migration_id text not null
+)`;
+var HISTORY = `create table if not exists okm_history (
+  migration_id text not null,
+  step_index integer not null,
+  class text not null,
+  catalog_hash text not null,
+  applied_at timestamptz not null default now(),
+  primary key (migration_id, step_index)
+)`;
+function applyUnits(migration, done) {
+  const pending = [];
+  for (let index = 0;index < migration.steps.length; index += 1) {
+    if (done.has(`${migration.id}:${String(index)}`))
+      continue;
+    const step = migration.steps[index];
+    if (step !== undefined)
+      pending.push({ index, step });
+  }
+  const units = [];
+  let batch = [];
+  const flush = () => {
+    if (batch.length === 0)
+      return;
+    const last = batch.at(-1);
+    units.push({
+      migrationId: migration.id,
+      catalogHash: migration.catalogHash,
+      finishes: last !== undefined && last.index === migration.steps.length - 1,
+      transactional: true,
+      steps: batch
+    });
+    batch = [];
+  };
+  for (const item of pending) {
+    if (item.step.transactional && !outsideTransaction(item.step.sql)) {
+      batch.push(item);
+      continue;
+    }
+    flush();
+    units.push({
+      migrationId: migration.id,
+      catalogHash: migration.catalogHash,
+      finishes: item.index === migration.steps.length - 1,
+      transactional: false,
+      steps: [item]
+    });
+  }
+  flush();
+  return units;
+}
+async function applyTarget(request) {
+  assertDirectConnection(request.url, request.allowPooler === true);
+  const pool = open2({
+    url: request.url,
+    max: 1,
+    ...request.searchPath !== undefined ? { searchPath: request.searchPath } : {}
+  });
+  if (pool.reserve === undefined) {
+    await pool.close();
+    throw new OkmError2("invalid", "The driver cannot reserve a connection.", {
+      fix: { summary: "Apply needs a driver with interactive transactions." }
+    });
+  }
+  const connection = await pool.reserve();
+  let locked = false;
+  try {
+    await setTimeouts(connection, request);
+    await lockTarget(connection, request.target);
+    locked = true;
+    request.onLocked?.();
+    await connection.execute(META);
+    await connection.execute(HISTORY);
+    const done = await readDone(connection);
+    const applied = [];
+    for (const migration of request.migrations) {
+      const units = applyUnits(migration, done);
+      if (units.length === 0)
+        continue;
+      for (const unit of units) {
+        assertUnitPolicy(request, unit);
+        await runUnit(connection, unit, request);
+        for (const item of unit.steps)
+          done.add(`${unit.migrationId}:${String(item.index)}`);
+      }
+      applied.push(migration.id);
+    }
+    return { target: request.target, applied };
+  } finally {
+    if (locked)
+      await connection.execute("select pg_advisory_unlock(hashtext($1))", [
+        lockKey(request.target)
+      ]);
+    await connection.release();
+    await pool.close();
+  }
+}
+async function applyProject(cwd, flags) {
+  const config = await loadConfig(cwd);
+  const target = selectTarget(config, flags.target);
+  const migrations = loadMigrations(joinMigrations(cwd, config.migrations));
+  if (migrations.length === 0)
+    return `target ${target.name}
+nothing to apply
+`;
+  const report = await applyTarget({
+    url: target.url,
+    target: target.name,
+    protected: target.protected,
+    allowProtected: flags.allowProtected,
+    allowPooler: flags.allowPooler || config.allowPooler === true,
+    ...flags.lockTimeoutMs !== undefined ? { lockTimeoutMs: flags.lockTimeoutMs } : config.timeouts?.lock !== undefined ? { lockTimeoutMs: config.timeouts.lock } : {},
+    ...flags.statementTimeoutMs !== undefined ? { statementTimeoutMs: flags.statementTimeoutMs } : config.timeouts?.statement !== undefined ? { statementTimeoutMs: config.timeouts.statement } : {},
+    migrations
+  });
+  return formatReport(report);
+}
+async function pushProject(cwd, flags) {
+  const config = await loadConfig(cwd);
+  const target = selectTarget(config, flags.target);
+  assertTargetPolicy(target, "push", flags.allowProtected);
+  const head = await projectHead(cwd);
+  const plan = planMigration({
+    before: head.previous,
+    after: head.catalog,
+    renames: head.renames,
+    name: "push"
+  });
+  if (plan.steps.length === 0)
+    return `target ${target.name}
+no changes
+`;
+  const report = await applyTarget({
+    url: target.url,
+    target: target.name,
+    protected: target.protected,
+    allowProtected: flags.allowProtected,
+    allowPooler: flags.allowPooler || config.allowPooler === true,
+    migrations: [
+      {
+        id: "push",
+        catalogHash: catalogHash2(head.catalog),
+        steps: plan.steps
+      }
+    ]
+  });
+  return formatReport(report);
+}
+function formatReport(report) {
+  if (report.applied.length === 0)
+    return `target ${report.target}
+nothing to apply
+`;
+  return `target ${report.target}
+${report.applied.map((id) => `applied ${id}`).join(`
+`)}
+`;
+}
+function joinMigrations(cwd, migrations) {
+  return join(cwd, migrations ?? "migrations");
+}
+function assertUnitPolicy(request, unit) {
+  let operation = "expand";
+  for (const item of unit.steps) {
+    if (item.step.action === "backfill") {
+      operation = "backfill";
+      break;
+    }
+    if (item.step.class === "contract" || item.step.class === "unclassified")
+      operation = item.step.class;
+  }
+  assertTargetPolicy({ name: request.target, protected: request.protected }, operation, request.allowProtected === true);
+}
+async function setTimeouts(connection, request) {
+  const lock = request.lockTimeoutMs ?? DEFAULT_LOCK_MS;
+  const statement = request.statementTimeoutMs ?? DEFAULT_STATEMENT_MS;
+  await connection.execute("select set_config('lock_timeout', $1, false)", [String(lock)]);
+  await connection.execute("select set_config('statement_timeout', $1, false)", [
+    String(statement)
+  ]);
+}
+async function lockTarget(connection, target) {
+  const result = await connection.execute("select pg_try_advisory_lock(hashtext($1))", [
+    lockKey(target)
+  ]);
+  if (!wireTrue(result.rows[0]?.[0])) {
+    throw new OkmError2("OKM1522", `Another apply holds the lock for ${target}.`, {
+      kind: "conflict",
+      fix: {
+        summary: "Wait for that apply to finish. Do not start a second apply against the same target."
+      }
+    });
+  }
+}
+function lockKey(target) {
+  return `okm:${target}`;
+}
+async function readDone(connection) {
+  const result = await connection.execute("select migration_id, step_index::text from okm_history");
+  const done = new Set;
+  for (const row of result.rows) {
+    const id = row[0];
+    const step = row[1];
+    if (id !== null && step !== null)
+      done.add(`${id}:${step}`);
+  }
+  return done;
+}
+async function runUnit(connection, unit, request) {
+  const retries = request.retries ?? DEFAULT_RETRIES;
+  for (let attempt = 0;attempt <= retries; attempt += 1) {
+    let began = false;
+    let current = unit.steps[0]?.index ?? 0;
+    try {
+      if (unit.transactional) {
+        await connection.execute("begin");
+        began = true;
+      }
+      for (const item of unit.steps) {
+        current = item.index;
+        await rebuildInvalidIndex(connection, item.step.sql);
+        await connection.execute(item.step.sql);
+        if (!unit.transactional) {
+          await connection.execute("begin");
+          began = true;
+          await writeStep(connection, unit, item);
+          if (unit.finishes)
+            await writeMeta(connection, unit);
+          await connection.execute("commit");
+          began = false;
+        }
+      }
+      if (unit.transactional) {
+        for (const item of unit.steps)
+          await writeStep(connection, unit, item);
+        if (unit.finishes)
+          await writeMeta(connection, unit);
+        await connection.execute("commit");
+        began = false;
+      }
+      return;
+    } catch (error) {
+      if (began)
+        await connection.execute("rollback").catch(() => {
+          return;
+        });
+      if (!isLockTimeout(error) || attempt === retries)
+        throw failStep(unit, current, error);
+      await delay(BACKOFF_MS * 2 ** attempt);
+    }
+  }
+}
+async function writeStep(connection, unit, item) {
+  await connection.execute("insert into okm_history (migration_id, step_index, class, catalog_hash) values ($1, $2, $3, $4)", [unit.migrationId, String(item.index), item.step.class, unit.catalogHash]);
+}
+async function writeMeta(connection, unit) {
+  await connection.execute(`insert into okm_meta (id, catalog_hash, migration_id) values ('head', $1, $2)
+     on conflict (id) do update set catalog_hash = excluded.catalog_hash, migration_id = excluded.migration_id`, [unit.catalogHash, unit.migrationId]);
+}
+async function rebuildInvalidIndex(connection, sql) {
+  const name = concurrentIndexName(sql);
+  if (name === undefined)
+    return;
+  const found = await connection.execute(`select i.indisvalid
+     from pg_class c
+     join pg_namespace n on n.oid = c.relnamespace
+     join pg_index i on i.indexrelid = c.oid
+     where c.relname = $1 and n.nspname = current_schema()`, [name]);
+  const valid = found.rows[0]?.[0];
+  if (valid === undefined || wireTrue(valid))
+    return;
+  await connection.execute(`drop index concurrently if exists ${quoteIdent(name)}`);
+}
+function concurrentIndexName(sql) {
+  const match = /^create\s+(?:unique\s+)?index\s+concurrently\s+(?:if\s+not\s+exists\s+)?(?:"([^"]+)"|([A-Za-z_][\w$]*))/i.exec(sql.trim());
+  return match?.[1] ?? match?.[2];
+}
+function outsideTransaction(sql) {
+  const text = sql.trim().toLowerCase();
+  if (text.startsWith("vacuum"))
+    return true;
+  if (/^alter\s+type\b/.test(text) && /\badd\s+value\b/.test(text))
+    return true;
+  if (/^create\s+(?:unique\s+)?index\s+concurrently\b/.test(text))
+    return true;
+  return false;
+}
+function failStep(unit, index, error) {
+  if (error instanceof OkmError2)
+    return error;
+  const message = error instanceof Error ? error.message : "The step failed.";
+  return new OkmError2("invalid", `Migration ${unit.migrationId} failed at step ${String(index)}: ${message}`, {
+    cause: error,
+    fix: { summary: "Fix the step and run apply again. Finished steps are not repeated." }
+  });
+}
+function isLockTimeout(error) {
+  if (typeof error !== "object" || error === null)
+    return false;
+  if ("sqlstate" in error && error.sqlstate === "55P03")
+    return true;
+  const message = error instanceof Error ? error.message : "";
+  return message.includes("lock timeout");
+}
+function wireTrue(value) {
+  return value === "t" || value === "true";
+}
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+export {
+  applyProject,
+  pushProject
+};