fragment-ts 1.0.30 → 1.0.32

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

@@ -23,63 +23,52 @@ 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)) {
-      console.log(
-        ` ℹ️ Token ${token.name} not explicitly registered, attempting to create instance`,
-      );
+    // Check if already resolved
+    if (this.singletons.has(token)) {
+      return this.singletons.get(token);
     }
 
+    // Handle circular dependencies
     if (this.constructing.has(token)) {
       throw new Error(
         `Circular dependency detected for ${token.name || token}`,
       );
     }
 
-    // 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
+    // Use factory if available
     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
+    // Create instance for class tokens
     if (typeof token === "function") {
-      console.log(` 🔨 Creating new instance: ${token.name}`);
-      this.constructing.add(token);
+      if (
+        !this.registered.has(token) &&
+        !Reflect.getMetadata(METADATA_KEYS.INJECTABLE, token)
+      ) {
+        console.warn(
+          `⚠️ ${token.name} is not registered as injectable. Consider adding @Injectable(), @Service(), @Controller(), or @Repository()`,
+        );
+      }
 
+      this.constructing.add(token);
       try {
         const instance = this.createInstance(token);
         const scope =
@@ -87,35 +76,25 @@ 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: ${typeof token === "function" ? token.name : token}`,
-    );
+    throw new Error(`Cannot resolve dependency: ${token}`);
   }
 
   private createInstance(target: any): any {
     const className = target.name;
-    console.log(` 🏗️  Constructing instance of ${className}`);
+    console.log(` 🔨 Creating instance of ${className}`);
 
-    // Get constructor parameter types
+    // Get constructor parameters
     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(
@@ -123,20 +102,19 @@ export class DIContainer {
         );
         return undefined;
       }
-
       console.log(
-        ` 🔌 Resolving constructor dependency [${index}]: ${type.name || type}`,
+        ` 📦 Resolving constructor dependency [${index}]: ${type.name || type}`,
       );
       return this.resolve(type);
     });
 
-    console.log(` 🚀 Instantiating ${className}`);
+    // Create instance
     const instance = new target(...params);
 
-    // Inject properties
+    // CRITICAL FIX: Inject properties using metadata storage
     this.injectProperties(instance);
 
-    // Call @PostConstruct
+    // Call @PostConstruct method if exists
     const postConstructMethod = Reflect.getMetadata(
       METADATA_KEYS.POST_CONSTRUCT,
       target,
@@ -162,81 +140,77 @@ export class DIContainer {
     console.log(` 🔍 Scanning for property injections on ${className}`);
 
     // Get all property injections from metadata storage
-    const propertyInjections =
-      this.metadataStorage.getPropertyInjections(constructor);
+    const injections = this.metadataStorage.getPropertyInjections(constructor);
 
-    if (propertyInjections.length === 0) {
+    if (injections.length === 0) {
       console.log(` ℹ️ No property injections registered for ${className}`);
       return;
     }
 
     console.log(
-      ` 📌 Found ${propertyInjections.length} property injection(s) for ${className}`,
+      ` 📌 Found ${injections.length} property injection(s) for ${className}`,
     );
 
-    for (const { propertyKey, injections } of propertyInjections) {
-      console.log(`   ➤ Property: ${propertyKey}`);
-
-      for (const injection of injections) {
-        console.log(`     • Injection type: ${injection.type}`);
+    for (const injection of injections) {
+      const { propertyKey, type, metadata } = injection;
+      console.log(`   ➤ Property: ${propertyKey} [${type}]`);
 
-        try {
-          switch (injection.type) {
-            case "autowired":
-              this.injectAutowiredProperty(
-                instance,
-                propertyKey,
-                injection.metadata?.type,
-                className,
-              );
-              break;
-            case "inject":
-              this.injectTokenProperty(
-                instance,
-                propertyKey,
-                injection.metadata?.token,
-                className,
-              );
-              break;
-            case "repository":
-              this.injectRepositoryProperty(
-                instance,
-                propertyKey,
-                injection.metadata?.entity,
-                className,
-              );
-              break;
-            case "value":
-              this.injectValueProperty(
-                instance,
-                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}`,
+      try {
+        switch (type) {
+          case "autowired":
+            this.injectAutowiredProperty(
+              instance,
+              propertyKey,
+              metadata?.type,
+              className,
+            );
+            break;
+          case "inject":
+            this.injectTokenProperty(
+              instance,
+              propertyKey,
+              metadata?.token,
+              className,
             );
-            throw error;
-          }
+            break;
+          case "repository":
+            this.injectRepositoryProperty(
+              instance,
+              propertyKey,
+              metadata?.entity,
+              className,
+            );
+            break;
+          case "value":
+            this.injectValueProperty(
+              instance,
+              propertyKey,
+              metadata?.expression,
+              className,
+            );
+            break;
+          case "lazy":
+            this.injectLazyProperty(instance, propertyKey, className);
+            break;
+        }
+      } catch (error) {
+        const isOptional = Reflect.getMetadata(
+          METADATA_KEYS.OPTIONAL,
+          constructor.prototype,
+          propertyKey,
+        );
 
-          console.warn(
-            ` ⚠️ Optional dependency ${propertyKey} not available for ${className}`,
+        if (!isOptional) {
+          console.error(
+            ` ❌ Failed to inject ${propertyKey} in ${className}: ${error}`,
           );
-          instance[propertyKey] = undefined;
+          throw error;
         }
+
+        console.warn(
+          ` ⚠️ Optional dependency ${propertyKey} not available for ${className}`,
+        );
+        instance[propertyKey] = undefined;
       }
     }
   }
@@ -248,21 +222,16 @@ export class DIContainer {
     className: string,
   ): void {
     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 {
+      // Fallback to design:type metadata
+      type = Reflect.getMetadata("design:type", instance, propertyKey);
+      if (!type || type === Object) {
         throw new Error(
           `Type information not available for ${className}.${propertyKey}`,
         );
       }
+      console.warn(
+        ` ⚠️ Using design:type metadata as fallback for ${className}.${propertyKey}`,
+      );
     }
 
     console.log(` 💉 @Autowired: ${className}.${propertyKey} -> ${type.name}`);
@@ -276,12 +245,6 @@ export class DIContainer {
     token: any,
     className: string,
   ): void {
-    if (!token) {
-      throw new Error(
-        `Token not provided for @Inject on ${className}.${propertyKey}`,
-      );
-    }
-
     const tokenName = typeof token === "string" ? token : token.name;
     console.log(` 💉 @Inject: ${className}.${propertyKey} -> ${tokenName}`);
     instance[propertyKey] = this.resolve(token);
@@ -294,12 +257,6 @@ export class DIContainer {
     entity: any,
     className: string,
   ): void {
-    if (!entity) {
-      throw new Error(
-        `Entity not provided for @InjectRepository on ${className}.${propertyKey}`,
-      );
-    }
-
     console.log(
       ` 💾 @InjectRepository: ${className}.${propertyKey} -> Repository<${entity.name}>`,
     );
@@ -315,12 +272,6 @@ export class DIContainer {
     expression: string,
     className: string,
   ): void {
-    if (!expression) {
-      throw new 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}`);
@@ -331,7 +282,6 @@ export class DIContainer {
     propertyKey: string,
     className: string,
   ): void {
-    // Get the type for later resolution
     const type = Reflect.getMetadata("design:type", instance, propertyKey);
     if (!type) {
       throw new Error(
@@ -374,33 +324,17 @@ export class DIContainer {
       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;
-        }
-      }
+      // Try to parse as boolean
+      if (defaultValue.toLowerCase() === "true") defaultValue = true;
+      else if (defaultValue.toLowerCase() === "false") defaultValue = false;
+      // Try to parse as number
+      else if (!isNaN(Number(defaultValue)))
+        defaultValue = Number(defaultValue);
     }
 
-    console.log(
-      ` 🔍 Resolving config value: ${key}${defaultValue !== undefined ? ` (default: ${defaultValue})` : ""}`,
-    );
-
-    // Check environment variables first
+    // Check environment variables
     const envValue = process.env[key.toUpperCase()] || process.env[key];
     if (envValue !== undefined) {
-      console.log(`   🌍 Found in environment: ${envValue}`);
-
       // Try to parse as JSON if it looks like an object/array
       if (envValue.startsWith("{") || envValue.startsWith("[")) {
         try {
@@ -424,19 +358,11 @@ export class DIContainer {
     }
 
     // Return default value if available
-    if (defaultValue !== undefined) {
-      console.log(`   📦 Using default value: ${defaultValue}`);
-      return defaultValue;
-    }
-
-    console.warn(` ⚠️ Config value not found: ${key}`);
-    return undefined;
+    return defaultValue !== undefined ? defaultValue : 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();
 
@@ -444,14 +370,8 @@ 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}`,
       );
@@ -471,7 +391,6 @@ export class DIContainer {
   }
 
   clear(): void {
-    console.log("🧹 Clearing DI Container");
     this.singletons.clear();
     this.transients.clear();
     this.factories.clear();
@@ -481,6 +400,5 @@ export class DIContainer {
 
   reset(): void {
     this.clear();
-    console.log("🔁 DI Container reset complete");
   }
 }

package/src/core/decorators/exception-filter.decorator.ts

@@ -0,0 +1,20 @@
+import { ExceptionFilter } from "../../web/interfaces";
+import { METADATA_KEYS } from "../metadata/metadata-keys";
+import { MetadataStorage } from "../metadata/metadata-storage";
+
+/**
+ * @ExceptionFilter - Handle exceptions globally or per controller/method
+ */
+export function ExceptionFilter(filterClass: new () => any): ClassDecorator & MethodDecorator {
+  return (target: any, propertyKey?: string | symbol) => {
+    if (propertyKey === undefined) {
+      Reflect.defineMetadata(METADATA_KEYS.USE_FILTERS, filterClass, target);
+      const storage = MetadataStorage.getInstance();
+      storage.addClassMetadata?.(target, 'exceptionFilter', filterClass);
+    } else {
+      Reflect.defineMetadata(METADATA_KEYS.USE_FILTERS, filterClass, target, propertyKey);
+      const storage = MetadataStorage.getInstance();
+      storage.addMethodMetadata?.(target.constructor, propertyKey.toString(), 'exceptionFilter', filterClass);
+    }
+  };
+}

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

@@ -0,0 +1,20 @@
+import { Guard } from "../../web/interfaces";
+import { METADATA_KEYS } from "../metadata/metadata-keys";
+import { MetadataStorage } from "../metadata/metadata-storage";
+
+/**
+ * @Guard - Apply authorization/activation guard
+ */
+export function Guard(guardClass: new () => any): ClassDecorator & MethodDecorator {
+  return (target: any, propertyKey?: string | symbol) => {
+    if (propertyKey === undefined) {
+      Reflect.defineMetadata(METADATA_KEYS.USE_GUARDS, guardClass, target);
+      const storage = MetadataStorage.getInstance();
+      storage.addClassMetadata?.(target, 'guard', guardClass);
+    } else {
+      Reflect.defineMetadata(METADATA_KEYS.USE_GUARDS, guardClass, target, propertyKey);
+      const storage = MetadataStorage.getInstance();
+      storage.addMethodMetadata?.(target.constructor, propertyKey.toString(), 'guard', guardClass);
+    }
+  };
+}

package/src/core/decorators/injection.decorators.ts

@@ -23,6 +23,7 @@ export function Autowired(): PropertyDecorator {
       type: "autowired",
       key: propertyKey.toString(),
       metadata: { type },
+      propertyKey: propertyKey.toString(),
     });
 
     // Also store in Reflect metadata for backward compatibility
@@ -43,6 +44,7 @@ export function Inject(token: string | Function): PropertyDecorator {
       type: "inject",
       key: propertyKey.toString(),
       metadata: { token },
+      propertyKey: propertyKey.toString(),
     });
 
     // Also store in Reflect metadata for backward compatibility
@@ -62,6 +64,7 @@ export function InjectRepository(entity: Function): PropertyDecorator {
       type: "repository",
       key: propertyKey.toString(),
       metadata: { entity },
+      propertyKey: propertyKey.toString(),
     });
 
     // Also store in Reflect metadata for backward compatibility
@@ -97,6 +100,7 @@ export function Value(expression: string): PropertyDecorator {
       type: "value",
       key: propertyKey.toString(),
       metadata: { expression },
+      propertyKey: propertyKey.toString(),
     });
 
     // Also store in Reflect metadata for backward compatibility
@@ -133,6 +137,7 @@ export function Lazy(): PropertyDecorator {
     storage.addPropertyInjection?.(target.constructor, propertyKey.toString(), {
       type: "lazy",
       key: propertyKey.toString(),
+      propertyKey: propertyKey.toString(),
     });
 
     // Get the type for later resolution

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

@@ -0,0 +1,20 @@
+import { Interceptor } from "../../web/interfaces";
+import { METADATA_KEYS } from "../metadata/metadata-keys";
+import { MetadataStorage } from "../metadata/metadata-storage";
+
+/**
+ * @Interceptor - Intercept and transform request/response
+ */
+export function Interceptor(interceptorClass: new () => any): ClassDecorator & MethodDecorator {
+  return (target: any, propertyKey?: string | symbol) => {
+    if (propertyKey === undefined) {
+      Reflect.defineMetadata(METADATA_KEYS.USE_INTERCEPTORS, interceptorClass, target);
+      const storage = MetadataStorage.getInstance();
+      storage.addClassMetadata?.(target, 'interceptor', interceptorClass);
+    } else {
+      Reflect.defineMetadata(METADATA_KEYS.USE_INTERCEPTORS, interceptorClass, target, propertyKey);
+      const storage = MetadataStorage.getInstance();
+      storage.addMethodMetadata?.(target.constructor, propertyKey.toString(), 'interceptor', interceptorClass);
+    }
+  };
+}

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

@@ -0,0 +1,25 @@
+import { Middleware } from "../../web/interfaces";
+import { METADATA_KEYS } from "../metadata/metadata-keys";
+import { MetadataStorage } from "../metadata/metadata-storage";
+
+/**
+ * @Middleware - Apply Express-compatible middleware at class or method level
+ * Usage:
+ *   @Middleware(AuthMiddleware) class MyController { }
+ *   @Middleware(AuthMiddleware) @Get('/') handler() { }
+ */
+export function Middleware(middlewareClass: new () => any): ClassDecorator & MethodDecorator {
+  return (target: any, propertyKey?: string | symbol) => {
+    if (propertyKey === undefined) {
+      // Class-level
+      Reflect.defineMetadata(METADATA_KEYS.USE_MIDDLEWARE, middlewareClass, target);
+      const storage = MetadataStorage.getInstance();
+      storage.addClassMetadata?.(target, 'middleware', middlewareClass);
+    } else {
+      // Method-level
+      Reflect.defineMetadata(METADATA_KEYS.USE_MIDDLEWARE, middlewareClass, target, propertyKey);
+      const storage = MetadataStorage.getInstance();
+      storage.addMethodMetadata?.(target.constructor, propertyKey.toString(), 'middleware', middlewareClass);
+    }
+  };
+}

package/src/core/metadata/metadata-keys.ts

@@ -33,6 +33,7 @@ export const METADATA_KEYS = {
   CONDITIONAL_ON_BEAN: "fragment:conditional-on-bean",
 
   // Middleware & Guards
+  USE_MIDDLEWARE: "fragment:use-middleware",
   USE_GUARDS: "fragment:use-guards",
   USE_INTERCEPTORS: "fragment:use-interceptors",
   USE_FILTERS: "fragment:use-filters",