fragment-ts 1.0.29 → 1.0.31

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

@@ -4,9 +4,10 @@ import { MetadataStorage } from "../metadata/metadata-storage";
 
 export function Controller(path: string = ""): ClassDecorator {
   return (target: any) => {
+    console.log(`🎮 Registering Controller: ${target.name} at ${path || '/'}`);
     Injectable("singleton")(target);
     Reflect.defineMetadata(METADATA_KEYS.CONTROLLER, path, target);
-
+    
     const storage = MetadataStorage.getInstance();
     storage.addClass({
       target,

package/src/core/decorators/http.decorators.ts

@@ -8,6 +8,13 @@ function createHttpMethodDecorator(method: string) {
       propertyKey: string | symbol,
       descriptor: PropertyDescriptor,
     ) => {
+      const className = target.constructor.name;
+      const methodName = String(propertyKey);
+
+      console.log(
+        `⚡ Registering ${method.toUpperCase()} route: ${className}.${methodName} at ${path || "/"}`,
+      );
+
       Reflect.defineMetadata(
         METADATA_KEYS.HTTP_METHOD,
         method,
@@ -50,6 +57,16 @@ function createParamDecorator(type: string) {
         throw new Error(`@${type}() cannot be used on constructor parameters`);
       }
 
+      const className = target.constructor.name;
+      const methodName = String(propertyKey);
+      const paramDisplay = paramName
+        ? `${paramName} (index: ${parameterIndex})`
+        : `index: ${parameterIndex}`;
+
+      console.log(
+        `  📥 Registering @${type} parameter for ${className}.${methodName}: ${paramDisplay}`,
+      );
+
       const storage = MetadataStorage.getInstance();
 
       storage.addParam({

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

@@ -5,6 +5,7 @@ export type Scope = 'singleton' | 'request' | 'transient';
 
 export function Injectable(scope: Scope = 'singleton'): ClassDecorator {
   return (target: any) => {
+    console.log(`💉 Registering Injectable: ${target.name} [${scope}]`);
     Reflect.defineMetadata(METADATA_KEYS.INJECTABLE, true, target);
     Reflect.defineMetadata(METADATA_KEYS.SCOPE, scope, target);
     

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

@@ -1,5 +1,6 @@
 import { METADATA_KEYS } from "../metadata/metadata-keys";
 import { MetadataStorage } from "../metadata/metadata-storage";
+import { DIContainer } from "../container/di-container";
 
 /**
  * @Autowired - Automatically inject dependencies by type
@@ -7,21 +8,25 @@ import { MetadataStorage } from "../metadata/metadata-storage";
  */
 export function Autowired(): PropertyDecorator {
   return (target: any, propertyKey: string | symbol) => {
+    // Get the design type from TypeScript metadata
+    const type = Reflect.getMetadata("design:type", target, propertyKey);
+    if (!type || type === Object) {
+      console.warn(
+        `⚠️ Could not determine type for ${target.constructor.name}.${String(propertyKey)}. ` +
+          `Ensure emitDecoratorMetadata is enabled in tsconfig.json`,
+      );
+    }
+
     // Store metadata for property injection
     const storage = MetadataStorage.getInstance();
     storage.addPropertyInjection?.(target.constructor, propertyKey.toString(), {
       type: "autowired",
       key: propertyKey.toString(),
+      metadata: { type },
+      propertyKey: propertyKey.toString(),
     });
 
     // Also store in Reflect metadata for backward compatibility
-    const type = Reflect.getMetadata("design:type", target, propertyKey);
-    if (!type || type === Object) {
-      console.warn(
-        `⚠️ Could not determine type for ${target.constructor.name}.${String(propertyKey)}. ` +
-          `Ensure emitDecoratorMetadata is enabled in tsconfig.json`,
-      );
-    }
     Reflect.defineMetadata(METADATA_KEYS.AUTOWIRED, type, target, propertyKey);
   };
 }
@@ -33,6 +38,16 @@ export function Autowired(): PropertyDecorator {
  */
 export function Inject(token: string | Function): PropertyDecorator {
   return (target: any, propertyKey: string | symbol) => {
+    // Store metadata for property injection
+    const storage = MetadataStorage.getInstance();
+    storage.addPropertyInjection?.(target.constructor, propertyKey.toString(), {
+      type: "inject",
+      key: propertyKey.toString(),
+      metadata: { token },
+      propertyKey: propertyKey.toString(),
+    });
+
+    // Also store in Reflect metadata for backward compatibility
     Reflect.defineMetadata(METADATA_KEYS.INJECT, token, target, propertyKey);
   };
 }
@@ -43,6 +58,16 @@ export function Inject(token: string | Function): PropertyDecorator {
  */
 export function InjectRepository(entity: Function): PropertyDecorator {
   return (target: any, propertyKey: string | symbol) => {
+    // Store metadata for property injection
+    const storage = MetadataStorage.getInstance();
+    storage.addPropertyInjection?.(target.constructor, propertyKey.toString(), {
+      type: "repository",
+      key: propertyKey.toString(),
+      metadata: { entity },
+      propertyKey: propertyKey.toString(),
+    });
+
+    // Also store in Reflect metadata for backward compatibility
     Reflect.defineMetadata(
       METADATA_KEYS.INJECT_REPOSITORY,
       entity,
@@ -69,6 +94,16 @@ export function Qualifier(name: string): PropertyDecorator {
  */
 export function Value(expression: string): PropertyDecorator {
   return (target: any, propertyKey: string | symbol) => {
+    // Store metadata for property injection
+    const storage = MetadataStorage.getInstance();
+    storage.addPropertyInjection?.(target.constructor, propertyKey.toString(), {
+      type: "value",
+      key: propertyKey.toString(),
+      metadata: { expression },
+      propertyKey: propertyKey.toString(),
+    });
+
+    // Also store in Reflect metadata for backward compatibility
     Reflect.defineMetadata(
       METADATA_KEYS.VALUE,
       expression,
@@ -94,27 +129,22 @@ export function Optional(): PropertyDecorator {
  */
 export function Lazy(): PropertyDecorator {
   return (target: any, propertyKey: string | symbol) => {
+    // Mark as lazy in metadata
     Reflect.defineMetadata(METADATA_KEYS.LAZY, true, target, propertyKey);
 
+    // Store metadata for property injection
+    const storage = MetadataStorage.getInstance();
+    storage.addPropertyInjection?.(target.constructor, propertyKey.toString(), {
+      type: "lazy",
+      key: propertyKey.toString(),
+      propertyKey: propertyKey.toString(),
+    });
+
+    // Get the type for later resolution
     const type = Reflect.getMetadata("design:type", target, propertyKey);
 
-    // Create a getter that resolves on first access
-    let cached: any = null;
-    let resolved = false;
-
-    Object.defineProperty(target, propertyKey, {
-      get() {
-        if (!resolved) {
-          const { DIContainer } = require("../container/di-container");
-          const container = DIContainer.getInstance();
-          cached = container.resolve(type);
-          resolved = true;
-        }
-        return cached;
-      },
-      enumerable: true,
-      configurable: true,
-    });
+    // This will be handled by the container during injection
+    // (not directly creating the getter here to avoid container dependency)
   };
 }
 
@@ -128,6 +158,11 @@ export function PostConstruct(): MethodDecorator {
     propertyKey: string | symbol,
     descriptor: PropertyDescriptor,
   ) => {
+    const className = target.constructor.name;
+    console.log(
+      ` 🏗️  Registering @PostConstruct: ${className}.${String(propertyKey)}`,
+    );
+
     Reflect.defineMetadata(
       METADATA_KEYS.POST_CONSTRUCT,
       propertyKey,
@@ -146,6 +181,11 @@ export function PreDestroy(): MethodDecorator {
     propertyKey: string | symbol,
     descriptor: PropertyDescriptor,
   ) => {
+    const className = target.constructor.name;
+    console.log(
+      ` 🧹 Registering @PreDestroy: ${className}.${String(propertyKey)}`,
+    );
+
     Reflect.defineMetadata(
       METADATA_KEYS.PRE_DESTROY,
       propertyKey,

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

@@ -4,6 +4,7 @@ import { MetadataStorage } from '../metadata/metadata-storage';
 
 export function Repository(): ClassDecorator {
   return (target: any) => {
+    console.log(`💾 Registering Repository: ${target.name}`);
     Injectable('singleton')(target);
     Reflect.defineMetadata(METADATA_KEYS.REPOSITORY, true, target);
     

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

@@ -4,6 +4,7 @@ import { MetadataStorage } from '../metadata/metadata-storage';
 
 export function Service(): ClassDecorator {
   return (target: any) => {
+    console.log(`⚙️  Registering Service: ${target.name}`);
     Injectable('singleton')(target);
     Reflect.defineMetadata(METADATA_KEYS.SERVICE, true, target);
     

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

@@ -28,19 +28,20 @@ export interface ParamMetadata {
   paramName?: string;
 }
 
+export interface PropertyInjectionMetadata {
+  propertyKey: string;
+  type: "autowired" | "inject" | "repository" | "value" | "lazy";
+  key: string;
+  metadata?: any;
+}
+
 export class MetadataStorage {
   private static instance: MetadataStorage;
   private classes: Map<any, ClassMetadata> = new Map();
   private methods: Map<string, MethodMetadata> = new Map();
   private params: Map<string, ParamMetadata[]> = new Map();
-  private propertyInjections: Map<
-    string,
-    {
-      type: string;
-      key: string;
-      metadata?: any;
-    }[]
-  > = new Map();
+  private propertyInjections: Map<string, PropertyInjectionMetadata[]> =
+    new Map();
 
   static getInstance(): MetadataStorage {
     if (!MetadataStorage.instance) {
@@ -49,35 +50,6 @@ export class MetadataStorage {
     return MetadataStorage.instance;
   }
 
-  addPropertyInjection(
-    target: any,
-    propertyKey: string,
-    injection: { type: string; key: string; metadata?: any },
-  ): void {
-    const className = target.name || target.constructor?.name;
-    const key = `${className}.${propertyKey}`;
-    const injections = this.propertyInjections.get(key) || [];
-    injections.push(injection);
-    this.propertyInjections.set(key, injections);
-  }
-
-  getAllPropertyInjections(target: any): {
-    propertyKey: string;
-    injections: { type: string; key: string; metadata?: any }[];
-  }[] {
-    const className = target.name || target.constructor?.name;
-    const injections: { propertyKey: string; injections: any[] }[] = [];
-
-    this.propertyInjections.forEach((value, key) => {
-      if (key.startsWith(`${className}.`)) {
-        const propertyKey = key.split(".")[1];
-        injections.push({ propertyKey, injections: value });
-      }
-    });
-
-    return injections;
-  }
-
   addClass(metadata: ClassMetadata): void {
     this.classes.set(metadata.target, metadata);
   }
@@ -125,4 +97,32 @@ export class MetadataStorage {
     const key = `${targetName}.${propertyKey}`;
     return this.params.get(key) || [];
   }
+
+  addPropertyInjection(
+    target: any,
+    propertyKey: string,
+    injection: PropertyInjectionMetadata,
+  ): void {
+    if (!this.propertyInjections.has(target)) {
+      this.propertyInjections.set(target, []);
+    }
+
+    const injections = this.propertyInjections.get(target)!;
+    injections.push(injection);
+  }
+
+  getPropertyInjections(target: any): PropertyInjectionMetadata[] {
+    // Get injections for this specific class
+    let injections = this.propertyInjections.get(target) || [];
+
+    // Also get injections from parent classes
+    let parent = Object.getPrototypeOf(target);
+    while (parent && parent !== Object && parent !== Function.prototype) {
+      const parentInjections = this.propertyInjections.get(parent) || [];
+      injections = [...injections, ...parentInjections];
+      parent = Object.getPrototypeOf(parent);
+    }
+
+    return injections;
+  }
 }

package/src/web/application.ts

@@ -16,14 +16,15 @@ export class FragmentWebApplication {
   private metadataStorage: MetadataStorage;
 
   constructor() {
+    console.log("🌱 Initializing Fragment Framework");
     this.app = express();
     this.container = DIContainer.getInstance();
     this.metadataStorage = MetadataStorage.getInstance();
     this.setupMiddleware();
-    this;
   }
 
   private setupMiddleware(): void {
+    console.log("⚙️  Setting up middleware");
     this.app.use(helmet());
     this.app.use(cors());
     this.app.use(compression());
@@ -32,17 +33,27 @@ export class FragmentWebApplication {
   }
 
   async bootstrap(appClass: any): Promise<void> {
-    await TypeORMModule.initialize();
+    console.log("\n🚀 Bootstrapping application");
+
+    try {
+      await TypeORMModule.initialize();
+      console.log("✅ TypeORM initialized successfully");
+    } catch (error) {
+      console.error("❌ Failed to initialize TypeORM:", error);
+      throw error;
+    }
 
     const appMetadata = Reflect.getMetadata(
       METADATA_KEYS.APPLICATION,
       appClass,
     );
 
+    console.log(`🎯 Application metadata:`, appMetadata);
+
     // CRITICAL: Scan and load all component files first
     // This triggers decorator execution
     if (appMetadata?.autoScan !== false) {
-      console.log("🔍 Scanning for components...");
+      console.log("\n🔍 Scanning for components...");
       await this.scanComponents();
     }
 
@@ -56,37 +67,41 @@ export class FragmentWebApplication {
     this.app.use(this.errorHandler.bind(this));
 
     this.app.listen(port, host, () => {
-      console.log(`✨ Fragment application running on http://${host}:${port}`);
+      console.log(
+        `\n✨ Fragment application running on http://${host}:${port}`,
+      );
+      console.log("========================================\n");
     });
   }
 
-  /**
-   * Detects environment and scans appropriate files
-   */
   private async scanComponents(): Promise<void> {
     const cwd = process.cwd();
     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}`);
+
     // Determine if we're running TypeScript directly (dev) or compiled JS (prod)
     const isDevMode = this.isRunningTypeScript();
+    console.log(
+      `💻 Running in ${isDevMode ? "development" : "production"} mode`,
+    );
 
     if (isDevMode && srcExists) {
       // Development mode: scan TypeScript source files
-      console.log("   📝 Development mode: scanning TypeScript 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");
+      console.log(" 📦 Production mode: scanning compiled files");
       await ComponentScanner.scan();
     } else {
-      console.warn("   ⚠️  Warning: No src/ or dist/ directory found");
+      console.warn(" ⚠️ Warning: No src/ or dist/ directory found");
     }
   }
 
-  /**
-   * Detects if we're running TypeScript directly (ts-node or similar)
-   */
   private isRunningTypeScript(): boolean {
     // Check if ts-node is in require.extensions
     if (require.extensions[".ts"]) {
@@ -120,28 +135,64 @@ export class FragmentWebApplication {
   }
 
   private discoverAndRegisterComponents(): void {
-    // First, register all components with the container
     const classes = this.metadataStorage.getAllClasses();
     console.log(`\n📦 Discovered ${classes.length} component(s)`);
 
-    // First pass: register all targets
-    classes.forEach((metadata) => {
-      if (!this.container.has(metadata.target)) {
-        this.container.register(metadata.target);
-      }
+    // Group by type for display
+    const grouped = classes.reduce(
+      (acc, cls) => {
+        if (!acc[cls.type]) acc[cls.type] = [];
+        acc[cls.type].push(cls);
+        return acc;
+      },
+      {} as Record<string, any[]>,
+    );
+
+    Object.entries(grouped).forEach(([type, items]) => {
+      const icon = this.getTypeIcon(type);
+      console.log(` ${icon} ${items.length} ${type}(s)`);
+
+      items.forEach((item) => {
+        console.log(
+          `   • ${item.target.name}${item.path ? ` (${item.path})` : ""}`,
+        );
+      });
     });
 
-    // Second pass: create and inject dependencies
+    let registered = 0;
+    let skipped = 0;
+
     classes.forEach((metadata) => {
       if (this.shouldRegister(metadata.target)) {
-        this.container.resolve(metadata.target);
-        console.log(` ✓ Initialized: ${metadata.target.name}`);
+        // CRITICAL: Register with container
+        if (!this.container.has(metadata.target)) {
+          this.container.register(metadata.target);
+          registered++;
+          console.log(` ✓ Registered: ${metadata.target.name}`);
+        } else {
+          console.log(` ✓ Already registered: ${metadata.target.name}`);
+        }
       } else {
+        skipped++;
         console.log(
           ` ⊘ Skipped: ${metadata.target.name} (conditional check failed)`,
         );
       }
     });
+
+    console.log(`\n✓ Registered ${registered} component(s)`);
+    if (skipped > 0) {
+      console.log(`⊘ Skipped ${skipped} component(s) (conditions not met)`);
+    }
+
+    // Pre-resolve all singleton components to ensure dependencies are injected
+    console.log("\n🔧 Initializing components");
+    classes.forEach((metadata) => {
+      if (this.shouldRegister(metadata.target)) {
+        const instance = this.container.resolve(metadata.target);
+        console.log(` ✓ Initialized: ${metadata.target.name}`);
+      }
+    });
   }
 
   private getTypeIcon(type: string): string {
@@ -160,7 +211,11 @@ export class FragmentWebApplication {
       METADATA_KEYS.CONDITIONAL_ON_CLASS,
       target,
     );
+
     if (conditionalClass && !this.isClassAvailable(conditionalClass)) {
+      console.log(
+        ` 🚫 Conditional check failed for ${target.name}: Class not available`,
+      );
       return false;
     }
 
@@ -168,7 +223,11 @@ export class FragmentWebApplication {
       METADATA_KEYS.CONDITIONAL_ON_MISSING_BEAN,
       target,
     );
+
     if (conditionalMissingBean && this.container.has(conditionalMissingBean)) {
+      console.log(
+        ` 🚫 Conditional check failed for ${target.name}: Bean already exists`,
+      );
       return false;
     }
 
@@ -176,15 +235,21 @@ export class FragmentWebApplication {
       METADATA_KEYS.CONDITIONAL_ON_PROPERTY,
       target,
     );
+
     if (conditionalProperty) {
       const value = process.env[conditionalProperty.key];
-      if (
-        conditionalProperty.expectedValue !== undefined &&
-        value !== conditionalProperty.expectedValue
-      ) {
-        return false;
-      }
-      if (!value) {
+
+      if (conditionalProperty.expectedValue !== undefined) {
+        if (value !== conditionalProperty.expectedValue) {
+          console.log(
+            ` 🚫 Conditional check failed for ${target.name}: Expected ${conditionalProperty.expectedValue}, got ${value}`,
+          );
+          return false;
+        }
+      } else if (!value) {
+        console.log(
+          ` 🚫 Conditional check failed for ${target.name}: Property not set`,
+        );
         return false;
       }
     }
@@ -206,23 +271,29 @@ export class FragmentWebApplication {
       .filter((c) => c.type === "controller");
 
     if (controllers.length === 0) {
-      console.log("🛣️  No routes to register\n");
+      console.log("\n🛣️ No routes to register");
       return;
     }
 
     let totalRoutes = 0;
-    console.log(`🛣️  Registering routes...\n`);
+    console.log(`\n🛣️ Registering routes...`);
 
     controllers.forEach((controllerMetadata) => {
-      const controller = this.container.resolve(controllerMetadata.target);
-      const basePath = controllerMetadata.path || "";
-      const methods = this.metadataStorage
-        .getAllMethods()
-        .filter((m) => m.target === controllerMetadata.target);
+      try {
+        console.log(`\n📍 Controller: ${controllerMetadata.target.name}`);
+        console.log(`  Base path: ${controllerMetadata.path || "/"}`);
+
+        const controller = this.container.resolve(controllerMetadata.target);
+        const basePath = controllerMetadata.path || "";
 
-      if (methods.length > 0) {
-        const controllerName = controllerMetadata.target.name;
-        console.log(`   📍 ${controllerName}`);
+        const methods = this.metadataStorage
+          .getAllMethods()
+          .filter((m) => m.target === controllerMetadata.target);
+
+        if (methods.length === 0) {
+          console.log(`  ⚠️ No routes defined for this controller`);
+          return;
+        }
 
         methods.forEach((methodMetadata) => {
           const fullPath = this.normalizePath(basePath + methodMetadata.path);
@@ -231,8 +302,9 @@ export class FragmentWebApplication {
           const methodIcon = this.getMethodIcon(httpMethod);
 
           console.log(
-            `      ${methodIcon} ${methodColor}${httpMethod.toUpperCase().padEnd(7)}\x1b[0m ${fullPath}`,
+            ` ${methodIcon} ${methodColor}${httpMethod.toUpperCase().padEnd(7)}\x1b[0m ${fullPath}`,
           );
+
           totalRoutes++;
 
           (this.app as any)[httpMethod](
@@ -244,23 +316,35 @@ export class FragmentWebApplication {
                   req,
                   res,
                 );
+
+                console.log(
+                  `\n🔍 Handling ${httpMethod.toUpperCase()} ${fullPath}`,
+                );
+                // console.log(`  Parameters:`, args);
+
                 const result = await (controller as any)[
                   methodMetadata.propertyKey
                 ](...args);
+
                 if (!res.headersSent) {
                   res.json(result);
                 }
               } catch (error) {
+                console.error(`❌ Error handling route ${fullPath}:`, error);
                 next(error);
               }
             },
           );
         });
-        console.log("");
+      } catch (error) {
+        console.error(
+          `❌ Failed to register controller ${controllerMetadata.target.name}:`,
+          error,
+        );
       }
     });
 
-    console.log(`   ✓ Registered ${totalRoutes} route(s)\n`);
+    console.log(`\n✓ Registered ${totalRoutes} route(s)`);
   }
 
   private getMethodColor(method: string): string {
@@ -290,7 +374,7 @@ export class FragmentWebApplication {
     req: Request,
     res: Response,
   ): any[] {
-    const params = methodMetadata.paramMetadata.sort(
+    const params = [...methodMetadata.paramMetadata].sort(
       (a: any, b: any) => a.index - b.index,
     );
 
@@ -326,10 +410,11 @@ export class FragmentWebApplication {
     res: Response,
     next: NextFunction,
   ): void {
-    console.error(err.stack);
+    console.error(`\n❌ Global error handler:`, err);
     res.status(500).json({
       error: "Internal Server Error",
       message: err.message,
+      timestamp: new Date().toISOString(),
     });
   }