fragment-ts 1.0.28 → 1.0.30

package/src/core/container/di-container.ts

@@ -1,5 +1,5 @@
 import { METADATA_KEYS } from "../metadata/metadata-keys";
-import { Scope } from "../decorators/injectable.decorator";
+import { MetadataStorage } from "../metadata/metadata-storage";
 
 export class DIContainer {
   private static instance: DIContainer;
@@ -8,6 +8,11 @@ export class DIContainer {
   private factories: Map<any, () => any> = new Map();
   private constructing: Set<any> = new Set();
   private registered: Set<any> = new Set();
+  private metadataStorage: MetadataStorage;
+
+  private constructor() {
+    this.metadataStorage = MetadataStorage.getInstance();
+  }
 
   static getInstance(): DIContainer {
     if (!DIContainer.instance) {
@@ -18,19 +23,23 @@ export class DIContainer {
 
   register(token: any, instance?: any, factory?: () => any): void {
     this.registered.add(token);
+    console.log(
+      ` ✓ Registered token: ${typeof token === "function" ? token.name : token}`,
+    );
 
     if (instance) {
       this.singletons.set(token, instance);
+      console.log(`   ➤ Singleton instance created`);
     } else if (factory) {
       this.factories.set(token, factory);
+      console.log(`   ➤ Factory registered`);
     }
   }
 
   resolve<T>(token: any): T {
     if (typeof token === "function" && !this.registered.has(token)) {
-      throw new Error(
-        `Cannot resolve ${token.name}: Not registered as injectable. ` +
-          `Did you forget to add @Injectable(), @Service(), @Controller(), or @Repository()?`,
+      console.log(
+        ` ℹ️ Token ${token.name} not explicitly registered, attempting to create instance`,
       );
     }
 
@@ -40,24 +49,35 @@ export class DIContainer {
       );
     }
 
+    // Check singletons first
     if (this.singletons.has(token)) {
+      console.log(
+        ` ✓ Resolved from singleton cache: ${typeof token === "function" ? token.name : token}`,
+      );
       return this.singletons.get(token);
     }
 
+    // Check factories
     if (this.factories.has(token)) {
+      console.log(
+        ` 🏭 Creating instance from factory: ${typeof token === "function" ? token.name : token}`,
+      );
       const factory = this.factories.get(token)!;
       const instance = factory();
+
       const scope =
         Reflect.getMetadata(METADATA_KEYS.SCOPE, token) || "singleton";
-
       if (scope === "singleton") {
         this.singletons.set(token, instance);
+        console.log(`   ➤ Cached as singleton`);
       }
 
       return instance;
     }
 
+    // Create new instance for class tokens
     if (typeof token === "function") {
+      console.log(` 🔨 Creating new instance: ${token.name}`);
       this.constructing.add(token);
 
       try {
@@ -67,38 +87,53 @@ export class DIContainer {
 
         if (scope === "singleton") {
           this.singletons.set(token, instance);
+          console.log(`   ➤ Registered as singleton`);
         }
 
         this.constructing.delete(token);
         return instance;
       } catch (error) {
         this.constructing.delete(token);
+        console.error(
+          ` ❌ Failed to create instance of ${token.name}: ${error}`,
+        );
         throw error;
       }
     }
 
-    throw new Error(`Cannot resolve dependency: ${token}`);
+    throw new Error(
+      `Cannot resolve dependency: ${typeof token === "function" ? token.name : token}`,
+    );
   }
 
   private createInstance(target: any): any {
-    console.log(`   🔨 Creating instance of ${target.name}`);
+    const className = target.name;
+    console.log(` 🏗️  Constructing instance of ${className}`);
 
+    // Get constructor parameter types
     const paramTypes = Reflect.getMetadata("design:paramtypes", target) || [];
+    console.log(
+      ` 📋 Constructor parameters for ${className}: ${paramTypes.length}`,
+    );
 
     const params = paramTypes.map((type: any, index: number) => {
       if (!type || type === Object) {
         console.warn(
-          `   ⚠️  Constructor param ${index} of ${target.name} has no type`,
+          ` ⚠️ Constructor param ${index} of ${className} has no type information`,
         );
         return undefined;
       }
-      console.log(`   📦 Resolving constructor dependency: ${type.name}`);
+
+      console.log(
+        ` 🔌 Resolving constructor dependency [${index}]: ${type.name || type}`,
+      );
       return this.resolve(type);
     });
 
+    console.log(` 🚀 Instantiating ${className}`);
     const instance = new target(...params);
 
-    // CRITICAL: Inject properties
+    // Inject properties
     this.injectProperties(instance);
 
     // Call @PostConstruct
@@ -106,12 +141,13 @@ export class DIContainer {
       METADATA_KEYS.POST_CONSTRUCT,
       target,
     );
+
     if (
       postConstructMethod &&
       typeof instance[postConstructMethod] === "function"
     ) {
       console.log(
-        `   🎯 Calling @PostConstruct: ${target.name}.${postConstructMethod}()`,
+        ` 🎯 Calling @PostConstruct method: ${className}.${String(postConstructMethod)}()`,
       );
       instance[postConstructMethod]();
     }
@@ -121,220 +157,204 @@ export class DIContainer {
 
   private injectProperties(instance: any): void {
     const constructor = instance.constructor;
-    console.log(`🔍 Checking properties for injection on ${constructor.name}`);
+    const className = constructor.name;
 
-    // Get all own property keys of the instance (including inherited via getters/setters if needed)
-    // But primarily own enumerable + non-enumerable properties
-    let props: string[] = [];
-    let obj = instance;
+    console.log(` 🔍 Scanning for property injections on ${className}`);
 
-    // Walk up the prototype chain to include properties from parent classes
-    while (obj && obj !== Object.prototype) {
-      props = props.concat(Object.getOwnPropertyNames(obj));
-      obj = Object.getPrototypeOf(obj);
-    }
+    // Get all property injections from metadata storage
+    const propertyInjections =
+      this.metadataStorage.getPropertyInjections(constructor);
 
-    // Deduplicate
-    const uniqueProps = Array.from(new Set(props));
+    if (propertyInjections.length === 0) {
+      console.log(` ℹ️ No property injections registered for ${className}`);
+      return;
+    }
 
     console.log(
-      `📋 Instance properties (including inherited): ${uniqueProps.filter((p) => p !== "constructor").join(", ") || "none"}`,
+      ` 📌 Found ${propertyInjections.length} property injection(s) for ${className}`,
     );
 
-    for (const prop of uniqueProps) {
-      if (prop === "constructor") continue;
+    for (const { propertyKey, injections } of propertyInjections) {
+      console.log(`   ➤ Property: ${propertyKey}`);
 
-      // Check each injection type on the instance and its prototype
-      this.tryInjectAutowired(instance, instance, prop, constructor.name);
-      this.tryInjectByToken(instance, instance, prop, constructor.name);
-      this.tryInjectValue(instance, instance, prop, constructor.name);
-      this.tryInjectRepository(instance, instance, prop, constructor.name);
-      this.tryInjectLazy(instance, instance, prop, constructor.name);
-    }
-  }
+      for (const injection of injections) {
+        console.log(`     • Injection type: ${injection.type}`);
 
-  private checkForDecoratedProperties(
-    instance: any,
-    constructor: Function,
-  ): void {
-    // Check all metadata keys that might be attached to properties
-    const propertyKeys = [
-      ...(Reflect.getMetadataKeys(constructor.prototype) || []),
-      ...(Reflect.getMetadataKeys(instance) || []),
-    ];
-
-    // Filter for property-related metadata
-    for (const key of propertyKeys) {
-      if (key.includes("fragment:")) {
-        // This is a Fragment metadata key, need to check if it's attached to a property
-        const metadataValue = Reflect.getMetadata(key, constructor.prototype);
-        if (metadataValue && typeof metadataValue === "object") {
-          // Could be a property metadata
-          for (const prop of Object.keys(metadataValue)) {
-            if (prop !== "constructor") {
-              this.tryInjectAutowired(
+        try {
+          switch (injection.type) {
+            case "autowired":
+              this.injectAutowiredProperty(
                 instance,
-                constructor.prototype,
-                prop,
-                constructor.name,
+                propertyKey,
+                injection.metadata?.type,
+                className,
               );
-              this.tryInjectByToken(
+              break;
+            case "inject":
+              this.injectTokenProperty(
                 instance,
-                constructor.prototype,
-                prop,
-                constructor.name,
+                propertyKey,
+                injection.metadata?.token,
+                className,
               );
-              this.tryInjectValue(
+              break;
+            case "repository":
+              this.injectRepositoryProperty(
                 instance,
-                constructor.prototype,
-                prop,
-                constructor.name,
+                propertyKey,
+                injection.metadata?.entity,
+                className,
               );
-              this.tryInjectRepository(
+              break;
+            case "value":
+              this.injectValueProperty(
                 instance,
-                constructor.prototype,
-                prop,
-                constructor.name,
+                propertyKey,
+                injection.metadata?.expression,
+                className,
               );
-            }
+              break;
+            case "lazy":
+              this.injectLazyProperty(instance, propertyKey, className);
+              break;
           }
+        } catch (error) {
+          const isOptional = Reflect.getMetadata(
+            METADATA_KEYS.OPTIONAL,
+            constructor.prototype,
+            propertyKey,
+          );
+
+          if (!isOptional) {
+            console.error(
+              ` ❌ Failed to inject ${propertyKey} in ${className}: ${error}`,
+            );
+            throw error;
+          }
+
+          console.warn(
+            ` ⚠️ Optional dependency ${propertyKey} not available for ${className}`,
+          );
+          instance[propertyKey] = undefined;
         }
       }
     }
   }
 
-  private tryInjectAutowired(
+  private injectAutowiredProperty(
     instance: any,
-    proto: any,
-    prop: string,
+    propertyKey: string,
+    type: any,
     className: string,
   ): void {
-    const type = Reflect.getMetadata(METADATA_KEYS.AUTOWIRED, proto, prop);
-
-    if (!type) return;
-
-    console.log(`   💉 @Autowired found: ${className}.${prop} -> ${type.name}`);
-
-    const isOptional = Reflect.getMetadata(METADATA_KEYS.OPTIONAL, proto, prop);
-
-    try {
-      instance[prop] = this.resolve(type);
-      console.log(`   ✅ Injected ${type.name} into ${className}.${prop}`);
-    } catch (error) {
-      if (!isOptional) {
+    if (!type) {
+      const designType = Reflect.getMetadata(
+        "design:type",
+        instance,
+        propertyKey,
+      );
+      if (designType && designType !== Object) {
+        type = designType;
+        console.warn(
+          ` ⚠️ Using design:type metadata for ${className}.${propertyKey} as fallback`,
+        );
+      } else {
         throw new Error(
-          `Failed to autowire ${type.name} into ${className}.${prop}: ${error}`,
+          `Type information not available for ${className}.${propertyKey}`,
         );
       }
-      console.warn(
-        `   ⚠️  Optional dependency ${type.name} not available for ${className}.${prop}`,
-      );
-      instance[prop] = undefined;
     }
+
+    console.log(` 💉 @Autowired: ${className}.${propertyKey} -> ${type.name}`);
+    instance[propertyKey] = this.resolve(type);
+    console.log(` ✅ Injected ${type.name} into ${className}.${propertyKey}`);
   }
 
-  private tryInjectByToken(
+  private injectTokenProperty(
     instance: any,
-    proto: any,
-    prop: string,
+    propertyKey: string,
+    token: any,
     className: string,
   ): void {
-    const token = Reflect.getMetadata(METADATA_KEYS.INJECT, proto, prop);
-
-    if (!token) return;
-
-    const tokenName = typeof token === "string" ? token : token.name;
-    console.log(`   💉 @Inject found: ${className}.${prop} -> ${tokenName}`);
-
-    const isOptional = Reflect.getMetadata(METADATA_KEYS.OPTIONAL, proto, prop);
-
-    try {
-      instance[prop] = this.resolve(token);
-      console.log(`   ✅ Injected ${tokenName} into ${className}.${prop}`);
-    } catch (error) {
-      if (!isOptional) {
-        throw new Error(
-          `Failed to inject ${tokenName} into ${className}.${prop}: ${error}`,
-        );
-      }
-      console.warn(
-        `   ⚠️  Optional dependency ${tokenName} not available for ${className}.${prop}`,
+    if (!token) {
+      throw new Error(
+        `Token not provided for @Inject on ${className}.${propertyKey}`,
       );
-      instance[prop] = undefined;
     }
+
+    const tokenName = typeof token === "string" ? token : token.name;
+    console.log(` 💉 @Inject: ${className}.${propertyKey} -> ${tokenName}`);
+    instance[propertyKey] = this.resolve(token);
+    console.log(` ✅ Injected ${tokenName} into ${className}.${propertyKey}`);
   }
 
-  private tryInjectValue(
+  private injectRepositoryProperty(
     instance: any,
-    proto: any,
-    prop: string,
+    propertyKey: string,
+    entity: any,
     className: string,
   ): void {
-    const expression = Reflect.getMetadata(METADATA_KEYS.VALUE, proto, prop);
-
-    if (expression === undefined) return;
+    if (!entity) {
+      throw new Error(
+        `Entity not provided for @InjectRepository on ${className}.${propertyKey}`,
+      );
+    }
 
-    console.log(`   🔧 @Value found: ${className}.${prop} = ${expression}`);
-    instance[prop] = this.resolveValue(expression);
-    console.log(`   ✅ Set value for ${className}.${prop}`);
+    console.log(
+      ` 💾 @InjectRepository: ${className}.${propertyKey} -> Repository<${entity.name}>`,
+    );
+    instance[propertyKey] = this.resolveRepository(entity);
+    console.log(
+      ` ✅ Injected Repository<${entity.name}> into ${className}.${propertyKey}`,
+    );
   }
 
-  private tryInjectRepository(
+  private injectValueProperty(
     instance: any,
-    proto: any,
-    prop: string,
+    propertyKey: string,
+    expression: string,
     className: string,
   ): void {
-    const entity = Reflect.getMetadata(
-      METADATA_KEYS.INJECT_REPOSITORY,
-      proto,
-      prop,
-    );
-
-    if (!entity) return;
-
-    console.log(
-      `   💾 @InjectRepository found: ${className}.${prop} -> Repository<${entity.name}>`,
-    );
-
-    try {
-      instance[prop] = this.resolveRepository(entity);
-      console.log(
-        `   ✅ Injected Repository<${entity.name}> into ${className}.${prop}`,
-      );
-    } catch (error) {
+    if (!expression) {
       throw new Error(
-        `Failed to inject repository for ${entity.name} into ${className}.${prop}: ${error}`,
+        `Expression not provided for @Value on ${className}.${propertyKey}`,
       );
     }
+
+    console.log(` 🔧 @Value: ${className}.${propertyKey} = ${expression}`);
+    instance[propertyKey] = this.resolveValue(expression);
+    console.log(` ✅ Set value for ${className}.${propertyKey}`);
   }
 
-  private tryInjectLazy(
+  private injectLazyProperty(
     instance: any,
-    proto: any,
-    prop: string,
+    propertyKey: string,
     className: string,
   ): void {
-    const isLazy = Reflect.getMetadata(METADATA_KEYS.LAZY, proto, prop);
+    // Get the type for later resolution
+    const type = Reflect.getMetadata("design:type", instance, propertyKey);
+    if (!type) {
+      throw new Error(
+        `Type information not available for @Lazy ${className}.${propertyKey}`,
+      );
+    }
 
-    if (!isLazy) return;
-
-    const type = Reflect.getMetadata("design:type", proto, prop);
-    console.log(
-      `   ⏳ @Lazy found: ${className}.${prop} (${type?.name || "unknown"})`,
-    );
+    console.log(` ⏳ @Lazy: ${className}.${propertyKey} (${type.name})`);
 
     let cached: any = null;
     let resolved = false;
 
-    Object.defineProperty(instance, prop, {
+    Object.defineProperty(instance, propertyKey, {
       get: () => {
         if (!resolved) {
           console.log(
-            `   🔓 Lazy-loading ${type.name} for ${className}.${prop}`,
+            ` 🔓 Lazy-loading ${type.name} for ${className}.${propertyKey}`,
           );
           cached = this.resolve(type);
           resolved = true;
+          console.log(
+            ` ✅ Lazy-loaded ${type.name} for ${className}.${propertyKey}`,
+          );
         }
         return cached;
       },
@@ -344,45 +364,79 @@ export class DIContainer {
   }
 
   private resolveValue(expression: string): any {
-    const match = expression.match(
-      /\$\{([^:}]+)(?::([^}]*))?\}|\$([A-Z_][A-Z0-9_]*)/i,
-    );
-    if (match) {
-      const key = match[1] || match[3];
-      const defaultValue = match[2];
-      const value = process.env[key];
-
-      if (value === undefined) {
-        if (defaultValue !== undefined) {
-          return defaultValue;
+    // Standardize expression format (remove ${} if present)
+    let key = expression.replace(/\$\{|\}/g, "");
+    let defaultValue: any = undefined;
+
+    // Handle default values (format: KEY:default)
+    const defaultMatch = key.match(/^(.*?):(.*)$/);
+    if (defaultMatch) {
+      key = defaultMatch[1].trim();
+      defaultValue = defaultMatch[2].trim();
+
+      // Try to parse default value as JSON or number if possible
+      try {
+        defaultValue = JSON.parse(defaultValue);
+      } catch {
+        // Try number conversion
+        const numValue = parseFloat(defaultValue);
+        if (!isNaN(numValue) && defaultValue.trim() === numValue.toString()) {
+          defaultValue = numValue;
+        }
+        // Try boolean conversion
+        else if (defaultValue.toLowerCase() === "true") {
+          defaultValue = true;
+        } else if (defaultValue.toLowerCase() === "false") {
+          defaultValue = false;
         }
-        console.warn(`   ⚠️  Environment variable "${key}" not defined`);
-        return "";
       }
+    }
+
+    console.log(
+      ` 🔍 Resolving config value: ${key}${defaultValue !== undefined ? ` (default: ${defaultValue})` : ""}`,
+    );
+
+    // Check environment variables first
+    const envValue = process.env[key.toUpperCase()] || process.env[key];
+    if (envValue !== undefined) {
+      console.log(`   🌍 Found in environment: ${envValue}`);
 
-      if (value.startsWith("{") || value.startsWith("[")) {
+      // Try to parse as JSON if it looks like an object/array
+      if (envValue.startsWith("{") || envValue.startsWith("[")) {
         try {
-          return JSON.parse(value);
+          return JSON.parse(envValue);
         } catch {
-          return value;
+          return envValue;
         }
       }
 
-      if (/^\d+(\.\d+)?$/.test(value)) {
-        return parseFloat(value);
+      // Try to parse as number
+      const numValue = parseFloat(envValue);
+      if (!isNaN(numValue) && envValue.trim() === numValue.toString()) {
+        return numValue;
       }
 
-      if (value.toLowerCase() === "true") return true;
-      if (value.toLowerCase() === "false") return false;
+      // Try to parse as boolean
+      if (envValue.toLowerCase() === "true") return true;
+      if (envValue.toLowerCase() === "false") return false;
+
+      return envValue;
+    }
 
-      return value;
+    // Return default value if available
+    if (defaultValue !== undefined) {
+      console.log(`   📦 Using default value: ${defaultValue}`);
+      return defaultValue;
     }
 
-    return expression;
+    console.warn(` ⚠️ Config value not found: ${key}`);
+    return undefined;
   }
 
   private resolveRepository(entity: any): any {
     try {
+      console.log(` 🔍 Resolving repository for entity: ${entity.name}`);
+
       const { TypeORMModule } = require("../../typeorm/typeorm-module");
       const dataSource = TypeORMModule.getDataSource();
 
@@ -390,8 +444,14 @@ export class DIContainer {
         throw new Error("TypeORM DataSource not initialized");
       }
 
+      console.log(
+        ` ✅ Found DataSource, creating repository for ${entity.name}`,
+      );
       return dataSource.getRepository(entity);
     } catch (error) {
+      console.error(
+        ` ❌ Failed to resolve repository for ${entity.name}: ${(error as Error).message}`,
+      );
       throw new Error(
         `Failed to resolve repository for ${entity.name}: ${(error as Error)?.message}`,
       );
@@ -399,7 +459,11 @@ export class DIContainer {
   }
 
   has(token: any): boolean {
-    return this.registered.has(token);
+    return (
+      this.registered.has(token) ||
+      this.singletons.has(token) ||
+      this.factories.has(token)
+    );
   }
 
   getAllInstances(): any[] {
@@ -407,6 +471,7 @@ export class DIContainer {
   }
 
   clear(): void {
+    console.log("🧹 Clearing DI Container");
     this.singletons.clear();
     this.transients.clear();
     this.factories.clear();
@@ -416,5 +481,6 @@ export class DIContainer {
 
   reset(): void {
     this.clear();
+    console.log("🔁 DI Container reset complete");
   }
 }

package/src/core/decorators/application.decorator.ts

@@ -11,6 +11,7 @@ export function FragmentApplication(
   options: ApplicationOptions = {},
 ): ClassDecorator {
   return (target: any) => {
+    console.log(`🚀 Registering Fragment application: ${target.name}`);
     Reflect.defineMetadata(
       METADATA_KEYS.APPLICATION,
       {
@@ -18,7 +19,7 @@ export function FragmentApplication(
         port: options.port || 3000,
         host: options.host || "0.0.0.0",
         configPath: options.configPath || "fragment.json",
-        autoScan: options.autoScan || true,
+        autoScan: options.autoScan !== false, // default to true
       },
       target,
     );