fragment-ts 1.0.0 → 1.0.1

package/src/cli/commands/diagnostics.command.ts

@@ -0,0 +1,438 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import * as fs from "fs";
+import * as path from "path";
+import { spawn } from "child_process";
+
+export class DiagnosticsCommand {
+  static register(program: Command): void {
+    program
+      .command("routes")
+      .description("List all registered routes")
+      .option(
+        "--env <environment>",
+        "Environment mode: dev (use src/) or prod (use dist/)",
+        "auto",
+      )
+      .action(async (options) => {
+        await this.showRoutes(options.env);
+      });
+
+    program
+      .command("beans")
+      .description("List all registered beans")
+      .option("--tree", "Show as tree")
+      .option(
+        "--env <environment>",
+        "Environment mode: dev (use src/) or prod (use dist/)",
+        "auto",
+      )
+      .action(async (options) => {
+        await this.showBeans(options.tree, options.env);
+      });
+
+    program
+      .command("info")
+      .description("Show application info")
+      .action(() => {
+        this.showInfo();
+      });
+
+    program
+      .command("config")
+      .description("Show current configuration")
+      .action(() => {
+        this.showConfig();
+      });
+
+    program
+      .command("version")
+      .description("Show Fragment version")
+      .action(() => {
+        this.showVersion();
+      });
+  }
+
+  private static async showRoutes(env: string = "auto"): Promise<void> {
+    console.log(chalk.blue("\n📍 Scanning for routes...\n"));
+
+    const result = await this.runDiagnosticScript("routes", env);
+
+    if (!result.success) {
+      console.log(chalk.yellow("  Unable to load routes."));
+      if (result.error) {
+        console.log(chalk.red(`  Error: ${result.error}`));
+      }
+      return;
+    }
+
+    if (!result.data || result.data.length === 0) {
+      console.log(chalk.yellow("  No routes registered"));
+      return;
+    }
+
+    result.data.forEach((controller: any) => {
+      if (controller.methods.length > 0) {
+        console.log(chalk.green(`  ${controller.name}:`));
+
+        controller.methods.forEach((method: any) => {
+          const methodColor = this.getMethodColor(method.method);
+          const methodIcon = this.getMethodIcon(method.method);
+          console.log(
+            `    ${methodIcon} ${methodColor}${method.method.toUpperCase().padEnd(7)}\x1b[0m ${method.path}`,
+          );
+        });
+        console.log("");
+      }
+    });
+  }
+
+  private static async showBeans(
+    tree: boolean,
+    env: string = "auto",
+  ): Promise<void> {
+    console.log(chalk.blue("\n🫘 Scanning for beans...\n"));
+
+    const result = await this.runDiagnosticScript("beans", env);
+
+    if (!result.success) {
+      console.log(chalk.yellow("  Unable to load beans."));
+      if (result.error) {
+        console.log(chalk.red(`  Error: ${result.error}`));
+      }
+      return;
+    }
+
+    if (!result.data || Object.keys(result.data).length === 0) {
+      console.log(chalk.yellow("  No beans registered"));
+      return;
+    }
+
+    Object.entries(result.data).forEach(([type, beans]: [string, any]) => {
+      const icon = this.getTypeIcon(type);
+      console.log(chalk.green(`  ${icon} ${type.toUpperCase()}:`));
+
+      beans.forEach((bean: any) => {
+        const scope = bean.scope || "singleton";
+        console.log(
+          `    ${tree ? "├─" : "•"} ${bean.name} ${chalk.gray(`(${scope})`)}`,
+        );
+      });
+      console.log("");
+    });
+  }
+
+  private static async runDiagnosticScript(
+    type: "routes" | "beans",
+    env: string = "auto",
+  ): Promise<any> {
+    return new Promise((resolve) => {
+      const cwd = process.cwd();
+
+      // Detect available directories
+      const hasSource = fs.existsSync(path.join(cwd, "src"));
+      const hasDist = fs.existsSync(path.join(cwd, "dist"));
+
+      // Determine which mode to use based on --env flag
+      let useTypeScript: boolean;
+      let mode: string;
+
+      if (env === "dev") {
+        // Force development mode (TypeScript source)
+        if (!hasSource) {
+          resolve({
+            success: false,
+            error: "Development mode requested but src/ directory not found",
+          });
+          return;
+        }
+        useTypeScript = true;
+        mode = "development (src/)";
+      } else if (env === "prod") {
+        // Force production mode (compiled JavaScript)
+        if (!hasDist) {
+          resolve({
+            success: false,
+            error:
+              "Production mode requested but dist/ directory not found. Run: fragment build",
+          });
+          return;
+        }
+        useTypeScript = false;
+        mode = "production (dist/)";
+      } else {
+        // Auto-detect - DEFAULT TO SOURCE
+        if (hasSource) {
+          // Prefer source (development)
+          useTypeScript = true;
+          mode = "auto-detected development (src/)";
+        } else if (hasDist) {
+          // Fall back to compiled
+          useTypeScript = false;
+          mode = "auto-detected production (dist/)";
+        } else {
+          resolve({
+            success: false,
+            error: "No src/ or dist/ directory found. Run: fragment init",
+          });
+          return;
+        }
+      }
+
+      const userBasePath = useTypeScript ? "src" : "dist";
+      console.log(chalk.gray(`   Mode: ${mode}\n`));
+
+      // Create diagnostic script
+      const scriptContent = `
+${useTypeScript ? "require('ts-node/register/transpile-only');" : ""}
+require('reflect-metadata');
+
+async function diagnose() {
+  try {
+    // Load Fragment framework from node_modules
+    const { MetadataStorage } = require('fragment');
+    const { ComponentScanner } = require('fragment');
+
+    // Scan user's components
+    const patterns = [
+      '${userBasePath}/**/*.controller.${useTypeScript ? "ts" : "js"}',
+      '${userBasePath}/**/*.service.${useTypeScript ? "ts" : "js"}',
+      '${userBasePath}/**/*.repository.${useTypeScript ? "ts" : "js"}',
+      '${userBasePath}/**/*.entity.${useTypeScript ? "ts" : "js"}'
+    ];
+
+    ${
+      useTypeScript
+        ? "await ComponentScanner.scanSource(patterns);"
+        : "await ComponentScanner.scan(patterns);"
+    }
+
+    const storage = MetadataStorage.getInstance();
+
+    if ('${type}' === 'routes') {
+      const controllers = storage.getAllClasses().filter(c => c.type === 'controller');
+      const result = controllers.map(ctrl => {
+        const methods = storage.getAllMethods()
+          .filter(m => m.target === ctrl.target)
+          .map(m => ({
+            method: m.method,
+            path: (ctrl.path || '') + m.path || '/'
+          }));
+
+        return {
+          name: ctrl.target.name,
+          methods
+        };
+      }).filter(c => c.methods.length > 0);
+
+      console.log(JSON.stringify({ success: true, data: result }));
+    } else if ('${type}' === 'beans') {
+      const classes = storage.getAllClasses();
+      const grouped = classes.reduce((acc, cls) => {
+        if (!acc[cls.type]) acc[cls.type] = [];
+        acc[cls.type].push({
+          name: cls.target.name,
+          scope: cls.scope || 'singleton'
+        });
+        return acc;
+      }, {});
+
+      console.log(JSON.stringify({ success: true, data: grouped }));
+    }
+  } catch (error) {
+    console.log(JSON.stringify({
+      success: false,
+      error: error.message,
+      stack: error.stack
+    }));
+  }
+  process.exit(0);
+}
+
+diagnose();
+`;
+
+      const scriptPath = path.join(cwd, ".fragment-diagnostic-temp.js");
+
+      try {
+        fs.writeFileSync(scriptPath, scriptContent);
+
+        const proc = spawn("node", [scriptPath], {
+          cwd,
+          stdio: ["ignore", "pipe", "pipe"],
+          env: { ...process.env, TS_NODE_TRANSPILE_ONLY: "true" },
+        });
+
+        let output = "";
+        let errorOutput = "";
+
+        proc.stdout?.on("data", (data) => {
+          output += data.toString();
+        });
+
+        proc.stderr?.on("data", (data) => {
+          errorOutput += data.toString();
+        });
+
+        proc.on("close", (code) => {
+          // Clean up temp file
+          try {
+            fs.unlinkSync(scriptPath);
+          } catch {}
+
+          if (output) {
+            try {
+              // Find the JSON output (last line that's valid JSON)
+              const lines = output.trim().split("\n");
+              for (let i = lines.length - 1; i >= 0; i--) {
+                try {
+                  const result = JSON.parse(lines[i]);
+                  if (result.success !== undefined) {
+                    resolve(result);
+                    return;
+                  }
+                } catch {}
+              }
+            } catch {}
+          }
+
+          resolve({
+            success: false,
+            error: errorOutput || "Failed to parse diagnostic output",
+          });
+        });
+
+        proc.on("error", (error) => {
+          try {
+            fs.unlinkSync(scriptPath);
+          } catch {}
+          resolve({ success: false, error: error.message });
+        });
+
+        // Timeout after 15 seconds
+        setTimeout(() => {
+          proc.kill();
+          try {
+            fs.unlinkSync(scriptPath);
+          } catch {}
+          resolve({ success: false, error: "Diagnostic scan timed out" });
+        }, 15000);
+      } catch (error: any) {
+        resolve({ success: false, error: error.message });
+      }
+    });
+  }
+
+  private static getMethodColor(method: string): string {
+    const colors: Record<string, string> = {
+      GET: "\x1b[32m", // Green
+      POST: "\x1b[33m", // Yellow
+      PUT: "\x1b[34m", // Blue
+      DELETE: "\x1b[31m", // Red
+      PATCH: "\x1b[35m", // Magenta
+    };
+    return colors[method.toUpperCase()] || "\x1b[37m";
+  }
+
+  private static getMethodIcon(method: string): string {
+    const icons: Record<string, string> = {
+      GET: "🔍",
+      POST: "➕",
+      PUT: "✏️",
+      DELETE: "🗑️",
+      PATCH: "🔧",
+    };
+    return icons[method.toUpperCase()] || "•";
+  }
+
+  private static getTypeIcon(type: string): string {
+    const icons: Record<string, string> = {
+      controller: "🎮",
+      service: "⚙️",
+      repository: "💾",
+      injectable: "💉",
+      "auto-configuration": "🔧",
+    };
+    return icons[type] || "📌";
+  }
+
+  private static showInfo(): void {
+    console.log(chalk.blue("\n📊 Application Information:\n"));
+
+    const packageJson = this.loadPackageJson();
+    const cwd = process.cwd();
+    const hasSource = fs.existsSync(path.join(cwd, "src"));
+    const hasDist = fs.existsSync(path.join(cwd, "dist"));
+
+    console.log(`  Name:        ${packageJson.name || "N/A"}`);
+    console.log(`  Version:     ${packageJson.version || "N/A"}`);
+    console.log(`  Node:        ${process.version}`);
+    console.log(`  Platform:    ${process.platform}`);
+    console.log(`  Architecture: ${process.arch}`);
+    console.log(`  Environment: ${process.env.NODE_ENV || "development"}`);
+    console.log(`  Source:      ${hasSource ? "✓ src/" : "✗ src/"}`);
+    console.log(`  Built:       ${hasDist ? "✓ dist/" : "✗ dist/"}`);
+    console.log("");
+  }
+
+  private static showConfig(): void {
+    console.log(chalk.blue("\n⚙️  Configuration:\n"));
+
+    const configPath = path.join(process.cwd(), "fragment.json");
+
+    if (fs.existsSync(configPath)) {
+      try {
+        const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+        console.log(
+          "  " + JSON.stringify(config, null, 2).replace(/\n/g, "\n  "),
+        );
+      } catch (error) {
+        console.log(chalk.red("  Error reading fragment.json"));
+      }
+    } else {
+      console.log(chalk.yellow("  No fragment.json found"));
+      console.log(chalk.gray("\n  Create one with:"));
+      console.log(chalk.cyan("  fragment init"));
+    }
+
+    console.log("");
+  }
+
+  private static showVersion(): void {
+    const packageJson = this.loadFragmentPackageJson();
+    const version = packageJson.version || "1.0.0";
+
+    console.log(chalk.bold(`\n✨ Fragment Framework v${version}\n`));
+    console.log(`  Node:     ${process.version}`);
+    console.log(`  Platform: ${process.platform}-${process.arch}\n`);
+  }
+
+  private static loadPackageJson(): any {
+    try {
+      const packagePath = path.join(process.cwd(), "package.json");
+      return JSON.parse(fs.readFileSync(packagePath, "utf-8"));
+    } catch {
+      return {};
+    }
+  }
+
+  private static loadFragmentPackageJson(): any {
+    try {
+      const possiblePaths = [
+        path.join(__dirname, "..", "..", "..", "package.json"),
+        path.join(__dirname, "..", "..", "package.json"),
+        path.join(process.cwd(), "node_modules", "fragment", "package.json"),
+      ];
+
+      for (const packagePath of possiblePaths) {
+        if (fs.existsSync(packagePath)) {
+          return JSON.parse(fs.readFileSync(packagePath, "utf-8"));
+        }
+      }
+
+      return { version: "1.0.0" };
+    } catch {
+      return { version: "1.0.0" };
+    }
+  }
+}