@metaobjectsdev/cli 1.0.5-rc.9 → 1.0.7-rc.1

package/src/lib/kysely.ts

@@ -1,7 +1,43 @@
 import { Kysely } from "kysely";
 import { BunSqliteDialect, isBun } from "./bun-sqlite-dialect.js";
+import { sep } from "node:path";
+import { fileURLToPath } from "node:url";
 import { installCommand } from "./pm-detect.js";
 
+/**
+ * The directory a dynamic `import()` of a DB driver resolves from: the project whose
+ * `node_modules` holds `@metaobjectsdev/cli`. `undefined` when the CLI is not running from
+ * an installed package (a source checkout), where there is no one place to name.
+ */
+export function cliInstallRoot(moduleUrl: string): string | undefined {
+  const path = moduleUrl.startsWith("file:") ? fileURLToPath(moduleUrl) : moduleUrl;
+  const marker = `${sep}node_modules${sep}@metaobjectsdev${sep}`;
+  const i = path.lastIndexOf(marker);
+  return i === -1 ? undefined : path.slice(0, i);
+}
+
+/**
+ * A missing driver says WHERE it must be installed. In a monorepo the package that
+ * depends on the CLI need not be the one that runs the app, and installing the driver in
+ * the wrong one changes nothing.
+ */
+export function missingDriverMessage(
+  dialect: string, pkg: string, root: string | undefined, cmd: string,
+): string {
+  const where = root === undefined
+    ? "where @metaobjectsdev/cli is installed"
+    : `where @metaobjectsdev/cli is installed (${root})`;
+  return `dialect '${dialect}' requires '${pkg}', resolvable from ${where} — in a monorepo, ` +
+    `the package that depends on the CLI, not necessarily the one that runs your app. ` +
+    `Install it there: '${cmd}'`;
+}
+
+async function missingDriver(dialect: string, pkg: string): Promise<Error> {
+  const root = cliInstallRoot(import.meta.url);
+  const cmd = await installCommand(pkg, root ?? process.cwd());
+  return new Error(missingDriverMessage(dialect, pkg, root, cmd));
+}
+
 export type Dialect = "sqlite" | "postgres" | "d1";
 
 export interface KyselyHandle {
@@ -81,10 +117,7 @@ export async function buildKyselyFromUrl(
         const mod = await import("@libsql/kysely-libsql");
         LibsqlDialect = mod.LibsqlDialect as unknown as LibsqlDialectCtor;
       } catch {
-        const cmd = await installCommand("@libsql/kysely-libsql", process.cwd());
-        throw new Error(
-          `dialect 'sqlite' requires '@libsql/kysely-libsql'; install it: '${cmd}'`,
-        );
+        throw await missingDriver("sqlite", "@libsql/kysely-libsql");
       }
       sqliteDialect = new LibsqlDialect({ url });
     }
@@ -110,10 +143,7 @@ export async function buildKyselyFromUrl(
     pg = await import("pg") as unknown as PgPoolModule;
     ({ PostgresDialect } = await import("kysely"));
   } catch {
-    const cmd = await installCommand("pg", process.cwd());
-    throw new Error(
-      `dialect 'postgres' requires 'pg'; install it: '${cmd}'`,
-    );
+    throw await missingDriver("postgres", "pg");
   }
   const PoolCtor = pg.Pool ?? pg.default?.Pool;
   if (PoolCtor === undefined) {

package/src/lib/output.ts

@@ -181,6 +181,12 @@ export interface MigrateResultShape {
    * that cannot work.
    */
   format?: "default" | "flyway";
+  /**
+   * Data-hazard warnings: changes that apply to an empty table and fail on a populated one.
+   * Text output already carries them on stderr; JSON/toon carry them here so a programmatic
+   * caller sees the risk before applying.
+   */
+  warnings?: string[];
 }
 
 export function formatMigrateResult(result: MigrateResultShape, _opts: FormatOptions): string {
@@ -298,6 +304,7 @@ export function migrateResultToData(result: MigrateResultShape): {
   written: string[];
   summary: string;
   help: string[];
+  warnings?: string[];
 } {
   const changeEntries = Object.entries(result.changeCounts).filter(([, v]) => v > 0);
   const changes = changeEntries.map(([kind, count]) => ({ kind, count }));
@@ -352,7 +359,12 @@ export function migrateResultToData(result: MigrateResultShape): {
     help = ["re-run with --slug <name> to write the migration"];
   }
 
-  return { changes, written: result.writtenPaths, summary, help };
+  const warnings = result.warnings ?? [];
+  return {
+    changes, written: result.writtenPaths, summary, help,
+    // Only when present, so a run with no hazard keeps its existing shape.
+    ...(warnings.length > 0 ? { warnings } : {}),
+  };
 }
 
 export function formatMigrateResultToon(result: MigrateResultShape): string {