fragment-ts 1.0.45 → 1.0.47

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

@@ -6,6 +6,7 @@ import ora from "ora";
 import { DataSource } from "typeorm";
 import { TypeORMModule } from "../../typeorm/typeorm-module";
 import { ConfigUtils } from "../../shared/config.utils";
+import { EnvUtils } from "../../shared/env.utils";
 import { TsConfigUtils } from "../../shared/tsconfig.utils";
 import { globSync } from "glob";
 
@@ -100,12 +101,18 @@ export class MigrateCommand {
   }
 
   /**
-   * Detect if we should use TypeScript or JavaScript
-   * - Check if tsconfig.json exists AND has decorator support
-   * - Check if TypeScript files exist in include patterns
-   * - Check if ts-node is available
+   * Use TypeScript only if:
+   * - NODE_ENV !== 'production'
+   * - tsconfig.json exists with decorators enabled
+   * - ts-node is available
+   * - TypeScript files exist
    */
   private static shouldUseTypeScript(): boolean {
+    // Never use TS in production
+    if (EnvUtils.getEnvironmentMode() === "production") {
+      return false;
+    }
+
     if (!TsConfigUtils.exists()) {
       return false;
     }
@@ -123,7 +130,9 @@ export class MigrateCommand {
 
     for (const pattern of includePatterns) {
       try {
-        const files = globSync(pattern, { cwd });
+        // Normalize pattern to forward slashes for Windows compatibility
+        const normalizedPattern = pattern.replace(/\\/g, "/");
+        const files = globSync(normalizedPattern, { cwd });
         if (
           files.some(
             (file: string) => file.endsWith(".ts") && !file.endsWith(".d.ts"),
@@ -176,12 +185,14 @@ export class MigrateCommand {
   } {
     const dbConfig = ConfigUtils.getDatabaseConfig();
 
+    // Helper to resolve extension based on mode
     const resolveExtension = (pattern: string): string => {
       return useTypeScript
         ? pattern.replace(/\.js$/, ".ts")
         : pattern.replace(/\.ts$/, ".js");
     };
 
+    // If fragment.json has explicit paths, use them
     if (dbConfig.entities || dbConfig.migrations) {
       const entities = dbConfig.entities
         ? dbConfig.entities.map(resolveExtension)
@@ -195,6 +206,7 @@ export class MigrateCommand {
               : "dist/migrations/**/*.js",
           ];
 
+      // Extract migration directory for file creation
       const migrationDir = this.extractMigrationDirectory(
         migrations[0],
         useTypeScript,
@@ -204,6 +216,7 @@ export class MigrateCommand {
       return { entities, migrations, seeds: seedsDir };
     }
 
+    // No fragment.json config - infer from tsconfig
     const rootDir = TsConfigUtils.getRootDir();
     const outDir = TsConfigUtils.getOutDir();
 
@@ -227,18 +240,23 @@ export class MigrateCommand {
     pattern: string,
     useTypeScript: boolean,
   ): string {
+    // Handle common patterns
     if (pattern.includes("/**/*")) {
+      // Pattern like "src/migrations/**/*.ts" → "src/migrations"
       return pattern.split("/**/*")[0];
     }
 
     if (pattern.includes("/*.")) {
+      // Pattern like "src/migrations/*.ts" → "src/migrations"
       return pattern.split("/*")[0];
     }
 
+    // Fallback: assume it's a directory path
     if (pattern.endsWith(".ts") || pattern.endsWith(".js")) {
       return path.dirname(pattern);
     }
 
+    // Default fallback
     return useTypeScript ? "src/migrations" : "dist/migrations";
   }
 
@@ -265,6 +283,7 @@ export class MigrateCommand {
 
       this.verifyEntities(dataSource);
 
+      // Setup migrations directory - FIXED: Proper directory extraction
       const migrationsPattern = migrations[0];
       const migrationsDir = this.extractMigrationDirectory(
         migrationsPattern,
@@ -283,6 +302,7 @@ export class MigrateCommand {
         : [];
       const isFirstMigration = existingMigrations.length === 0;
 
+      // Generate schema changes
       spinner.text = "Analyzing schema changes...";
       const sqlInMemory = await dataSource.driver.createSchemaBuilder().log();
       const upQueries = sqlInMemory.upQueries || [];
@@ -294,6 +314,7 @@ export class MigrateCommand {
         return;
       }
 
+      // Create migration
       const migrationName =
         options.name ||
         (nameOrPath ? path.basename(nameOrPath).replace(/\.ts$/, "") : null) ||
@@ -366,10 +387,11 @@ export class MigrateCommand {
   }
 
   private static async createMigration(name: string): Promise<void> {
-    const useTypeScript = this.setupEnvironment();
+    // Always create TypeScript migrations (user can compile if needed)
+    const useTypeScript = true; // Force TS for creation
     const spinner = ora("Creating TypeScript migration...").start();
     try {
-      const { migrations } = this.getPaths(true);
+      const { migrations } = this.getPaths(true); // Always use TS for creation
       const migrationsDir = this.extractMigrationDirectory(migrations[0], true);
       const timestamp = Date.now();
       const fileName = `${timestamp}-${name}.ts`;
@@ -489,6 +511,7 @@ export class ${name}${timestamp} implements MigrationInterface {
         });
       }
 
+      // Show migration directory from config
       const migrationsPattern = migrations[0];
       const migrationsDir = this.extractMigrationDirectory(
         migrationsPattern,
@@ -506,7 +529,11 @@ export class ${name}${timestamp} implements MigrationInterface {
         );
       }
 
+      // Show detection info
       console.log(chalk.gray(`\n  Configuration:`));
+      console.log(
+        chalk.gray(`    - Environment mode: ${EnvUtils.getEnvironmentMode()}`),
+      );
       console.log(
         chalk.gray(`    - ts-node available: ${this.isTsNodeAvailable()}`),
       );
@@ -622,10 +649,10 @@ export class ${name}${timestamp} implements MigrationInterface {
   }
 
   private static async createSeed(name: string): Promise<void> {
-    const useTypeScript = this.setupEnvironment();
+    const useTypeScript = true; // Always create TS seeds
     const spinner = ora("Creating TypeScript seed...").start();
     try {
-      const { seeds: seedsDir } = this.getPaths(true);
+      const { seeds: seedsDir } = this.getPaths(true); // Always create TS seeds
       const fileName = `${name}.seed.ts`;
       const filePath = path.join(seedsDir, fileName);
 
@@ -647,6 +674,7 @@ export class ${name}${timestamp} implements MigrationInterface {
     }
   }
 
+  // Helper methods remain the same
   private static verifyEntities(dataSource: DataSource): void {
     const entities = dataSource.entityMetadatas;
     if (entities.length === 0) {

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

@@ -5,196 +5,231 @@ import * as fs from "fs";
 import * as path from "path";
 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 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> {
+    // If NODE_ENV=production, delegate to npm start
+    if (process.env.NODE_ENV === "production") {
+      const pkg = require(path.join(process.cwd(), "package.json"));
+      if (!pkg.scripts?.start) {
+        console.error(
+          chalk.red("❌ package.json missing 'start' script for production"),
+        );
+        process.exit(1);
+      }
+
+      console.log(chalk.blue("🚀 Running production server via npm start..."));
+
+      const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
+
+      try {
+        const proc = spawn(npmCmd, ["start"], {
+          stdio: "inherit",
+          env: { ...process.env, PORT: options.port },
+        });
+        proc.on("exit", (code) => process.exit(code || 0));
+        return;
+      } catch {
+        console.error(chalk.red("Failed to run npm start"));
+        process.exit(1);
+      }
     }
 
-    static async execute(options: any): Promise<void> {
-        console.log(chalk.blue("🚀 Starting Fragment development server...\n"));
+    console.log(chalk.blue("🚀 Starting Fragment development server...\n"));
 
-        // Use TsConfigUtils to get the correct main file path
-        const srcDir = TsConfigUtils.getRootDir();
-        const mainFile = path.join(srcDir, "main.ts");
+    const srcDir = TsConfigUtils.getRootDir();
+    const mainFile = path.join(srcDir, "main.ts");
 
-        if (!fs.existsSync(mainFile)) {
-            console.error(
-                chalk.red(
-                    `Main file not found at ${path.relative(process.cwd(), mainFile)}`
-                )
-            );
-            process.exit(1);
-        }
+    if (!fs.existsSync(mainFile)) {
+      console.error(
+        chalk.red(
+          `Main file not found at ${path.relative(process.cwd(), mainFile)}`,
+        ),
+      );
+      process.exit(1);
+    }
 
-        // 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);
-        }
+    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);
+    }
 
-        let appProcess: ChildProcess | null = null;
-        let isRestarting = false;
+    let appProcess: ChildProcess | null = null;
+    let isRestarting = false;
 
-        const startServer = () => {
-            if (isRestarting) return;
+    const startServer = () => {
+      if (isRestarting) return;
 
-            // Use ts-node directly instead of node with -r flag
-            appProcess = spawn(tsNode, [mainFile], {
-                stdio: "inherit",
-                env: { ...process.env, PORT: options.port },
-            });
+      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("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}`));
-                }
-            });
-        };
+      appProcess.on("exit", (code) => {
+        if (!isRestarting && code !== null && code !== 0) {
+          console.error(chalk.red(`Server exited with code ${code}`));
+        }
+      });
+    };
+
+    const killServer = (): Promise<void> => {
+      return new Promise((resolve) => {
+        if (!appProcess || appProcess.killed) {
+          resolve();
+          return;
+        }
 
-        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");
+        if (process.platform === "win32") {
+          try {
+            execSync(`taskkill /pid ${appProcess.pid} /T /F`, {
+              stdio: "ignore",
             });
-        };
-
-        const restartServer = async (filePath?: string) => {
-            if (isRestarting) return;
-            isRestarting = true;
-
-            if (filePath) {
-                console.log(
-                    chalk.yellow(
-                        `\n🔄 File changed: ${path.relative(process.cwd(), filePath)}`
-                    )
-                );
+          } catch {}
+          appProcess = null;
+          resolve();
+        } else {
+          const timeout = setTimeout(() => {
+            if (appProcess && !appProcess.killed) {
+              console.log(chalk.yellow("Force killing server..."));
+              appProcess.kill("SIGKILL");
             }
-            console.log(chalk.blue("Restarting server...\n"));
-
-            await killServer();
-
-            // Wait a bit for port to be released
-            await new Promise((resolve) => setTimeout(resolve, 500));
+            resolve();
+          }, 3000);
 
-            isRestarting = false;
-            startServer();
-        };
+          appProcess.once("exit", () => {
+            clearTimeout(timeout);
+            appProcess = null;
+            resolve();
+          });
 
-        // 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);
+          appProcess.kill("SIGTERM");
         }
-    }
-
-    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"
+      });
+    };
+
+    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();
+      await new Promise((r) => setTimeout(r, 500));
+      isRestarting = false;
+      startServer();
+    };
+
+    startServer();
+
+    if (options.watch) {
+      try {
+        const chokidar = await import("chokidar");
+        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) => {
+          if (debounceTimer) clearTimeout(debounceTimer);
+          debounceTimer = setTimeout(() => restartServer(filePath), 300);
+        });
+
+        watcher.on("error", (error) => {
+          console.error(chalk.red(`Watcher error: ${error}`));
+        });
+
+        const cleanup = async () => {
+          console.log(chalk.yellow("\n\n🛑 Shutting down..."));
+          await watcher.close();
+          await killServer();
+          process.exit(0);
+        };
 
-        if (fs.existsSync(localTsNode)) {
-            return localTsNode;
-        }
+        process.on("exit", cleanup);
+        process.on("SIGINT", () => process.exit(0));
+        process.on("SIGTERM", () => process.exit(0));
 
-        // Try global ts-node
-        try {
-            execSync("ts-node --version", { stdio: "ignore" });
-            return "ts-node";
-        } catch {
-            return null;
+        if (process.platform === "win32") {
+          const rl = require("readline").createInterface({
+            input: process.stdin,
+            output: process.stdout,
+          });
+          rl.on("close", () => process.exit(0));
         }
+      } catch {
+        console.error(
+          chalk.red(
+            "Failed to start file watcher. Install chokidar: npm install chokidar",
+          ),
+        );
+        process.exit(1);
+      }
+    } else {
+      const cleanup = async () => {
+        await killServer();
+        process.exit(0);
+      };
+
+      process.on("exit", cleanup);
+      process.on("SIGINT", () => process.exit(0));
+      process.on("SIGTERM", () => process.exit(0));
+
+      if (process.platform === "win32") {
+        const rl = require("readline").createInterface({
+          input: process.stdin,
+          output: process.stdout,
+        });
+        rl.on("close", () => process.exit(0));
+      }
+    }
+  }
+
+  private static findTsNode(): string | null {
+    const binName = process.platform === "win32" ? "ts-node.cmd" : "ts-node";
+    const localTsNode = path.join(
+      process.cwd(),
+      "node_modules",
+      ".bin",
+      binName,
+    );
+
+    if (fs.existsSync(localTsNode)) {
+      return localTsNode;
+    }
+
+    try {
+      execSync("ts-node --version", { stdio: "ignore" });
+      return binName;
+    } catch {
+      return null;
     }
+  }
 }

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

@@ -23,27 +23,49 @@ export class TestCommand {
 
   private static async runTests(options: any): Promise<void> {
     console.log(chalk.blue("\n🧪 Running Fragment Tests...\n"));
+
     const cwd = process.cwd();
     const hasSource = fs.existsSync(path.join(cwd, "src"));
     const hasDist = fs.existsSync(path.join(cwd, "dist"));
 
+    // Determine mode based on NODE_ENV
+    const isProduction = EnvUtils.getEnvironmentMode() === "production";
     let useTypeScript: boolean;
+    let mode: string;
     let basePath: string;
     let pattern: string;
 
-    if (hasSource) {
-      useTypeScript = true;
-      basePath = "src";
-      pattern = options.pattern || "**/*.spec.ts";
-    } else if (hasDist) {
+    if (isProduction) {
+      if (!hasDist) {
+        console.log(
+          chalk.red(
+            "Production mode detected but dist/ directory not found. Run: fragment build",
+          ),
+        );
+        return;
+      }
       useTypeScript = false;
+      mode = "production (dist/)";
       basePath = "dist";
-      pattern = (options.pattern || "**/*.spec.ts").replace(/\.ts$/, ".js");
+      pattern = options.pattern.replace(/\.ts$/, ".js") || "**/*.spec.js";
     } else {
-      console.log(chalk.red("No src/ or dist/ found. Run: fragment init"));
-      return;
+      if (!hasSource) {
+        console.log(
+          chalk.red(
+            "Development mode detected but src/ directory not found. Run: fragment init",
+          ),
+        );
+        return;
+      }
+      useTypeScript = true;
+      mode = "development (src/)";
+      basePath = "src";
+      pattern = options.pattern || "**/*.spec.ts";
     }
 
+    console.log(chalk.gray(`   Mode: ${mode}`));
+    console.log(chalk.gray(`   Pattern: ${basePath}/${pattern}`));
+
     // Check if we need to use ts-node for TypeScript files
     const hasTsConfig = TsConfigUtils.exists();
 

package/src/cli/index.ts

@@ -4,21 +4,13 @@ import * as path from "path";
 
 const cwd = process.cwd();
 
-// Order: lowest priority → highest priority
-const envFiles = [
-  ".env", // base
-  ".env.local", // gitignored local overrides
-  ".env.prod", // production (or use .env.staging, etc.)
-]
-  .map((file) => path.join(cwd, file))
+const envFiles = [".env", ".env.local"]
+  .map((f) => path.join(cwd, f))
   .filter(fs.existsSync);
 
-envFiles.forEach((file) => {
-  dotenv.config({ path: file });
-});
+envFiles.forEach((f) => dotenv.config({ path: f }));
 
 import { Command } from "commander";
-import { EnvCommand } from "./commands/env.command";
 import { InitCommand } from "./commands/init.command";
 import { GenerateCommand } from "./commands/generate.command";
 import { ServeCommand } from "./commands/serve.command";
@@ -37,7 +29,6 @@ program
   .version("1.0.0");
 
 // Register all commands
-EnvCommand.register(program);
 InitCommand.register(program);
 GenerateCommand.register(program);
 ServeCommand.register(program);

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

@@ -196,4 +196,19 @@ 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 = EnvUtils.isDevelopmentMode();;
+
+    if (isDevMode) {
+      await this.scanSource();
+    } else {
+      await this.scan();
+    }
+  }
+
 }