fragment-ts 1.0.16 → 1.0.18

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

@@ -1,11 +1,12 @@
-import { METADATA_KEYS } from '../metadata/metadata-keys';
-import { Scope } from '../decorators/injectable.decorator';
+import { METADATA_KEYS } from "../metadata/metadata-keys";
+import { Scope } from "../decorators/injectable.decorator";
 
 export class DIContainer {
   private static instance: 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
 
   static getInstance(): DIContainer {
     if (!DIContainer.instance) {
@@ -23,78 +24,212 @@ export class DIContainer {
   }
 
   resolve<T>(token: any): T {
+    // Check for circular dependency
+    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();
-      const scope = Reflect.getMetadata(METADATA_KEYS.SCOPE, token) || 'singleton';
-      
-      if (scope === 'singleton') {
+      const scope =
+        Reflect.getMetadata(METADATA_KEYS.SCOPE, token) || "singleton";
+
+      if (scope === "singleton") {
         this.singletons.set(token, instance);
       }
-      
+
       return instance;
     }
 
-    if (typeof token === 'function') {
-      const instance = this.createInstance(token);
-      const scope = Reflect.getMetadata(METADATA_KEYS.SCOPE, token) || 'singleton';
-      
-      if (scope === 'singleton') {
-        this.singletons.set(token, instance);
+    // Create new instance
+    if (typeof token === "function") {
+      this.constructing.add(token);
+
+      try {
+        const instance = this.createInstance(token);
+        const scope =
+          Reflect.getMetadata(METADATA_KEYS.SCOPE, token) || "singleton";
+
+        if (scope === "singleton") {
+          this.singletons.set(token, instance);
+        }
+
+        this.constructing.delete(token);
+        return instance;
+      } catch (error) {
+        this.constructing.delete(token);
+        throw error;
       }
-      
-      return instance;
     }
 
     throw new Error(`Cannot resolve dependency: ${token}`);
   }
 
   private createInstance(target: any): any {
-    const paramTypes = Reflect.getMetadata('design:paramtypes', target) || [];
-    const params = paramTypes.map((type: any) => this.resolve(type));
+    // Get constructor parameter types
+    const paramTypes = Reflect.getMetadata("design:paramtypes", target) || [];
+
+    // Resolve constructor dependencies
+    const params = paramTypes.map((type: any) => {
+      if (!type || type === Object) {
+        return undefined;
+      }
+      return this.resolve(type);
+    });
+
+    // Create instance
     const instance = new target(...params);
-    
+
+    // Inject properties AFTER construction
     this.injectProperties(instance);
-    
+
+    // Call post-construct hook if it exists
+    if (typeof instance.onInit === "function") {
+      instance.onInit();
+    }
+
     return instance;
   }
 
   private injectProperties(instance: any): void {
-    const properties = Object.getOwnPropertyNames(instance.constructor.prototype);
-    
-    properties.forEach(prop => {
-      const autowired = Reflect.getMetadata(METADATA_KEYS.AUTOWIRED, instance, prop);
-      const inject = Reflect.getMetadata(METADATA_KEYS.INJECT, instance, prop);
-      const value = Reflect.getMetadata(METADATA_KEYS.VALUE, instance, prop);
-      
+    const prototype = Object.getPrototypeOf(instance);
+
+    // Get all property keys from the prototype chain
+    const properties = this.getAllPropertyKeys(instance);
+
+    properties.forEach((prop) => {
+      // Check for @Autowired
+      const autowired = Reflect.getMetadata(
+        METADATA_KEYS.AUTOWIRED,
+        prototype,
+        prop,
+      );
       if (autowired) {
         instance[prop] = this.resolve(autowired);
-      } else if (inject) {
+        return;
+      }
+
+      // Check for @Inject
+      const inject = Reflect.getMetadata(METADATA_KEYS.INJECT, prototype, prop);
+      if (inject) {
         instance[prop] = this.resolve(inject);
-      } else if (value) {
+        return;
+      }
+
+      // Check for @Value
+      const value = Reflect.getMetadata(METADATA_KEYS.VALUE, prototype, prop);
+      if (value !== undefined) {
         instance[prop] = this.resolveValue(value);
+        return;
+      }
+
+      // Check for @InjectRepository - special TypeORM handling
+      const repositoryEntity = Reflect.getMetadata(
+        METADATA_KEYS.INJECT_REPOSITORY,
+        prototype,
+        prop,
+      );
+      if (repositoryEntity) {
+        instance[prop] = this.resolveRepository(repositoryEntity);
+        return;
       }
     });
   }
 
+  private getAllPropertyKeys(obj: any): string[] {
+    const keys = new Set<string>();
+    let current = obj;
+
+    while (current && current !== Object.prototype) {
+      Object.getOwnPropertyNames(current).forEach((key) => keys.add(key));
+      current = Object.getPrototypeOf(current);
+    }
+
+    return Array.from(keys);
+  }
+
   private resolveValue(expression: string): any {
-    const match = expression.match(/\$\{(.+?)\}/);
+    // Handle environment variable syntax: ${VAR_NAME} or $VAR_NAME
+    const match = expression.match(/\$\{([^}]+)\}|\$([A-Z_][A-Z0-9_]*)/i);
     if (match) {
-      const key = match[1];
-      return process.env[key] || '';
+      const key = match[1] || match[2];
+      const value = process.env[key];
+
+      if (value === undefined) {
+        console.warn(
+          `⚠️  Warning: Environment variable "${key}" is not defined`,
+        );
+        return "";
+      }
+
+      // Try to parse as JSON for complex types
+      if (value.startsWith("{") || value.startsWith("[")) {
+        try {
+          return JSON.parse(value);
+        } catch {
+          return value;
+        }
+      }
+
+      // Parse numbers
+      if (/^\d+$/.test(value)) {
+        return parseInt(value, 10);
+      }
+
+      // Parse booleans
+      if (value.toLowerCase() === "true") return true;
+      if (value.toLowerCase() === "false") return false;
+
+      return value;
     }
+
     return expression;
   }
 
+  private resolveRepository(entity: any): any {
+    try {
+      // Import TypeORM module dynamically to avoid circular dependencies
+      const { TypeORMModule } = require("../../typeorm/typeorm-module");
+      const dataSource = TypeORMModule.getDataSource();
+      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.`,
+      );
+    }
+  }
+
   has(token: any): boolean {
-    return this.singletons.has(token) || this.factories.has(token);
+    return (
+      this.singletons.has(token) ||
+      this.factories.has(token) ||
+      typeof token === "function"
+    );
   }
 
   getAllInstances(): any[] {
     return Array.from(this.singletons.values());
   }
+
+  clear(): void {
+    this.singletons.clear();
+    this.transients.clear();
+    this.factories.clear();
+    this.constructing.clear();
+  }
+
+  // For testing purposes
+  reset(): void {
+    this.clear();
+  }
 }

package/src/core/decorators/DECORATOR_USAGE.md

@@ -0,0 +1,326 @@
+// ============================================
+// Example: Complete Fragment Application
+// Demonstrates all decorators working together
+// ============================================
+
+import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';
+import { 
+  FragmentApplication, 
+  Controller, 
+  Service, 
+  Repository,
+  Injectable,
+  Get, 
+  Post, 
+  Body, 
+  Param,
+  Autowired,
+  InjectRepository,
+  Value,
+  PostConstruct,
+} from 'fragment-ts';
+import { Repository as TypeORMRepository } from 'typeorm';
+
+// ============================================
+// 1. Entity Definition
+// ============================================
+@Entity()
+export class User {
+  @PrimaryGeneratedColumn()
+  id!: number;
+
+  @Column()
+  name!: string;
+
+  @Column()
+  email!: string;
+
+  @Column({ default: true })
+  isActive!: boolean;
+}
+
+// ============================================
+// 2. Repository Layer
+// ============================================
+@Repository()
+export class UserRepository {
+  // TypeORM repository is automatically injected
+  @InjectRepository(User)
+  private repo!: TypeORMRepository<User>;
+
+  async findAll(): Promise<User[]> {
+    return this.repo.find();
+  }
+
+  async findById(id: number): Promise<User | null> {
+    return this.repo.findOne({ where: { id } });
+  }
+
+  async create(data: Partial<User>): Promise<User> {
+    const user = this.repo.create(data);
+    return this.repo.save(user);
+  }
+
+  async update(id: number, data: Partial<User>): Promise<User | null> {
+    await this.repo.update(id, data);
+    return this.findById(id);
+  }
+
+  async delete(id: number): Promise<boolean> {
+    const result = await this.repo.delete(id);
+    return (result.affected ?? 0) > 0;
+  }
+
+  async findByEmail(email: string): Promise<User | null> {
+    return this.repo.findOne({ where: { email } });
+  }
+}
+
+// ============================================
+// 3. Service Layer with Configuration
+// ============================================
+@Injectable()
+export class EmailService {
+  @Value('${EMAIL_FROM}')
+  private fromEmail!: string;
+
+  @Value('${EMAIL_ENABLED:true}')
+  private enabled!: boolean;
+
+  @PostConstruct()
+  init() {
+    console.log(`📧 Email service initialized`);
+    console.log(`   From: ${this.fromEmail}`);
+    console.log(`   Enabled: ${this.enabled}`);
+  }
+
+  async sendWelcomeEmail(email: string, name: string): Promise<void> {
+    if (!this.enabled) {
+      console.log(`Email disabled, skipping welcome email to ${email}`);
+      return;
+    }
+
+    console.log(`Sending welcome email to ${email}`);
+    // Actual email sending logic would go here
+  }
+
+  async sendPasswordReset(email: string, token: string): Promise<void> {
+    if (!this.enabled) {
+      console.log(`Email disabled, skipping reset email to ${email}`);
+      return;
+    }
+
+    console.log(`Sending password reset to ${email} with token ${token}`);
+  }
+}
+
+// ============================================
+// 4. Business Logic Service
+// ============================================
+@Service()
+export class UserService {
+  // Dependencies are automatically injected using @Autowired
+  @Autowired()
+  private userRepository!: UserRepository;
+
+  @Autowired()
+  private emailService!: EmailService;
+
+  @Value('${MAX_USERS:1000}')
+  private maxUsers!: number;
+
+  @PostConstruct()
+  init() {
+    console.log(`👤 User service initialized (max users: ${this.maxUsers})`);
+  }
+
+  async getAllUsers(): Promise<User[]> {
+    return this.userRepository.findAll();
+  }
+
+  async getUserById(id: number): Promise<User | null> {
+    return this.userRepository.findById(id);
+  }
+
+  async createUser(data: Partial<User>): Promise<User> {
+    // Check max users limit
+    const users = await this.userRepository.findAll();
+    if (users.length >= this.maxUsers) {
+      throw new Error(`Maximum user limit (${this.maxUsers}) reached`);
+    }
+
+    // Check if email already exists
+    if (data.email) {
+      const existing = await this.userRepository.findByEmail(data.email);
+      if (existing) {
+        throw new Error(`User with email ${data.email} already exists`);
+      }
+    }
+
+    // Create user
+    const user = await this.userRepository.create(data);
+
+    // Send welcome email
+    if (user.email && user.name) {
+      await this.emailService.sendWelcomeEmail(user.email, user.name);
+    }
+
+    return user;
+  }
+
+  async updateUser(id: number, data: Partial<User>): Promise<User | null> {
+    const user = await this.userRepository.findById(id);
+    if (!user) {
+      throw new Error(`User with id ${id} not found`);
+    }
+
+    return this.userRepository.update(id, data);
+  }
+
+  async deleteUser(id: number): Promise<boolean> {
+    const user = await this.userRepository.findById(id);
+    if (!user) {
+      throw new Error(`User with id ${id} not found`);
+    }
+
+    return this.userRepository.delete(id);
+  }
+
+  async requestPasswordReset(email: string): Promise<void> {
+    const user = await this.userRepository.findByEmail(email);
+    if (!user) {
+      throw new Error(`User with email ${email} not found`);
+    }
+
+    // Generate reset token (simplified)
+    const token = Math.random().toString(36).substring(7);
+    await this.emailService.sendPasswordReset(email, token);
+  }
+}
+
+// ============================================
+// 5. Controller Layer
+// ============================================
+@Controller('/api/users')
+export class UserController {
+  // Service is automatically injected
+  @Autowired()
+  private userService!: UserService;
+
+  @Get('/')
+  async getAllUsers() {
+    const users = await this.userService.getAllUsers();
+    return {
+      success: true,
+      data: users,
+      count: users.length,
+    };
+  }
+
+  @Get('/:id')
+  async getUserById(@Param('id') id: string) {
+    const userId = parseInt(id, 10);
+    const user = await this.userService.getUserById(userId);
+
+    if (!user) {
+      return {
+        success: false,
+        error: 'User not found',
+      };
+    }
+
+    return {
+      success: true,
+      data: user,
+    };
+  }
+
+  @Post('/')
+  async createUser(@Body() data: any) {
+    try {
+      const user = await this.userService.createUser(data);
+      return {
+        success: true,
+        data: user,
+        message: 'User created successfully',
+      };
+    } catch (error: any) {
+      return {
+        success: false,
+        error: error.message,
+      };
+    }
+  }
+
+  @Post('/:id')
+  async updateUser(@Param('id') id: string, @Body() data: any) {
+    try {
+      const userId = parseInt(id, 10);
+      const user = await this.userService.updateUser(userId, data);
+      return {
+        success: true,
+        data: user,
+        message: 'User updated successfully',
+      };
+    } catch (error: any) {
+      return {
+        success: false,
+        error: error.message,
+      };
+    }
+  }
+
+  @Post('/:id/delete')
+  async deleteUser(@Param('id') id: string) {
+    try {
+      const userId = parseInt(id, 10);
+      const deleted = await this.userService.deleteUser(userId);
+      return {
+        success: deleted,
+        message: deleted ? 'User deleted successfully' : 'Failed to delete user',
+      };
+    } catch (error: any) {
+      return {
+        success: false,
+        error: error.message,
+      };
+    }
+  }
+
+  @Post('/password-reset')
+  async requestPasswordReset(@Body() data: { email: string }) {
+    try {
+      await this.userService.requestPasswordReset(data.email);
+      return {
+        success: true,
+        message: 'Password reset email sent',
+      };
+    } catch (error: any) {
+      return {
+        success: false,
+        error: error.message,
+      };
+    }
+  }
+}
+
+// ============================================
+// 6. Application Entry Point
+// ============================================
+@FragmentApplication({
+  port: 3000,
+  host: '0.0.0.0',
+})
+export class App {}
+
+// ============================================
+// 7. Bootstrap
+// ============================================
+import { FragmentWebApplication } from 'fragment-ts';
+
+async function bootstrap() {
+  const app = new FragmentWebApplication();
+  await app.bootstrap(App);
+}
+
+bootstrap().catch(console.error);

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

@@ -1,18 +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 Controller(path: string = ''): ClassDecorator {
+export function Controller(path: string = ""): ClassDecorator {
   return (target: any) => {
-    Injectable('singleton')(target);
+    Injectable("singleton")(target);
     Reflect.defineMetadata(METADATA_KEYS.CONTROLLER, path, target);
-    
+
     const storage = MetadataStorage.getInstance();
     storage.addClass({
       target,
-      type: 'controller',
-      scope: 'singleton',
-      path
+      type: "controller",
+      scope: "singleton",
+      path,
     });
   };
 }