fragment-ts 1.0.23 → 1.0.25

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

@@ -1,97 +1,150 @@
-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, propertyKey) => {
+  return (target: any, propertyKey: string | symbol) => {
+    // Get the design type from TypeScript metadata
     const type = Reflect.getMetadata("design:type", target, propertyKey);
-    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",
-    });
+    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
+    Reflect.defineMetadata(METADATA_KEYS.AUTOWIRED, type, target, propertyKey);
   };
 }
 
+/**
+ * @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, propertyKey) => {
+  return (target: any, propertyKey: string | symbol) => {
     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, propertyKey) => {
+  return (target: any, propertyKey: string | symbol) => {
     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, propertyKey) => {
+  return (target: any, propertyKey: string | symbol) => {
     Reflect.defineMetadata(
       METADATA_KEYS.VALUE,
       expression,
       target,
       propertyKey,
     );
-    MetadataStorage.getInstance().addParam({
-      target,
-      propertyKey: propertyKey.toString(),
-      index: -1,
-      type: "value",
-    });
   };
 }
 
 /**
- * @Qualifier - Specify which bean to inject when multiple exist
- * Usage: @Qualifier('primary') @Autowired() private service: MyService;
+ * @Optional - Mark dependency as optional (won't throw if not found)
+ * Usage: @Optional() @Autowired() private service?: MyService;
  */
-export function Qualifier(name: string): PropertyDecorator {
+export function Optional(): PropertyDecorator {
   return (target: any, propertyKey: string | symbol) => {
-    if (!propertyKey) return;
+    Reflect.defineMetadata(METADATA_KEYS.OPTIONAL, true, target, propertyKey);
+  };
+}
 
-    Reflect.defineMetadata(METADATA_KEYS.QUALIFIER, name, target, propertyKey);
+/**
+ * @Lazy - Lazy load dependency (create on first access)
+ * Usage: @Lazy() @Autowired() private service: MyService;
+ */
+export function Lazy(): PropertyDecorator {
+  return (target: any, propertyKey: string | symbol) => {
+    Reflect.defineMetadata(METADATA_KEYS.LAZY, true, target, propertyKey);
 
-    MetadataStorage.getInstance().addParam({
-      target,
-      propertyKey: propertyKey.toString(),
-      index: -1,
-      type: "qualifier",
+    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,
     });
   };
 }
 
-export function Optional(): PropertyDecorator {
-  return (target, propertyKey) => {
-    Reflect.defineMetadata(METADATA_KEYS.OPTIONAL, true, target, propertyKey);
+/**
+ * @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 Lazy(): PropertyDecorator {
-  return (target, propertyKey) => {
-    Reflect.defineMetadata(METADATA_KEYS.LAZY, 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,
+    );
   };
 }

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

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) || [];
   }
 }

package/src/web/application.ts

@@ -20,7 +20,7 @@ export class FragmentWebApplication {
     this.container = DIContainer.getInstance();
     this.metadataStorage = MetadataStorage.getInstance();
     this.setupMiddleware();
-    this
+    this;
   }
 
   private setupMiddleware(): void {
@@ -122,7 +122,9 @@ export class FragmentWebApplication {
   private discoverAndRegisterComponents(): void {
     const classes = this.metadataStorage.getAllClasses();
 
-    // Group by type
+    console.log(`\n📦 Discovered ${classes.length} component(s)`);
+
+    // Group by type for display
     const grouped = classes.reduce(
       (acc, cls) => {
         if (!acc[cls.type]) acc[cls.type] = [];
@@ -132,29 +134,37 @@ export class FragmentWebApplication {
       {} as Record<string, any[]>,
     );
 
-    const total = classes.length;
-    const registered = classes.filter((m) =>
-      this.shouldRegister(m.target),
-    ).length;
-
-    console.log(`\n📦 Discovered ${total} component(s)`);
-
     Object.entries(grouped).forEach(([type, items]) => {
       const icon = this.getTypeIcon(type);
       console.log(`   ${icon} ${items.length} ${type}(s)`);
     });
 
-    let count = 0;
+    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);
-          count++;
+          registered++;
+          console.log(`   ✓ Registered: ${metadata.target.name}`);
         }
+      } else {
+        skipped++;
+        console.log(
+          `   ⊘ Skipped: ${metadata.target.name} (conditional check failed)`,
+        );
       }
     });
 
-    console.log(`   ✓ Registered ${count}/${total} component(s)\n`);
+    console.log(
+      `\n   ✓ Registered ${registered}/${classes.length} component(s)`,
+    );
+    if (skipped > 0) {
+      console.log(`   ⊘ Skipped ${skipped} (conditions not met)`);
+    }
+    console.log("");
   }
 
   private getTypeIcon(type: string): string {