@fragno-dev/cli 0.1.2 → 0.1.4

package/src/commands/db/migrate.ts

@@ -1,131 +1,133 @@
 import { resolve } from "node:path";
-import type { CommandContext } from "gunshi";
+import { define } from "gunshi";
 import { findFragnoDatabases } from "../../utils/find-fragno-databases";
+import { type FragnoDatabase } from "@fragno-dev/db";
+import { executeMigrations, type ExecuteMigrationResult } from "@fragno-dev/db/generation-engine";
+import type { AnySchema } from "@fragno-dev/db/schema";
+
+export const migrateCommand = define({
+  name: "migrate",
+  description: "Run database migrations for all fragments to their latest versions",
+  args: {},
+  run: async (ctx) => {
+    const targets = ctx.positionals;
+
+    if (targets.length === 0) {
+      throw new Error("At least one target file path is required");
+    }
 
-export async function migrate(ctx: CommandContext) {
-  const target = ctx.values["target"];
-  const version = ctx.values["to"];
-  const fromVersion = ctx.values["from"];
-
-  if (!target || typeof target !== "string") {
-    throw new Error("Target file path is required and must be a string");
-  }
-
-  if (version !== undefined && typeof version !== "string" && typeof version !== "number") {
-    throw new Error("Version must be a number or string");
-  }
-
-  if (
-    fromVersion !== undefined &&
-    typeof fromVersion !== "string" &&
-    typeof fromVersion !== "number"
-  ) {
-    throw new Error("Version must be a number or string");
-  }
-
-  // Resolve the target file path relative to current working directory
-  const targetPath = resolve(process.cwd(), target);
-
-  console.log(`Loading target file: ${targetPath}`);
-
-  // Dynamically import the target file
-  let targetModule: Record<string, unknown>;
-  try {
-    targetModule = await import(targetPath);
-  } catch (error) {
-    throw new Error(
-      `Failed to import target file: ${error instanceof Error ? error.message : String(error)}`,
-    );
-  }
+    // De-duplicate targets
+    const uniqueTargets = Array.from(new Set(targets));
 
-  // Find all FragnoDatabase instances or instantiated fragments with databases
-  const fragnoDatabases = findFragnoDatabases(targetModule);
+    // Load all target files and collect FragnoDatabase instances
+    const allFragnoDatabases: FragnoDatabase<AnySchema>[] = [];
 
-  if (fragnoDatabases.length === 0) {
-    throw new Error(
-      `No FragnoDatabase instances found in ${target}.\n` +
-        `Make sure you export either:\n` +
-        `  - A FragnoDatabase instance created with .create(adapter)\n` +
-        `  - An instantiated fragment with embedded database definition\n`,
-    );
-  }
+    for (const target of uniqueTargets) {
+      const targetPath = resolve(process.cwd(), target);
+      console.log(`Loading target file: ${targetPath}`);
 
-  if (fragnoDatabases.length > 1) {
-    console.warn(
-      `Warning: Multiple FragnoDatabase instances found (${fragnoDatabases.length}). Using the first one.`,
-    );
-  }
+      // Dynamically import the target file
+      let targetModule: Record<string, unknown>;
+      try {
+        targetModule = await import(targetPath);
+      } catch (error) {
+        throw new Error(
+          `Failed to import target file ${target}: ${error instanceof Error ? error.message : String(error)}`,
+        );
+      }
 
-  // Use the first FragnoDatabase instance
-  const fragnoDb = fragnoDatabases[0];
+      // Find all FragnoDatabase instances or instantiated fragments with databases
+      const fragnoDatabases = findFragnoDatabases(targetModule);
 
-  console.log(`Migrating database for namespace: ${fragnoDb.namespace}`);
+      if (fragnoDatabases.length === 0) {
+        console.warn(
+          `Warning: No FragnoDatabase instances found in ${target}.\n` +
+            `Make sure you export either:\n` +
+            `  - A FragnoDatabase instance created with .create(adapter)\n` +
+            `  - An instantiated fragment with embedded database definition\n`,
+        );
+        continue;
+      }
 
-  // Check if the adapter supports migrations
-  if (!fragnoDb.adapter.createMigrationEngine) {
-    throw new Error(
-      `Adapter does not support running migrations. The adapter only supports schema generation.\n` +
-        `Try using 'fragno db generate' instead to generate schema files.`,
-    );
-  }
-
-  // Parse versions if provided
-  const targetVersion = version !== undefined ? parseInt(String(version), 10) : undefined;
-  const expectedFromVersion =
-    fromVersion !== undefined ? parseInt(String(fromVersion), 10) : undefined;
-
-  if (targetVersion !== undefined && isNaN(targetVersion)) {
-    throw new Error(`Invalid version number: ${version}`);
-  }
-
-  if (expectedFromVersion !== undefined && isNaN(expectedFromVersion)) {
-    throw new Error(`Invalid version number: ${fromVersion}`);
-  }
-
-  // Run migrations
-  let didMigrate: boolean;
-  try {
-    if (targetVersion !== undefined) {
-      console.log(`Migrating to version ${targetVersion}...`);
-      const migrator = fragnoDb.adapter.createMigrationEngine(fragnoDb.schema, fragnoDb.namespace);
-      const currentVersion = await migrator.getVersion();
-      console.log(`Current version: ${currentVersion}`);
-
-      // Validate from version if provided
-      if (expectedFromVersion !== undefined && currentVersion !== expectedFromVersion) {
-        throw new Error(
-          `Current database version (${currentVersion}) does not match expected --from version (${expectedFromVersion})`,
+      if (fragnoDatabases.length > 1) {
+        console.warn(
+          `Warning: Multiple FragnoDatabase instances found in ${target} (${fragnoDatabases.length}). Using all of them.`,
         );
       }
 
-      const preparedMigration = await migrator.prepareMigrationTo(targetVersion, {
-        updateSettings: true,
-      });
+      allFragnoDatabases.push(...fragnoDatabases);
+    }
+
+    if (allFragnoDatabases.length === 0) {
+      throw new Error(
+        `No FragnoDatabase instances found in any of the target files.\n` +
+          `Make sure your files export either:\n` +
+          `  - A FragnoDatabase instance created with .create(adapter)\n` +
+          `  - An instantiated fragment with embedded database definition\n`,
+      );
+    }
+
+    console.log(
+      `Found ${allFragnoDatabases.length} FragnoDatabase instance(s) across ${uniqueTargets.length} file(s)`,
+    );
+
+    // Validate all databases use the same adapter object (identity)
+    const firstDb = allFragnoDatabases[0];
+    const firstAdapter = firstDb.adapter;
+    const allSameAdapter = allFragnoDatabases.every((db) => db.adapter === firstAdapter);
+
+    if (!allSameAdapter) {
+      throw new Error(
+        "All fragments must use the same database adapter instance. Mixed adapters are not supported.",
+      );
+    }
+
+    console.log("\nMigrating all fragments to their latest versions...\n");
 
-      if (preparedMigration.operations.length === 0) {
-        console.log("✓ Database is already at the target version. No migrations needed.");
-        didMigrate = false;
+    let results: ExecuteMigrationResult[];
+    try {
+      results = await executeMigrations(allFragnoDatabases);
+    } catch (error) {
+      throw new Error(
+        `Migration failed: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+
+    // Display progress for each result
+    for (const result of results) {
+      console.log(`Fragment: ${result.namespace}`);
+      console.log(`  Current version: ${result.fromVersion}`);
+      console.log(`  Target version: ${result.toVersion}`);
+
+      if (result.didMigrate) {
+        console.log(`  ✓ Migration completed: v${result.fromVersion} → v${result.toVersion}\n`);
       } else {
-        await preparedMigration.execute();
-        didMigrate = true;
+        console.log(`  ✓ Already at latest version. No migration needed.\n`);
       }
-    } else {
-      console.log(`Migrating to latest version (${fragnoDb.schema.version})...`);
-      didMigrate = await fragnoDb.runMigrations();
     }
-  } catch (error) {
-    throw new Error(
-      `Failed to run migrations: ${error instanceof Error ? error.message : String(error)}`,
-    );
-  }
-
-  if (didMigrate) {
-    console.log(`✓ Migration completed successfully`);
-    console.log(`  Namespace: ${fragnoDb.namespace}`);
-    if (targetVersion !== undefined) {
-      console.log(`  New version: ${targetVersion}`);
-    } else {
-      console.log(`  New version: ${fragnoDb.schema.version}`);
+
+    // Summary
+    console.log("═══════════════════════════════════════");
+    console.log("Migration Summary");
+    console.log("═══════════════════════════════════════");
+
+    const migrated = results.filter((r) => r.didMigrate);
+    const skipped = results.filter((r) => !r.didMigrate);
+
+    if (migrated.length > 0) {
+      console.log(`\n✓ Migrated ${migrated.length} fragment(s):`);
+      for (const r of migrated) {
+        console.log(`  - ${r.namespace}: v${r.fromVersion} → v${r.toVersion}`);
+      }
     }
-  }
-}
+
+    if (skipped.length > 0) {
+      console.log(`\n○ Skipped ${skipped.length} fragment(s) (already up-to-date):`);
+      for (const r of skipped) {
+        console.log(`  - ${r.namespace}: v${r.toVersion}`);
+      }
+    }
+
+    console.log("\n✓ All migrations completed successfully");
+  },
+});

package/.turbo/turbo-types$colon$check.log

@@ -1 +0,0 @@
-$ tsc --noEmit