fragment-ts 1.0.29 → 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,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,24 @@ 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 },
     });
 
     // 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 +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);
   };
 }
@@ -43,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,
@@ -69,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,
@@ -94,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)
   };
 }
 
@@ -128,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,
@@ -146,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,19 +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,
-    {
-      type: string;
-      key: string;
-      metadata?: any;
-    }[]
-  > = new Map();
+  private propertyInjections: Map<string, PropertyInjectionMetadata[]> =
+    new Map();
 
   static getInstance(): MetadataStorage {
     if (!MetadataStorage.instance) {
@@ -49,35 +49,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 +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;
+  }
 }