@schemic/cli 0.1.0-alpha.2 → 0.1.0-alpha.4

package/lib/cli.js

@@ -7,8 +7,13 @@ import {
   mkdirSync as mkdirSync3,
   writeFileSync as writeFileSync3
 } from "fs";
-import { dirname as dirname2, join as join3, relative as relative2 } from "path";
+import { dirname as dirname3, join as join3, relative as relative2 } from "path";
 import { createInterface } from "readline/promises";
+
+// package.json
+var version = "0.1.0-alpha.4";
+
+// src/cli/index.ts
 import {
   actionLabel,
   applyPull,
@@ -423,8 +428,9 @@ async function closeQuietly(conn) {
 }
 
 // src/cli/resolve.ts
+import { readFileSync as readFileSync2 } from "fs";
 import { createRequire } from "module";
-import { join as join2 } from "path";
+import { dirname as dirname2, join as join2 } from "path";
 import { pathToFileURL } from "url";
 import {
   driverNames,
@@ -433,23 +439,54 @@ import {
   loadProject,
   resolveConnectionConfig
 } from "@schemic/core";
+function pickCompiled(node) {
+  if (typeof node === "string") return node;
+  if (node && typeof node === "object") {
+    const o = node;
+    return pickCompiled(o.import) ?? pickCompiled(o.default) ?? pickCompiled(o.require);
+  }
+  return void 0;
+}
+function compiledEntry(pkg, base) {
+  try {
+    const manifestPath = createRequire(base).resolve(`${pkg}/package.json`);
+    const m = JSON.parse(readFileSync2(manifestPath, "utf8"));
+    const rel = pickCompiled(m.exports?.["."]) ?? m.module ?? m.main ?? "index.js";
+    return join2(dirname2(manifestPath), rel);
+  } catch {
+    return null;
+  }
+}
 async function ensureDriver(name) {
   if (driverNames().includes(name)) return;
   const pkg = `@schemic/${name}`;
-  try {
-    const fromCwd = createRequire(join2(process.cwd(), "noop.js"));
-    await import(pathToFileURL(fromCwd.resolve(pkg)).href);
-  } catch {
+  let lastErr;
+  let loaded = false;
+  for (const base of [join2(process.cwd(), "noop.js"), import.meta.url]) {
+    const entry = compiledEntry(pkg, base);
+    if (!entry) continue;
+    try {
+      await import(pathToFileURL(entry).href);
+      loaded = true;
+      break;
+    } catch (e) {
+      lastErr = e;
+    }
+  }
+  if (!loaded) {
     try {
       await import(pkg);
+      loaded = true;
     } catch (e) {
-      throw new Error(
-        `could not load the "${name}" database driver (package ${pkg}). Install it in your project, then re-run:
-    bun add ${pkg}
-  (${e instanceof Error ? e.message : String(e)})`
-      );
+      lastErr = e;
     }
   }
+  if (!loaded)
+    throw new Error(
+      `could not load the "${name}" database driver (package ${pkg}). Install it in your project, then re-run:
+    bun add ${pkg}
+  (${lastErr instanceof Error ? lastErr.message : String(lastErr)})`
+    );
   if (!driverNames().includes(name))
     throw new Error(`package ${pkg} did not register a "${name}" driver.`);
 }
@@ -730,7 +767,7 @@ var dbFlags = (cmd) => configFlag(cmd).option(
 var program = new Command();
 program.name("schemic").description(
   "Schema-as-code migrations for any database \u2014 generate DDL, diff, and migrate via drivers"
-).version("0.1.0-alpha.0").showHelpAfterError("(run `schemic --help` for usage)").addHelpText(
+).version(version).showHelpAfterError("(run `schemic --help` for usage)").addHelpText(
   "after",
   `
 Examples:
@@ -1280,7 +1317,7 @@ configFlag(
     );
     if (existsSync3(target))
       throw new Error(`${relative2(config.root, target)} already exists.`);
-    mkdirSync3(dirname2(target), { recursive: true });
+    mkdirSync3(dirname3(target), { recursive: true });
     writeFileSync3(target, content);
     console.log(
       `${ok2(relative2(config.root, target))}  ${style2.dim("\u2014 author its fields, then `schemic gen`")}`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@schemic/cli",
-  "version": "0.1.0-alpha.2",
+  "version": "0.1.0-alpha.4",
   "description": "The Schemic CLI — driver-agnostic schema migrations (gen/migrate/diff/push/pull/check).",
   "license": "MIT",
   "author": "Vertio Solutions",
@@ -35,14 +35,14 @@
     "lint": "biome check ."
   },
   "dependencies": {
-    "@schemic/core": "0.1.0-alpha.2",
+    "@schemic/core": "0.1.0-alpha.4",
     "commander": "^14.0.2"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.3.11",
     "@electric-sql/pglite": "^0.5.2",
-    "@schemic/postgres": "0.1.0-alpha.2",
-    "@schemic/surrealdb": "0.1.0-alpha.2",
+    "@schemic/postgres": "0.1.0-alpha.4",
+    "@schemic/surrealdb": "0.1.0-alpha.4",
     "@types/bun": "latest",
     "surrealdb": "^2.0.3",
     "tsup": "^8",

package/src/cli/index.ts

@@ -6,6 +6,9 @@ import {
 } from "node:fs";
 import { dirname, join, relative } from "node:path";
 import { createInterface } from "node:readline/promises";
+// The CLI's own version — sourced from package.json (inlined at build) so it never drifts from the
+// published package version the way a hardcoded string does.
+import { version as CLI_VERSION } from "../../package.json";
 import {
   actionLabel,
   applyPull,
@@ -284,7 +287,7 @@ program
   .description(
     "Schema-as-code migrations for any database — generate DDL, diff, and migrate via drivers",
   )
-  .version("0.1.0-alpha.0")
+  .version(CLI_VERSION)
   .showHelpAfterError("(run `schemic --help` for usage)")
   .addHelpText(
     "after",

package/src/cli/resolve.ts

@@ -10,8 +10,9 @@
 // connects the sibling on demand (the dependency graph falls out of access; cycles error) and we close
 // anything it opened once resolution settles. The returned configs are connected FRESH by each command.
 
+import { readFileSync } from "node:fs";
 import { createRequire } from "node:module";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { pathToFileURL } from "node:url";
 import {
   type ConnectionEntry,
@@ -32,27 +33,77 @@ import {
  * (`@schemic/<name>`) that self-register with the core registry on import; the CLI itself contains no
  * dialect code and discovers the driver from the project's connection config at runtime. Idempotent.
  */
+/** Pick a package's COMPILED entry from its exports, deliberately skipping the `bun` condition. */
+function pickCompiled(node: unknown): string | undefined {
+  if (typeof node === "string") return node;
+  if (node && typeof node === "object") {
+    const o = node as Record<string, unknown>;
+    // import/default/require are the published (compiled) conditions; never `bun` (raw src/*.ts).
+    return (
+      pickCompiled(o.import) ??
+      pickCompiled(o.default) ??
+      pickCompiled(o.require)
+    );
+  }
+  return undefined;
+}
+
+/**
+ * Resolve a driver package to its COMPILED entry file, from `base`'s module scope. We read the
+ * manifest and pick the `import`/`default` export rather than letting the runtime choose the `bun`
+ * export condition (which points at raw `src/*.ts` for monorepo dev) — loading a PUBLISHED package's
+ * TypeScript source is fragile (every transitive src import must re-resolve at the consumer).
+ */
+function compiledEntry(pkg: string, base: string): string | null {
+  try {
+    const manifestPath = createRequire(base).resolve(`${pkg}/package.json`);
+    const m = JSON.parse(readFileSync(manifestPath, "utf8")) as {
+      exports?: Record<string, unknown>;
+      module?: string;
+      main?: string;
+    };
+    const rel =
+      pickCompiled(m.exports?.["."]) ?? m.module ?? m.main ?? "index.js";
+    return join(dirname(manifestPath), rel);
+  } catch {
+    return null;
+  }
+}
+
 export async function ensureDriver(name: string): Promise<void> {
   if (driverNames().includes(name)) return;
   const pkg = `@schemic/${name}`;
-  // Resolve the driver from the USER's project (cwd) first, then fall back to the CLI's own location.
-  // The CLI is often run via `bunx`/`npx` from a temp dir, so a plain `import(pkg)` (resolved relative
-  // to the CLI module) would MISS a driver installed in the user's project — resolve from cwd instead.
-  try {
-    const fromCwd = createRequire(join(process.cwd(), "noop.js"));
-    await import(pathToFileURL(fromCwd.resolve(pkg)).href);
-  } catch {
+  // Try the USER's project (cwd) first, then the CLI's own module scope — the CLI is often run via
+  // `bunx`/`npx` from a temp dir, so a driver installed in the user's project must be found by cwd.
+  let lastErr: unknown;
+  let loaded = false;
+  for (const base of [join(process.cwd(), "noop.js"), import.meta.url]) {
+    const entry = compiledEntry(pkg, base);
+    if (!entry) continue;
+    try {
+      await import(pathToFileURL(entry).href);
+      loaded = true;
+      break;
+    } catch (e) {
+      lastErr = e;
+    }
+  }
+  // Last resort: a plain specifier import (covers an unbuilt monorepo checkout, where lib is absent).
+  if (!loaded) {
     try {
       await import(pkg);
+      loaded = true;
     } catch (e) {
-      throw new Error(
-        `could not load the "${name}" database driver (package ${pkg}). ` +
-          `Install it in your project, then re-run:\n    bun add ${pkg}\n  (${
-            e instanceof Error ? e.message : String(e)
-          })`,
-      );
+      lastErr = e;
     }
   }
+  if (!loaded)
+    throw new Error(
+      `could not load the "${name}" database driver (package ${pkg}). ` +
+        `Install it in your project, then re-run:\n    bun add ${pkg}\n  (${
+          lastErr instanceof Error ? lastErr.message : String(lastErr)
+        })`,
+    );
   if (!driverNames().includes(name))
     throw new Error(`package ${pkg} did not register a "${name}" driver.`);
 }