@fragno-dev/cli 0.1.2 → 0.1.4

package/src/commands/db/generate.ts

@@ -1,168 +1,175 @@
-import { writeFile, stat, mkdir } from "node:fs/promises";
-import { resolve, join, dirname, basename } from "node:path";
-import type { CommandContext } from "gunshi";
-import { findFragnoDatabases } from "../../utils/find-fragno-databases.js";
-
-export async function generate(ctx: CommandContext) {
-  const target = ctx.values["target"];
-  const output = ctx.values["output"];
-  const toVersion = ctx.values["to"];
-  const fromVersion = ctx.values["from"];
-  const prefix = ctx.values["prefix"];
-
-  if (!target || typeof target !== "string") {
-    throw new Error("Target file path is required and must be a string");
-  }
-
-  if (typeof output === "number" || typeof output === "boolean") {
-    throw new Error("Output file path is required and must be a string");
-  }
-
-  if (toVersion !== undefined && typeof toVersion !== "string" && typeof toVersion !== "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");
-  }
-
-  if (prefix !== undefined && typeof prefix !== "string") {
-    throw new Error("Prefix must be a 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)}`,
-    );
-  }
-
-  // Find all FragnoDatabase instances or instantiated fragments with databases
-  const fragnoDatabases = findFragnoDatabases(targetModule);
+import { writeFile, mkdir } from "node:fs/promises";
+import { resolve, dirname } from "node:path";
+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";
+import { generateMigrationsOrSchema } from "@fragno-dev/db/generation-engine";
+
+// Define the db generate command with type safety
+export const generateCommand = define({
+  name: "generate",
+  description: "Generate schema files from FragnoDatabase definitions",
+  args: {
+    output: {
+      type: "string",
+      short: "o",
+      description:
+        "Output path: for single file, exact file path; for multiple files, output directory (default: current directory)",
+    },
+    from: {
+      type: "number",
+      short: "f",
+      description: "Source version to generate migration from (default: current database version)",
+    },
+    to: {
+      type: "number",
+      short: "t",
+      description: "Target version to generate migration to (default: latest schema version)",
+    },
+    prefix: {
+      type: "string",
+      short: "p",
+      description: "String to prepend to the generated file (e.g., '/* eslint-disable */')",
+    },
+  },
+  run: async (ctx) => {
+    // With `define()` and `multiple: true`, targets is properly typed as string[]
+    const targets = ctx.positionals;
+    const output = ctx.values.output;
+    const toVersion = ctx.values.to;
+    const fromVersion = ctx.values.from;
+    const prefix = ctx.values.prefix;
+
+    // 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}). Using all of them.`,
+        );
+      }
+
+      allFragnoDatabases.push(...fragnoDatabases);
+    }
 
-  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`,
-    );
-  }
+    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`,
+      );
+    }
 
-  if (fragnoDatabases.length > 1) {
-    console.warn(
-      `Warning: Multiple FragnoDatabase instances found (${fragnoDatabases.length}). Using the first one.`,
+    console.log(
+      `Found ${allFragnoDatabases.length} FragnoDatabase instance(s) across ${uniqueTargets.length} file(s)`,
     );
-  }
 
-  // Use the first FragnoDatabase instance
-  const fragnoDb = fragnoDatabases[0];
+    // 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);
 
-  // Parse versions if provided
-  const targetVersion = toVersion !== undefined ? parseInt(String(toVersion), 10) : undefined;
-  const sourceVersion = fromVersion !== undefined ? parseInt(String(fromVersion), 10) : undefined;
-
-  if (targetVersion !== undefined && isNaN(targetVersion)) {
-    throw new Error(`Invalid version number: ${toVersion}`);
-  }
-
-  if (sourceVersion !== undefined && isNaN(sourceVersion)) {
-    throw new Error(`Invalid version number: ${fromVersion}`);
-  }
+    if (!allSameAdapter) {
+      throw new Error(
+        "All fragments must use the same database adapter instance. Mixed adapters are not supported.",
+      );
+    }
 
-  if (sourceVersion !== undefined && targetVersion !== undefined) {
-    console.log(
-      `Generating schema for namespace: ${fragnoDb.namespace} (from version ${sourceVersion} to version ${targetVersion})`,
-    );
-  } else if (targetVersion !== undefined) {
-    console.log(
-      `Generating schema for namespace: ${fragnoDb.namespace} (to version ${targetVersion})`,
-    );
-  } else if (sourceVersion !== undefined) {
-    console.log(
-      `Generating schema for namespace: ${fragnoDb.namespace} (from version ${sourceVersion})`,
-    );
-  } else {
-    console.log(`Generating schema for namespace: ${fragnoDb.namespace}`);
-  }
+    // Check if adapter supports any form of schema generation
+    if (!firstDb.adapter.createSchemaGenerator && !firstDb.adapter.createMigrationEngine) {
+      throw new Error(
+        `The adapter does not support schema generation. ` +
+          `Please use an adapter that implements either createSchemaGenerator or createMigrationEngine.`,
+      );
+    }
 
-  // Determine if output is a directory or file
-  let isDirectory = false;
+    // Generate schema for all fragments
+    console.log("Generating schema...");
 
-  if (output) {
-    const resolvedOutput = resolve(process.cwd(), output);
+    let results: { schema: string; path: string; namespace: string }[];
     try {
-      const stats = await stat(resolvedOutput);
-      isDirectory = stats.isDirectory();
-    } catch {
-      // Path doesn't exist - check if it looks like a directory (ends with /)
-      isDirectory = output.endsWith("/");
+      results = await generateMigrationsOrSchema(allFragnoDatabases, {
+        path: output,
+        toVersion,
+        fromVersion,
+      });
+    } catch (error) {
+      throw new Error(
+        `Failed to generate schema: ${error instanceof Error ? error.message : String(error)}`,
+      );
     }
-  }
-
-  // Generate schema
-  let result: { schema: string; path: string };
-  try {
-    // If output is a directory, pass undefined to get the default file name
-    // Otherwise pass the output path as-is
-    result = await fragnoDb.generateSchema({
-      path: isDirectory ? undefined : output,
-      toVersion: targetVersion,
-      fromVersion: sourceVersion,
-    });
-  } catch (error) {
-    throw new Error(
-      `Failed to generate schema: ${error instanceof Error ? error.message : String(error)}`,
-    );
-  }
-
-  // Resolve final output path
-  let finalOutputPath: string;
-  if (isDirectory && output) {
-    // Combine directory with generated file name
-    const resolvedDir = resolve(process.cwd(), output);
-    finalOutputPath = join(resolvedDir, basename(result.path));
-  } else if (output) {
-    // Use the provided path as-is
-    finalOutputPath = resolve(process.cwd(), output);
-  } else {
-    // Use the generated file name in current directory
-    finalOutputPath = resolve(process.cwd(), result.path);
-  }
-
-  // Ensure parent directory exists
-  const parentDir = dirname(finalOutputPath);
-  try {
-    await mkdir(parentDir, { recursive: true });
-  } catch (error) {
-    throw new Error(
-      `Failed to create directory: ${error instanceof Error ? error.message : String(error)}`,
-    );
-  }
-
-  // Write schema to file
-  try {
-    const content = prefix ? `${prefix}\n${result.schema}` : result.schema;
-    await writeFile(finalOutputPath, content, { encoding: "utf-8" });
-  } catch (error) {
-    throw new Error(
-      `Failed to write schema file: ${error instanceof Error ? error.message : String(error)}`,
-    );
-  }
 
-  console.log(`✓ Schema generated successfully: ${finalOutputPath}`);
-  console.log(`  Namespace: ${fragnoDb.namespace}`);
-  console.log(`  Schema version: ${fragnoDb.schema.version}`);
-}
+    // Write all generated files
+    for (const result of results) {
+      // For single file: use output as exact file path
+      // For multiple files: use output as base directory
+      const finalOutputPath =
+        output && results.length === 1
+          ? resolve(process.cwd(), output)
+          : output
+            ? resolve(process.cwd(), output, result.path)
+            : resolve(process.cwd(), result.path);
+
+      // Ensure parent directory exists
+      const parentDir = dirname(finalOutputPath);
+      try {
+        await mkdir(parentDir, { recursive: true });
+      } catch (error) {
+        throw new Error(
+          `Failed to create directory: ${error instanceof Error ? error.message : String(error)}`,
+        );
+      }
+
+      // Write schema to file
+      try {
+        const content = prefix ? `${prefix}\n${result.schema}` : result.schema;
+        await writeFile(finalOutputPath, content, { encoding: "utf-8" });
+      } catch (error) {
+        throw new Error(
+          `Failed to write schema file: ${error instanceof Error ? error.message : String(error)}`,
+        );
+      }
+
+      console.log(`✓ Generated: ${finalOutputPath}`);
+    }
+
+    console.log(`\n✓ Schema generated successfully!`);
+    console.log(`  Files generated: ${results.length}`);
+    console.log(`  Fragments:`);
+    for (const db of allFragnoDatabases) {
+      console.log(`    - ${db.namespace} (version ${db.schema.version})`);
+    }
+  },
+});

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));
-}
+  },
+});