fragment-ts 1.0.21 → 1.0.23

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

@@ -1,4 +1,5 @@
 import { METADATA_KEYS } from "../metadata/metadata-keys";
+import { MetadataStorage } from "../metadata/metadata-storage";
 
 export interface ApplicationOptions {
   port?: number;
@@ -8,19 +9,28 @@ export interface ApplicationOptions {
 }
 
 export function FragmentApplication(
-  options: ApplicationOptions = {},
+  options: {
+    port?: number;
+    host?: string;
+    configPath?: string;
+    autoScan?: boolean;
+  } = {},
 ): ClassDecorator {
   return (target: any) => {
     Reflect.defineMetadata(
       METADATA_KEYS.APPLICATION,
       {
-        ...options,
         port: options.port || 3000,
         host: options.host || "0.0.0.0",
         configPath: options.configPath || "fragment.json",
-        autoScan: options.autoScan || true,
+        autoScan: options.autoScan ?? true,
       },
       target,
     );
+    MetadataStorage.getInstance().addClass({
+      target,
+      type: "injectable",
+      scope: "singleton",
+    });
   };
 }

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

@@ -1,17 +1,15 @@
-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);
+    Injectable("singleton")(target);
     Reflect.defineMetadata(METADATA_KEYS.AUTO_CONFIGURATION, true, target);
-    
-    const storage = MetadataStorage.getInstance();
-    storage.addClass({
+    MetadataStorage.getInstance().addClass({
       target,
-      type: 'auto-configuration',
-      scope: 'singleton'
+      type: "auto-configuration",
+      scope: "singleton",
     });
   };
-}
+}

package/src/core/decorators/conditional.decorators.ts

@@ -1,19 +1,55 @@
-import { METADATA_KEYS } from '../metadata/metadata-keys';
+import { METADATA_KEYS } from "../metadata/metadata-keys";
+import { MetadataStorage } from "../metadata/metadata-storage";
+
+/**
+ * Conditional decorators
+ * Ensures the class is registered in MetadataStorage
+ */
 
 export function ConditionalOnClass(classRef: any): ClassDecorator {
   return (target: any) => {
     Reflect.defineMetadata(METADATA_KEYS.CONDITIONAL_ON_CLASS, classRef, target);
+
+    // Register in MetadataStorage if not already
+    const storage = MetadataStorage.getInstance();
+    if (!storage.getClass(target)) {
+      storage.addClass({
+        target,
+        type: 'injectable', // default type
+        scope: 'singleton',
+      });
+    }
   };
 }
 
 export function ConditionalOnMissingBean(token: any): ClassDecorator {
   return (target: any) => {
     Reflect.defineMetadata(METADATA_KEYS.CONDITIONAL_ON_MISSING_BEAN, token, target);
+
+    // Register in MetadataStorage if not already
+    const storage = MetadataStorage.getInstance();
+    if (!storage.getClass(target)) {
+      storage.addClass({
+        target,
+        type: 'injectable',
+        scope: 'singleton',
+      });
+    }
   };
 }
 
 export function ConditionalOnProperty(key: string, expectedValue?: any): ClassDecorator {
   return (target: any) => {
     Reflect.defineMetadata(METADATA_KEYS.CONDITIONAL_ON_PROPERTY, { key, expectedValue }, target);
+
+    // Register in MetadataStorage if not already
+    const storage = MetadataStorage.getInstance();
+    if (!storage.getClass(target)) {
+      storage.addClass({
+        target,
+        type: 'injectable',
+        scope: 'singleton',
+      });
+    }
   };
 }

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

@@ -6,9 +6,7 @@ export function Controller(path: string = ""): ClassDecorator {
   return (target: any) => {
     Injectable("singleton")(target);
     Reflect.defineMetadata(METADATA_KEYS.CONTROLLER, path, target);
-
-    const storage = MetadataStorage.getInstance();
-    storage.addClass({
+    MetadataStorage.getInstance().addClass({
       target,
       type: "controller",
       scope: "singleton",

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

@@ -1,33 +1,20 @@
+import "reflect-metadata";
 import { METADATA_KEYS } from "../metadata/metadata-keys";
 import { MetadataStorage } from "../metadata/metadata-storage";
 
 function createHttpMethodDecorator(method: string) {
   return (path: string = ""): MethodDecorator => {
-    return (
-      target: any,
-      propertyKey: string | symbol,
-      descriptor: PropertyDescriptor,
-    ) => {
-      Reflect.defineMetadata(
-        METADATA_KEYS.HTTP_METHOD,
-        method,
-        target,
-        propertyKey,
-      );
-      Reflect.defineMetadata(
-        METADATA_KEYS.ROUTE_PATH,
-        path,
-        target,
-        propertyKey,
-      );
+    return (target: any, propertyKey: string | symbol) => {
+      Reflect.defineMetadata(METADATA_KEYS.HTTP_METHOD, method, target, propertyKey);
+      Reflect.defineMetadata(METADATA_KEYS.ROUTE_PATH, path, target, propertyKey);
 
       const storage = MetadataStorage.getInstance();
       storage.addMethod({
         target: target.constructor,
-        propertyKey: propertyKey as string,
+        propertyKey: propertyKey.toString(),
         method,
         path,
-        paramMetadata: storage.getParams(target, propertyKey as string),
+        paramMetadata: storage.getParams(target, propertyKey.toString()),
       });
     };
   };
@@ -39,23 +26,15 @@ export const Put = createHttpMethodDecorator("PUT");
 export const Delete = createHttpMethodDecorator("DELETE");
 export const Patch = createHttpMethodDecorator("PATCH");
 
+// Parameter decorators
 function createParamDecorator(type: string) {
   return (paramName?: string): ParameterDecorator => {
-    return (
-      target: Object,
-      propertyKey: string | symbol | undefined,
-      parameterIndex: number,
-    ): void => {
-      if (!propertyKey) {
-        throw new Error(`@${type}() cannot be used on constructor parameters`);
-      }
-
-      const storage = MetadataStorage.getInstance();
-
-      storage.addParam({
+    return (target, propertyKey, index) => {
+      if (!propertyKey) throw new Error(`@${type} cannot be used on constructor params`);
+      MetadataStorage.getInstance().addParam({
         target,
         propertyKey: propertyKey.toString(),
-        index: parameterIndex,
+        index,
         type: type as any,
         paramName,
       });

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

@@ -1,18 +1,25 @@
-import { METADATA_KEYS } from '../metadata/metadata-keys';
-import { MetadataStorage } from '../metadata/metadata-storage';
+import { METADATA_KEYS } from "../metadata/metadata-keys";
+import { MetadataStorage } from "../metadata/metadata-storage";
 
 export type Scope = 'singleton' | 'request' | 'transient';
 
+/**
+ * @Injectable - Marks a class as injectable with a scope
+ */
 export function Injectable(scope: Scope = 'singleton'): ClassDecorator {
   return (target: any) => {
+    // Define Reflect metadata
     Reflect.defineMetadata(METADATA_KEYS.INJECTABLE, true, target);
     Reflect.defineMetadata(METADATA_KEYS.SCOPE, scope, target);
-    
+
+    // Register in MetadataStorage if not already
     const storage = MetadataStorage.getInstance();
-    storage.addClass({
-      target,
-      type: 'injectable',
-      scope
-    });
+    if (!storage.getClass(target)) {
+      storage.addClass({
+        target,
+        type: 'injectable',
+        scope
+      });
+    }
   };
 }

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

@@ -1,150 +1,97 @@
+import "reflect-metadata";
 import { METADATA_KEYS } from "../metadata/metadata-keys";
+import { MetadataStorage } from "../metadata/metadata-storage";
 
-/**
- * @Autowired - Automatically inject dependencies by type
- * Usage: @Autowired() private myService: MyService;
- */
 export function Autowired(): PropertyDecorator {
-  return (target: any, propertyKey: string | symbol) => {
-    // Get the design type from TypeScript metadata
+  return (target, propertyKey) => {
     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.`,
-      );
-    }
-
-    // Store the type in metadata so DI container can resolve it
+    if (!type)
+      throw new Error(`Cannot use @Autowired on ${String(propertyKey)}`);
     Reflect.defineMetadata(METADATA_KEYS.AUTOWIRED, type, target, propertyKey);
+
+    MetadataStorage.getInstance().addParam({
+      target,
+      propertyKey: propertyKey.toString(),
+      index: -1,
+      type: "autowired",
+    });
   };
 }
 
-/**
- * @Inject - Inject dependency by token (string or class)
- * Usage: @Inject('MyService') private service: MyService;
- * or: @Inject(MyService) private service: MyService;
- */
 export function Inject(token: string | Function): PropertyDecorator {
-  return (target: any, propertyKey: string | symbol) => {
+  return (target, propertyKey) => {
     Reflect.defineMetadata(METADATA_KEYS.INJECT, token, target, propertyKey);
+    MetadataStorage.getInstance().addParam({
+      target,
+      propertyKey: propertyKey.toString(),
+      index: -1,
+      type: "inject",
+      paramName: typeof token === "string" ? token : undefined,
+    });
   };
 }
 
-/**
- * @InjectRepository - Inject TypeORM repository for an entity
- * Usage: @InjectRepository(User) private userRepo: Repository<User>;
- */
 export function InjectRepository(entity: Function): PropertyDecorator {
-  return (target: any, propertyKey: string | symbol) => {
+  return (target, propertyKey) => {
     Reflect.defineMetadata(
       METADATA_KEYS.INJECT_REPOSITORY,
       entity,
       target,
       propertyKey,
     );
+    MetadataStorage.getInstance().addParam({
+      target,
+      propertyKey: propertyKey.toString(),
+      index: -1,
+      type: "inject-repo",
+    });
   };
 }
 
-/**
- * @Qualifier - Specify which bean to inject when multiple exist
- * Usage: @Qualifier('primary') @Autowired() private service: MyService;
- */
-export function Qualifier(name: string): PropertyDecorator {
-  return (target: any, propertyKey: string | symbol) => {
-    Reflect.defineMetadata(METADATA_KEYS.QUALIFIER, name, target, propertyKey);
-  };
-}
-
-/**
- * @Value - Inject configuration value from environment or config
- * Usage: @Value('${PORT}') private port: number;
- * or: @Value('${DB_HOST:localhost}') private host: string;
- */
 export function Value(expression: string): PropertyDecorator {
-  return (target: any, propertyKey: string | symbol) => {
+  return (target, propertyKey) => {
     Reflect.defineMetadata(
       METADATA_KEYS.VALUE,
       expression,
       target,
       propertyKey,
     );
+    MetadataStorage.getInstance().addParam({
+      target,
+      propertyKey: propertyKey.toString(),
+      index: -1,
+      type: "value",
+    });
   };
 }
 
 /**
- * @Optional - Mark dependency as optional (won't throw if not found)
- * Usage: @Optional() @Autowired() private service?: MyService;
- */
-export function Optional(): PropertyDecorator {
-  return (target: any, propertyKey: string | symbol) => {
-    Reflect.defineMetadata(METADATA_KEYS.OPTIONAL, true, target, propertyKey);
-  };
-}
-
-/**
- * @Lazy - Lazy load dependency (create on first access)
- * Usage: @Lazy() @Autowired() private service: MyService;
+ * @Qualifier - Specify which bean to inject when multiple exist
+ * Usage: @Qualifier('primary') @Autowired() private service: MyService;
  */
-export function Lazy(): PropertyDecorator {
+export function Qualifier(name: string): PropertyDecorator {
   return (target: any, propertyKey: string | symbol) => {
-    Reflect.defineMetadata(METADATA_KEYS.LAZY, true, target, propertyKey);
-
-    const type = Reflect.getMetadata("design:type", target, propertyKey);
+    if (!propertyKey) return;
 
-    // Create a getter that resolves on first access
-    let cached: any = null;
-    let resolved = false;
+    Reflect.defineMetadata(METADATA_KEYS.QUALIFIER, name, target, propertyKey);
 
-    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,
+    MetadataStorage.getInstance().addParam({
+      target,
+      propertyKey: propertyKey.toString(),
+      index: -1,
+      type: "qualifier",
     });
   };
 }
 
-/**
- * @PostConstruct - Method called after dependency injection is complete
- * Usage: @PostConstruct() init() { ... }
- */
-export function PostConstruct(): MethodDecorator {
-  return (
-    target: any,
-    propertyKey: string | symbol,
-    descriptor: PropertyDescriptor,
-  ) => {
-    Reflect.defineMetadata(
-      METADATA_KEYS.POST_CONSTRUCT,
-      propertyKey,
-      target.constructor,
-    );
+export function Optional(): PropertyDecorator {
+  return (target, propertyKey) => {
+    Reflect.defineMetadata(METADATA_KEYS.OPTIONAL, true, target, propertyKey);
   };
 }
 
-/**
- * @PreDestroy - Method called before bean is destroyed
- * Usage: @PreDestroy() cleanup() { ... }
- */
-export function PreDestroy(): MethodDecorator {
-  return (
-    target: any,
-    propertyKey: string | symbol,
-    descriptor: PropertyDescriptor,
-  ) => {
-    Reflect.defineMetadata(
-      METADATA_KEYS.PRE_DESTROY,
-      propertyKey,
-      target.constructor,
-    );
+export function Lazy(): PropertyDecorator {
+  return (target, propertyKey) => {
+    Reflect.defineMetadata(METADATA_KEYS.LAZY, true, target, propertyKey);
   };
 }

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

@@ -1,17 +1,15 @@
-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 Repository(): ClassDecorator {
   return (target: any) => {
-    Injectable('singleton')(target);
+    Injectable("singleton")(target);
     Reflect.defineMetadata(METADATA_KEYS.REPOSITORY, true, target);
-    
-    const storage = MetadataStorage.getInstance();
-    storage.addClass({
+    MetadataStorage.getInstance().addClass({
       target,
-      type: 'repository',
-      scope: 'singleton'
+      type: "repository",
+      scope: "singleton",
     });
   };
-}
+}

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

@@ -1,17 +1,15 @@
-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 Service(): ClassDecorator {
   return (target: any) => {
-    Injectable('singleton')(target);
+    Injectable("singleton")(target);
     Reflect.defineMetadata(METADATA_KEYS.SERVICE, true, target);
-    
-    const storage = MetadataStorage.getInstance();
-    storage.addClass({
+    MetadataStorage.getInstance().addClass({
       target,
-      type: 'service',
-      scope: 'singleton'
+      type: "service",
+      scope: "singleton",
     });
   };
-}
+}

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

@@ -1,39 +1,21 @@
-import { METADATA_KEYS } from "./metadata-keys";
-
-export interface ClassMetadata {
-  target: any;
-  type:
-    | "injectable"
-    | "service"
-    | "controller"
-    | "repository"
-    | "auto-configuration";
-  scope?: "singleton" | "request" | "transient";
-  path?: string;
-}
-
-export interface MethodMetadata {
-  target: any;
-  propertyKey: string;
-  method: string;
-  path: string;
-  paramMetadata: ParamMetadata[];
-}
-
-export interface ParamMetadata {
-  target: any;
-  propertyKey: string;
-  index: number;
-  type: "body" | "param" | "query" | "header" | "req" | "res";
-  paramName?: string;
-}
-
+import {
+  ClassMetadata,
+  MethodMetadata,
+  ParamMetadata,
+} from "../types/decoration.types";
+
+/**
+ * Central storage for all metadata: classes, methods, parameters
+ */
 export class MetadataStorage {
   private static instance: MetadataStorage;
-  private classes: Map<any, ClassMetadata> = new Map();
+
+  // Maps for storing metadata
+  private classes: Map<Function, ClassMetadata> = new Map();
   private methods: Map<string, MethodMetadata> = new Map();
   private params: Map<string, ParamMetadata[]> = new Map();
 
+  // Singleton instance
   static getInstance(): MetadataStorage {
     if (!MetadataStorage.instance) {
       MetadataStorage.instance = new MetadataStorage();
@@ -41,11 +23,16 @@ export class MetadataStorage {
     return MetadataStorage.instance;
   }
 
+  // ----- Classes -----
   addClass(metadata: ClassMetadata): void {
-    this.classes.set(metadata.target, metadata);
+    if (!metadata?.target) return;
+    if (!this.classes.has(metadata.target)) {
+      this.classes.set(metadata.target, metadata);
+    }
   }
 
   getClass(target: any): ClassMetadata | undefined {
+    if (!target) return undefined;
     return this.classes.get(target);
   }
 
@@ -53,20 +40,35 @@ export class MetadataStorage {
     return Array.from(this.classes.values());
   }
 
+  hasClass(target: any): boolean {
+    return !!target && this.classes.has(target);
+  }
+
+  // ----- Methods -----
+  private getMethodKey(target: Function, propertyKey: string): string {
+    return `${target.name}_${propertyKey}`;
+  }
+
   addMethod(metadata: MethodMetadata): void {
-    const key = `${metadata.target.name}.${metadata.propertyKey}`;
+    if (!metadata?.target || !metadata.propertyKey) return;
+
+    const targetForKey = metadata.target.prototype || metadata.target;
+    const key = this.getMethodKey(metadata.target, metadata.propertyKey);
 
+    // Attach existing params for this method
     const existingParams = this.getParams(
-      metadata.target,
+      targetForKey,
       metadata.propertyKey,
-    );
-    metadata.paramMetadata = existingParams.sort((a, b) => a.index - b.index);
+    ).sort((a, b) => a.index - b.index);
+
+    metadata.paramMetadata = existingParams;
 
     this.methods.set(key, metadata);
   }
 
   getMethod(target: any, propertyKey: string): MethodMetadata | undefined {
-    const key = `${target.name}.${propertyKey}`;
+    if (!target || !propertyKey) return undefined;
+    const key = this.getMethodKey(target.constructor || target, propertyKey);
     return this.methods.get(key);
   }
 
@@ -74,18 +76,48 @@ export class MetadataStorage {
     return Array.from(this.methods.values());
   }
 
+  hasMethod(target: any, propertyKey: string): boolean {
+    if (!target || !propertyKey) return false;
+    const key = this.getMethodKey(target.constructor || target, propertyKey);
+    return this.methods.has(key);
+  }
+
+  // ----- Params -----
+  private getParamKey(target: any, propertyKey: string): string {
+    return `${target.constructor.name}_${propertyKey}`;
+  }
+
   addParam(metadata: ParamMetadata): void {
-    const key = `${metadata.target.constructor.name}.${metadata.propertyKey}`;
+    if (!metadata?.target || !metadata.propertyKey) return;
+
+    const key = this.getParamKey(metadata.target, metadata.propertyKey);
     const existing = this.params.get(key) || [];
-    existing.push(metadata);
+
+    // Deduplicate by propertyKey + index
+    if (
+      !existing.some(
+        (p) =>
+          p.index === metadata.index && p.propertyKey === metadata.propertyKey,
+      )
+    ) {
+      existing.push(metadata);
+    }
+
     this.params.set(key, existing);
   }
 
   getParams(target: any, propertyKey: string): ParamMetadata[] {
-    const targetName = target.name || target.constructor?.name;
-    if (!targetName) return [];
-
-    const key = `${targetName}.${propertyKey}`;
+    if (!target || !propertyKey) return [];
+    const key = this.getParamKey(target, propertyKey);
     return this.params.get(key) || [];
   }
+
+  hasParam(target: any, propertyKey: string, index?: number): boolean {
+    if (!target || !propertyKey) return false;
+    const key = this.getParamKey(target, propertyKey);
+    const existing = this.params.get(key) || [];
+    return index !== undefined
+      ? existing.some((p) => p.index === index)
+      : existing.length > 0;
+  }
 }