okmodel 0.7.0 → 0.9.0

package/dist/shared/xv8qj97g.js

@@ -0,0 +1,96 @@
+import {
+  DriverError2
+} from "./cm3w0ywp.js";
+import {
+  connectClient2,
+  send3
+} from "./mazpbcdj.js";
+import {
+  resetSession2
+} from "./99qp9vtg.js";
+import {
+  isConnectionLost
+} from "./cnkky55j.js";
+import {
+  noTimeout
+} from "./tr64w5p0.js";
+import {
+  WireSession
+} from "./e275q7sd.js";
+import {
+  rejectClosed,
+  runCall
+} from "./mfvx6kjx.js";
+
+// src/adapters/pg/neon-extra.ts
+async function checkout(held) {
+  const { pool, counters, named, isClosed } = held;
+  if (isClosed())
+    return rejectClosed();
+  const client = await connectClient2(pool, held.acquireMs, counters);
+  counters.reserved += 1;
+  let lost = false;
+  const onError = () => {
+    lost = true;
+  };
+  const events = client;
+  events.on("error", onError);
+  const local = new Set;
+  const session = new WireSession((text, params) => {
+    const pending = send3(client, text, params, named);
+    const guarded = pending.catch((error) => {
+      if (isConnectionLost(error) || lost) {
+        lost = true;
+        if (isConnectionLost(error))
+          throw error;
+        throw Object.assign(new DriverError2("CONNECTION_CLOSED", { cause: error }), {
+          code: "CONNECTION_CLOSED"
+        });
+      }
+      throw error;
+    });
+    return guarded;
+  }, held.notices, isClosed, false, () => {
+    counters.reservedBusy += 1;
+  }, () => {
+    counters.reservedBusy = Math.max(0, counters.reservedBusy - 1);
+  }, local);
+  const guard = (run) => lost ? rejectClosed() : run();
+  let released = false;
+  return {
+    execute: (text, params, options) => {
+      const refused = noTimeout(options);
+      if (refused !== undefined)
+        return refused;
+      return guard(() => runCall(isClosed(), options, (watch) => session.query(text, params, watch)));
+    },
+    batch: (statements, options) => {
+      const refused = noTimeout(options);
+      if (refused !== undefined)
+        return refused;
+      return guard(() => runCall(isClosed(), options, async (watch) => {
+        const { runAtomicBatch } = await import("./b76b8d95.js");
+        return runAtomicBatch(session, statements, watch);
+      }));
+    },
+    async release() {
+      if (released)
+        return;
+      released = true;
+      try {
+        if (!lost)
+          await reset(session, client);
+      } finally {
+        counters.reserved = Math.max(0, counters.reserved - 1);
+        events.removeListener("error", onError);
+        client.release(lost);
+      }
+    }
+  };
+}
+async function reset(session, client) {
+  await resetSession2(session.depth(), (text) => client.query(text));
+}
+export {
+  checkout
+};

package/dist/shared/{bg3rym3g.js → xwhdcrm4.js}

@@ -1,7 +1,7 @@
 import {
   touchFields,
   fieldSealed
-} from "./1w508jbr.js";
+} from "./9dtgn1z2.js";
 import {
   projectExpr,
   quote,
@@ -9,7 +9,7 @@ import {
   isRecord,
   registerFailFix,
   fail2
-} from "./67txcrcw.js";
+} from "./kgwp4jdd.js";
 import {
   throwNamed2
 } from "./52szzakm.js";

package/dist/shared/{kr0jzbw2.js → yvabyg9k.js}

@@ -1,24 +1,24 @@
 import {
   open2
-} from "./14vx95q4.js";
-import"./qq3899ht.js";
+} from "./dd5pmnky.js";
+import"./12z7aznj.js";
+import"./fk9vef30.js";
 import"./n442h54c.js";
 import {
   assertRoleHealth
-} from "./8skf0cam.js";
-import"./b5pftnn2.js";
+} from "./jpybhf98.js";
+import"./myk8fswx.js";
 import {
   errorDoc,
   openProject
-} from "./gs74dbj5.js";
+} from "./2zdxkt7b.js";
 import {
   omitManagedObjects,
   sessionFailure,
   finishQuiet,
   assertTargetPolicy,
   selectTarget
-} from "./tsvww22q.js";
-import"./9s0ypp87.js";
+} from "./6nae0spm.js";
 import {
   OkmError2
 } from "./52szzakm.js";

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/shared/{jznfax0y.js → zq1he88x.js}

@@ -1,16 +1,16 @@
-import {
-  assertNoControl
-} from "./zchaghkf.js";
 import {
   searchValue
 } from "./dzj09cye.js";
+import {
+  assertNoControl
+} from "./zchaghkf.js";
 import {
   refuseHidden,
   indexes,
   list,
   isRecord,
   fail2
-} from "./67txcrcw.js";
+} from "./kgwp4jdd.js";
 import {
   isOperator,
   operatorName,

package/dist/tooling/cli.js

@@ -1,6 +1,7 @@
-import"../shared/qq3899ht.js";
+import"../shared/12z7aznj.js";
 import"../shared/n442h54c.js";
-import"../shared/14vx95q4.js";
+import"../shared/fk9vef30.js";
+import"../shared/dd5pmnky.js";
 import {
   formatFindings,
   hasError,
@@ -8,12 +9,12 @@ import {
   buildProject,
   generateProject,
   planProject,
-  checkProject
-} from "../shared/gs74dbj5.js";
+  checkProject,
+  exportProject
+} from "../shared/2zdxkt7b.js";
 import {
   sessionFailure
-} from "../shared/tsvww22q.js";
-import"../shared/9s0ypp87.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/rs73fca9.js");
+    const { devProject } = await import("../shared/8qzkd9f3.js");
     stdout(await devProject(cwd));
     return;
   }
   if (command === "push") {
-    const { pushProject } = await import("../shared/2shdbn8q.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/2shdbn8q.js");
+      const { applyProject } = await import("../shared/n306gqkd.js");
       stdout(await applyProject(cwd, invoke(parsed), stdout));
       return;
     }
     if (sub === "status") {
-      const { statusProject } = await import("../shared/svncdeh5.js");
+      const { statusProject } = await import("../shared/mgaq2sd3.js");
       stdout(await statusProject(cwd, invoke(parsed)));
       return;
     }
     if (sub === "check") {
-      const { checkMigrations } = await import("../shared/wa07eas9.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,34 +152,78 @@ async function run(argv, io) {
         fix: { summary: "Pass okm seed <file>." }
       });
     }
-    const { seedProject } = await import("../shared/w72kgg4q.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/kr0jzbw2.js");
+    const { doctorProject } = await import("../shared/yvabyg9k.js");
     stdout(await doctorProject(cwd, parsed.name, invoke(parsed)));
     return;
   }
-  if (command === "ext") {
+  if (command === "driver") {
     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 !== "test") {
+      const message = sub === undefined ? "Unknown command driver." : `Unknown command driver ${sub}.`;
+      throw new OkmError2("invalid", message, {
+        fix: { summary: "Use okm driver test <driver>." }
       });
     }
+    const { driverTest } = await import("../shared/n7kg8mmx.js");
+    await driverTest(rest.slice(1), stdout);
+    return;
+  }
+  if (command === "ext") {
+    const sub = rest[0];
+    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/ktz42yez.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 } : {},
@@ -228,17 +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() {