fragment-ts 1.0.23 → 1.0.24

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

@@ -1,15 +1,17 @@
-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);
-    MetadataStorage.getInstance().addClass({
+    
+    const storage = MetadataStorage.getInstance();
+    storage.addClass({
       target,
-      type: "service",
-      scope: "singleton",
+      type: 'service',
+      scope: 'singleton'
     });
   };
-}
+}

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

@@ -1,21 +1,39 @@
-import {
-  ClassMetadata,
-  MethodMetadata,
-  ParamMetadata,
-} from "../types/decoration.types";
-
-/**
- * Central storage for all metadata: classes, methods, parameters
- */
+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;
+}
+
 export class MetadataStorage {
   private static instance: MetadataStorage;
-
-  // Maps for storing metadata
-  private classes: Map<Function, ClassMetadata> = new Map();
+  private classes: Map<any, 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();
@@ -23,16 +41,11 @@ export class MetadataStorage {
     return MetadataStorage.instance;
   }
 
-  // ----- Classes -----
   addClass(metadata: ClassMetadata): void {
-    if (!metadata?.target) return;
-    if (!this.classes.has(metadata.target)) {
-      this.classes.set(metadata.target, metadata);
-    }
+    this.classes.set(metadata.target, metadata);
   }
 
   getClass(target: any): ClassMetadata | undefined {
-    if (!target) return undefined;
     return this.classes.get(target);
   }
 
@@ -40,35 +53,20 @@ 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 {
-    if (!metadata?.target || !metadata.propertyKey) return;
-
-    const targetForKey = metadata.target.prototype || metadata.target;
-    const key = this.getMethodKey(metadata.target, metadata.propertyKey);
+    const key = `${metadata.target.name}.${metadata.propertyKey}`;
 
-    // Attach existing params for this method
     const existingParams = this.getParams(
-      targetForKey,
+      metadata.target,
       metadata.propertyKey,
-    ).sort((a, b) => a.index - b.index);
-
-    metadata.paramMetadata = existingParams;
+    );
+    metadata.paramMetadata = existingParams.sort((a, b) => a.index - b.index);
 
     this.methods.set(key, metadata);
   }
 
   getMethod(target: any, propertyKey: string): MethodMetadata | undefined {
-    if (!target || !propertyKey) return undefined;
-    const key = this.getMethodKey(target.constructor || target, propertyKey);
+    const key = `${target.name}.${propertyKey}`;
     return this.methods.get(key);
   }
 
@@ -76,48 +74,18 @@ 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 {
-    if (!metadata?.target || !metadata.propertyKey) return;
-
-    const key = this.getParamKey(metadata.target, metadata.propertyKey);
+    const key = `${metadata.target.constructor.name}.${metadata.propertyKey}`;
     const existing = this.params.get(key) || [];
-
-    // Deduplicate by propertyKey + index
-    if (
-      !existing.some(
-        (p) =>
-          p.index === metadata.index && p.propertyKey === metadata.propertyKey,
-      )
-    ) {
-      existing.push(metadata);
-    }
-
+    existing.push(metadata);
     this.params.set(key, existing);
   }
 
   getParams(target: any, propertyKey: string): ParamMetadata[] {
-    if (!target || !propertyKey) return [];
-    const key = this.getParamKey(target, propertyKey);
-    return this.params.get(key) || [];
-  }
+    const targetName = target.name || target.constructor?.name;
+    if (!targetName) return [];
 
-  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;
+    const key = `${targetName}.${propertyKey}`;
+    return this.params.get(key) || [];
   }
 }