fragment-ts 1.0.28 → 1.0.30

package/src/core/decorators/auto-configuration.decorator.ts

@@ -1,17 +1,18 @@
-import { Injectable } from './injectable.decorator';
-import { METADATA_KEYS } from '../metadata/metadata-keys';
-import { MetadataStorage } from '../metadata/metadata-storage';
+import { Injectable } from "./injectable.decorator";
+import { METADATA_KEYS } from "../metadata/metadata-keys";
+import { MetadataStorage } from "../metadata/metadata-storage";
 
 export function AutoConfiguration(): ClassDecorator {
   return (target: any) => {
-    Injectable('singleton')(target);
+    console.log(`🔧 Registering AutoConfiguration: ${target.name}`);
+    Injectable("singleton")(target);
     Reflect.defineMetadata(METADATA_KEYS.AUTO_CONFIGURATION, true, target);
-    
+
     const storage = MetadataStorage.getInstance();
     storage.addClass({
       target,
-      type: 'auto-configuration',
-      scope: 'singleton'
+      type: "auto-configuration",
+      scope: "singleton",
     });
   };
-}
+}

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,4 +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
@@ -8,15 +10,22 @@ 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) {
-      throw new Error(
-        `Cannot use @Autowired on property "${String(propertyKey)}" in ${target.constructor.name}. ` +
-          `Make sure TypeScript emitDecoratorMetadata is enabled and the type is explicitly declared.`,
+      console.warn(
+        `⚠️ Could not determine type for ${target.constructor.name}.${String(propertyKey)}. ` +
+          `Ensure emitDecoratorMetadata is enabled in tsconfig.json`,
       );
     }
 
-    // Store the type in metadata so DI container can resolve it
+    // Store metadata for property injection
+    const storage = MetadataStorage.getInstance();
+    storage.addPropertyInjection?.(target.constructor, propertyKey.toString(), {
+      type: "autowired",
+      key: propertyKey.toString(),
+      metadata: { type },
+    });
+
+    // Also store in Reflect metadata for backward compatibility
     Reflect.defineMetadata(METADATA_KEYS.AUTOWIRED, type, target, propertyKey);
   };
 }
@@ -28,6 +37,15 @@ 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 },
+    });
+
+    // Also store in Reflect metadata for backward compatibility
     Reflect.defineMetadata(METADATA_KEYS.INJECT, token, target, propertyKey);
   };
 }
@@ -38,6 +56,15 @@ 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 },
+    });
+
+    // Also store in Reflect metadata for backward compatibility
     Reflect.defineMetadata(
       METADATA_KEYS.INJECT_REPOSITORY,
       entity,
@@ -64,6 +91,15 @@ 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 },
+    });
+
+    // Also store in Reflect metadata for backward compatibility
     Reflect.defineMetadata(
       METADATA_KEYS.VALUE,
       expression,
@@ -89,27 +125,21 @@ 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(),
+    });
+
+    // 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)
   };
 }
 
@@ -123,6 +153,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,
@@ -141,6 +176,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,11 +28,19 @@ export interface ParamMetadata {
   paramName?: string;
 }
 
+export interface PropertyInjectionMetadata {
+  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, PropertyInjectionMetadata[]> =
+    new Map();
 
   static getInstance(): MetadataStorage {
     if (!MetadataStorage.instance) {
@@ -88,4 +96,43 @@ export class MetadataStorage {
     const key = `${targetName}.${propertyKey}`;
     return this.params.get(key) || [];
   }
+
+  addPropertyInjection(
+    target: any,
+    propertyKey: string,
+    injection: PropertyInjectionMetadata,
+  ): void {
+    const className = target.name || target.constructor?.name;
+    const key = `${className}.${propertyKey}`;
+
+    if (!this.propertyInjections.has(key)) {
+      this.propertyInjections.set(key, []);
+    }
+
+    const injections = this.propertyInjections.get(key)!;
+    injections.push(injection);
+
+    console.log(
+      `  🎯 Registered property injection: ${className}.${propertyKey} [${injection.type}]`,
+    );
+  }
+
+  getPropertyInjections(
+    target: any,
+  ): { propertyKey: string; injections: PropertyInjectionMetadata[] }[] {
+    const className = target.name || target.constructor?.name;
+    const result: {
+      propertyKey: string;
+      injections: PropertyInjectionMetadata[];
+    }[] = [];
+
+    this.propertyInjections.forEach((injections, key) => {
+      if (key.startsWith(`${className}.`)) {
+        const propertyKey = key.split(".")[1];
+        result.push({ propertyKey, injections });
+      }
+    });
+
+    return result;
+  }
 }

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();
     }
 
@@ -52,51 +63,51 @@ export class FragmentWebApplication {
 
     const port = appMetadata?.port || 3000;
     const host = appMetadata?.host || "0.0.0.0";
-
+    
     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"]) {
       return true;
     }
-
+    
     // Check if process is running with ts-node or tsx
     const execPath = process.argv[0];
     const scriptPath = process.argv[1] || "";
-
+    
     if (
       execPath.includes("ts-node") ||
       execPath.includes("tsx") ||
@@ -105,25 +116,24 @@ export class FragmentWebApplication {
     ) {
       return true;
     }
-
+    
     // Check if main module has .ts extension
     if (require.main?.filename.endsWith(".ts")) {
       return true;
     }
-
+    
     // Check NODE_ENV or explicit flag
     if (process.env.FRAGMENT_DEV_MODE === "true") {
       return true;
     }
-
+    
     return false;
   }
 
   private discoverAndRegisterComponents(): void {
     const classes = this.metadataStorage.getAllClasses();
-
     console.log(`\n📦 Discovered ${classes.length} component(s)`);
-
+    
     // Group by type for display
     const grouped = classes.reduce(
       (acc, cls) => {
@@ -133,38 +143,50 @@ export class FragmentWebApplication {
       },
       {} as Record<string, any[]>,
     );
-
+    
     Object.entries(grouped).forEach(([type, items]) => {
       const icon = this.getTypeIcon(type);
-      console.log(`   ${icon} ${items.length} ${type}(s)`);
+      console.log(` ${icon} ${items.length} ${type}(s)`);
+      
+      items.forEach(item => {
+        console.log(`   • ${item.target.name}${item.path ? ` (${item.path})` : ''}`);
+      });
     });
 
     let registered = 0;
     let skipped = 0;
-
+    
     classes.forEach((metadata) => {
       if (this.shouldRegister(metadata.target)) {
         // CRITICAL: Register with container
         if (!this.container.has(metadata.target)) {
           this.container.register(metadata.target);
           registered++;
-          console.log(`   ✓ Registered: ${metadata.target.name}`);
+          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)`,
+          ` ⊘ Skipped: ${metadata.target.name} (conditional check failed)`,
         );
       }
     });
 
-    console.log(
-      `\n   ✓ Registered ${registered}/${classes.length} component(s)`,
-    );
+    console.log(`\n✓ Registered ${registered} component(s)`);
     if (skipped > 0) {
-      console.log(`   ⊘ Skipped ${skipped} (conditions not met)`);
+      console.log(`⊘ Skipped ${skipped} component(s) (conditions not met)`);
     }
-    console.log("");
+    
+    // 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 {
@@ -183,7 +205,9 @@ 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;
     }
 
@@ -191,7 +215,9 @@ 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;
     }
 
@@ -199,15 +225,17 @@ 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;
       }
     }
@@ -227,37 +255,44 @@ export class FragmentWebApplication {
     const controllers = this.metadataStorage
       .getAllClasses()
       .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);
-
-      if (methods.length > 0) {
-        const controllerName = controllerMetadata.target.name;
-        console.log(`   📍 ${controllerName}`);
-
+      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 || "";
+        
+        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);
           const httpMethod = methodMetadata.method.toLowerCase();
           const methodColor = this.getMethodColor(httpMethod);
           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](
             fullPath,
             async (req: Request, res: Response, next: NextFunction) => {
@@ -267,23 +302,30 @@ 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 {
@@ -313,10 +355,10 @@ 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,
     );
-
+    
     return params.map((param: any) => {
       switch (param.type) {
         case "body":
@@ -349,14 +391,15 @@ 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(),
     });
   }
 
   getExpressApp(): Express {
     return this.app;
   }
-}
+}