fragment-ts 1.0.34 → 1.0.35

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

@@ -1,189 +1,200 @@
+import chalk from "chalk";
+import { ChildProcess, spawn, execSync } from "child_process";
 import { Command } from "commander";
-import { spawn, ChildProcess, execSync } from "child_process";
 import * as fs from "fs";
 import * as path from "path";
-import chalk from "chalk";
+import { TsConfigUtils } from "../../shared/tsconfig.utils";
+
 
 export class ServeCommand {
-  static register(program: Command): void {
-    program
-      .command("serve")
-      .description("Start the development server")
-      .option("-w, --watch", "Watch for changes", true)
-      .option("-p, --port <port>", "Port to run on", "3000")
-      .action(async (options) => {
-        await ServeCommand.execute(options);
-      });
-  }
-
-  static async execute(options: any): Promise<void> {
-    console.log(chalk.blue("🚀 Starting Fragment development server...\n"));
-
-    const mainFile = path.join(process.cwd(), "src", "main.ts");
-
-    if (!fs.existsSync(mainFile)) {
-      console.error(chalk.red("Main file not found at src/main.ts"));
-      process.exit(1);
+    static register(program: Command): void {
+        program
+            .command("serve")
+            .description("Start the development server")
+            .option("-w, --watch", "Watch for changes", true)
+            .option("-p, --port <port>", "Port to run on", "3000")
+            .action(async (options) => {
+                await ServeCommand.execute(options);
+            });
     }
 
-    // Find ts-node
-    const tsNode = this.findTsNode();
-    if (!tsNode) {
-      console.error(chalk.red("ts-node not found. Install it:"));
-      console.log(chalk.cyan("  npm install --save-dev ts-node"));
-      process.exit(1);
-    }
+    static async execute(options: any): Promise<void> {
+        console.log(chalk.blue("🚀 Starting Fragment development server...\n"));
 
-    let appProcess: ChildProcess | null = null;
-    let isRestarting = false;
+        // Use TsConfigUtils to get the correct main file path
+        const srcDir = TsConfigUtils.getRootDir();
+        const mainFile = path.join(srcDir, "main.ts");
 
-    const startServer = () => {
-      if (isRestarting) return;
+        if (!fs.existsSync(mainFile)) {
+            console.error(
+                chalk.red(
+                    `Main file not found at ${path.relative(process.cwd(), mainFile)}`
+                )
+            );
+            process.exit(1);
+        }
 
-      // Use ts-node directly instead of node with -r flag
-      appProcess = spawn(tsNode, [mainFile], {
-        stdio: "inherit",
-        env: { ...process.env, PORT: options.port },
-      });
+        // Find ts-node
+        const tsNode = this.findTsNode();
+        if (!tsNode) {
+            console.error(chalk.red("ts-node not found. Install it:"));
+            console.log(chalk.cyan("  npm install --save-dev ts-node"));
+            process.exit(1);
+        }
 
-      appProcess.on("error", (error) => {
-        console.error(chalk.red(`Failed to start server: ${error.message}`));
-      });
+        let appProcess: ChildProcess | null = null;
+        let isRestarting = false;
 
-      appProcess.on("exit", (code, signal) => {
-        if (!isRestarting && signal !== "SIGTERM" && signal !== "SIGINT") {
-          console.error(chalk.red(`Server exited with code ${code}`));
-        }
-      });
-    };
-
-    const killServer = (): Promise<void> => {
-      return new Promise((resolve) => {
-        if (!appProcess || appProcess.killed) {
-          resolve();
-          return;
-        }
+        const startServer = () => {
+            if (isRestarting) return;
 
-        const timeout = setTimeout(() => {
-          if (appProcess && !appProcess.killed) {
-            console.log(chalk.yellow("Force killing server..."));
-            appProcess.kill("SIGKILL");
-          }
-          resolve();
-        }, 3000);
-
-        appProcess.once("exit", () => {
-          clearTimeout(timeout);
-          appProcess = null;
-          resolve();
-        });
-
-        appProcess.kill("SIGTERM");
-      });
-    };
-
-    const restartServer = async (filePath?: string) => {
-      if (isRestarting) return;
-      isRestarting = true;
-
-      if (filePath) {
-        console.log(
-          chalk.yellow(
-            `\n🔄 File changed: ${path.relative(process.cwd(), filePath)}`,
-          ),
-        );
-      }
-      console.log(chalk.blue("Restarting server...\n"));
-
-      await killServer();
-
-      // Wait a bit for port to be released
-      await new Promise((resolve) => setTimeout(resolve, 500));
-
-      isRestarting = false;
-      startServer();
-    };
-
-    // Start initial server
-    startServer();
-
-    // Watch for changes
-    if (options.watch) {
-      try {
-        const chokidar = await import("chokidar");
-
-        const watcher = chokidar.watch("src/**/*.ts", {
-          ignored: /(^|[/\\])\../,
-          persistent: true,
-          ignoreInitial: true,
-        });
-
-        let debounceTimer: NodeJS.Timeout | null = null;
-
-        watcher.on("change", (filePath) => {
-          // Debounce rapid changes
-          if (debounceTimer) {
-            clearTimeout(debounceTimer);
-          }
-
-          debounceTimer = setTimeout(() => {
-            restartServer(filePath);
-          }, 300);
-        });
-
-        watcher.on("error", (error) => {
-          console.error(chalk.red(`Watcher error: ${error}`));
-        });
-
-        // Cleanup on exit
-        const cleanup = async () => {
-          console.log(chalk.yellow("\n\n🛑 Shutting down..."));
-          watcher.close();
-          await killServer();
-          process.exit(0);
+            // Use ts-node directly instead of node with -r flag
+            appProcess = spawn(tsNode, [mainFile], {
+                stdio: "inherit",
+                env: { ...process.env, PORT: options.port },
+            });
+
+            appProcess.on("error", (error) => {
+                console.error(chalk.red(`Failed to start server: ${error.message}`));
+            });
+
+            appProcess.on("exit", (code, signal) => {
+                if (!isRestarting && signal !== "SIGTERM" && signal !== "SIGINT") {
+                    console.error(chalk.red(`Server exited with code ${code}`));
+                }
+            });
         };
 
-        process.on("SIGINT", cleanup);
-        process.on("SIGTERM", cleanup);
-      } catch (error) {
-        console.error(
-          chalk.red(
-            "Failed to start file watcher. Install chokidar: npm install chokidar",
-          ),
-        );
-        process.exit(1);
-      }
-    } else {
-      // No watch mode - just handle cleanup
-      const cleanup = async () => {
-        await killServer();
-        process.exit(0);
-      };
-
-      process.on("SIGINT", cleanup);
-      process.on("SIGTERM", cleanup);
-    }
-  }
-
-  private static findTsNode(): string | null {
-    // Try local ts-node
-    const localTsNode = path.join(
-      process.cwd(),
-      "node_modules",
-      ".bin",
-      process.platform === "win32" ? "ts-node.cmd" : "ts-node",
-    );
-
-    if (fs.existsSync(localTsNode)) {
-      return localTsNode;
+        const killServer = (): Promise<void> => {
+            return new Promise((resolve) => {
+                if (!appProcess || appProcess.killed) {
+                    resolve();
+                    return;
+                }
+
+                const timeout = setTimeout(() => {
+                    if (appProcess && !appProcess.killed) {
+                        console.log(chalk.yellow("Force killing server..."));
+                        appProcess.kill("SIGKILL");
+                    }
+                    resolve();
+                }, 3000);
+
+                appProcess.once("exit", () => {
+                    clearTimeout(timeout);
+                    appProcess = null;
+                    resolve();
+                });
+
+                appProcess.kill("SIGTERM");
+            });
+        };
+
+        const restartServer = async (filePath?: string) => {
+            if (isRestarting) return;
+            isRestarting = true;
+
+            if (filePath) {
+                console.log(
+                    chalk.yellow(
+                        `\n🔄 File changed: ${path.relative(process.cwd(), filePath)}`
+                    )
+                );
+            }
+            console.log(chalk.blue("Restarting server...\n"));
+
+            await killServer();
+
+            // Wait a bit for port to be released
+            await new Promise((resolve) => setTimeout(resolve, 500));
+
+            isRestarting = false;
+            startServer();
+        };
+
+        // Start initial server
+        startServer();
+
+        // Watch for changes
+        if (options.watch) {
+            try {
+                const chokidar = await import("chokidar");
+
+                // Use source directory from tsconfig
+                const watchPattern = path.join(srcDir, "**/*.ts");
+
+                const watcher = chokidar.watch(watchPattern, {
+                    ignored: /(^|[/\\])\../,
+                    persistent: true,
+                    ignoreInitial: true,
+                });
+
+                let debounceTimer: NodeJS.Timeout | null = null;
+
+                watcher.on("change", (filePath) => {
+                    // Debounce rapid changes
+                    if (debounceTimer) {
+                        clearTimeout(debounceTimer);
+                    }
+
+                    debounceTimer = setTimeout(() => {
+                        restartServer(filePath);
+                    }, 300);
+                });
+
+                watcher.on("error", (error) => {
+                    console.error(chalk.red(`Watcher error: ${error}`));
+                });
+
+                // Cleanup on exit
+                const cleanup = async () => {
+                    console.log(chalk.yellow("\n\n🛑 Shutting down..."));
+                    watcher.close();
+                    await killServer();
+                    process.exit(0);
+                };
+
+                process.on("SIGINT", cleanup);
+                process.on("SIGTERM", cleanup);
+            } catch (error) {
+                console.error(
+                    chalk.red(
+                        "Failed to start file watcher. Install chokidar: npm install chokidar"
+                    )
+                );
+                process.exit(1);
+            }
+        } else {
+            // No watch mode - just handle cleanup
+            const cleanup = async () => {
+                await killServer();
+                process.exit(0);
+            };
+
+            process.on("SIGINT", cleanup);
+            process.on("SIGTERM", cleanup);
+        }
     }
 
-    // Try global ts-node
-    try {
-      execSync("ts-node --version", { stdio: "ignore" });
-      return "ts-node";
-    } catch {
-      return null;
+    private static findTsNode(): string | null {
+        // Try local ts-node
+        const localTsNode = path.join(
+            process.cwd(),
+            "node_modules",
+            ".bin",
+            process.platform === "win32" ? "ts-node.cmd" : "ts-node"
+        );
+
+        if (fs.existsSync(localTsNode)) {
+            return localTsNode;
+        }
+
+        // Try global ts-node
+        try {
+            execSync("ts-node --version", { stdio: "ignore" });
+            return "ts-node";
+        } catch {
+            return null;
+        }
     }
-  }
 }

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

@@ -4,6 +4,8 @@ import * as path from "path";
 import { spawn } from "child_process";
 import * as fs from "fs";
 import chokidar from "chokidar";
+import { EnvUtils } from "../../shared/env.utils";
+import { TsConfigUtils } from "../../shared/tsconfig.utils";
 
 export class TestCommand {
   static register(program: Command): void {
@@ -28,6 +30,9 @@ export class TestCommand {
     console.log(chalk.blue("\n🧪 Running Fragment Tests...\n"));
 
     const cwd = process.cwd();
+
+    // Use EnvUtils for consistent environment detection
+    const isDevMode = EnvUtils.isDevelopmentMode();
     const hasSource = fs.existsSync(path.join(cwd, "src"));
     const hasDist = fs.existsSync(path.join(cwd, "dist"));
 
@@ -61,13 +66,25 @@ export class TestCommand {
       basePath = "dist";
       pattern = options.pattern.replace(/\.ts$/, ".js") || "**/*.spec.js";
     } else {
-      // Auto-detect
-      if (hasSource) {
+      // Auto-detect using same logic as EnvUtils
+      if (isDevMode && hasSource) {
+        useTypeScript = true;
+        mode = "auto-detected development (src/)";
+        basePath = "src";
+        pattern = options.pattern || "**/*.spec.ts";
+      } else if (!isDevMode && hasDist) {
+        useTypeScript = false;
+        mode = "auto-detected production (dist/)";
+        basePath = "dist";
+        pattern = options.pattern.replace(/\.ts$/, ".js") || "**/*.spec.js";
+      } else if (hasSource) {
+        // Fallback to source if available
         useTypeScript = true;
         mode = "auto-detected development (src/)";
         basePath = "src";
         pattern = options.pattern || "**/*.spec.ts";
       } else if (hasDist) {
+        // Fallback to dist if available
         useTypeScript = false;
         mode = "auto-detected production (dist/)";
         basePath = "dist";
@@ -84,8 +101,7 @@ export class TestCommand {
     console.log(chalk.gray(`   Pattern: ${basePath}/${pattern}`));
 
     // Check if we need to use ts-node for TypeScript files
-    const tsConfigPath = path.join(cwd, "tsconfig.json");
-    const hasTsConfig = fs.existsSync(tsConfigPath);
+    const hasTsConfig = TsConfigUtils.exists();
 
     // Create a simple runner script that uses our test runner module
     const scriptContent = this.generateRunnerScript({
@@ -93,7 +109,7 @@ export class TestCommand {
       basePath,
       pattern,
       hasTsConfig,
-      tsConfigPath,
+      tsConfigPath: path.join(cwd, "tsconfig.json"),
       watchMode: options.watch,
       coverage: options.coverage,
       noColor: options.color === false,
@@ -113,12 +129,10 @@ export class TestCommand {
           chalk.green("\n👀 Watch mode enabled. Listening for changes...\n"),
         );
 
-        const watcher = chokidar.watch(
-          `${basePath}/**/*.spec.${useTypeScript ? "ts" : "js"}`,
-          {
-            ignoreInitial: true,
-          },
-        );
+        const watchPattern = `${basePath}/**/*.spec.${useTypeScript ? "ts" : "js"}`;
+        const watcher = chokidar.watch(watchPattern, {
+          ignoreInitial: true,
+        });
 
         const runTests = () => {
           const proc = spawn("node", [scriptPath], { stdio: "inherit" });

package/src/core/scanner/component-scanner.ts

@@ -1,25 +1,25 @@
 import * as path from "path";
 import * as fs from "fs";
 import { glob } from "glob";
+import { ConfigUtils } from "../../shared/config.utils";
+import { TsConfigUtils } from "../../shared/tsconfig.utils";
 
 export class ComponentScanner {
   /**
    * Scans and imports compiled JS files (production mode)
    * This ensures decorators are executed
    */
-  static async scan(
-    patterns: string[] = [
-      "dist/**/*.controller.js",
-      "dist/**/*.service.js",
-      "dist/**/*.repository.js",
-      "dist/**/*.entity.js",
-    ],
-  ): Promise<void> {
+  static async scan(patterns: string[] = []): Promise<void> {
     const cwd = process.cwd();
+
+    // If no patterns provided, use defaults from fragment.json config
+    const scanPatterns =
+      patterns.length > 0 ? patterns : this.getDefaultPatterns(false);
+
     const allFiles: string[] = [];
 
     // Collect all matching files
-    for (const pattern of patterns) {
+    for (const pattern of scanPatterns) {
       try {
         const files = await glob(pattern, { cwd, absolute: true });
         allFiles.push(...files);
@@ -56,18 +56,16 @@ export class ComponentScanner {
   /**
    * Scans TypeScript source files (development mode with ts-node/tsx)
    */
-  static async scanSource(
-    patterns: string[] = [
-      "src/**/*.controller.ts",
-      "src/**/*.service.ts",
-      "src/**/*.repository.ts",
-      "src/**/*.entity.ts",
-    ],
-  ): Promise<void> {
+  static async scanSource(patterns: string[] = []): Promise<void> {
     const cwd = process.cwd();
+
+    // If no patterns provided, use defaults from fragment.json config
+    const scanPatterns =
+      patterns.length > 0 ? patterns : this.getDefaultPatterns(true);
+
     const allFiles: string[] = [];
 
-    for (const pattern of patterns) {
+    for (const pattern of scanPatterns) {
       try {
         const files = await glob(pattern, { cwd, absolute: true });
         allFiles.push(...files);
@@ -98,6 +96,55 @@ export class ComponentScanner {
     );
   }
 
+  /**
+   * Get default scan patterns based on fragment.json configuration
+   */
+  private static getDefaultPatterns(useTypeScript: boolean): string[] {
+    const dbConfig = ConfigUtils.getDatabaseConfig();
+    const patterns: string[] = [];
+
+    // Use configured entity paths if available
+    if (dbConfig.entities && dbConfig.entities.length > 0) {
+      // Convert entity patterns to component patterns
+      const entityPatterns = dbConfig.entities.map((p) =>
+        p.replace(/\.entity\.[tj]s$/, `.${useTypeScript ? "ts" : "js"}`),
+      );
+
+      // Extract base directory and create component patterns
+      const baseDirs = new Set<string>();
+      entityPatterns.forEach((pattern) => {
+        const dir = path.dirname(pattern.replace("/**/*", ""));
+        baseDirs.add(dir);
+      });
+
+      // Create patterns for all component types
+      baseDirs.forEach((baseDir) => {
+        patterns.push(
+          `${baseDir}/**/*.controller.${useTypeScript ? "ts" : "js"}`,
+          `${baseDir}/**/*.service.${useTypeScript ? "ts" : "js"}`,
+          `${baseDir}/**/*.repository.${useTypeScript ? "ts" : "js"}`,
+          `${baseDir}/**/*.entity.${useTypeScript ? "ts" : "js"}`,
+        );
+      });
+    }
+
+    // Fallback to default patterns if no config found
+    if (patterns.length === 0) {
+      const srcDir = useTypeScript
+        ? TsConfigUtils.getRootDir()
+        : path.join(process.cwd(), "dist");
+      const ext = useTypeScript ? "ts" : "js";
+      patterns.push(
+        `${srcDir}/**/*.controller.${ext}`,
+        `${srcDir}/**/*.service.${ext}`,
+        `${srcDir}/**/*.repository.${ext}`,
+        `${srcDir}/**/*.entity.${ext}`,
+      );
+    }
+
+    return patterns;
+  }
+
   /**
    * Recursive directory scan (alternative approach)
    */
@@ -126,4 +173,39 @@ export class ComponentScanner {
       }
     }
   }
+
+  /**
+   * Auto-scan based on current environment mode
+   */
+  static async autoScan(): Promise<void> {
+    // Detect environment using the same logic as other components
+    const isDevMode = this.isDevelopmentMode();
+
+    if (isDevMode) {
+      await this.scanSource();
+    } else {
+      await this.scan();
+    }
+  }
+
+  /**
+   * Environment detection logic (replicated from EnvUtils for independence)
+   */
+  private static isDevelopmentMode(): boolean {
+    // Check explicit FRAGMENT_DEV_MODE
+    if (process.env.FRAGMENT_DEV_MODE !== undefined) {
+      return process.env.FRAGMENT_DEV_MODE === "true";
+    }
+
+    // Check NODE_ENV
+    if (process.env.NODE_ENV) {
+      return process.env.NODE_ENV === "development";
+    }
+
+    // Check filesystem (src/ vs dist/)
+    const cwd = process.cwd();
+    const hasSource = fs.existsSync(path.join(cwd, "src"));
+    const hasDist = fs.existsSync(path.join(cwd, "dist"));
+    return hasSource && (!hasDist || hasSource);
+  }
 }