fragment-ts 1.0.23 → 1.0.25

package/src/cli/commands/init.command.ts

@@ -173,7 +173,7 @@ export class InitCommand {
         "migrate:revert": "fragment migrate:revert",
       },
       dependencies: {
-        "fragment-ts": "^1.0.23",
+        "fragment-ts": "^1.0.25",
         "reflect-metadata": "^0.1.13",
       },
       devDependencies: {

package/src/core/container/di-container.ts

@@ -6,7 +6,8 @@ export class DIContainer {
   private singletons: Map<any, any> = new Map();
   private transients: Map<any, any> = new Map();
   private factories: Map<any, () => any> = new Map();
-  private constructing: Set<any> = new Set(); // Prevent circular dependencies
+  private constructing: Set<any> = new Set();
+  private registered: Set<any> = new Set(); // Track what's actually injectable
 
   static getInstance(): DIContainer {
     if (!DIContainer.instance) {
@@ -16,27 +17,36 @@ export class DIContainer {
   }
 
   register(token: any, instance?: any, factory?: () => any): void {
+    // Mark this token as registered
+    this.registered.add(token);
+
     if (instance) {
       this.singletons.set(token, instance);
     } else if (factory) {
       this.factories.set(token, factory);
     }
+    // If neither instance nor factory, it will be created on-demand
   }
 
   resolve<T>(token: any): T {
-    // Check for circular dependency
+    // Check if this is actually an injectable class
+    if (typeof token === "function" && !this.registered.has(token)) {
+      throw new Error(
+        `Cannot resolve ${token.name}: Not registered as injectable. ` +
+          `Did you forget to add @Injectable(), @Service(), @Controller(), or @Repository()?`,
+      );
+    }
+
     if (this.constructing.has(token)) {
       throw new Error(
         `Circular dependency detected for ${token.name || token}`,
       );
     }
 
-    // Return existing singleton
     if (this.singletons.has(token)) {
       return this.singletons.get(token);
     }
 
-    // Use factory if available
     if (this.factories.has(token)) {
       const factory = this.factories.get(token)!;
       const instance = factory();
@@ -50,7 +60,6 @@ export class DIContainer {
       return instance;
     }
 
-    // Create new instance
     if (typeof token === "function") {
       this.constructing.add(token);
 
@@ -75,103 +84,211 @@ export class DIContainer {
   }
 
   private createInstance(target: any): any {
-    // Get constructor parameter types
+    console.log(`   🔨 Creating instance of ${target.name}`);
+
     const paramTypes = Reflect.getMetadata("design:paramtypes", target) || [];
 
-    // Resolve constructor dependencies
-    const params = paramTypes.map((type: any) => {
+    const params = paramTypes.map((type: any, index: number) => {
       if (!type || type === Object) {
+        console.warn(
+          `   ⚠️  Constructor param ${index} of ${target.name} has no type metadata`,
+        );
         return undefined;
       }
+      console.log(`   📦 Resolving constructor dependency: ${type.name}`);
       return this.resolve(type);
     });
 
-    // Create instance
     const instance = new target(...params);
 
-    // Inject properties AFTER construction
+    // Inject properties
     this.injectProperties(instance);
 
-    // Call post-construct hook if it exists
-    if (typeof instance.onInit === "function") {
-      instance.onInit();
+    // Call post-construct
+    const postConstructMethod = Reflect.getMetadata(
+      METADATA_KEYS.POST_CONSTRUCT,
+      target,
+    );
+    if (
+      postConstructMethod &&
+      typeof instance[postConstructMethod] === "function"
+    ) {
+      console.log(
+        `   🎯 Calling @PostConstruct: ${target.name}.${postConstructMethod}()`,
+      );
+      instance[postConstructMethod]();
     }
 
     return instance;
   }
 
   private injectProperties(instance: any): void {
-    const prototype = Object.getPrototypeOf(instance);
+    const target = instance.constructor;
+    let currentProto = target.prototype;
+
+    // Walk the prototype chain
+    while (currentProto && currentProto !== Object.prototype) {
+      // Get all property names including inherited ones
+      const propertyNames = Object.getOwnPropertyNames(currentProto);
+
+      for (const prop of propertyNames) {
+        // Skip constructor
+        if (prop === "constructor") continue;
+
+        // Check @Autowired - stores the TYPE to inject
+        const autowiredType = Reflect.getMetadata(
+          METADATA_KEYS.AUTOWIRED,
+          currentProto,
+          prop,
+        );
 
-    // Get all property keys from the prototype chain
-    const properties = this.getAllPropertyKeys(instance);
+        if (autowiredType) {
+          console.log(
+            `   💉 @Autowired: ${target.name}.${prop} = ${autowiredType.name}`,
+          );
+
+          const isOptional = Reflect.getMetadata(
+            METADATA_KEYS.OPTIONAL,
+            currentProto,
+            prop,
+          );
+
+          try {
+            instance[prop] = this.resolve(autowiredType);
+          } catch (error) {
+            if (!isOptional) {
+              throw new Error(
+                `Failed to autowire ${autowiredType.name} into ${target.name}.${prop}: ${error}`,
+              );
+            }
+            console.warn(
+              `   ⚠️  Optional autowired dependency ${autowiredType.name} not available`,
+            );
+            instance[prop] = undefined;
+          }
+          continue;
+        }
 
-    properties.forEach((prop) => {
-      // Check for @Autowired
-      const autowired = Reflect.getMetadata(
-        METADATA_KEYS.AUTOWIRED,
-        prototype,
-        prop,
-      );
-      if (autowired) {
-        instance[prop] = this.resolve(autowired);
-        return;
-      }
+        // Check @Inject - stores the TOKEN to inject
+        const injectToken = Reflect.getMetadata(
+          METADATA_KEYS.INJECT,
+          currentProto,
+          prop,
+        );
 
-      // Check for @Inject
-      const inject = Reflect.getMetadata(METADATA_KEYS.INJECT, prototype, prop);
-      if (inject) {
-        instance[prop] = this.resolve(inject);
-        return;
-      }
+        if (injectToken) {
+          const tokenName =
+            typeof injectToken === "string" ? injectToken : injectToken.name;
+          console.log(`   💉 @Inject: ${target.name}.${prop} = ${tokenName}`);
+
+          const isOptional = Reflect.getMetadata(
+            METADATA_KEYS.OPTIONAL,
+            currentProto,
+            prop,
+          );
+
+          try {
+            instance[prop] = this.resolve(injectToken);
+          } catch (error) {
+            if (!isOptional) {
+              throw new Error(
+                `Failed to inject ${tokenName} into ${target.name}.${prop}: ${error}`,
+              );
+            }
+            console.warn(
+              `   ⚠️  Optional inject dependency ${tokenName} not available`,
+            );
+            instance[prop] = undefined;
+          }
+          continue;
+        }
 
-      // Check for @Value
-      const value = Reflect.getMetadata(METADATA_KEYS.VALUE, prototype, prop);
-      if (value !== undefined) {
-        instance[prop] = this.resolveValue(value);
-        return;
-      }
+        // Check @Value
+        const valueExpression = Reflect.getMetadata(
+          METADATA_KEYS.VALUE,
+          currentProto,
+          prop,
+        );
 
-      // Check for @InjectRepository - special TypeORM handling
-      const repositoryEntity = Reflect.getMetadata(
-        METADATA_KEYS.INJECT_REPOSITORY,
-        prototype,
-        prop,
-      );
-      if (repositoryEntity) {
-        instance[prop] = this.resolveRepository(repositoryEntity);
-        return;
-      }
-    });
-  }
+        if (valueExpression !== undefined) {
+          console.log(
+            `   🔧 @Value: ${target.name}.${prop} = ${valueExpression}`,
+          );
+          instance[prop] = this.resolveValue(valueExpression);
+          continue;
+        }
 
-  private getAllPropertyKeys(obj: any): string[] {
-    const keys = new Set<string>();
-    let current = obj;
+        // Check @InjectRepository
+        const repositoryEntity = Reflect.getMetadata(
+          METADATA_KEYS.INJECT_REPOSITORY,
+          currentProto,
+          prop,
+        );
 
-    while (current && current !== Object.prototype) {
-      Object.getOwnPropertyNames(current).forEach((key) => keys.add(key));
-      current = Object.getPrototypeOf(current);
-    }
+        if (repositoryEntity) {
+          console.log(
+            `   💾 @InjectRepository: ${target.name}.${prop} = Repository<${repositoryEntity.name}>`,
+          );
+          instance[prop] = this.resolveRepository(repositoryEntity);
+          continue;
+        }
+
+        // Check @Lazy
+        const isLazy = Reflect.getMetadata(
+          METADATA_KEYS.LAZY,
+          currentProto,
+          prop,
+        );
+
+        if (isLazy) {
+          const type = Reflect.getMetadata("design:type", currentProto, prop);
+          console.log(
+            `   ⏳ @Lazy: ${target.name}.${prop} (will resolve on access)`,
+          );
+
+          let cached: any = null;
+          let resolved = false;
+
+          Object.defineProperty(instance, prop, {
+            get: () => {
+              if (!resolved) {
+                console.log(
+                  `   🔓 Lazy-loading ${type.name} for ${target.name}.${prop}`,
+                );
+                cached = this.resolve(type);
+                resolved = true;
+              }
+              return cached;
+            },
+            enumerable: true,
+            configurable: true,
+          });
+          continue;
+        }
+      }
 
-    return Array.from(keys);
+      currentProto = Object.getPrototypeOf(currentProto);
+    }
   }
 
   private resolveValue(expression: string): any {
-    // Handle environment variable syntax: ${VAR_NAME} or $VAR_NAME
-    const match = expression.match(/\$\{([^}]+)\}|\$([A-Z_][A-Z0-9_]*)/i);
+    const match = expression.match(
+      /\$\{([^:}]+)(?::([^}]*))?\}|\$([A-Z_][A-Z0-9_]*)/i,
+    );
     if (match) {
-      const key = match[1] || match[2];
+      const key = match[1] || match[3];
+      const defaultValue = match[2];
       const value = process.env[key];
 
       if (value === undefined) {
-        console.warn(
-          `⚠️  Warning: Environment variable "${key}" is not defined`,
-        );
+        if (defaultValue !== undefined) {
+          return defaultValue;
+        }
+        console.warn(`⚠️  Environment variable "${key}" not defined`);
         return "";
       }
 
-      // Try to parse as JSON for complex types
+      // Parse JSON
       if (value.startsWith("{") || value.startsWith("[")) {
         try {
           return JSON.parse(value);
@@ -181,8 +298,8 @@ export class DIContainer {
       }
 
       // Parse numbers
-      if (/^\d+$/.test(value)) {
-        return parseInt(value, 10);
+      if (/^\d+(\.\d+)?$/.test(value)) {
+        return parseFloat(value);
       }
 
       // Parse booleans
@@ -197,24 +314,23 @@ export class DIContainer {
 
   private resolveRepository(entity: any): any {
     try {
-      // Import TypeORM module dynamically to avoid circular dependencies
       const { TypeORMModule } = require("../../typeorm/typeorm-module");
       const dataSource = TypeORMModule.getDataSource();
+
+      if (!dataSource || !dataSource.isInitialized) {
+        throw new Error("TypeORM DataSource not initialized");
+      }
+
       return dataSource.getRepository(entity);
     } catch (error) {
       throw new Error(
-        `Failed to resolve repository for entity ${entity.name}: ${(error as Error)?.message}. ` +
-          `Make sure TypeORM is initialized before using @InjectRepository.`,
+        `Failed to resolve repository for ${entity.name}: ${(error as Error)?.message}`,
       );
     }
   }
 
   has(token: any): boolean {
-    return (
-      this.singletons.has(token) ||
-      this.factories.has(token) ||
-      typeof token === "function"
-    );
+    return this.registered.has(token);
   }
 
   getAllInstances(): any[] {
@@ -226,9 +342,9 @@ export class DIContainer {
     this.transients.clear();
     this.factories.clear();
     this.constructing.clear();
+    this.registered.clear();
   }
 
-  // For testing purposes
   reset(): void {
     this.clear();
   }

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

@@ -1,5 +1,4 @@
 import { METADATA_KEYS } from "../metadata/metadata-keys";
-import { MetadataStorage } from "../metadata/metadata-storage";
 
 export interface ApplicationOptions {
   port?: number;
@@ -9,28 +8,19 @@ export interface ApplicationOptions {
 }
 
 export function FragmentApplication(
-  options: {
-    port?: number;
-    host?: string;
-    configPath?: string;
-    autoScan?: boolean;
-  } = {},
+  options: ApplicationOptions = {},
 ): 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,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 AutoConfiguration(): ClassDecorator {
   return (target: any) => {
-    Injectable("singleton")(target);
+    Injectable('singleton')(target);
     Reflect.defineMetadata(METADATA_KEYS.AUTO_CONFIGURATION, true, target);
-    MetadataStorage.getInstance().addClass({
+    
+    const storage = MetadataStorage.getInstance();
+    storage.addClass({
       target,
-      type: "auto-configuration",
-      scope: "singleton",
+      type: 'auto-configuration',
+      scope: 'singleton'
     });
   };
-}
+}

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

@@ -1,55 +1,19 @@
-import { METADATA_KEYS } from "../metadata/metadata-keys";
-import { MetadataStorage } from "../metadata/metadata-storage";
-
-/**
- * Conditional decorators
- * Ensures the class is registered in MetadataStorage
- */
+import { METADATA_KEYS } from '../metadata/metadata-keys';
 
 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,7 +6,9 @@ export function Controller(path: string = ""): ClassDecorator {
   return (target: any) => {
     Injectable("singleton")(target);
     Reflect.defineMetadata(METADATA_KEYS.CONTROLLER, path, target);
-    MetadataStorage.getInstance().addClass({
+
+    const storage = MetadataStorage.getInstance();
+    storage.addClass({
       target,
       type: "controller",
       scope: "singleton",

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

@@ -1,20 +1,33 @@
-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) => {
-      Reflect.defineMetadata(METADATA_KEYS.HTTP_METHOD, method, target, propertyKey);
-      Reflect.defineMetadata(METADATA_KEYS.ROUTE_PATH, path, target, propertyKey);
+    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,
+      );
 
       const storage = MetadataStorage.getInstance();
       storage.addMethod({
         target: target.constructor,
-        propertyKey: propertyKey.toString(),
+        propertyKey: propertyKey as string,
         method,
         path,
-        paramMetadata: storage.getParams(target, propertyKey.toString()),
+        paramMetadata: storage.getParams(target, propertyKey as string),
       });
     };
   };
@@ -26,15 +39,23 @@ 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, propertyKey, index) => {
-      if (!propertyKey) throw new Error(`@${type} cannot be used on constructor params`);
-      MetadataStorage.getInstance().addParam({
+    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({
         target,
         propertyKey: propertyKey.toString(),
-        index,
+        index: parameterIndex,
         type: type as any,
         paramName,
       });

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

@@ -1,25 +1,18 @@
-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();
-    if (!storage.getClass(target)) {
-      storage.addClass({
-        target,
-        type: 'injectable',
-        scope
-      });
-    }
+    storage.addClass({
+      target,
+      type: 'injectable',
+      scope
+    });
   };
 }