@metaobjectsdev/cli 0.8.1 → 0.9.0

package/src/index.ts

@@ -58,6 +58,12 @@ EXPORT FLAGS:
 
 VERIFY FLAGS:
   --prompts <dir>       Directory of provider-resolved template text (default: prompts)
+  --db <url>            Live DB URL — enables the schema-drift gate (exit 1 on drift).
+                        Supports: file:, libsql:, postgres:, postgresql:. Omit to skip.
+  --dialect sqlite|postgres   Optional override (auto-detected from --db URL scheme)
+  --allow <csv>         Accepted for parity with 'migrate'; does NOT affect the
+                        verify drift gate (the gate fails on ANY detected change)
+  --skip-schema         Skip the schema-drift gate even when --db is present
 
 PROMPT-SNAPSHOT FLAGS:
   --check               Compare against committed snapshots; exit 1 on drift (CI gate)

package/src/lib/allow.ts

@@ -0,0 +1,54 @@
+// Shared destructive-change-permission parsing + change description, used by
+// both `meta migrate` and `meta verify --db`. Keeping a single copy avoids the
+// two commands drifting on which `--allow` tokens exist or how a change reads.
+
+import type { AllowOptions, Change } from "@metaobjectsdev/migrate-ts";
+
+// Map CLI allow tokens → migrate-ts AllowOptions field names.
+const ALLOW_TOKEN_MAP: Record<string, keyof AllowOptions> = {
+  "drop-column": "dropColumn",
+  "drop-table": "dropTable",
+  "type-change": "typeChange",
+  "drop-index": "dropIndex",
+  "drop-fk": "dropFk",
+  "nullable-to-not-null": "nullableToNotNull",
+};
+
+/** Translate parsed `--allow` tokens into the migrate-ts `AllowOptions` shape. */
+export function tokensToAllowOptions(tokens: string[]): AllowOptions {
+  const opts: AllowOptions = {};
+  for (const tok of tokens) {
+    const field = ALLOW_TOKEN_MAP[tok];
+    if (field !== undefined) {
+      opts[field] = true;
+    }
+  }
+  return opts;
+}
+
+/**
+ * One-line, human-readable detail for a single change (table/column/index/fk/
+ * view). This is the shared core: `migrate` prints it as-is; `verify` prefixes
+ * a +/-/~ glyph and a noun (`table`/`column`/…) on top.
+ */
+export function describeChange(c: Change): string {
+  switch (c.kind) {
+    case "create-table": return c.table.name;
+    case "drop-table": return c.table;
+    case "rename-table": return `${c.from} → ${c.to}`;
+    case "add-column": return `${c.table}.${c.column.name}`;
+    case "drop-column": return `${c.table}.${c.column}`;
+    case "rename-column": return `${c.table}.${c.from} → ${c.table}.${c.to}`;
+    case "change-column-type": return `${c.table}.${c.column} (${c.from.kind} → ${c.to.kind})`;
+    case "change-column-nullable": return `${c.table}.${c.column} (${c.from ? "NULL" : "NOT NULL"} → ${c.to ? "NULL" : "NOT NULL"})`;
+    case "change-column-default": return `${c.table}.${c.column}`;
+    case "add-index": return `${c.table} idx ${c.index.name}`;
+    case "drop-index": return `${c.table} idx ${c.index}`;
+    case "add-fk": return `${c.table} fk ${c.fk.name}`;
+    case "drop-fk": return `${c.table} fk ${c.fk}`;
+    case "create-view": return c.view.name;
+    case "replace-view": return c.view.name;
+    case "drop-view": return c.view;
+    default: return JSON.stringify(c);
+  }
+}

package/src/lib/args.ts

@@ -92,6 +92,23 @@ export function parseExportArgs(argv: string[]): ExportFlags {
   };
 }
 
+// ---------------------------------------------------------------------------
+// shared DB-connection vocab (used by both verify --db and migrate)
+// ---------------------------------------------------------------------------
+
+const DIALECTS = ["sqlite", "postgres", "d1"] as const;
+type Dialect = (typeof DIALECTS)[number];
+
+const ALLOW_TOKENS = [
+  "drop-column",
+  "drop-table",
+  "type-change",
+  "drop-index",
+  "drop-fk",
+  "nullable-to-not-null",
+] as const;
+type AllowToken = (typeof ALLOW_TOKENS)[number];
+
 // ---------------------------------------------------------------------------
 // verify flags
 // ---------------------------------------------------------------------------
@@ -99,6 +116,14 @@ export function parseExportArgs(argv: string[]): ExportFlags {
 export interface VerifyFlags {
   /** Directory (relative to cwd) holding provider-resolved template text. */
   prompts: string | undefined;
+  /** Live DB connection URL; when present, enables the schema-drift gate. */
+  db: string | undefined;
+  /** Optional dialect override (auto-detected from --db URL scheme otherwise). */
+  dialect: Dialect | undefined;
+  /** Destructive-change permissions; only affects how drift is described. */
+  allow: AllowToken[];
+  /** Skip the schema-drift gate even when --db is present. */
+  skipSchema: boolean;
 }
 
 export function parseVerifyArgs(argv: string[]): VerifyFlags {
@@ -106,12 +131,38 @@ export function parseVerifyArgs(argv: string[]): VerifyFlags {
     args: argv,
     options: {
       prompts: { type: "string" },
+      db: { type: "string" },
+      dialect: { type: "string" },
+      allow: { type: "string" },
+      "skip-schema": { type: "boolean", default: false },
     },
     strict: true,
     allowPositionals: false,
   });
+
+  const dialect = values.dialect as string | undefined;
+  if (dialect !== undefined && !DIALECTS.includes(dialect as Dialect)) {
+    throw new Error(`invalid --dialect '${dialect}'; expected: ${DIALECTS.join(", ")}`);
+  }
+
+  const allowRaw = (values.allow as string | undefined) ?? "";
+  const allowTokens = allowRaw.length === 0
+    ? []
+    : allowRaw.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+  for (const tok of allowTokens) {
+    if (!ALLOW_TOKENS.includes(tok as AllowToken)) {
+      throw new Error(
+        `invalid --allow token '${tok}'; expected one of: ${ALLOW_TOKENS.join(", ")}`,
+      );
+    }
+  }
+
   return {
     prompts: values.prompts,
+    db: values.db as string | undefined,
+    dialect: dialect as Dialect | undefined,
+    allow: allowTokens as AllowToken[],
+    skipSchema: !!values["skip-schema"],
   };
 }
 
@@ -146,19 +197,6 @@ export function parsePromptSnapshotArgs(argv: string[]): PromptSnapshotFlags {
 // migrate flags
 // ---------------------------------------------------------------------------
 
-const DIALECTS = ["sqlite", "postgres", "d1"] as const;
-type Dialect = (typeof DIALECTS)[number];
-
-const ALLOW_TOKENS = [
-  "drop-column",
-  "drop-table",
-  "type-change",
-  "drop-index",
-  "drop-fk",
-  "nullable-to-not-null",
-] as const;
-type AllowToken = (typeof ALLOW_TOKENS)[number];
-
 const ON_AMBIGUOUS = ["abort", "rename", "drop-add"] as const;
 type OnAmbiguous = (typeof ON_AMBIGUOUS)[number];
 
@@ -174,11 +212,21 @@ export interface MigrateFlags {
   d1Binding: string | undefined;
   remote: boolean;
   apply: boolean;
+  /**
+   * Roll back all applied migrations NEWER than this target (the target itself
+   * is retained), running each migration's down.sql in reverse order. Mutually
+   * exclusive with --apply. postgres/sqlite only (not d1).
+   */
+  rollback: string | undefined;
   yes: boolean;
+  /** Use live-DB introspection instead of the committed snapshot (legacy/adoption). */
+  fromDb: boolean;
+  /** `migrate baseline` subcommand: seed the snapshot, emit no migration. */
+  baseline: boolean;
 }
 
 export function parseMigrateArgs(argv: string[]): MigrateFlags {
-  const { values } = parseArgs({
+  const { values, positionals } = parseArgs({
     args: argv,
     options: {
       "db": { type: "string" },
@@ -188,15 +236,26 @@ export function parseMigrateArgs(argv: string[]): MigrateFlags {
       "allow": { type: "string" },
       "on-ambiguous": { type: "string" },
       "dry-run": { type: "boolean", default: false },
+      "from-db": { type: "boolean", default: false },
       "d1": { type: "string" },
       "remote": { type: "boolean", default: false },
       "apply": { type: "boolean", default: false },
+      "rollback": { type: "string" },
       "yes": { type: "boolean", default: false },
     },
     strict: true,
-    allowPositionals: false,
+    allowPositionals: true,
   });
 
+  const baseline = positionals[0] === "baseline";
+  if (positionals.length > 0 && !baseline) {
+    throw new Error(`unknown migrate subcommand '${positionals[0]}'; expected 'baseline' or no subcommand`);
+  }
+
+  if (values.rollback !== undefined && values.apply === true) {
+    throw new Error(`--rollback and --apply are mutually exclusive`);
+  }
+
   const dialect = values.dialect as string | undefined;
   if (dialect !== undefined && !DIALECTS.includes(dialect as Dialect)) {
     throw new Error(`invalid --dialect '${dialect}'; expected: ${DIALECTS.join(", ")}`);
@@ -230,6 +289,9 @@ export function parseMigrateArgs(argv: string[]): MigrateFlags {
     d1Binding: values.d1 as string | undefined,
     remote: !!values.remote,
     apply: !!values.apply,
+    rollback: values.rollback as string | undefined,
     yes: !!values.yes,
+    fromDb: !!values["from-db"],
+    baseline,
   };
 }

package/src/lib/bun-sqlite-dialect.ts

@@ -0,0 +1,146 @@
+// A Kysely SQLite dialect backed by Bun's built-in `bun:sqlite`.
+//
+// WHY: the standalone `meta` binary is produced with `bun build --compile`,
+// which embeds the Bun runtime but CANNOT bundle native node addons. The
+// default sqlite driver (`@libsql/kysely-libsql`) loads a platform-native
+// `.node` addon (`@libsql/linux-x64-gnu` etc.) via a runtime require that the
+// single-file binary's virtual filesystem can't resolve — so libsql fails
+// inside the compiled binary with `Cannot find module '@libsql/linux-x64-gnu'`.
+//
+// `bun:sqlite` ships *inside* the Bun runtime that `--compile` embeds, so it
+// needs no on-disk addon. This dialect is therefore the sqlite driver the
+// standalone binary uses. The npm/Node distribution keeps using libsql (this
+// module is only loaded when running under Bun — see buildKyselyFromUrl).
+//
+// The `bun:sqlite` import is dynamic + typed loosely so the tsc → Node build
+// (which has no `bun:sqlite` module) never tries to resolve it statically.
+
+import {
+  type DatabaseConnection,
+  type Dialect,
+  type Driver,
+  type QueryResult,
+  SqliteAdapter,
+  SqliteIntrospector,
+  SqliteQueryCompiler,
+  type CompiledQuery,
+  type DatabaseIntrospector,
+  type Kysely,
+  type DialectAdapter,
+  type QueryCompiler,
+} from "kysely";
+
+/** Minimal structural view of a `bun:sqlite` Database — only what we use. */
+interface BunSqliteDatabase {
+  query(sql: string): BunSqliteStatement;
+  run(sql: string): void;
+  close(): void;
+}
+interface BunSqliteStatement {
+  all(...params: readonly unknown[]): unknown[];
+  run(...params: readonly unknown[]): { changes: number; lastInsertRowid: number | bigint };
+}
+
+/**
+ * Open a `bun:sqlite` database for a `file:`/`libsql:` URL (or a bare path).
+ * Throws when not running under Bun (no `bun:sqlite` module).
+ */
+async function openBunSqlite(url: string): Promise<BunSqliteDatabase> {
+  // `bun:sqlite` is a Bun built-in; the dynamic specifier keeps Node/tsc from
+  // resolving it. The cast is necessary because there's no ambient type here.
+  const mod = (await import("bun:sqlite")) as unknown as {
+    Database: new (filename: string) => BunSqliteDatabase;
+  };
+  // Strip a file:/libsql: scheme to a plain filesystem path; `:memory:` stays.
+  let filename = url;
+  const schemeMatch = /^(file|libsql):\/\/(.*)$/i.exec(url) ?? /^(file|libsql):(.*)$/i.exec(url);
+  if (schemeMatch) filename = schemeMatch[2] ?? "";
+  if (filename === "") filename = ":memory:";
+  return new mod.Database(filename);
+}
+
+class BunSqliteConnection implements DatabaseConnection {
+  constructor(private readonly db: BunSqliteDatabase) {}
+
+  async executeQuery<R>(compiledQuery: CompiledQuery): Promise<QueryResult<R>> {
+    const { sql, parameters } = compiledQuery;
+    const stmt = this.db.query(sql);
+    const params = parameters as readonly unknown[];
+    // SELECT-shaped statements return rows; everything else reports counts.
+    const isReturningRows = /^\s*(select|with|pragma)\b/i.test(sql);
+    if (isReturningRows) {
+      const rows = stmt.all(...params) as R[];
+      return { rows };
+    }
+    const info = stmt.run(...params);
+    return {
+      numAffectedRows: BigInt(info.changes),
+      insertId: BigInt(info.lastInsertRowid),
+      rows: [],
+    };
+  }
+
+  // Async generator that never yields by design — streaming is unsupported.
+  async *streamQuery<R>(): AsyncIterableIterator<QueryResult<R>> {
+    throw new Error("bun:sqlite dialect does not support streaming");
+  }
+}
+
+class BunSqliteDriver implements Driver {
+  private db: BunSqliteDatabase | undefined;
+  private connection: BunSqliteConnection | undefined;
+
+  constructor(private readonly url: string) {}
+
+  async init(): Promise<void> {
+    this.db = await openBunSqlite(this.url);
+    this.connection = new BunSqliteConnection(this.db);
+  }
+
+  async acquireConnection(): Promise<DatabaseConnection> {
+    if (this.connection === undefined) throw new Error("bun:sqlite driver not initialized");
+    return this.connection;
+  }
+
+  async beginTransaction(conn: DatabaseConnection): Promise<void> {
+    await conn.executeQuery({ sql: "begin", parameters: [], query: { kind: "RawNode" } as never });
+  }
+  async commitTransaction(conn: DatabaseConnection): Promise<void> {
+    await conn.executeQuery({ sql: "commit", parameters: [], query: { kind: "RawNode" } as never });
+  }
+  async rollbackTransaction(conn: DatabaseConnection): Promise<void> {
+    await conn.executeQuery({ sql: "rollback", parameters: [], query: { kind: "RawNode" } as never });
+  }
+
+  async releaseConnection(): Promise<void> {
+    /* single shared connection — nothing to release */
+  }
+
+  async destroy(): Promise<void> {
+    this.db?.close();
+    this.db = undefined;
+    this.connection = undefined;
+  }
+}
+
+/** Kysely Dialect backed by `bun:sqlite`. */
+export class BunSqliteDialect implements Dialect {
+  constructor(private readonly url: string) {}
+  createDriver(): Driver {
+    return new BunSqliteDriver(this.url);
+  }
+  createQueryCompiler(): QueryCompiler {
+    return new SqliteQueryCompiler();
+  }
+  createAdapter(): DialectAdapter {
+    return new SqliteAdapter();
+  }
+  createIntrospector(db: Kysely<Record<string, unknown>>): DatabaseIntrospector {
+    return new SqliteIntrospector(db);
+  }
+}
+
+/** True when running under the Bun runtime (where `bun:sqlite` is available). */
+export function isBun(): boolean {
+  return typeof (globalThis as { Bun?: unknown }).Bun !== "undefined";
+}

package/src/lib/config.ts

@@ -42,7 +42,18 @@ export interface ResolvedMigrateConfig {
   allow: string[];
   slug: string | undefined;
   dryRun: boolean;
+  /** Run pending migration files against the DB (postgres/sqlite, ledger-backed). */
+  apply: boolean;
+  /**
+   * Roll back all applied migrations newer than this target (target retained),
+   * postgres/sqlite only. Mutually exclusive with apply.
+   */
+  rollback: string | undefined;
   yes: boolean;
+  /** Use live-DB introspection instead of the committed snapshot. */
+  fromDb: boolean;
+  /** Seed the snapshot and exit (no migration). */
+  baseline: boolean;
   d1: ResolvedD1Config;
 }
 
@@ -87,7 +98,11 @@ export async function resolveMigrateConfig(
       : (cfgBlock.allow ?? MIGRATE_DEFAULTS.allow),
     slug: flags.slug,
     dryRun: flags.dryRun,
+    apply: flags.apply,
+    rollback: flags.rollback,
     yes: flags.yes,
+    fromDb: flags.fromDb,
+    baseline: flags.baseline,
     d1: {
       binding: flags.d1Binding ?? d1Block.binding,
       remote: flags.remote || (d1Block.remote ?? false),

package/src/lib/kysely.ts

@@ -1,4 +1,5 @@
 import { Kysely } from "kysely";
+import { BunSqliteDialect, isBun } from "./bun-sqlite-dialect.js";
 
 export type Dialect = "sqlite" | "postgres" | "d1";
 
@@ -63,17 +64,29 @@ export async function buildKyselyFromUrl(
   }
 
   if (dialect === "sqlite") {
-    type LibsqlDialectCtor = new (opts: { url: string }) => ConstructorParameters<typeof Kysely<Record<string, unknown>>>[0]["dialect"];
-    let LibsqlDialect: LibsqlDialectCtor;
-    try {
-      const mod = await import("@libsql/kysely-libsql");
-      LibsqlDialect = mod.LibsqlDialect as unknown as LibsqlDialectCtor;
-    } catch {
-      throw new Error(
-        `dialect 'sqlite' requires '@libsql/kysely-libsql'; install it: 'bun add @libsql/kysely-libsql'`,
-      );
+    // Under Bun (notably the `bun build --compile` standalone binary), use the
+    // built-in `bun:sqlite` driver. It ships inside the embedded Bun runtime,
+    // so — unlike `@libsql/kysely-libsql`, whose platform-native `.node` addon
+    // can't be bundled into a single-file binary — it works in the compiled
+    // `meta` binary with no on-disk dependency. The Node/npm distribution falls
+    // through to libsql below.
+    let sqliteDialect: ConstructorParameters<typeof Kysely<Record<string, unknown>>>[0]["dialect"];
+    if (isBun()) {
+      sqliteDialect = new BunSqliteDialect(url);
+    } else {
+      type LibsqlDialectCtor = new (opts: { url: string }) => ConstructorParameters<typeof Kysely<Record<string, unknown>>>[0]["dialect"];
+      let LibsqlDialect: LibsqlDialectCtor;
+      try {
+        const mod = await import("@libsql/kysely-libsql");
+        LibsqlDialect = mod.LibsqlDialect as unknown as LibsqlDialectCtor;
+      } catch {
+        throw new Error(
+          `dialect 'sqlite' requires '@libsql/kysely-libsql'; install it: 'bun add @libsql/kysely-libsql'`,
+        );
+      }
+      sqliteDialect = new LibsqlDialect({ url });
     }
-    const db = new Kysely<Record<string, unknown>>({ dialect: new LibsqlDialect({ url }) });
+    const db = new Kysely<Record<string, unknown>>({ dialect: sqliteDialect });
     let closed = false;
     return {
       db,

package/src/lib/projection-migrations.ts

@@ -10,6 +10,7 @@ import {
 } from "@metaobjectsdev/codegen-ts";
 import {
   computeViewMigrations,
+  viewSqlEquals,
   type ViewMigrationInput,
   type ViewMigrationsResult,
 } from "@metaobjectsdev/migrate-ts";
@@ -33,11 +34,6 @@ export interface ProjectionMigrationsOpts {
   readonly existingViewSql?: ReadonlyMap<string, string>;
 }
 
-/** Collapse whitespace + strip trailing ";" for textual view-SQL comparison. */
-function normalizeViewSql(sql: string): string {
-  return sql.replace(/\s+/g, " ").replace(/;\s*$/, "").trim();
-}
-
 /**
  * Walk all projection entities in metadata, extract their ViewSpec, emit CREATE
  * VIEW DDL, and compute view migration SQL via computeViewMigrations.
@@ -96,7 +92,7 @@ export function computeProjectionMigrations(
     // Avoids the "every migration re-creates every view" noise when nothing
     // about the view's body actually changed.
     const existing = opts.existingViewSql?.get(spec.viewName);
-    if (existing !== undefined && normalizeViewSql(existing) === normalizeViewSql(createSql)) {
+    if (existing !== undefined && viewSqlEquals(existing, createSql)) {
       continue;
     }