@martel/calyx 1.11.0 → 1.13.0

package/src/validation/compiler.ts

@@ -28,16 +28,139 @@ export class ValidationCompiler {
 
       const propCode: string[] = [];
       for (const rule of propRules) {
-        if (rule.type === 'optional') continue;
-
-        if (rule.type === 'string') {
-          propCode.push(`if (typeof obj.${prop} !== 'string') errors.push('${prop} must be a string');`);
-        } else if (rule.type === 'number') {
-          propCode.push(`if (typeof obj.${prop} !== 'number' || isNaN(obj.${prop})) errors.push('${prop} must be a number');`);
-        } else if (rule.type === 'email') {
-          propCode.push(
-            `if (typeof obj.${prop} !== 'string' || !obj.${prop}.includes('@')) errors.push('${prop} must be a valid email');`
-          );
+        const args = rule.args || [];
+        const type = rule.type;
+        
+        if (type === 'optional') continue;
+        
+        switch (type) {
+          case 'isDefined':
+            propCode.push(`if (obj.${prop} === undefined || obj.${prop} === null) errors.push('${prop} must be defined');`);
+            break;
+          case 'equals':
+            propCode.push(`if (obj.${prop} !== ${JSON.stringify(args[0])}) errors.push('${prop} must be equal to ${args[0]}');`);
+            break;
+          case 'notEquals':
+            propCode.push(`if (obj.${prop} === ${JSON.stringify(args[0])}) errors.push('${prop} must not be equal to ${args[0]}');`);
+            break;
+          case 'isEmpty':
+            propCode.push(`if (obj.${prop} !== '' && obj.${prop} !== undefined && obj.${prop} !== null) errors.push('${prop} must be empty');`);
+            break;
+          case 'isNotEmpty':
+            propCode.push(`if (obj.${prop} === '' || obj.${prop} === undefined || obj.${prop} === null) errors.push('${prop} should not be empty');`);
+            break;
+          case 'isIn':
+            propCode.push(`if (!${JSON.stringify(args[0])}.includes(obj.${prop})) errors.push('${prop} must be one of the following values: ' + ${JSON.stringify(args[0])}.join(', '));`);
+            break;
+          case 'isNotIn':
+            propCode.push(`if (${JSON.stringify(args[0])}.includes(obj.${prop})) errors.push('${prop} must not be one of the following values: ' + ${JSON.stringify(args[0])}.join(', '));`);
+            break;
+          case 'isBoolean':
+            propCode.push(`if (typeof obj.${prop} !== 'boolean') errors.push('${prop} must be a boolean');`);
+            break;
+          case 'isDate':
+            propCode.push(`if (!(obj.${prop} instanceof Date) || isNaN(obj.${prop}.getTime())) errors.push('${prop} must be a Date instance');`);
+            break;
+          case 'string':
+            propCode.push(`if (typeof obj.${prop} !== 'string') errors.push('${prop} must be a string');`);
+            break;
+          case 'number':
+            propCode.push(`if (typeof obj.${prop} !== 'number' || isNaN(obj.${prop})) errors.push('${prop} must be a number');`);
+            break;
+          case 'isInt':
+            propCode.push(`if (typeof obj.${prop} !== 'number' || !Number.isInteger(obj.${prop})) errors.push('${prop} must be an integer');`);
+            break;
+          case 'isArray':
+            propCode.push(`if (!Array.isArray(obj.${prop})) errors.push('${prop} must be an array');`);
+            break;
+          case 'isEnum':
+            const enumValues = Object.values(args[0]);
+            propCode.push(`if (!${JSON.stringify(enumValues)}.includes(obj.${prop})) errors.push('${prop} must be a valid enum value');`);
+            break;
+          case 'isObject':
+            propCode.push(`if (typeof obj.${prop} !== 'object' || obj.${prop} === null || Array.isArray(obj.${prop})) errors.push('${prop} must be an object');`);
+            break;
+          case 'isPositive':
+            propCode.push(`if (typeof obj.${prop} !== 'number' || obj.${prop} <= 0) errors.push('${prop} must be a positive number');`);
+            break;
+          case 'isNegative':
+            propCode.push(`if (typeof obj.${prop} !== 'number' || obj.${prop} >= 0) errors.push('${prop} must be a negative number');`);
+            break;
+          case 'min':
+            propCode.push(`if (typeof obj.${prop} !== 'number' || obj.${prop} < ${args[0]}) errors.push('${prop} must not be less than ${args[0]}');`);
+            break;
+          case 'max':
+            propCode.push(`if (typeof obj.${prop} !== 'number' || obj.${prop} > ${args[0]}) errors.push('${prop} must not be greater than ${args[0]}');`);
+            break;
+          case 'contains':
+            propCode.push(`if (typeof obj.${prop} !== 'string' || !obj.${prop}.includes(${JSON.stringify(args[0])})) errors.push('${prop} must contain a ${args[0]} string');`);
+            break;
+          case 'notContains':
+            propCode.push(`if (typeof obj.${prop} !== 'string' || obj.${prop}.includes(${JSON.stringify(args[0])})) errors.push('${prop} must not contain a ${args[0]} string');`);
+            break;
+          case 'isAlpha':
+            propCode.push(`if (typeof obj.${prop} !== 'string' || !/^[a-zA-Z]+$/.test(obj.${prop})) errors.push('${prop} must contain only letters');`);
+            break;
+          case 'isAlphanumeric':
+            propCode.push(`if (typeof obj.${prop} !== 'string' || !/^[a-zA-Z0-9]+$/.test(obj.${prop})) errors.push('${prop} must contain only letters and numbers');`);
+            break;
+          case 'isDecimal':
+            propCode.push(`if (typeof obj.${prop} !== 'string' && typeof obj.${prop} !== 'number' || !/^\\d+\\.\\d+$/.test(String(obj.${prop}))) errors.push('${prop} must be a decimal number');`);
+            break;
+          case 'email':
+            propCode.push(`if (typeof obj.${prop} !== 'string' || !obj.${prop}.includes('@')) errors.push('${prop} must be a valid email');`);
+            break;
+          case 'isUrl':
+            propCode.push(`if (typeof obj.${prop} !== 'string' || !/^(https?:\\/\\/)?([\\da-z\\.-]+)\\.([a-z\\.]{2,6})([\\/\\w \\.-]*)*\\/?$/.test(obj.${prop})) errors.push('${prop} must be a URL address');`);
+            break;
+          case 'isIP':
+            propCode.push(`if (typeof obj.${prop} !== 'string' || !/^(?:[0-9]{1,3}\\.){3}[0-9]{1,3}$/.test(obj.${prop})) errors.push('${prop} must be an IP address');`);
+            break;
+          case 'isPort':
+            propCode.push(`if (typeof obj.${prop} !== 'number' && typeof obj.${prop} !== 'string' || Number(obj.${prop}) < 0 || Number(obj.${prop}) > 65535) errors.push('${prop} must be a port');`);
+            break;
+          case 'isJSON':
+            propCode.push(`if (typeof obj.${prop} !== 'string') errors.push('${prop} must be a json string'); else { try { JSON.parse(obj.${prop}); } catch { errors.push('${prop} must be a json string'); } }`);
+            break;
+          case 'isLowercase':
+            propCode.push(`if (typeof obj.${prop} !== 'string' || obj.${prop} !== obj.${prop}.toLowerCase()) errors.push('${prop} must be a lowercase string');`);
+            break;
+          case 'isUppercase':
+            propCode.push(`if (typeof obj.${prop} !== 'string' || obj.${prop} !== obj.${prop}.toUpperCase()) errors.push('${prop} must be a uppercase string');`);
+            break;
+          case 'isNumberString':
+            propCode.push(`if (typeof obj.${prop} !== 'string' || isNaN(Number(obj.${prop}))) errors.push('${prop} must be a number string');`);
+            break;
+          case 'isUUID':
+            propCode.push(`if (typeof obj.${prop} !== 'string' || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(obj.${prop})) errors.push('${prop} must be a UUID');`);
+            break;
+          case 'isDateString':
+            propCode.push(`if (typeof obj.${prop} !== 'string' || isNaN(Date.parse(obj.${prop}))) errors.push('${prop} must be a valid ISO 8601 date string');`);
+            break;
+          case 'length':
+            propCode.push(`if (typeof obj.${prop} !== 'string' || obj.${prop}.length < ${args[0]} || obj.${prop}.length > ${args[1]}) errors.push('${prop} length must be between ${args[0]} and ${args[1]}');`);
+            break;
+          case 'minLength':
+            propCode.push(`if (typeof obj.${prop} !== 'string' || obj.${prop}.length < ${args[0]}) errors.push('${prop} length must be at least ${args[0]}');`);
+            break;
+          case 'maxLength':
+            propCode.push(`if (typeof obj.${prop} !== 'string' || obj.${prop}.length > ${args[0]}) errors.push('${prop} length must not exceed ${args[0]}');`);
+            break;
+          case 'matches':
+            propCode.push(`if (typeof obj.${prop} !== 'string' || !${args[0].toString()}.test(obj.${prop})) errors.push('${prop} must match regular expression');`);
+            break;
+          case 'arrayNotEmpty':
+            propCode.push(`if (!Array.isArray(obj.${prop}) || obj.${prop}.length === 0) errors.push('${prop} should not be empty');`);
+            break;
+          case 'arrayMinSize':
+            propCode.push(`if (!Array.isArray(obj.${prop}) || obj.${prop}.length < ${args[0]}) errors.push('${prop} must contain at least ${args[0]} elements');`);
+            break;
+          case 'arrayMaxSize':
+            propCode.push(`if (!Array.isArray(obj.${prop}) || obj.${prop}.length > ${args[0]}) errors.push('${prop} must contain not more than ${args[0]} elements');`);
+            break;
+          case 'arrayUnique':
+            propCode.push(`if (!Array.isArray(obj.${prop}) || new Set(obj.${prop}).size !== obj.${prop}.length) errors.push('${prop} must contain unique elements');`);
+            break;
         }
       }
 

package/src/validation/decorators.ts

@@ -12,6 +12,48 @@ function registerValidationRule(type: string, target: any, propertyKey: string,
   Reflect.defineMetadata('calyx:validation_rules', existing, target.constructor);
 }
 
+// 1. Conditional & Basic
+export function IsOptional(): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('optional', target, String(propertyKey));
+}
+
+export function IsDefined(): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('isDefined', target, String(propertyKey));
+}
+
+export function Equals(value: any): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('equals', target, String(propertyKey), [value]);
+}
+
+export function NotEquals(value: any): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('notEquals', target, String(propertyKey), [value]);
+}
+
+export function IsEmpty(): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('isEmpty', target, String(propertyKey));
+}
+
+export function IsNotEmpty(): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('isNotEmpty', target, String(propertyKey));
+}
+
+export function IsIn(values: any[]): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('isIn', target, String(propertyKey), [values]);
+}
+
+export function IsNotIn(values: any[]): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('isNotIn', target, String(propertyKey), [values]);
+}
+
+// 2. Core Types
+export function IsBoolean(): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('isBoolean', target, String(propertyKey));
+}
+
+export function IsDate(): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('isDate', target, String(propertyKey));
+}
+
 export function IsString(): PropertyDecorator {
   return (target, propertyKey) => registerValidationRule('string', target, String(propertyKey));
 }
@@ -20,14 +62,134 @@ export function IsNumber(): PropertyDecorator {
   return (target, propertyKey) => registerValidationRule('number', target, String(propertyKey));
 }
 
-export function IsOptional(): PropertyDecorator {
-  return (target, propertyKey) => registerValidationRule('optional', target, String(propertyKey));
+export function IsInt(): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('isInt', target, String(propertyKey));
+}
+
+export function IsArray(): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('isArray', target, String(propertyKey));
+}
+
+export function IsEnum(entity: any): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('isEnum', target, String(propertyKey), [entity]);
+}
+
+export function IsObject(): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('isObject', target, String(propertyKey));
+}
+
+// 3. Number Constraints
+export function IsPositive(): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('isPositive', target, String(propertyKey));
+}
+
+export function IsNegative(): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('isNegative', target, String(propertyKey));
+}
+
+export function Min(num: number): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('min', target, String(propertyKey), [num]);
+}
+
+export function Max(num: number): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('max', target, String(propertyKey), [num]);
+}
+
+// 4. String Constraints
+export function Contains(str: string): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('contains', target, String(propertyKey), [str]);
+}
+
+export function NotContains(str: string): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('notContains', target, String(propertyKey), [str]);
+}
+
+export function IsAlpha(): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('isAlpha', target, String(propertyKey));
+}
+
+export function IsAlphanumeric(): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('isAlphanumeric', target, String(propertyKey));
+}
+
+export function IsDecimal(): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('isDecimal', target, String(propertyKey));
 }
 
 export function IsEmail(): PropertyDecorator {
   return (target, propertyKey) => registerValidationRule('email', target, String(propertyKey));
 }
 
+export function IsUrl(): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('isUrl', target, String(propertyKey));
+}
+
+export function IsIP(): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('isIP', target, String(propertyKey));
+}
+
+export function IsPort(): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('isPort', target, String(propertyKey));
+}
+
+export function IsJSON(): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('isJSON', target, String(propertyKey));
+}
+
+export function IsLowercase(): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('isLowercase', target, String(propertyKey));
+}
+
+export function IsUppercase(): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('isUppercase', target, String(propertyKey));
+}
+
+export function IsNumberString(): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('isNumberString', target, String(propertyKey));
+}
+
+export function IsUUID(): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('isUUID', target, String(propertyKey));
+}
+
+export function IsDateString(): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('isDateString', target, String(propertyKey));
+}
+
+export function Length(min: number, max: number): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('length', target, String(propertyKey), [min, max]);
+}
+
+export function MinLength(min: number): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('minLength', target, String(propertyKey), [min]);
+}
+
+export function MaxLength(max: number): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('maxLength', target, String(propertyKey), [max]);
+}
+
+export function Matches(regex: RegExp): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('matches', target, String(propertyKey), [regex]);
+}
+
+// 5. Array Constraints
+export function ArrayNotEmpty(): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('arrayNotEmpty', target, String(propertyKey));
+}
+
+export function ArrayMinSize(num: number): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('arrayMinSize', target, String(propertyKey), [num]);
+}
+
+export function ArrayMaxSize(num: number): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('arrayMaxSize', target, String(propertyKey), [num]);
+}
+
+export function ArrayUnique(): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('arrayUnique', target, String(propertyKey));
+}
+
+// Class-Transformer Aliases/Overrides
 export function Expose(): PropertyDecorator {
   return (target, propertyKey) => {
     const constructor = target.constructor;

package/src/validation/http-pipes.ts

@@ -0,0 +1,128 @@
+import { PipeTransform, ArgumentMetadata } from '../lifecycle/interfaces.ts';
+import { Injectable } from '../core/decorators.ts';
+import { HttpException } from '../http/exceptions.ts';
+
+@Injectable()
+export class ParseIntPipe implements PipeTransform<string | number, number> {
+  transform(value: string | number, metadata: ArgumentMetadata): number {
+    const val = typeof value === 'string' ? parseInt(value, 10) : value;
+    if (isNaN(val)) {
+      throw new HttpException(`Validation failed (numeric string is expected) for parameter "${metadata.data ?? ''}"`, 400);
+    }
+    return val;
+  }
+}
+
+@Injectable()
+export class ParseFloatPipe implements PipeTransform<string | number, number> {
+  transform(value: string | number, metadata: ArgumentMetadata): number {
+    const val = typeof value === 'string' ? parseFloat(value) : value;
+    if (isNaN(val)) {
+      throw new HttpException(`Validation failed (float string is expected) for parameter "${metadata.data ?? ''}"`, 400);
+    }
+    return val;
+  }
+}
+
+@Injectable()
+export class ParseBoolPipe implements PipeTransform<string | boolean, boolean> {
+  transform(value: string | boolean, metadata: ArgumentMetadata): boolean {
+    if (value === true || value === 'true') return true;
+    if (value === false || value === 'false') return false;
+    throw new HttpException(`Validation failed (boolean string is expected) for parameter "${metadata.data ?? ''}"`, 400);
+  }
+}
+
+export interface ParseArrayOptions {
+  items?: any;
+  separator?: string;
+  optional?: boolean;
+}
+
+@Injectable()
+export class ParseArrayPipe implements PipeTransform {
+  constructor(private readonly options: ParseArrayOptions = {}) {}
+
+  transform(value: any, metadata: ArgumentMetadata): any[] {
+    if (value === undefined || value === null) {
+      if (this.options.optional) return [];
+      throw new HttpException(`Validation failed (array is expected) for parameter "${metadata.data ?? ''}"`, 400);
+    }
+    const separator = this.options.separator ?? ',';
+    let arr: any[] = [];
+    if (typeof value === 'string') {
+      arr = value.split(separator);
+    } else if (Array.isArray(value)) {
+      arr = value;
+    } else {
+      throw new HttpException(`Validation failed (array is expected) for parameter "${metadata.data ?? ''}"`, 400);
+    }
+
+    if (this.options.items) {
+      const type = this.options.items;
+      arr = arr.map((item) => {
+        if (type === Number) {
+          const val = Number(item);
+          if (isNaN(val)) throw new HttpException(`Validation failed (array of numbers is expected) for parameter "${metadata.data ?? ''}"`, 400);
+          return val;
+        }
+        if (type === Boolean) {
+          if (item === true || item === 'true') return true;
+          if (item === false || item === 'false') return false;
+          throw new HttpException(`Validation failed (array of booleans is expected) for parameter "${metadata.data ?? ''}"`, 400);
+        }
+        return item;
+      });
+    }
+    return arr;
+  }
+}
+
+@Injectable()
+export class ParseUUIDPipe implements PipeTransform<string, string> {
+  private static readonly uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+
+  transform(value: string, metadata: ArgumentMetadata): string {
+    if (typeof value !== 'string' || !ParseUUIDPipe.uuidRegex.test(value)) {
+      throw new HttpException(`Validation failed (uuid string is expected) for parameter "${metadata.data ?? ''}"`, 400);
+    }
+    return value;
+  }
+}
+
+@Injectable()
+export class ParseEnumPipe implements PipeTransform {
+  constructor(private readonly enumType: any) {}
+
+  transform(value: any, metadata: ArgumentMetadata): any {
+    const values = Object.values(this.enumType);
+    if (!values.includes(value)) {
+      throw new HttpException(`Validation failed (enum value is expected) for parameter "${metadata.data ?? ''}"`, 400);
+    }
+    return value;
+  }
+}
+
+@Injectable()
+export class ParseFilePipe implements PipeTransform {
+  constructor(private readonly validators: any[] = []) {}
+
+  transform(value: any, metadata: ArgumentMetadata): any {
+    if (!value || (typeof value === 'object' && !value.buffer)) {
+      throw new HttpException(`Validation failed (file is expected) for parameter "${metadata.data ?? ''}"`, 400);
+    }
+    return value;
+  }
+}
+
+@Injectable()
+export class DefaultValuePipe implements PipeTransform {
+  constructor(private readonly defaultValue: any) {}
+
+  transform(value: any, metadata: ArgumentMetadata): any {
+    if (value === undefined || value === null || value === '') {
+      return this.defaultValue;
+    }
+    return value;
+  }
+}

package/src/validation/index.ts

@@ -1,3 +1,4 @@
 export * from './decorators.ts';
 export * from './compiler.ts';
 export * from './pipe.ts';
+export * from './http-pipes.ts';

package/src/websockets/decorators.ts

@@ -28,12 +28,22 @@ export function SubscribeMessage(event: string): MethodDecorator {
   };
 }
 
-export function MessageBody(): ParameterDecorator {
+export function MessageBody(first?: any, ...pipes: any[]): ParameterDecorator {
   return (target, propertyKey, parameterIndex) => {
     if (!propertyKey) return;
     const constructor = target.constructor;
+
+    let name: string | undefined = undefined;
+    let parsedPipes: any[] = [];
+    if (typeof first === 'string') {
+      name = first;
+      parsedPipes = pipes;
+    } else if (first !== undefined) {
+      parsedPipes = [first, ...pipes];
+    }
+
     const existing = Reflect.getOwnMetadata('calyx:message_body', constructor) || [];
-    existing.push({ propertyKey, parameterIndex });
+    existing.push({ propertyKey, parameterIndex, name, pipes: parsedPipes });
     Reflect.defineMetadata('calyx:message_body', existing, constructor);
   };
 }

package/src/websockets/exceptions.ts

@@ -0,0 +1,10 @@
+export class WsException extends Error {
+  constructor(private readonly error: string | object) {
+    super(typeof error === 'string' ? error : JSON.stringify(error));
+    this.name = 'WsException';
+  }
+
+  getError() {
+    return this.error;
+  }
+}

package/src/websockets/index.ts

@@ -1,2 +1,3 @@
 export * from './decorators.ts';
 export * from './gateway.ts';
+export * from './exceptions.ts';

package/tests/circular-di.test.ts

@@ -0,0 +1,151 @@
+import { describe, test, expect } from 'bun:test';
+import {
+  Module,
+  Injectable,
+  Inject,
+  forwardRef,
+  CalyxContainer,
+  Scope,
+  REQUEST,
+} from '../src/index.ts';
+
+describe('Circular DI and Recursive Dynamic Modules', () => {
+  test('should resolve circular dependencies with property-based injection', () => {
+    @Injectable()
+    class ClassA {
+      @Inject(forwardRef(() => ClassB))
+      public b: any;
+
+      getName() {
+        return 'A';
+      }
+    }
+
+    @Injectable()
+    class ClassB {
+      @Inject(forwardRef(() => ClassA))
+      public a: any;
+
+      getName() {
+        return 'B';
+      }
+    }
+
+    @Module({
+      providers: [ClassA, ClassB],
+    })
+    class RootModule {}
+
+    const container = new CalyxContainer();
+    container.bootstrap(RootModule);
+
+    const a = container.getGlobalOrAnyInstance(ClassA);
+    const b = container.getGlobalOrAnyInstance(ClassB);
+
+    expect(a.b.getName()).toBe('B');
+    expect(b.a.getName()).toBe('A');
+  });
+
+  test('should resolve recursive dynamic module imports', () => {
+    @Injectable()
+    class DatabaseConfig {
+      getUri() {
+        return 'mongodb://localhost';
+      }
+    }
+
+    @Module({
+      providers: [DatabaseConfig],
+      exports: [DatabaseConfig],
+    })
+    class ConfigModule {}
+
+    @Module({})
+    class DatabaseModule {
+      static forRoot() {
+        return {
+          module: DatabaseModule,
+          imports: [ConfigModule],
+          providers: [
+            {
+              provide: 'DATABASE_URI',
+              useFactory: (cfg: DatabaseConfig) => cfg.getUri(),
+              inject: [DatabaseConfig],
+            },
+          ],
+          exports: ['DATABASE_URI'],
+        };
+      }
+    }
+
+    @Injectable()
+    class AppService {
+      constructor(@Inject('DATABASE_URI') public uri: string) {}
+    }
+
+    @Module({
+      imports: [DatabaseModule.forRoot()],
+      providers: [AppService],
+    })
+    class AppModule {}
+
+    const container = new CalyxContainer();
+    container.bootstrap(AppModule);
+
+    const appService = container.getGlobalOrAnyInstance(AppService);
+    expect(appService.uri).toBe('mongodb://localhost');
+  });
+
+  test('should support request-scoped circular dependency JIT DI compilation', async () => {
+    @Injectable({ scope: Scope.REQUEST })
+    class ReqA {
+      constructor(
+        @Inject(REQUEST) public req: any,
+        @Inject(forwardRef(() => ReqB)) public b: any
+      ) {}
+
+      sayHi() {
+        return 'A';
+      }
+    }
+
+    @Injectable({ scope: Scope.REQUEST })
+    class ReqB {
+      constructor(
+        @Inject(REQUEST) public req: any,
+        @Inject(forwardRef(() => ReqA)) public a: any
+      ) {}
+
+      sayHi() {
+        return 'B';
+      }
+    }
+
+    // A controller is needed because JIT compiling factories runs for controllers
+    @Injectable()
+    class ReqController {
+      constructor(
+        public a: ReqA,
+        public b: ReqB
+      ) {}
+    }
+
+    @Module({
+      providers: [ReqA, ReqB],
+      controllers: [ReqController],
+    })
+    class RootModule {}
+
+    const container = new CalyxContainer();
+    container.bootstrap(RootModule);
+
+    // Get the JIT factory or resolve in a request context
+    const reqContext = new Map<any, any>();
+    reqContext.set(REQUEST, { url: '/test' });
+
+    const ctrl = container.resolveControllerInRequestContext(RootModule, ReqController, reqContext);
+    expect(ctrl.a.req).toEqual({ url: '/test' });
+    expect(ctrl.a.b.sayHi()).toBe('B');
+    expect(ctrl.b.a.sayHi()).toBe('A');
+  });
+});