@martel/calyx 1.12.0 → 1.13.1

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;
         }
       }
 
@@ -92,15 +215,12 @@ export class SerializationCompiler {
     const jsonParts: string[] = [];
     for (const key of keys) {
       const propRules = rules.filter((r) => r.propertyKey === key);
-      const isNumber = propRules.some((r) => r.type === 'number');
-      const isString = propRules.some((r) => r.type === 'string');
+      const designType = Reflect.getMetadata('design:type', dtoClass.prototype, key);
+      const isNumber = propRules.some((r) => r.type === 'number') || designType === Number;
+      const isBoolean = propRules.some((r) => r.type === 'isBoolean') || designType === Boolean;
 
-      if (isNumber) {
+      if (isNumber || isBoolean) {
         jsonParts.push(`"${key}":\${obj.${key} === undefined || obj.${key} === null ? null : obj.${key}}`);
-      } else if (isString) {
-        jsonParts.push(
-          `"${key}":\${obj.${key} === undefined || obj.${key} === null ? null : JSON.stringify(obj.${key})}`
-        );
       } else {
         jsonParts.push(
           `"${key}":\${obj.${key} === undefined || obj.${key} === null ? null : JSON.stringify(obj.${key})}`

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/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');
+  });
+});

package/tests/di.test.ts

@@ -167,15 +167,17 @@ describe('Dependency Injection System', () => {
     expect(() => container.bootstrap(RootModule)).toThrow(/Cannot resolve dependency/);
   });
 
-  test('should detect circular dependencies and throw error', () => {
+  test('should resolve circular dependencies using lazy proxies', () => {
     @Injectable()
     class ServiceA {
       constructor(@Inject(forwardRef(() => ServiceB)) public b: any) {}
+      getValue() { return 'A'; }
     }
 
     @Injectable()
     class ServiceB {
       constructor(@Inject(forwardRef(() => ServiceA)) public a: any) {}
+      getValue() { return 'B'; }
     }
 
     @Module({
@@ -184,7 +186,13 @@ describe('Dependency Injection System', () => {
     class RootModule {}
 
     const container = new CalyxContainer();
-    expect(() => container.bootstrap(RootModule)).toThrow(/Circular dependency detected/);
+    container.bootstrap(RootModule);
+
+    const a = container.getGlobalOrAnyInstance(ServiceA);
+    const b = container.getGlobalOrAnyInstance(ServiceB);
+
+    expect(a.b.getValue()).toBe('B');
+    expect(b.a.getValue()).toBe('A');
   });
 
   test('should isolate module scopes and resolve exported providers', () => {