okmodel 0.2.1 → 0.4.0

package/dist/shared/eqmtn1bj.js

@@ -1,399 +0,0 @@
-import {
-  open2
-} from "./ecdzej21.js";
-import {
-  catalogHash2
-} from "./d2whjz4k.js";
-import"./n442h54c.js";
-import {
-  loadMigrations
-} from "./rtnaqre0.js";
-import {
-  quoteIdent,
-  planMigration,
-  assertTargetPolicy,
-  assertDirectConnection,
-  selectTarget,
-  projectHead,
-  loadConfig
-} from "./5z4q2zda.js";
-import {
-  OkmError2
-} from "./52szzakm.js";
-
-// src/tooling/migrate/apply.ts
-import { join } from "node:path";
-
-// src/tooling/migrate/engine.ts
-var IDENT = String.raw`"(?:[^"]|"")+"|[A-Za-z_][\w$]*`;
-var DEFAULT_UUIDV7 = /\bdefault\s+uuidv7\s*\(\s*\)/i;
-var TABLE = new RegExp(String.raw`^\s*(?:create\s+table(?:\s+if\s+not\s+exists)?|alter\s+table(?:\s+if\s+exists)?(?:\s+only)?)\s+(?:(?:${IDENT})\.)?(${IDENT})`, "i");
-var COLUMN = new RegExp(String.raw`(${IDENT})\s+(?:uuid\b|set\s+default\b)`, "i");
-function findUuidV7Default(migrations) {
-  for (const migration of migrations) {
-    for (let stepIndex = 0;stepIndex < migration.steps.length; stepIndex += 1) {
-      const sql = migration.steps[stepIndex]?.sql ?? "";
-      if (!DEFAULT_UUIDV7.test(sql))
-        continue;
-      return { migrationId: migration.id, stepIndex, column: columnOf(sql) };
-    }
-  }
-  return;
-}
-async function assertUuidV7Available(connection, migrations) {
-  const found = findUuidV7Default(migrations);
-  if (found === undefined)
-    return;
-  const result = await connection.execute("select current_setting('server_version_num'), to_regprocedure('uuidv7()')::text");
-  const row = result.rows[0];
-  const major = Math.floor(Number(row?.[0] ?? "0") / 1e4);
-  const defined = row?.[1] !== null && row?.[1] !== undefined;
-  if (major >= 18 || defined)
-    return;
-  const where = found.column === undefined ? "A column" : `Column ${found.column}`;
-  throw new OkmError2("OKM1812", `${where} has a uuidv7() default (migration ${found.migrationId}, step ${String(found.stepIndex)}), and the server is PostgreSQL ${String(major)}. uuidv7() arrives in PostgreSQL 18. Nothing was changed.`, {
-    fix: {
-      summary: 'Either run PostgreSQL 18 and declare schema({ requires: { postgres: ">=18" } }), or use t.id({ default: "uuidv4" }) (or schema({ defaults: { id: "uuidv4" } })), which uses gen_random_uuid() and works on PostgreSQL 13 and newer. Then delete the migration that was not applied and generate it again.'
-    }
-  });
-}
-function columnOf(sql) {
-  const table = TABLE.exec(sql)?.[1];
-  if (table === undefined)
-    return;
-  const line = sql.split(`
-`).find((text) => DEFAULT_UUIDV7.test(text));
-  const column = line === undefined ? undefined : COLUMN.exec(line)?.[1];
-  if (column === undefined)
-    return;
-  return `${unquote(table)}.${unquote(column)}`;
-}
-function unquote(name) {
-  return name.startsWith('"') ? name.slice(1, -1).replaceAll('""', '"') : name;
-}
-
-// src/tooling/migrate/apply.ts
-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 assertUuidV7Available(connection, request.migrations);
-    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
-};

package/dist/shared/rtnaqre0.js

@@ -1,37 +0,0 @@
-import {
-  catalogHash2,
-  parseCatalog2
-} from "./d2whjz4k.js";
-import {
-  parsePlan
-} from "./5z4q2zda.js";
-import {
-  OkmError2
-} from "./52szzakm.js";
-
-// src/tooling/migrate/files.ts
-import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-function loadMigrations(directory) {
-  if (!existsSync(directory))
-    return [];
-  const names = readdirSync(directory).filter((file) => file.endsWith(".sql")).sort();
-  const migrations = [];
-  for (const file of names) {
-    const id = file.slice(0, -".sql".length);
-    const catalogPath = join(directory, `${id}.catalog.json`);
-    if (!existsSync(catalogPath)) {
-      throw new OkmError2("invalid", `Migration ${id} is missing its catalog snapshot.`, {
-        fix: {
-          summary: "Generate the migration again so the SQL and the catalog are written together."
-        }
-      });
-    }
-    const plan = parsePlan(readFileSync(join(directory, file), "utf8"));
-    const hash = catalogHash2(parseCatalog2(readFileSync(catalogPath, "utf8")));
-    migrations.push({ id, catalogHash: hash, steps: plan.steps });
-  }
-  return migrations;
-}
-
-export { loadMigrations };

package/dist/shared/zwmqxb0g.js

@@ -1,79 +0,0 @@
-import {
-  OkmError2
-} from "./52szzakm.js";
-
-// src/runtime/drift-detail.ts
-function driftVerdict(codeHash, recordedHash, migrations) {
-  const codeAt = indexOfHash(migrations, codeHash);
-  const recordedAt = indexOfHash(migrations, recordedHash);
-  if (codeAt < 0 || recordedAt < 0 || recordedAt < codeAt)
-    return "behind";
-  if (recordedAt === codeAt)
-    return "ok";
-  for (let index = codeAt + 1;index <= recordedAt; index += 1) {
-    if (migrations[index]?.expand !== true)
-      return "contract";
-  }
-  return "ok";
-}
-async function assertDrift(pool, codeHash, recordedHash, options) {
-  let rows;
-  try {
-    const result = await pool.execute("select migration_id, class, catalog_hash from okm_history order by migration_id, step_index", undefined, options);
-    rows = result.rows;
-  } catch (error) {
-    throw behind(error);
-  }
-  const verdict = driftVerdict(codeHash, recordedHash, groupMigrations(rows));
-  if (verdict === "ok")
-    return;
-  if (verdict === "contract") {
-    throw new OkmError2("OKM1520", "The database is ahead of the code by a contract migration.", {
-      fix: {
-        summary: "Roll the application forward, or repair the database. A contract step is not compatible with this code."
-      }
-    });
-  }
-  throw behind(undefined);
-}
-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 behind(cause) {
-  return new OkmError2("OKM1520", "The database is behind the code.", {
-    ...cause === undefined ? {} : { cause },
-    fix: {
-      summary: "Inspect the diff and repair the database, or generate a migration that matches the drift."
-    }
-  });
-}
-export {
-  assertDrift
-};

package/dist/shared/{m9tv7xn7.js → radd3z4g.js}

@@ -1,9 +1,9 @@
-import {
-  runWrite
-} from "./n4jqhpqz.js";
 import {
   stack
 } from "./672t5vym.js";
+import {
+  runWrite
+} from "./n4jqhpqz.js";
 import {
   withRowFilters,
   archiveRules,