okmodel 0.8.0 → 0.9.0

package/dist/shared/yybhre6n.js

@@ -0,0 +1,136 @@
+import {
+  POSTGRES_FLOOR,
+  isPostgresMajor,
+  parsePostgresFloor,
+  serverNeedsPostgres
+} from "./ga9j92qj.js";
+import {
+  withHttp,
+  attachHttp,
+  mapOptions
+} from "./npdftanb.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/runtime/artifact-file.ts
+function artifactDir(catalogDir) {
+  if (catalogDir !== undefined)
+    return catalogDir.replace(/[/\\]+$/, "");
+  const cwd = globalThis.process?.cwd?.() ?? ".";
+  return `${cwd}/.okm`;
+}
+async function readText(path) {
+  const bun = globalThis.Bun;
+  if (bun !== undefined) {
+    const file = bun.file(path);
+    if (!await file.exists())
+      return;
+    return file.text();
+  }
+  const loader = globalThis.process?.getBuiltinModule;
+  if (loader === undefined)
+    return;
+  try {
+    return await loader("node:fs/promises").readFile(path, "utf8");
+  } catch {
+    return;
+  }
+}
+
+// src/runtime/server-check.ts
+var versionQuery = "select current_setting('server_version_num'), version(), (select (xpath('//catalog_hash/text()', query_to_xml('select catalog_hash from okm_meta where id = ''head''', true, false, '')))[1]::text where to_regclass('okm_meta') is not null)";
+var historyQuery = "select migration_id, class, catalog_hash from okm_history order by migration_id, step_index";
+async function versionSql(namespace) {
+  if (namespace === "public")
+    return versionQuery;
+  const relation = await qualified("okm_meta", namespace);
+  const literal = relation.replaceAll("'", "''");
+  return `select current_setting('server_version_num'), version(), (select (xpath('//catalog_hash/text()', query_to_xml('select catalog_hash from ${literal} where id = ''head''', true, false, '')))[1]::text where to_regclass('${literal}') is not null)`;
+}
+async function historySql2(namespace) {
+  if (namespace === "public")
+    return historyQuery;
+  return `select migration_id, class, catalog_hash from ${await qualified("okm_history", namespace)} order by migration_id, step_index`;
+}
+async function recordedNamespace(catalogDir) {
+  const text = await readText(`${artifactDir(catalogDir)}/namespace`);
+  if (text === undefined)
+    return "public";
+  const line = text.trim();
+  if (line === "" || line === "public")
+    return "public";
+  if (line.includes("\x00") || line.includes(`
+`) || line.includes("\r")) {
+    throw new OkmError2("OKM1122", "The catalog namespace file is not one identifier.", {
+      fix: { summary: "Run okm build so .okm/namespace is the schema from defineConfig." }
+    });
+  }
+  return line;
+}
+async function acceptServer2(pool, schema, http, requireMeta, options, source) {
+  const namespace = await recordedNamespace(source.catalogDir);
+  let rows;
+  try {
+    const result = await pool.execute(await versionSql(namespace), undefined, options);
+    rows = result.rows;
+  } catch (error) {
+    const { mapPostgresError } = await import("./63qtkrca.js");
+    throw mapPostgresError(error, mapOptions(http, false, schema));
+  }
+  for (const name in schema.model) {
+    if (schema.model[name]?.presets !== undefined) {
+      (await import("./m7n9h2a5.js")).checkSchema(schema);
+      break;
+    }
+  }
+  const version = rows[0]?.[1];
+  if (version === null || version === undefined || !version.startsWith("PostgreSQL")) {
+    throw new OkmError2("OKM1801", "The server is not PostgreSQL. The schema dialect is postgres.", withHttp(http, {
+      fix: { summary: "Open the schema with the Postgres driver that matches it." }
+    }));
+  }
+  const recorded = rows[0]?.[2];
+  if (recorded === null || recorded === undefined || recorded.length === 0) {
+    if (requireMeta) {
+      throw new OkmError2("OKM1520", "okm_meta has no catalog hash.", withHttp(http, {
+        fix: {
+          summary: "Apply migrations so okm_meta records the catalog, or omit requireMeta to adopt this database."
+        }
+      }));
+    }
+  } else {
+    const { assertCompatible } = await import("./pg4ezgyf.js");
+    try {
+      await assertCompatible(pool, schema, recorded, source, options, namespace);
+    } catch (error) {
+      if (error instanceof OkmError2)
+        throw attachHttp(http, error);
+      throw error;
+    }
+  }
+  const major = Math.floor(Number(rows[0]?.[0] ?? "0") / 1e4);
+  const raw = schema.requires?.postgres;
+  if (raw === undefined) {
+    if (major < POSTGRES_FLOOR) {
+      throw new OkmError2("OKM1803", serverNeedsPostgres(major, POSTGRES_FLOOR), withHttp(http, {
+        fix: {
+          summary: `Upgrade to PostgreSQL ${String(POSTGRES_FLOOR)} or higher.`
+        }
+      }));
+    }
+    return;
+  }
+  const need = parsePostgresFloor(raw);
+  if (!isPostgresMajor(need) || major < need) {
+    throw new OkmError2("OKM1802", serverNeedsPostgres(major, isPostgresMajor(need) ? need : POSTGRES_FLOOR), withHttp(http, {
+      fix: { summary: "Upgrade the server, or lower minPostgres to a major the server meets." }
+    }));
+  }
+}
+async function qualified(table, namespace) {
+  const { quoteIdent } = await import("./61bmrmhr.js");
+  return `${quoteIdent(namespace)}.${table}`;
+}
+
+export { artifactDir, readText, historySql2, acceptServer2 };

package/dist/shared/zdqf8k5d.js

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

package/dist/tooling/cli.js

@@ -1,6 +1,7 @@
 import"../shared/12z7aznj.js";
 import"../shared/n442h54c.js";
-import"../shared/35q0n9tz.js";
+import"../shared/fk9vef30.js";
+import"../shared/dd5pmnky.js";
 import {
   formatFindings,
   hasError,
@@ -8,12 +9,12 @@ import {
   buildProject,
   generateProject,
   planProject,
-  checkProject
-} from "../shared/f4jy1j7x.js";
+  checkProject,
+  exportProject
+} from "../shared/2zdxkt7b.js";
 import {
   sessionFailure
-} from "../shared/dpc2r7rb.js";
-import"../shared/sjk86yrx.js";
+} from "../shared/6nae0spm.js";
 import {
   OkmError2
 } from "../shared/52szzakm.js";
@@ -53,6 +54,16 @@ async function run(argv, io) {
 `);
     return;
   }
+  if (command === "catalog") {
+    const sub = rest[0];
+    if (sub !== "export") {
+      throw new OkmError2("invalid", `Unknown command catalog ${sub ?? ""}.`, {
+        fix: { summary: "Use okm catalog export." }
+      });
+    }
+    stdout(await exportProject(cwd, rest.slice(1)));
+    return;
+  }
   if (command === "check") {
     const findings = await checkProject(cwd, invoke(splitFlags(rest)));
     const warnings = formatFindings(findings);
@@ -73,41 +84,62 @@ async function run(argv, io) {
     return;
   }
   if (command === "dev") {
-    const { devProject } = await import("../shared/zgex00fd.js");
+    const { devProject } = await import("../shared/8qzkd9f3.js");
     stdout(await devProject(cwd));
     return;
   }
   if (command === "push") {
-    const { pushProject } = await import("../shared/njga14v4.js");
+    const { pushProject } = await import("../shared/n306gqkd.js");
     stdout(await pushProject(cwd, invoke(splitFlags(rest))));
     return;
   }
+  if (command === "pull") {
+    const { pullProject } = await import("../shared/7ba5h6pb.js");
+    stdout((await pullProject(cwd, rest)).text);
+    return;
+  }
+  if (command === "import") {
+    const sub = rest[0];
+    if (sub !== "drizzle") {
+      throw new OkmError2("invalid", `Unknown command import ${sub ?? ""}.`, {
+        fix: { summary: "Use okm import drizzle <path>." }
+      });
+    }
+    const { importDrizzle } = await import("../shared/n5whk3mt.js");
+    stdout((await importDrizzle(cwd, rest.slice(1))).text);
+    return;
+  }
   if (command === "migrate") {
     const sub = rest[0];
-    const parsed = splitFlags(rest.slice(1));
+    const migrateArgs = rest.slice(1);
+    const parsed = splitFlags(sub === "plan" ? migrateArgs.filter((arg) => arg !== "--json") : migrateArgs);
     if (sub === "plan") {
       if (parsed.name === undefined) {
         throw new OkmError2("invalid", "okm migrate plan needs a name.");
       }
       const planned = await planProject(cwd, parsed.name, parsed.flags, invoke(parsed));
-      stdout(planned.text);
-      stdout(formatFindings(planned.findings));
+      if (migrateArgs.includes("--json"))
+        stdout(planned.json);
+      else {
+        stdout(planned.text);
+        stdout(formatFindings(planned.findings));
+      }
       if (hasError(planned.findings))
         throw lintRefusal(planned.findings);
       return;
     }
     if (sub === "apply") {
-      const { applyProject } = await import("../shared/njga14v4.js");
+      const { applyProject } = await import("../shared/n306gqkd.js");
       stdout(await applyProject(cwd, invoke(parsed), stdout));
       return;
     }
     if (sub === "status") {
-      const { statusProject } = await import("../shared/195pzzzz.js");
+      const { statusProject } = await import("../shared/mgaq2sd3.js");
       stdout(await statusProject(cwd, invoke(parsed)));
       return;
     }
     if (sub === "check") {
-      const { checkMigrations } = await import("../shared/jp36k7dp.js");
+      const { checkMigrations } = await import("../shared/qvwwp1mp.js");
       const provision = parsed.flags.includes("--provision") || rest.slice(1).includes("--provision");
       stdout(await checkMigrations(cwd, invoke(parsed), { provision }));
       return;
@@ -120,13 +152,13 @@ async function run(argv, io) {
         fix: { summary: "Pass okm seed <file>." }
       });
     }
-    const { seedProject } = await import("../shared/hfqmpasr.js");
+    const { seedProject } = await import("../shared/ss2kv2rs.js");
     stdout(await seedProject(cwd, parsed.name, invoke(parsed)));
     return;
   }
   if (command === "doctor") {
     const parsed = splitFlags(rest);
-    const { doctorProject } = await import("../shared/hm5f8jby.js");
+    const { doctorProject } = await import("../shared/yvabyg9k.js");
     stdout(await doctorProject(cwd, parsed.name, invoke(parsed)));
     return;
   }
@@ -144,22 +176,54 @@ async function run(argv, io) {
   }
   if (command === "ext") {
     const sub = rest[0];
-    if (sub === "test" || sub === "scaffold") {
-      throw new OkmError2("invalid", `okm ext ${sub} is not available yet.`, {
-        fix: { summary: "okm ext list and okm ext check are the commands in this version." }
-      });
+    if (sub === "scaffold" || sub === "test") {
+      const parsed = extInvocation(rest.slice(1));
+      const { extScaffold, extTest } = await import("../shared/stfa9xcw.js");
+      const text = sub === "scaffold" ? await extScaffold(cwd, requireName(parsed, "okm ext scaffold <name>"), parsed.flags, parsed.out) : await extTest(cwd, requireName(parsed, "okm ext test <file>"), parsed.flags);
+      stdout(text);
+      return;
     }
     if (sub === "list" || sub === "check") {
-      const { extProject } = await import("../shared/n41w4fbz.js");
+      const { extProject } = await import("../shared/stfa9xcw.js");
       stdout(await extProject(cwd, sub, invoke(splitFlags(rest.slice(1)))));
       return;
     }
     throw new OkmError2("invalid", `Unknown command ext ${sub ?? ""}.`, {
-      fix: { summary: "Use okm ext list or okm ext check." }
+      fix: { summary: "Use okm ext list, okm ext check, okm ext scaffold, or okm ext test." }
     });
   }
   throw new OkmError2("invalid", `Unknown command ${command ?? ""}.`);
 }
+function requireName(parsed, usage) {
+  if (parsed.name === undefined || parsed.name.length === 0) {
+    throw new OkmError2("invalid", `${usage} needs a name.`, {
+      fix: { summary: `Pass ${usage}.` }
+    });
+  }
+  return parsed.name;
+}
+function extInvocation(args) {
+  const rest = [];
+  let out;
+  for (let index = 0;index < args.length; index += 1) {
+    const arg = args[index] ?? "";
+    if (arg === "--out" || arg.startsWith("--out=")) {
+      const value = arg === "--out" ? args[index + 1] : arg.slice("--out=".length);
+      if (value === undefined || value.length === 0 || value.startsWith("--")) {
+        throw new OkmError2("invalid", "--out needs a file.", {
+          fix: { summary: "Pass --out <file>. The command never overwrites." }
+        });
+      }
+      out = value;
+      if (arg === "--out")
+        index += 1;
+      continue;
+    }
+    rest.push(arg);
+  }
+  const parsed = splitFlags(rest);
+  return { name: parsed.name, out, flags: invoke(parsed) };
+}
 function invoke(parsed) {
   return {
     ...parsed.target !== undefined ? { target: parsed.target } : {},
@@ -240,18 +304,26 @@ function splitFlags(args) {
 }
 var COMMANDS = [
   ["build", "Write the schema build."],
+  ["catalog export", "Write the catalog snapshot."],
   ["check", "Lint the schema and compare it with one target."],
   ["dev", "Watch the schema and reload."],
   ["doctor [code]", "Print a target report, or one error code."],
   ["driver test <driver>", "Run conformance against one driver."],
   ["ext list", "List extensions the server can install."],
   ["ext check", "Compare declared extensions with the server."],
+  ["ext scaffold <name>", "Print a starting extension() definition."],
+  ["ext test <file>", "Check an extension() definition against the server."],
   ["generate [name]", "Write the next migration."],
-  ["migrate plan <name>", "Print the plan and its lock estimates."],
+  [
+    "import drizzle <path>",
+    "Import a Drizzle schema. This runs that file. Writes table files and needs no database."
+  ],
+  ["migrate plan <name>", "Print the plan and its lock estimates. --json prints a document."],
   ["migrate apply", "Apply pending migrations."],
   ["migrate status", "Print whether the target is current."],
   ["migrate check", "Replay migration history in a scratch schema."],
   ["push", "Apply the schema diff to one target."],
+  ["pull", "Write table files and a schema from one database."],
   ["seed <file>", "Run a seed file on one target."]
 ];
 function commandsTable() {