okmodel 0.5.1 → 0.7.0

package/dist/shared/7zwwyh0v.js

@@ -1,448 +0,0 @@
-import {
-  parseCatalog2
-} from "./8bwbwy8h.js";
-import"./krxx77g0.js";
-import"./n442h54c.js";
-import {
-  applyTarget2,
-  backfillTiming2
-} from "./cctw17hj.js";
-import {
-  sealViews,
-  catalogQuery2,
-  managedRoleOptions2
-} from "./sycnx8gt.js";
-import {
-  loadMigrations,
-  catalogsEqual,
-  snapshotDifference
-} from "./gde73es6.js";
-import"./szm0cksa.js";
-import {
-  introspectSchema
-} from "./fancm5pt.js";
-import {
-  lintMigrationDirectory,
-  hasError,
-  lintRefusal,
-  openProject
-} from "./qv2ydck9.js";
-import {
-  canonicalTypeName,
-  classOf,
-  strictestClass,
-  planMigration,
-  parsePlan,
-  assertDirectConnection,
-  assertStableBackend,
-  selectTarget
-} from "./ga3sfy93.js";
-import {
-  quoteIdent
-} from "./8xsbagad.js";
-import {
-  catalog,
-  isDomain
-} from "./g7ez901n.js";
-import {
-  identityKey2
-} from "./t4tbsy9h.js";
-import {
-  OkmError2
-} from "./52szzakm.js";
-
-// src/tooling/migrate/check.ts
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import postgres from "postgres";
-var CHECK_SCHEMA_PREFIX = "okm_check_";
-var HISTORY_CODE = "OKM1547";
-var PREVIOUS_CODE = "OKM1548";
-var STALE_CODE = "OKM1549";
-var HISTORY_FIX = "Regenerate the migration so the stored catalog matches the schema the SQL applies.";
-var FORK_FIX = "Generate the later migration from the previous migration's catalog, not from an older parent.";
-var PREVIOUS_FIX = "Keep every table, column, constraint, and type the previous catalog relies on, or classify the migration as contract.";
-var STALE_FIX = "Run okm generate.";
-async function checkMigrations(cwd, flags, options) {
-  const opened = await openProject(cwd);
-  const target = selectTarget(opened.config, flags.target);
-  const allowPooler = flags.allowPooler || opened.config.allowPooler === true;
-  assertDirectConnection(target.url, allowPooler);
-  if (target.protected) {
-    throw new OkmError2("OKM1850", `okm migrate check writes a scratch schema and refuses protected target ${target.name}. Point it at a throwaway Postgres.`, {
-      kind: "forbidden",
-      fix: {
-        summary: "Point okm migrate check at a throwaway Postgres. --allow-protected does not apply."
-      }
-    });
-  }
-  const directory = join(cwd, opened.config.migrations ?? "migrations");
-  const history = readHistory(directory);
-  if (options?.provision === true) {
-    const equivalence = await proveSnapshot(opened.config, target.url, target.name, flags, history);
-    if (equivalence !== undefined)
-      throwFailure([equivalence]);
-  }
-  const previous = previousFailures(history);
-  const stale = staleFailure(history, opened.built.catalog);
-  const lint = lintFailure(directory, history, opened.config.lintFrom);
-  const replayed = await replayHistory(opened.config, target.url, target.name, flags, history);
-  const failures = [...replayed, ...previous, ...stale, ...lint];
-  if (failures.length > 0)
-    throwFailure(failures);
-  return `ok ${String(history.length)} migrations
-`;
-}
-function previousCatalogGaps(before, after) {
-  const afterBy = new Map(after.objects.map((object) => [identityKey2(object.identity), object]));
-  const gaps = [];
-  for (const object of before.objects) {
-    if (!checkedKind(object.kind))
-      continue;
-    const next = afterBy.get(identityKey2(object.identity));
-    if (next === undefined || next.kind !== object.kind) {
-      gaps.push(`${objectLabel(object)} is missing`);
-      continue;
-    }
-    if (object.kind === "column" && next.kind === "column") {
-      gaps.push(...columnGaps(object, next));
-    }
-    if (object.kind === "type" && next.kind === "type" && !sameType(object.definition, next.definition)) {
-      gaps.push(`${objectLabel(object)} changed`);
-    }
-  }
-  return gaps;
-}
-function recomputedMigrationClass(plan, before, after) {
-  if (plan.steps.length === 0)
-    return "expand";
-  if (plan.steps.some((step) => step.kind === undefined)) {
-    return planMigration({ before, after, name: plan.name }).class;
-  }
-  return strictestClass(plan.steps.map((step) => classOf(step.kind ?? "raw-sql")));
-}
-function migrationAllowsPreviousGaps(plan, before, after) {
-  return recomputedMigrationClass(plan, before, after) === "contract" && plan.class !== "expand";
-}
-function previousFailures(history) {
-  const failures = [];
-  let before = catalog([]);
-  for (const migration of history) {
-    const gaps = previousCatalogGaps(before, migration.catalog);
-    if (gaps.length > 0 && !migrationAllowsPreviousGaps(migration.plan, before, migration.catalog)) {
-      const stated = migration.plan.class === "expand" ? "expand" : recomputedMigrationClass(migration.plan, before, migration.catalog);
-      failures.push({
-        code: PREVIOUS_CODE,
-        message: `${migration.id}: previous catalog is not satisfied (${gaps.join("; ")}). The migration is classified ${stated}.`,
-        fix: PREVIOUS_FIX
-      });
-    }
-    before = migration.catalog;
-  }
-  return failures;
-}
-function staleFailure(history, head) {
-  const last = history.at(-1)?.catalog ?? catalog([]);
-  if (catalogsEqual(last, head))
-    return [];
-  return [
-    {
-      code: STALE_CODE,
-      message: "The last migration's catalog does not match the schema.",
-      fix: STALE_FIX
-    }
-  ];
-}
-function lintFailure(directory, history, lintFrom) {
-  const findings = lintMigrationDirectory(directory, lintIds(history, lintFrom));
-  if (!hasError(findings))
-    return [];
-  const refusal = lintRefusal(findings);
-  return [{ code: refusal.code, message: refusal.message, fix: refusal.fix.summary }];
-}
-function lintIds(history, lintFrom) {
-  if (lintFrom === undefined)
-    return;
-  const ids = history.map((migration) => migration.id);
-  const start = ids.indexOf(lintFrom);
-  if (start < 0) {
-    throw new OkmError2("invalid", `lintFrom ${lintFrom} is not a migration id.`, {
-      fix: {
-        summary: "Set lintFrom to a migration id. Files before that id are the adoption baseline and are not linted."
-      }
-    });
-  }
-  return new Set(ids.slice(start));
-}
-async function proveSnapshot(config, url, target, flags, history) {
-  const head = history.at(-1);
-  if (head === undefined)
-    return;
-  const sql = postgres(url, {
-    max: 1,
-    connect_timeout: 5,
-    idle_timeout: 1,
-    onnotice: () => {}
-  });
-  const allowPooler = flags.allowPooler || config.allowPooler === true;
-  const provided = `${CHECK_SCHEMA_PREFIX}p${crypto.randomUUID().replaceAll("-", "")}`;
-  const replayed = `${CHECK_SCHEMA_PREFIX}r${crypto.randomUUID().replaceAll("-", "")}`;
-  const timing = {
-    ...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 } : {},
-    ...backfillTiming2(config.backfill)
-  };
-  try {
-    await assertStableBackend(async () => {
-      const rows = await sql`select pg_backend_pid()::text as pid`;
-      return rows[0]?.pid ?? "";
-    }, allowPooler);
-    await sql.unsafe(`create schema ${quoteIdent(provided)}`);
-    await sql.unsafe(`create schema ${quoteIdent(replayed)}`);
-    const role = config.roles === undefined ? {} : { migrationRole: config.roles.migration, schema: provided };
-    await applyTarget2({
-      url,
-      target,
-      protected: false,
-      allowProtected: false,
-      allowPooler: flags.allowPooler || config.allowPooler === true,
-      searchPath: provided,
-      ...timing,
-      migrations: history.map((migration) => ({
-        id: migration.id,
-        catalogHash: migration.catalogHash,
-        steps: migration.steps
-      })),
-      snapshot: {
-        catalog: head.catalog,
-        migrationId: head.id,
-        catalogHash: head.catalogHash,
-        reference: [],
-        only: true
-      },
-      ...role
-    });
-    await applyTarget2({
-      url,
-      target,
-      protected: false,
-      allowProtected: false,
-      allowPooler: flags.allowPooler || config.allowPooler === true,
-      searchPath: replayed,
-      ...timing,
-      migrations: history.map((migration) => ({
-        id: migration.id,
-        catalogHash: migration.catalogHash,
-        steps: retargetSteps(migration.steps, replayed)
-      })),
-      ...config.roles !== undefined ? { migrationRole: config.roles.migration, schema: replayed } : {}
-    });
-    const liveProvided = await introspectScratch(sql, provided, config);
-    const liveReplayed = await introspectScratch(sql, replayed, config);
-    const difference = snapshotDifference(liveProvided, liveReplayed);
-    if (difference === undefined)
-      return;
-    return {
-      code: "OKM1521",
-      message: `Provisioning from the snapshot does not match the replayed history.
-${difference}`,
-      fix: "Regenerate the snapshot from the history. okm migrate check --provision is the command that reports this."
-    };
-  } finally {
-    await sql.unsafe(`drop schema if exists ${quoteIdent(provided)} cascade`).catch(() => {
-      return;
-    });
-    await sql.unsafe(`drop schema if exists ${quoteIdent(replayed)} cascade`).catch(() => {
-      return;
-    });
-    await sql.end({ timeout: 5 });
-  }
-}
-async function replayHistory(config, url, target, flags, history) {
-  if (history.length === 0)
-    return [];
-  const sql = postgres(url, {
-    max: 1,
-    connect_timeout: 5,
-    idle_timeout: 1,
-    onnotice: () => {}
-  });
-  const allowPooler = flags.allowPooler || config.allowPooler === true;
-  const scratch = `${CHECK_SCHEMA_PREFIX}${crypto.randomUUID().replaceAll("-", "")}`;
-  const failures = [];
-  try {
-    await assertStableBackend(async () => {
-      const rows = await sql`select pg_backend_pid()::text as pid`;
-      return rows[0]?.pid ?? "";
-    }, allowPooler);
-    await sql.unsafe(`create schema ${quoteIdent(scratch)}`);
-    const runner = catalogQuery2(sql);
-    for (let index = 0;index < history.length; index += 1) {
-      const migration = history[index];
-      if (migration === undefined)
-        continue;
-      await applyTarget2({
-        url,
-        target,
-        protected: false,
-        allowProtected: false,
-        allowPooler: flags.allowPooler || config.allowPooler === true,
-        searchPath: scratch,
-        ...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 } : {},
-        ...backfillTiming2(config.backfill),
-        migrations: [
-          {
-            id: migration.id,
-            catalogHash: migration.catalogHash,
-            steps: retargetSteps(migration.steps, scratch)
-          }
-        ],
-        ...config.roles !== undefined ? { migrationRole: config.roles.migration, schema: scratch } : {}
-      });
-      const live = await introspectScratch(sql, scratch, config);
-      const sealed = await sealViews(runner, migration.catalog);
-      const back = planMigration({ before: live, after: sealed, name: migration.id });
-      if (back.steps.length === 0)
-        continue;
-      failures.push(historyFailure(history, index, back));
-      break;
-    }
-  } finally {
-    await sql.unsafe(`drop schema if exists ${quoteIdent(scratch)} cascade`).catch(() => {
-      return;
-    });
-    await sql.end({ timeout: 5 });
-  }
-  return failures;
-}
-async function introspectScratch(sql, schema, config) {
-  const previous = await sql`select current_setting('search_path') as path`;
-  const saved = previous[0]?.path ?? "public";
-  try {
-    await sql.unsafe(`set search_path to ${quoteIdent(schema)}`);
-    return await introspectSchema(catalogQuery2(sql), schema, "public", managedRoleOptions2(config.roles));
-  } finally {
-    await sql`select set_config('search_path', ${saved}, false)`.catch(() => {
-      return;
-    });
-  }
-}
-function historyFailure(history, index, back) {
-  const migration = history[index];
-  const id = migration?.id ?? "migration";
-  const fork = migration === undefined ? undefined : forkMessage(history, index);
-  if (fork !== undefined)
-    return { code: HISTORY_CODE, message: fork, fix: FORK_FIX };
-  const steps = back.steps.map((step) => step.sql).join(`
-`);
-  return {
-    code: HISTORY_CODE,
-    message: `${id}: history differs from the stored catalog
-${steps}`,
-    fix: HISTORY_FIX
-  };
-}
-function forkMessage(history, index) {
-  const current = history[index];
-  const previous = history[index - 1];
-  if (current === undefined || previous === undefined)
-    return;
-  if (samePlan(previous.catalog, current.catalog, current.plan))
-    return;
-  for (let parentIndex = 0;parentIndex < index; parentIndex += 1) {
-    const parent = parentIndex === 0 ? catalog([]) : history[parentIndex - 1]?.catalog;
-    if (parent === undefined)
-      continue;
-    if (!samePlan(parent, current.catalog, current.plan))
-      continue;
-    return `migration ${current.id} was generated from a different parent than ${previous.id}`;
-  }
-  return;
-}
-function samePlan(before, after, file) {
-  try {
-    return sameSql(planMigration({ before, after, name: "parent" }), file);
-  } catch (error) {
-    if (error instanceof OkmError2 && error.code === "OKM1530")
-      return false;
-    throw error;
-  }
-}
-function sameSql(planned, file) {
-  if (planned.steps.length !== file.steps.length)
-    return false;
-  return planned.steps.every((step, index) => step.sql === file.steps[index]?.sql);
-}
-function retargetSteps(steps, schema) {
-  const from = `${quoteIdent("public")}.`;
-  const to = `${quoteIdent(schema)}.`;
-  const fromDefaults = `in schema ${quoteIdent("public")} `;
-  const toDefaults = `in schema ${quoteIdent(schema)} `;
-  return steps.map((step) => ({
-    ...step,
-    sql: step.sql.replaceAll(from, to).replaceAll(fromDefaults, toDefaults),
-    ...step.backfill === undefined ? {} : { backfill: { ...step.backfill, table: step.backfill.table.replaceAll(from, to) } }
-  }));
-}
-function readHistory(directory) {
-  return loadMigrations(directory).map((migration) => ({
-    id: migration.id,
-    catalogHash: migration.catalogHash,
-    steps: migration.steps,
-    plan: parsePlan(readFileSync(join(directory, `${migration.id}.sql`), "utf8")),
-    catalog: parseCatalog2(readFileSync(join(directory, `${migration.id}.catalog.json`), "utf8"))
-  }));
-}
-function throwFailure(failures) {
-  const first = failures[0];
-  if (first === undefined)
-    throw new Error("okm migrate check has no failure to report.");
-  const message = failures.length === 1 ? first.message : failures.map((failure) => `${failure.code} ${failure.message}`).join(`
-`);
-  throw new OkmError2(first.code, message, { fix: { summary: first.fix } });
-}
-function checkedKind(kind) {
-  return kind === "table" || kind === "column" || kind === "constraint" || kind === "type";
-}
-function columnGaps(before, after) {
-  const gaps = [];
-  const place = objectLabel(before);
-  if (canonicalTypeName(before.definition.dataType) !== canonicalTypeName(after.definition.dataType)) {
-    gaps.push(`${place} changed type from ${before.definition.dataType} to ${after.definition.dataType}`);
-  }
-  if (before.definition.nullable && !after.definition.nullable && !columnHasDefault(after)) {
-    gaps.push(`${place} nullability tightened without a default`);
-  }
-  return gaps;
-}
-function columnHasDefault(column) {
-  return column.definition.defaultExpression !== undefined || column.definition.identity !== undefined || column.definition.generated !== undefined;
-}
-function sameType(before, after) {
-  const beforeDomain = isDomain(before);
-  const afterDomain = isDomain(after);
-  if (beforeDomain !== afterDomain)
-    return false;
-  if (beforeDomain && afterDomain) {
-    return canonicalTypeName(before.base) === canonicalTypeName(after.base) && before.check === after.check;
-  }
-  if (!beforeDomain && !afterDomain) {
-    if (before.labels.length !== after.labels.length)
-      return false;
-    return before.labels.every((label, index) => label === after.labels[index]);
-  }
-  return false;
-}
-function objectLabel(object) {
-  if (object.kind === "column" || object.kind === "constraint") {
-    return `${object.kind} ${object.identity.parent.name}.${object.identity.name}`;
-  }
-  if (object.kind === "table" || object.kind === "type") {
-    return `${object.kind} ${object.identity.name}`;
-  }
-  return object.kind;
-}
-export {
-  checkMigrations
-};

package/dist/shared/aj2qxyhj.js

@@ -1,90 +0,0 @@
-import {
-  runWrite
-} from "./n4jqhpqz.js";
-import {
-  withHttp,
-  settleCall
-} from "./hf22e0wt.js";
-import {
-  rejectKeys,
-  isRecord,
-  fail
-} from "./gbtcc2d7.js";
-import {
-  OkmError2
-} from "./52szzakm.js";
-
-// src/runtime/batch.ts
-async function batch(session, ops, options, replica) {
-  try {
-    if (replica !== undefined) {
-      throw new OkmError2("OKM1840", "batch() needs the primary. .replica() is not allowed on a batch.", withHttp(session.http, {
-        fix: { summary: "Remove .replica(). A batch always runs on the primary." }
-      }));
-    }
-    if (!Array.isArray(ops))
-      fail("OKM1121", "batch expects a list of write operations.");
-    const record = options ?? {};
-    if (!isRecord(record))
-      fail("OKM1121", "batch options must be an object.");
-    rejectKeys(record, ["signal", "timeout"], "batch");
-    const prepared = [];
-    for (const op of ops) {
-      const plan = typeof op === "object" && op !== null ? op["~plan"] : undefined;
-      if (plan === undefined) {
-        fail("OKM1121", "batch takes write operations: insert, update, delete, and archive. Pass them without awaiting.");
-      }
-      const item = await plan();
-      if (item.checked !== undefined) {
-        fail("OKM1121", item.checked === "restore" ? "batch does not take restore: it is refused while its parent is archived, and a batch cannot report that after it commits. Use tx()." : "batch does not take a write with expect: the count is checked after the statement ran, and a batch cannot report that after it commits. Use tx().");
-      }
-      prepared.push(item);
-    }
-    return await run(session, prepared, record);
-  } catch (error) {
-    return settleCall(session, error);
-  }
-}
-async function run(session, prepared, options) {
-  await session.connected;
-  const statements = [];
-  const starts = [];
-  for (const item of prepared) {
-    starts.push(statements.length);
-    statements.push(...item.statements);
-  }
-  if (statements.length === 0)
-    return prepared.map((item) => item.finish([]));
-  let results;
-  try {
-    results = await runWrite(session, statements, call(options), true);
-  } catch (error) {
-    throw at(error, starts);
-  }
-  return prepared.map((item, index) => {
-    const from = starts[index] ?? 0;
-    return item.finish(results.slice(from, from + item.statements.length));
-  });
-}
-function call(options) {
-  const { signal, timeout } = options;
-  if (signal === undefined && timeout === undefined)
-    return;
-  return {
-    ...signal !== undefined ? { signal } : {},
-    ...typeof timeout === "number" ? { timeout } : {}
-  };
-}
-function at(error, starts) {
-  const failed = error?.batchIndex;
-  const move = error?.at;
-  if (typeof failed !== "number" || typeof move !== "function")
-    return error;
-  let index = 0;
-  while (index + 1 < starts.length && (starts[index + 1] ?? Infinity) <= failed)
-    index += 1;
-  return index === failed ? error : move.call(error, index);
-}
-export {
-  batch
-};