fragment-ts 1.0.30 → 1.0.32

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

@@ -29,11 +29,26 @@ export interface ParamMetadata {
 }
 
 export interface PropertyInjectionMetadata {
+  propertyKey: string;
   type: "autowired" | "inject" | "repository" | "value" | "lazy";
   key: string;
   metadata?: any;
 }
 
+export interface ExtendedClassMetadata extends ClassMetadata {
+  middlewares: any[];
+  guards: any[];
+  interceptors: any[];
+  exceptionFilters: any[];
+}
+
+export interface ExtendedMethodMetadata extends MethodMetadata {
+  middlewares?: any[];
+  guards?: any[];
+  interceptors?: any[];
+  exceptionFilters?: any[];
+}
+
 export class MetadataStorage {
   private static instance: MetadataStorage;
   private classes: Map<any, ClassMetadata> = new Map();
@@ -41,6 +56,8 @@ export class MetadataStorage {
   private params: Map<string, ParamMetadata[]> = new Map();
   private propertyInjections: Map<string, PropertyInjectionMetadata[]> =
     new Map();
+  private extendedClasses: Map<any, ExtendedClassMetadata> = new Map();
+  private extendedMethods: Map<string, ExtendedMethodMetadata> = new Map();
 
   static getInstance(): MetadataStorage {
     if (!MetadataStorage.instance) {
@@ -102,37 +119,124 @@ export class MetadataStorage {
     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, []);
+    if (!this.propertyInjections.has(target)) {
+      this.propertyInjections.set(target, []);
     }
 
-    const injections = this.propertyInjections.get(key)!;
+    const injections = this.propertyInjections.get(target)!;
     injections.push(injection);
+  }
 
-    console.log(
-      `  🎯 Registered property injection: ${className}.${propertyKey} [${injection.type}]`,
-    );
+  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;
   }
 
-  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 });
+  addClassMetadata(target: any, type: string, value: any): void {
+    let meta = this.extendedClasses.get(target);
+
+    if (!meta) {
+      const base = this.classes.get(target);
+      if (!base) {
+        // If no base ClassMetadata exists (e.g., decorator used on non-@Controller/@Service class),
+        // we cannot safely create ExtendedClassMetadata — skip or warn.
+        console.warn(
+          `⚠️ @${type} applied to ${target.name}, but it's not registered as a known component (missing @Controller, @Service, etc.). Ignoring.`,
+        );
+        return;
       }
-    });
 
-    return result;
+      // Clone base and add enhancement arrays
+      meta = {
+        ...base,
+        middlewares: [],
+        guards: [],
+        interceptors: [],
+        exceptionFilters: [],
+      };
+    }
+
+    switch (type) {
+      case "middleware":
+        meta.middlewares.push(value);
+        break;
+      case "guard":
+        meta.guards.push(value);
+        break;
+      case "interceptor":
+        meta.interceptors.push(value);
+        break;
+      case "exceptionFilter":
+        meta.exceptionFilters.push(value);
+        break;
+      default:
+        console.warn(`Unknown metadata type: ${type}`);
+        return;
+    }
+
+    this.extendedClasses.set(target, meta);
+  }
+
+  addMethodMetadata(
+    target: any,
+    propertyKey: string,
+    type: string,
+    value: any,
+  ): void {
+    const key = `${target.name}.${propertyKey}`;
+    let meta = this.extendedMethods.get(key);
+    if (!meta) {
+      const base = this.methods.get(key);
+      meta = {
+        ...(base || {
+          target,
+          propertyKey,
+          method: "",
+          path: "",
+          paramMetadata: [],
+        }),
+        middlewares: [],
+        guards: [],
+        interceptors: [],
+        exceptionFilters: [],
+      };
+    }
+    switch (type) {
+      case "middleware":
+        meta.middlewares!.push(value);
+        break;
+      case "guard":
+        meta.guards!.push(value);
+        break;
+      case "interceptor":
+        meta.interceptors!.push(value);
+        break;
+      case "exceptionFilter":
+        meta.exceptionFilters!.push(value);
+        break;
+    }
+    this.extendedMethods.set(key, meta);
+  }
+
+  getExtendedClass(target: any): ExtendedClassMetadata | undefined {
+    return this.extendedClasses.get(target);
+  }
+
+  getExtendedMethod(
+    target: any,
+    propertyKey: string,
+  ): ExtendedMethodMetadata | undefined {
+    const key = `${target.name}.${propertyKey}`;
+    return this.extendedMethods.get(key);
   }
 }

package/src/web/application.ts

@@ -9,6 +9,16 @@ import { MetadataStorage } from "../core/metadata/metadata-storage";
 import { METADATA_KEYS } from "../core/metadata/metadata-keys";
 import { ComponentScanner } from "../core/scanner/component-scanner";
 import { TypeORMModule } from "../typeorm/typeorm-module";
+import {
+  MiddlewareClass,
+  GuardClass,
+  InterceptorClass,
+  ExceptionFilterClass,
+  Middleware,
+  Guard,
+  Interceptor,
+  ExceptionFilter,
+} from "./interfaces";
 
 export class FragmentWebApplication {
   private app: Express;
@@ -34,7 +44,7 @@ export class FragmentWebApplication {
 
   async bootstrap(appClass: any): Promise<void> {
     console.log("\n🚀 Bootstrapping application");
-    
+
     try {
       await TypeORMModule.initialize();
       console.log("✅ TypeORM initialized successfully");
@@ -47,7 +57,7 @@ export class FragmentWebApplication {
       METADATA_KEYS.APPLICATION,
       appClass,
     );
-    
+
     console.log(`🎯 Application metadata:`, appMetadata);
 
     // CRITICAL: Scan and load all component files first
@@ -63,11 +73,13 @@ 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(`\n✨ Fragment application running on http://${host}:${port}`);
+      console.log(
+        `\n✨ Fragment application running on http://${host}:${port}`,
+      );
       console.log("========================================\n");
     });
   }
@@ -76,15 +88,17 @@ export class FragmentWebApplication {
     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`);
-    
+    console.log(
+      `💻 Running in ${isDevMode ? "development" : "production"} mode`,
+    );
+
     if (isDevMode && srcExists) {
       // Development mode: scan TypeScript source files
       console.log(" 📝 Development mode: scanning TypeScript files");
@@ -103,11 +117,11 @@ export class FragmentWebApplication {
     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") ||
@@ -116,24 +130,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) => {
@@ -143,19 +157,21 @@ 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)`);
-      
-      items.forEach(item => {
-        console.log(`   • ${item.target.name}${item.path ? ` (${item.path})` : ''}`);
+
+      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
@@ -178,10 +194,10 @@ export class FragmentWebApplication {
     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 => {
+    classes.forEach((metadata) => {
       if (this.shouldRegister(metadata.target)) {
         const instance = this.container.resolve(metadata.target);
         console.log(` ✓ Initialized: ${metadata.target.name}`);
@@ -205,9 +221,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`);
+      console.log(
+        ` 🚫 Conditional check failed for ${target.name}: Class not available`,
+      );
       return false;
     }
 
@@ -215,9 +233,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`);
+      console.log(
+        ` 🚫 Conditional check failed for ${target.name}: Bean already exists`,
+      );
       return false;
     }
 
@@ -225,17 +245,21 @@ export class FragmentWebApplication {
       METADATA_KEYS.CONDITIONAL_ON_PROPERTY,
       target,
     );
-    
+
     if (conditionalProperty) {
       const value = process.env[conditionalProperty.key];
-      
+
       if (conditionalProperty.expectedValue !== undefined) {
         if (value !== conditionalProperty.expectedValue) {
-          console.log(` 🚫 Conditional check failed for ${target.name}: Expected ${conditionalProperty.expectedValue}, got ${value}`);
+          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`);
+        console.log(
+          ` 🚫 Conditional check failed for ${target.name}: Property not set`,
+        );
         return false;
       }
     }
@@ -255,73 +279,203 @@ export class FragmentWebApplication {
     const controllers = this.metadataStorage
       .getAllClasses()
       .filter((c) => c.type === "controller");
-      
+
     if (controllers.length === 0) {
       console.log("\n🛣️ No routes to register");
       return;
     }
-    
+
     let totalRoutes = 0;
     console.log(`\n🛣️ Registering routes...`);
-    
+
     controllers.forEach((controllerMetadata) => {
       try {
         console.log(`\n📍 Controller: ${controllerMetadata.target.name}`);
-        console.log(`  Base path: ${controllerMetadata.path || '/'}`);
-        
+        console.log(`  Base path: ${controllerMetadata.path || "/"}`);
+
         const controller = this.container.resolve(controllerMetadata.target);
         const basePath = controllerMetadata.path || "";
-        
+
+        // Get controller-level enhancements
+        const controllerMiddlewares = (Reflect.getMetadata(
+          METADATA_KEYS.USE_MIDDLEWARE,
+          controllerMetadata.target,
+        ) || []) as MiddlewareClass[];
+
+        const controllerGuards = (Reflect.getMetadata(
+          METADATA_KEYS.USE_GUARDS,
+          controllerMetadata.target,
+        ) || []) as GuardClass[];
+
+        const controllerInterceptors = (Reflect.getMetadata(
+          METADATA_KEYS.USE_INTERCEPTORS,
+          controllerMetadata.target,
+        ) || []) as InterceptorClass[];
+
+        const controllerFilters = (Reflect.getMetadata(
+          METADATA_KEYS.USE_FILTERS,
+          controllerMetadata.target,
+        ) || []) as ExceptionFilterClass[];
+
         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}`,
           );
-          
+
           totalRoutes++;
-          
+
+          // Collect method-level enhancements
+          const methodMiddlewares = (Reflect.getMetadata(
+            METADATA_KEYS.USE_MIDDLEWARE,
+            controllerMetadata.target.prototype,
+            methodMetadata.propertyKey,
+          ) || []) as MiddlewareClass[];
+
+          const methodGuards = (Reflect.getMetadata(
+            METADATA_KEYS.USE_GUARDS,
+            controllerMetadata.target.prototype,
+            methodMetadata.propertyKey,
+          ) || []) as GuardClass[];
+
+          const methodInterceptors = (Reflect.getMetadata(
+            METADATA_KEYS.USE_INTERCEPTORS,
+            controllerMetadata.target.prototype,
+            methodMetadata.propertyKey,
+          ) || []) as InterceptorClass[];
+
+          const methodFilters = (Reflect.getMetadata(
+            METADATA_KEYS.USE_FILTERS,
+            controllerMetadata.target.prototype,
+            methodMetadata.propertyKey,
+          ) || []) as ExceptionFilterClass[];
+
+          // Combine: controller + method
+          const allMiddlewares = [
+            ...controllerMiddlewares,
+            ...methodMiddlewares,
+          ];
+          const allGuards = [...controllerGuards, ...methodGuards];
+          const allInterceptors = [
+            ...controllerInterceptors,
+            ...methodInterceptors,
+          ];
+          const allFilters = [...controllerFilters, ...methodFilters];
+
+          // Resolve via DI container
+          const resolvedMiddlewares = allMiddlewares.map(
+            (M) => this.container.resolve(M) as Middleware,
+          );
+          const resolvedGuards = allGuards.map(
+            (G) => this.container.resolve(G) as Guard,
+          );
+          const resolvedInterceptors = allInterceptors.map(
+            (I) => this.container.resolve(I) as Interceptor,
+          );
+
+          // Build Express route handler with pipeline
           (this.app as any)[httpMethod](
             fullPath,
+            // Middleware stack (Express-compatible)
+            ...resolvedMiddlewares.map(
+              (mw) => (req: Request, res: Response, next: NextFunction) =>
+                Promise.resolve(mw.use(req, res, next)).catch(next),
+            ),
+            // Final unified handler
             async (req: Request, res: Response, next: NextFunction) => {
               try {
+                // ➤ Step 1: Guards
+                for (const guard of resolvedGuards) {
+                  const canActivate = await Promise.resolve(
+                    guard.canActivate(req),
+                  );
+                  if (!canActivate) {
+                    const error = new Error("Forbidden");
+                    (error as any).status = 403;
+                    throw error;
+                  }
+                }
+
+                // ➤ Step 2: Resolve parameters
                 const args = this.resolveMethodParameters(
                   methodMetadata,
                   req,
                   res,
                 );
-                
-                console.log(`\n🔍 Handling ${httpMethod.toUpperCase()} ${fullPath}`);
-                // console.log(`  Parameters:`, args);
-                
-                const result = await (controller as any)[
-                  methodMetadata.propertyKey
-                ](...args);
-                
+
+                console.log(
+                  `\n🔍 Handling ${httpMethod.toUpperCase()} ${fullPath}`,
+                );
+
+                // ➤ Step 3: Interceptors (wrap handler)
+                let result: any;
+                if (resolvedInterceptors.length > 0) {
+                  // First, call the real handler
+                  const rawResult = await (controller as any)[
+                    methodMetadata.propertyKey
+                  ](...args);
+
+                  // Then pass result through interceptors in reverse order (or forward — your choice)
+                  result = rawResult;
+                  for (const interceptor of resolvedInterceptors) {
+                    // Allow interceptor to transform the result
+                    result = await Promise.resolve(
+                      interceptor.intercept(req, res, result),
+                    );
+                  }
+                } else {
+                  result = await (controller as any)[
+                    methodMetadata.propertyKey
+                  ](...args);
+                }
+
+                // ➤ Step 4: Send response
                 if (!res.headersSent) {
                   res.json(result);
                 }
               } catch (error) {
-                console.error(`❌ Error handling route ${fullPath}:`, error);
-                next(error);
+                // ➤ Step 5: Exception Filters (method + controller level)
+                let handled = false;
+                for (const FilterClass of allFilters) {
+                  const filter = this.container.resolve(
+                    FilterClass,
+                  ) as ExceptionFilter;
+                  try {
+                    const err =
+                      error instanceof Error ? error : new Error(String(error));
+                    filter.catch(err, req, res);
+                    handled = true;
+                    break;
+                  } catch (e) {
+                    console.error(`❌ Exception filter failed:`, e);
+                  }
+                }
+
+                if (!handled) {
+                  next(error);
+                }
               }
             },
           );
         });
       } catch (error) {
-        console.error(`❌ Failed to register controller ${controllerMetadata.target.name}:`, error);
+        console.error(
+          `❌ Failed to register controller ${controllerMetadata.target.name}:`,
+          error,
+        );
       }
     });
 
@@ -358,7 +512,7 @@ export class FragmentWebApplication {
     const params = [...methodMetadata.paramMetadata].sort(
       (a: any, b: any) => a.index - b.index,
     );
-    
+
     return params.map((param: any) => {
       switch (param.type) {
         case "body":
@@ -402,4 +556,4 @@ export class FragmentWebApplication {
   getExpressApp(): Express {
     return this.app;
   }
-}
+}

package/src/web/interfaces.ts

@@ -1,4 +1,4 @@
-import { Request, Response, NextFunction } from 'express';
+import { Request, Response, NextFunction } from "express";
 
 export interface Middleware {
   use(req: Request, res: Response, next: NextFunction): void | Promise<void>;
@@ -9,9 +9,18 @@ export interface Guard {
 }
 
 export interface Interceptor {
-  intercept(req: Request, res: Response, next: NextFunction): void | Promise<void>;
+  intercept(
+    req: Request,
+    res: Response,
+    next: NextFunction,
+  ): void | Promise<void>;
 }
 
 export interface ExceptionFilter {
   catch(exception: Error, req: Request, res: Response): void;
 }
+
+export type MiddlewareClass = new () => Middleware;
+export type GuardClass = new () => Guard;
+export type InterceptorClass = new () => Interceptor;
+export type ExceptionFilterClass = new () => ExceptionFilter;