fragment-ts 1.0.43 → 1.0.45

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

@@ -13,11 +13,6 @@ export class TestCommand {
       .command("test")
       .description("Run tests")
       .option("--watch", "Run tests in watch mode")
-      .option(
-        "--env <environment>",
-        "Environment mode: dev (use src/) or prod (use dist/)",
-        "auto",
-      )
       .option("--pattern <pattern>", "Test file pattern", "**/*.spec.ts")
       .option("--coverage", "Generate coverage report")
       .option("--no-color", "Disable colored output")
@@ -28,78 +23,27 @@ export class TestCommand {
 
   private static async runTests(options: any): Promise<void> {
     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"));
 
     let useTypeScript: boolean;
-    let mode: string;
     let basePath: string;
     let pattern: string;
 
-    if (options.env === "dev") {
-      if (!hasSource) {
-        console.log(
-          chalk.red("Development mode requested but src/ directory not found"),
-        );
-        return;
-      }
+    if (hasSource) {
       useTypeScript = true;
-      mode = "development (src/)";
       basePath = "src";
       pattern = options.pattern || "**/*.spec.ts";
-    } else if (options.env === "prod") {
-      if (!hasDist) {
-        console.log(
-          chalk.red(
-            "Production mode requested but dist/ directory not found. Run: fragment build",
-          ),
-        );
-        return;
-      }
+    } else if (hasDist) {
       useTypeScript = false;
-      mode = "production (dist/)";
       basePath = "dist";
-      pattern = options.pattern.replace(/\.ts$/, ".js") || "**/*.spec.js";
+      pattern = (options.pattern || "**/*.spec.ts").replace(/\.ts$/, ".js");
     } else {
-      // 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";
-        pattern = options.pattern.replace(/\.ts$/, ".js") || "**/*.spec.js";
-      } else {
-        console.log(
-          chalk.red("No src/ or dist/ directory found. Run: fragment init"),
-        );
-        return;
-      }
+      console.log(chalk.red("No src/ or dist/ found. Run: fragment init"));
+      return;
     }
 
-    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

@@ -1,4 +1,24 @@
+import * as dotenv from "dotenv";
+import * as fs from "fs";
+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))
+  .filter(fs.existsSync);
+
+envFiles.forEach((file) => {
+  dotenv.config({ path: file });
+});
+
 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";
@@ -17,6 +37,7 @@ 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,19 +196,4 @@ 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();
-    }
-  }
-
 }

package/src/shared/config.utils.ts

@@ -1,8 +1,9 @@
+// shared/config.utils.ts
+
 import * as fs from "fs";
 import * as path from "path";
 import { EnvUtils } from "./env.utils";
 
-// Define the fragment.json structure
 interface FragmentDatabaseConfig {
   type?: string;
   host?: string;
@@ -17,33 +18,21 @@ interface FragmentDatabaseConfig {
   subscribers?: string[];
   pool?: any;
   maxQueryExecutionTime?: number;
-  [key: string]: any; // Allow additional database-specific properties
+  [key: string]: any;
 }
 
+// Only support flat structure now
 interface FragmentConfig {
-  development?: {
-    database?: FragmentDatabaseConfig;
-  };
-  production?: {
-    database?: FragmentDatabaseConfig;
-  };
-  // Legacy flat structure (for backward compatibility)
   database?: FragmentDatabaseConfig;
 }
 
 export class ConfigUtils {
   private static configCache: FragmentConfig | null = null;
 
-  /**
-   * Load and parse fragment.json with caching
-   */
   private static loadConfig(): FragmentConfig {
-    if (this.configCache) {
-      return this.configCache;
-    }
+    if (this.configCache) return this.configCache;
 
     const configPath = path.join(process.cwd(), "fragment.json");
-
     if (!fs.existsSync(configPath)) {
       this.configCache = {};
       return this.configCache;
@@ -51,10 +40,9 @@ export class ConfigUtils {
 
     try {
       const raw = fs.readFileSync(configPath, "utf-8");
-      this.configCache = JSON.parse(raw);
-
+      this.configCache = JSON.parse(raw) || {};
       if (!this.configCache) {
-        this.configCache = {};
+        return {};
       }
       return this.configCache;
     } catch (error) {
@@ -64,9 +52,6 @@ export class ConfigUtils {
     }
   }
 
-  /**
-   * Interpolate environment variables in config values
-   */
   static interpolateEnvVars(value: any): any {
     if (typeof value === "string") {
       return value.replace(
@@ -89,32 +74,15 @@ export class ConfigUtils {
     return value;
   }
 
-  /**
-   * Get the current database configuration based on environment
-   */
+  // Always return the single database config
   static getDatabaseConfig(): FragmentDatabaseConfig {
     const config = this.loadConfig();
-    const mode = EnvUtils.getEnvironmentMode();
-
-    // Try environment-specific config first
-    if (config[mode]?.database) {
-      const interpolated = this.interpolateEnvVars(config[mode].database);
-      return interpolated;
-    }
-
-    // Fallback to legacy flat structure
     if (config.database) {
-      const interpolated = this.interpolateEnvVars(config.database);
-      return interpolated;
+      return this.interpolateEnvVars(config.database);
     }
-
-    // Return empty config if none found
     return {};
   }
 
-  /**
-   * Get a specific database configuration property
-   */
   static getDatabaseProperty<T>(property: string, defaultValue: T): T {
     const dbConfig = this.getDatabaseConfig();
     return (
@@ -122,26 +90,14 @@ export class ConfigUtils {
     ) as T;
   }
 
-  /**
-   * Get the full fragment configuration
-   */
   static getFullConfig(): FragmentConfig {
     return this.loadConfig();
   }
 
-  /**
-   * Check if database feature is enabled
-   */
   static isDatabaseEnabled(): boolean {
-    const config = this.loadConfig();
-    const mode = EnvUtils.getEnvironmentMode();
-
-    return !!(config[mode]?.database || config.database);
+    return !!this.getFullConfig().database;
   }
 
-  /**
-   * Clear the configuration cache (useful for testing)
-   */
   static clearCache(): void {
     this.configCache = null;
   }

package/src/shared/env.utils.ts

@@ -2,71 +2,77 @@ import * as fs from "fs";
 import * as path from "path";
 
 export class EnvUtils {
-  /**
-   * Get a string environment variable with optional default
-   */
   static getString(key: string, defaultValue?: string): string {
-    const value = process.env[key];
-    return value !== undefined ? value : (defaultValue ?? "");
+    return process.env[key] ?? defaultValue ?? "";
   }
 
-  /**
-   * Get a boolean environment variable (supports 'true'/'false', '1'/'0')
-   */
-  static getBoolean(key: string, defaultValue: boolean = false): boolean {
-    const value = process.env[key];
-    if (value === undefined) return defaultValue;
-
-    return ["true", "1", "yes", "on"].includes(value.toLowerCase());
+  static getBoolean(key: string, defaultValue = false): boolean {
+    const val = process.env[key];
+    if (val === undefined) return defaultValue;
+    return ["true", "1", "yes", "on"].includes(val.toLowerCase());
   }
 
-  /**
-   * Get a number environment variable
-   */
-  static getNumber(key: string, defaultValue: number = 0): number {
-    const value = process.env[key];
-    if (value === undefined) return defaultValue;
-
-    const num = Number(value);
+  static getNumber(key: string, defaultValue = 0): number {
+    const val = process.env[key];
+    if (val === undefined) return defaultValue;
+    const num = Number(val);
     return isNaN(num) ? defaultValue : num;
   }
 
-  /**
-   * Get a parsed JSON environment variable
-   */
   static getJson<T>(key: string, defaultValue: T): T {
-    const value = process.env[key];
-    if (value === undefined) return defaultValue;
-
+    const val = process.env[key];
+    if (val === undefined) return defaultValue;
     try {
-      return JSON.parse(value) as T;
+      return JSON.parse(val) as T;
     } catch {
-      console.warn(`⚠️ Invalid JSON in env var ${key}, using default`);
+      console.warn(`⚠️ Invalid JSON in env var ${key}`);
       return defaultValue;
     }
   }
 
   /**
-   * Check if running in development mode
+   * Returns the current environment name based on the active .env file.
+   * - If .env matches .env.prod → returns "prod"
+   * - If .env matches .env.staging → returns "staging"
+   * - If .env is custom or unmatched → returns "local"
+   * - If no .env exists → returns "default"
    */
-  static isDevelopmentMode(): boolean {
-    // Check explicit FRAGMENT_DEV_MODE
-    if (process.env.FRAGMENT_DEV_MODE !== undefined) {
-      return process.env.FRAGMENT_DEV_MODE === "true";
+  static getEnv(): string {
+    const cwd = process.cwd();
+    const envPath = path.join(cwd, ".env");
+
+    // Fast path: check for .env.mode (written by `fragment env:use`)
+    const modePath = path.join(cwd, ".env.mode");
+    if (fs.existsSync(modePath)) {
+      try {
+        const mode = fs.readFileSync(modePath, "utf8").trim();
+        if (mode) return mode;
+      } catch {
+        // Ignore read errors
+      }
     }
 
-    // Check NODE_ENV
-    if (process.env.NODE_ENV) {
-      return process.env.NODE_ENV === "development";
+    // Fallback: compare .env content with .env.* files
+    if (!fs.existsSync(envPath)) {
+      return "default";
     }
 
-    return false;
-  }
+    const envContent = fs.readFileSync(envPath, "utf8");
+    const files = fs.readdirSync(cwd).filter((f) => /^\.env\..+$/.test(f));
 
-  /**
-   * Get current environment mode ('development' or 'production')
-   */
-  static getEnvironmentMode(): "development" | "production" {
-    return this.isDevelopmentMode() ? "development" : "production";
+    for (const file of files) {
+      const name = file.replace(/\.env\./, "");
+      const fullPath = path.join(cwd, file);
+      try {
+        const content = fs.readFileSync(fullPath, "utf8");
+        if (content === envContent) {
+          return name;
+        }
+      } catch {
+        // Skip unreadable files
+      }
+    }
+
+    return "local"; // custom or modified .env
   }
 }

package/src/testing/runner.ts

@@ -191,17 +191,8 @@ export class TestRunner {
    * Auto-detect test patterns based on environment and configuration
    */
   getAutoTestPattern(): string {
-    const isDevMode = EnvUtils.isDevelopmentMode();
-
-    if (isDevMode) {
-      // Development mode - use TypeScript
-      const srcDir = TsConfigUtils.getRootDir();
-      return `${path.relative(process.cwd(), srcDir)}/**/*.spec.ts`;
-    } else {
-      // Production mode - use JavaScript
-      const outDir = TsConfigUtils.getOutDir();
-      return `${path.relative(process.cwd(), outDir)}/**/*.spec.js`;
-    }
+    const srcDir = TsConfigUtils.getRootDir();
+    return `${path.relative(process.cwd(), srcDir)}/**/*.spec.ts`;
   }
 }
 

package/src/typeorm/typeorm-module.ts

@@ -749,21 +749,12 @@ export class TypeORMModule {
         fs.readFileSync(configPath, "utf-8"),
       ) as FragmentConfig;
 
-      // Determine environment mode
-      const isDevMode = EnvUtils.isDevelopmentMode();
-      console.log(`Detected ${isDevMode ? "development" : "production"} mode`);
-
-      // Get the appropriate config section
-      let dbConfig = {};
-      if (isDevMode && raw.development?.database) {
-        dbConfig = raw.development.database;
-      } else if (!isDevMode && raw.production?.database) {
-        dbConfig = raw.production.database;
-      } else if (raw.development?.database) {
-        // Fallback to development if production not found
-        dbConfig = raw.development.database;
-        console.warn("Production config not found, using development config");
+      if (!raw.development) {
+        throw new Error("fragment config not found | Invalid");
       }
+      var dbConfig;
+
+      dbConfig = raw.development.database;
 
       // Interpolate environment variables
       return this.interpolateEnvVars(dbConfig);

package/src/web/application.ts

@@ -90,27 +90,7 @@ export class FragmentWebApplication {
     const distExists = fs.existsSync(path.join(cwd, "dist"));
     const srcExists = fs.existsSync(path.join(cwd, "src"));
 
-    console.log(`📁 Current working directory: ${cwd}`);
-    console.log(`📁 dist/ exists: ${distExists}`);
-    console.log(`📁 src/ exists: ${srcExists}`);
-
-    // Use EnvUtils for consistent environment detection
-    const isDevMode = EnvUtils.isDevelopmentMode();
-    console.log(
-      `💻 Running in ${isDevMode ? "development" : "production"} mode`,
-    );
-
-    if (isDevMode && srcExists) {
-      // Development mode: scan TypeScript source files
-      console.log(" 📝 Development mode: scanning TypeScript files");
-      await ComponentScanner.scanSource();
-    } else if (distExists) {
-      // Production mode: scan compiled JavaScript files
-      console.log(" 📦 Production mode: scanning compiled files");
-      await ComponentScanner.scan();
-    } else {
-      console.warn(" ⚠️ Warning: No src/ or dist/ directory found");
-    }
+    await ComponentScanner.scanSource();
   }
 
   // Remove the old isRunningTypeScript method since we're using EnvUtils