fragment-ts 1.0.34 → 1.0.35

package/src/shared/config.utils.ts

@@ -0,0 +1,148 @@
+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;
+  port?: number;
+  username?: string;
+  password?: string;
+  database?: string;
+  synchronize?: boolean;
+  logging?: boolean;
+  entities?: string[];
+  migrations?: string[];
+  subscribers?: string[];
+  pool?: any;
+  maxQueryExecutionTime?: number;
+  [key: string]: any; // Allow additional database-specific properties
+}
+
+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;
+    }
+
+    const configPath = path.join(process.cwd(), "fragment.json");
+
+    if (!fs.existsSync(configPath)) {
+      this.configCache = {};
+      return this.configCache;
+    }
+
+    try {
+      const raw = fs.readFileSync(configPath, "utf-8");
+      this.configCache = JSON.parse(raw);
+
+      if (!this.configCache) {
+        this.configCache = {};
+      }
+      return this.configCache;
+    } catch (error) {
+      console.error("❌ Error loading fragment.json:", error);
+      this.configCache = {};
+      return this.configCache;
+    }
+  }
+
+  /**
+   * Interpolate environment variables in config values
+   */
+  static interpolateEnvVars(value: any): any {
+    if (typeof value === "string") {
+      return value.replace(
+        /\$\{([^}]+)\}/g,
+        (_, varName) => EnvUtils.getString(varName) || "",
+      );
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => this.interpolateEnvVars(item));
+    }
+    if (value !== null && typeof value === "object") {
+      const result: any = {};
+      for (const key in value) {
+        if (Object.prototype.hasOwnProperty.call(value, key)) {
+          result[key] = this.interpolateEnvVars(value[key]);
+        }
+      }
+      return result;
+    }
+    return value;
+  }
+
+  /**
+   * Get the current database configuration based on environment
+   */
+  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 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 (
+      dbConfig[property] !== undefined ? dbConfig[property] : defaultValue
+    ) 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);
+  }
+
+  /**
+   * Clear the configuration cache (useful for testing)
+   */
+  static clearCache(): void {
+    this.configCache = null;
+  }
+}

package/src/shared/env.utils.ts

@@ -0,0 +1,72 @@
+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 ?? "");
+  }
+
+  /**
+   * 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());
+  }
+
+  /**
+   * 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);
+    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;
+
+    try {
+      return JSON.parse(value) as T;
+    } catch {
+      console.warn(`⚠️ Invalid JSON in env var ${key}, using default`);
+      return defaultValue;
+    }
+  }
+
+  /**
+   * Check if running in development mode
+   */
+  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";
+    }
+
+    return false;
+  }
+
+  /**
+   * Get current environment mode ('development' or 'production')
+   */
+  static getEnvironmentMode(): "development" | "production" {
+    return this.isDevelopmentMode() ? "development" : "production";
+  }
+}

package/src/shared/tsconfig.utils.ts

@@ -0,0 +1,360 @@
+// src/utils/tsconfig.utils.ts
+import * as fs from "fs";
+import * as path from "path";
+
+// Define the tsconfig.json structure (partial, covering common properties)
+interface TsConfigCompilerOptions {
+  target?: string;
+  module?: string;
+  moduleResolution?: string;
+  outDir?: string;
+  rootDir?: string;
+  baseUrl?: string;
+  paths?: Record<string, string[]>;
+  declaration?: boolean;
+  sourceMap?: boolean;
+  removeComments?: boolean;
+  emitDecoratorMetadata?: boolean;
+  experimentalDecorators?: boolean;
+  allowSyntheticDefaultImports?: boolean;
+  esModuleInterop?: boolean;
+  strict?: boolean;
+  noImplicitAny?: boolean;
+  strictNullChecks?: boolean;
+  strictFunctionTypes?: boolean;
+  strictBindCallApply?: boolean;
+  strictPropertyInitialization?: boolean;
+  noImplicitThis?: boolean;
+  alwaysStrict?: boolean;
+  noUnusedLocals?: boolean;
+  noUnusedParameters?: boolean;
+  noImplicitReturns?: boolean;
+  noFallthroughCasesInSwitch?: boolean;
+  skipLibCheck?: boolean;
+  forceConsistentCasingInFileNames?: boolean;
+  [key: string]: any; // Allow additional compiler options
+}
+
+interface TsConfig {
+  compilerOptions?: TsConfigCompilerOptions;
+  include?: string[];
+  exclude?: string[];
+  files?: string[];
+  references?: Array<{ path: string }>;
+  extends?: string;
+  [key: string]: any; // Allow additional top-level properties
+}
+
+export class TsConfigUtils {
+  private static configCache: TsConfig | null = null;
+  private static readonly DEFAULT_TSCONFIG_PATHS = [
+    "tsconfig.json",
+    "tsconfig.build.json",
+    "tsconfig.app.json",
+  ];
+
+  /**
+   * Load and parse tsconfig.json with caching
+   * @param configPath Optional custom path to tsconfig file
+   */
+  private static loadConfig(configPath?: string): TsConfig {
+    if (this.configCache) {
+      return this.configCache;
+    }
+
+    let finalConfigPath: string | null = null;
+
+    if (configPath) {
+      // Use provided path
+      finalConfigPath = path.isAbsolute(configPath)
+        ? configPath
+        : path.join(process.cwd(), configPath);
+    } else {
+      // Try default paths
+      for (const defaultPath of this.DEFAULT_TSCONFIG_PATHS) {
+        const fullPath = path.join(process.cwd(), defaultPath);
+        if (fs.existsSync(fullPath)) {
+          finalConfigPath = fullPath;
+          break;
+        }
+      }
+    }
+
+    if (!finalConfigPath || !fs.existsSync(finalConfigPath)) {
+      this.configCache = {};
+      return this.configCache;
+    }
+
+    try {
+      const raw = fs.readFileSync(finalConfigPath, "utf-8");
+      const parsed = JSON.parse(raw);
+
+      // Handle "extends" by merging parent config
+      if (parsed.extends) {
+        const parentConfig = this.loadParentConfig(
+          parsed.extends,
+          path.dirname(finalConfigPath),
+        );
+        this.configCache = this.mergeConfigs(parentConfig, parsed);
+      } else {
+        this.configCache = parsed;
+      }
+
+      if (!this.configCache) {
+        this.configCache = {};
+      }
+
+      return this.configCache;
+    } catch (error) {
+      console.error("❌ Error loading tsconfig.json:", error);
+      this.configCache = {};
+      return this.configCache;
+    }
+  }
+
+  /**
+   * Load parent config when "extends" is used
+   */
+  private static loadParentConfig(
+    extendsPath: string,
+    basePath: string,
+  ): TsConfig {
+    // Handle relative paths and node_modules
+    let parentPath: string;
+
+    if (extendsPath.startsWith(".")) {
+      // Relative path
+      parentPath = path.resolve(basePath, extendsPath);
+      if (!parentPath.endsWith(".json")) {
+        parentPath += ".json";
+      }
+    } else if (extendsPath.startsWith("/")) {
+      // Absolute path
+      parentPath = extendsPath;
+      if (!parentPath.endsWith(".json")) {
+        parentPath += ".json";
+      }
+    } else {
+      // Assume node_modules package
+      try {
+        // Try to resolve as a package
+        const packageJsonPath = require.resolve(`${extendsPath}/package.json`, {
+          paths: [basePath],
+        });
+        const packageDir = path.dirname(packageJsonPath);
+        parentPath = path.join(packageDir, "tsconfig.json");
+      } catch {
+        // Fallback to direct path
+        parentPath = path.join(basePath, "node_modules", extendsPath);
+        if (!parentPath.endsWith(".json")) {
+          parentPath += ".json";
+        }
+      }
+    }
+
+    if (fs.existsSync(parentPath)) {
+      try {
+        const raw = fs.readFileSync(parentPath, "utf-8");
+        const parsed = JSON.parse(raw);
+
+        // Recursively handle extends in parent
+        if (parsed.extends) {
+          const grandParent = this.loadParentConfig(
+            parsed.extends,
+            path.dirname(parentPath),
+          );
+          return this.mergeConfigs(grandParent, parsed);
+        }
+        return parsed;
+      } catch (error) {
+        console.warn(`⚠️ Could not load parent tsconfig: ${extendsPath}`);
+        return {};
+      }
+    }
+
+    return {};
+  }
+
+  /**
+   * Merge two tsconfig objects (child overrides parent)
+   */
+  private static mergeConfigs(parent: TsConfig, child: TsConfig): TsConfig {
+    const result: TsConfig = { ...parent };
+
+    // Merge compilerOptions
+    if (parent.compilerOptions || child.compilerOptions) {
+      result.compilerOptions = {
+        ...parent.compilerOptions,
+        ...child.compilerOptions,
+      };
+    }
+
+    // Override other top-level properties
+    for (const key in child) {
+      if (key !== "compilerOptions") {
+        result[key] = child[key];
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Get the full tsconfig configuration
+   * @param configPath Optional custom path to tsconfig file
+   */
+  static getFullConfig(configPath?: string): TsConfig {
+    return this.loadConfig(configPath);
+  }
+
+  /**
+   * Get compiler options from tsconfig
+   * @param configPath Optional custom path to tsconfig file
+   */
+  static getCompilerOptions(configPath?: string): TsConfigCompilerOptions {
+    const config = this.loadConfig(configPath);
+    return config.compilerOptions || {};
+  }
+
+  /**
+   * Get a specific compiler option value
+   * @param option The compiler option name
+   * @param defaultValue Default value if option is not set
+   * @param configPath Optional custom path to tsconfig file
+   */
+  static getCompilerOption<T>(
+    option: string,
+    defaultValue: T,
+    configPath?: string,
+  ): T {
+    const compilerOptions = this.getCompilerOptions(configPath);
+    return (
+      compilerOptions[option] !== undefined
+        ? compilerOptions[option]
+        : defaultValue
+    ) as T;
+  }
+
+  /**
+   * Check if a specific compiler option is enabled
+   * @param option The compiler option name
+   * @param configPath Optional custom path to tsconfig file
+   */
+  static isCompilerOptionEnabled(option: string, configPath?: string): boolean {
+    const value = this.getCompilerOption(option, false, configPath);
+    return Boolean(value);
+  }
+
+  /**
+   * Get the output directory (outDir) with proper resolution
+   * @param configPath Optional custom path to tsconfig file
+   */
+  static getOutDir(configPath?: string): string {
+    const outDir = this.getCompilerOption("outDir", "dist", configPath);
+    return path.isAbsolute(outDir) ? outDir : path.join(process.cwd(), outDir);
+  }
+
+  /**
+   * Get the source root directory (rootDir) with proper resolution
+   * @param configPath Optional custom path to tsconfig file
+   */
+  static getRootDir(configPath?: string): string {
+    const rootDir = this.getCompilerOption("rootDir", "src", configPath);
+    return path.isAbsolute(rootDir)
+      ? rootDir
+      : path.join(process.cwd(), rootDir);
+  }
+
+  /**
+   * Get include patterns
+   * @param configPath Optional custom path to tsconfig file
+   */
+  static getIncludePatterns(configPath?: string): string[] {
+    const config = this.loadConfig(configPath);
+    return config.include || ["src/**/*"];
+  }
+
+  /**
+   * Get exclude patterns
+   * @param configPath Optional custom path to tsconfig file
+   */
+  static getExcludePatterns(configPath?: string): string[] {
+    const config = this.loadConfig(configPath);
+    return config.exclude || ["node_modules", "**/*.spec.ts"];
+  }
+
+  /**
+   * Check if the project is configured for decorators (required for Fragment)
+   */
+  static hasDecoratorSupport(configPath?: string): boolean {
+    return (
+      this.isCompilerOptionEnabled("experimentalDecorators", configPath) &&
+      this.isCompilerOptionEnabled("emitDecoratorMetadata", configPath)
+    );
+  }
+
+  /**
+   * Resolve a file path based on tsconfig baseUrl and paths
+   * @param importPath The import path to resolve
+   * @param configPath Optional custom path to tsconfig file
+   */
+  static resolvePath(importPath: string, configPath?: string): string | null {
+    const compilerOptions = this.getCompilerOptions(configPath);
+
+    // Handle absolute paths starting with baseUrl
+    if (
+      compilerOptions.baseUrl &&
+      importPath.startsWith(compilerOptions.baseUrl)
+    ) {
+      return path.join(process.cwd(), importPath);
+    }
+
+    // Handle path mappings
+    if (compilerOptions.paths && compilerOptions.baseUrl) {
+      const baseUrl = path.isAbsolute(compilerOptions.baseUrl)
+        ? compilerOptions.baseUrl
+        : path.join(process.cwd(), compilerOptions.baseUrl);
+
+      for (const [pattern, paths] of Object.entries(compilerOptions.paths)) {
+        // Convert pattern like "@app/*" to regex
+        const regexPattern = pattern.replace(/\*/g, "(.*)");
+        const regex = new RegExp(`^${regexPattern}$`);
+        const match = importPath.match(regex);
+
+        if (match) {
+          const replacement = match[1] || "";
+          if (paths[0]) {
+            const resolvedPath = paths[0].replace("*", replacement);
+            return path.join(baseUrl, resolvedPath);
+          }
+        }
+      }
+    }
+
+    // Return null if cannot resolve
+    return null;
+  }
+
+  /**
+   * Clear the configuration cache (useful for testing)
+   */
+  static clearCache(): void {
+    this.configCache = null;
+  }
+
+  /**
+   * Check if tsconfig.json exists
+   */
+  static exists(configPath?: string): boolean {
+    if (configPath) {
+      const fullPath = path.isAbsolute(configPath)
+        ? configPath
+        : path.join(process.cwd(), configPath);
+      return fs.existsSync(fullPath);
+    }
+
+    return this.DEFAULT_TSCONFIG_PATHS.some((defaultPath) =>
+      fs.existsSync(path.join(process.cwd(), defaultPath)),
+    );
+  }
+}