@fragno-dev/cli 0.1.1 → 0.1.3

package/src/commands/db/info.ts

@@ -1,93 +1,178 @@
-import { isFragnoDatabase, type FragnoDatabase } from "@fragno-dev/db";
-import type { AnySchema } from "@fragno-dev/db/schema";
 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 type { AnySchema } from "@fragno-dev/db/schema";
 
-export async function info(ctx: CommandContext) {
-  const target = ctx.values["target"];
+export const infoCommand = define({
+  name: "info",
+  description: "Display database information and migration status",
+  args: {},
+  run: async (ctx) => {
+    const targets = ctx.positionals;
 
-  if (!target || typeof target !== "string") {
-    throw new Error("Target file path is required and must be a string");
-  }
+    if (targets.length === 0) {
+      throw new Error("At least one target file path is required");
+    }
 
-  // Resolve the target file path relative to current working directory
-  const targetPath = resolve(process.cwd(), target);
+    // De-duplicate targets (in case same file was specified multiple times)
+    const uniqueTargets = Array.from(new Set(targets));
+
+    // Load all target files and collect FragnoDatabase instances
+    const allFragnoDatabases: FragnoDatabase<AnySchema>[] = [];
+
+    for (const target of uniqueTargets) {
+      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 ${target}: ${error instanceof Error ? error.message : String(error)}`,
+        );
+      }
+
+      // Find all FragnoDatabase instances or instantiated fragments with databases
+      const fragnoDatabases = findFragnoDatabases(targetModule);
+
+      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;
+      }
+
+      if (fragnoDatabases.length > 1) {
+        console.warn(
+          `Warning: Multiple FragnoDatabase instances found in ${target} (${fragnoDatabases.length}). Showing info for all of them.`,
+        );
+      }
+
+      allFragnoDatabases.push(...fragnoDatabases);
+    }
 
-  console.log(`Loading target file: ${targetPath}`);
+    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`,
+      );
+    }
 
-  // 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)}`,
+    // Collect database information
+    const dbInfos = await Promise.all(
+      allFragnoDatabases.map(async (fragnoDb) => {
+        const info: {
+          namespace: string;
+          schemaVersion: number;
+          migrationSupport: boolean;
+          currentVersion?: number;
+          pendingVersions?: number;
+          status?: string;
+          error?: string;
+        } = {
+          namespace: fragnoDb.namespace,
+          schemaVersion: fragnoDb.schema.version,
+          migrationSupport: !!fragnoDb.adapter.createMigrationEngine,
+        };
+
+        // Get current database version if migrations are supported
+        if (fragnoDb.adapter.createMigrationEngine) {
+          try {
+            const migrator = fragnoDb.adapter.createMigrationEngine(
+              fragnoDb.schema,
+              fragnoDb.namespace,
+            );
+            const currentVersion = await migrator.getVersion();
+            info.currentVersion = currentVersion;
+            info.pendingVersions = fragnoDb.schema.version - currentVersion;
+
+            if (info.pendingVersions > 0) {
+              info.status = `Pending (${info.pendingVersions} migration(s))`;
+            } else if (info.pendingVersions === 0) {
+              info.status = "Up to date";
+            }
+          } catch (error) {
+            info.error = error instanceof Error ? error.message : String(error);
+            info.status = "Error";
+          }
+        } else {
+          info.status = "Schema only";
+        }
+
+        return info;
+      }),
     );
-  }
 
-  // Find all FragnoDatabase instances in the exported values
-  const fragnoDatabases: FragnoDatabase<AnySchema>[] = [];
+    // Determine if any database supports migrations
+    const hasMigrationSupport = dbInfos.some((info) => info.migrationSupport);
 
-  for (const [key, value] of Object.entries(targetModule)) {
-    if (isFragnoDatabase(value)) {
-      fragnoDatabases.push(value);
-      console.log(`Found FragnoDatabase instance: ${key}`);
-    }
-  }
+    // Print compact table
+    console.log("");
+    console.log(
+      `Found ${allFragnoDatabases.length} database(s) across ${uniqueTargets.length} file(s):`,
+    );
+    console.log("");
 
-  if (fragnoDatabases.length === 0) {
-    throw new Error(`No FragnoDatabase instances found in ${target}.\n`);
-  }
+    // Table header
+    const namespaceHeader = "Namespace";
+    const versionHeader = "Schema";
+    const currentHeader = "Current";
+    const statusHeader = "Status";
 
-  if (fragnoDatabases.length > 1) {
-    console.warn(
-      `Warning: Multiple FragnoDatabase instances found (${fragnoDatabases.length}). Using the first one.`,
+    const maxNamespaceLen = Math.max(
+      namespaceHeader.length,
+      ...dbInfos.map((info) => info.namespace.length),
     );
-  }
+    const namespaceWidth = Math.max(maxNamespaceLen + 2, 20);
+    const versionWidth = 8;
+    const currentWidth = 9;
+    const statusWidth = 25;
 
-  // Use the first FragnoDatabase instance
-  const fragnoDb = fragnoDatabases[0];
+    // Print table
+    console.log(
+      namespaceHeader.padEnd(namespaceWidth) +
+        versionHeader.padEnd(versionWidth) +
+        (hasMigrationSupport ? currentHeader.padEnd(currentWidth) : "") +
+        statusHeader,
+    );
+    console.log(
+      "-".repeat(namespaceWidth) +
+        "-".repeat(versionWidth) +
+        (hasMigrationSupport ? "-".repeat(currentWidth) : "") +
+        "-".repeat(statusWidth),
+    );
 
-  console.log("");
-  console.log("Database Information");
-  console.log("=".repeat(50));
-  console.log(`Namespace: ${fragnoDb.namespace}`);
-  console.log(`Latest Schema Version: ${fragnoDb.schema.version}`);
+    for (const info of dbInfos) {
+      const currentVersionStr =
+        info.currentVersion !== undefined ? String(info.currentVersion) : "-";
+      console.log(
+        info.namespace.padEnd(namespaceWidth) +
+          String(info.schemaVersion).padEnd(versionWidth) +
+          (hasMigrationSupport ? currentVersionStr.padEnd(currentWidth) : "") +
+          (info.status || "-"),
+      );
+    }
 
-  // Check if the adapter supports migrations
-  if (!fragnoDb.adapter.createMigrationEngine) {
-    console.log(`Migration Support: No`);
+    // Print help text
     console.log("");
-    console.log("Note: This adapter does not support running migrations.");
-    console.log("Use 'fragno db generate' to generate schema files.");
-    return;
-  }
-
-  console.log(`Migration Support: Yes`);
-
-  // Get current database version
-  try {
-    const migrator = fragnoDb.adapter.createMigrationEngine(fragnoDb.schema, fragnoDb.namespace);
-    const currentVersion = await migrator.getVersion();
-
-    console.log(`Current Database Version: ${currentVersion}`);
-
-    // Check if migrations are pending
-    const pendingVersions = fragnoDb.schema.version - currentVersion;
-    if (pendingVersions > 0) {
-      console.log("");
-      console.log(`⚠ Pending Migrations: ${pendingVersions} version(s) behind`);
-      console.log(`  Run '@fragno-dev/cli db migrate --target ${target}' to update`);
-    } else if (pendingVersions === 0) {
-      console.log("");
-      console.log(`✓ Database is up to date`);
+    if (!hasMigrationSupport) {
+      console.log("Note: These adapters do not support migrations.");
+      console.log("Use '@fragno-dev/cli db generate' to generate schema files.");
+    } else {
+      const hasPendingMigrations = dbInfos.some(
+        (info) => info.pendingVersions && info.pendingVersions > 0,
+      );
+      if (hasPendingMigrations) {
+        console.log("Run '@fragno-dev/cli db migrate <target>' to apply pending migrations.");
+      }
     }
-  } catch (error) {
-    console.log("");
-    console.log(
-      `Warning: Could not retrieve current version: ${error instanceof Error ? error.message : String(error)}`,
-    );
-  }
-
-  console.log("=".repeat(50));
-}
+  },
+});

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