@martel/calyx 1.12.0 → 1.13.0

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', () => {

package/tests/nestjs-parity.test.ts

@@ -1,4 +1,6 @@
 import { expect, test, describe } from 'bun:test';
+import { filter, map } from 'rxjs/operators';
+import { Observable } from 'rxjs';
 import {
   Test,
   LazyModuleLoader,
@@ -30,6 +32,28 @@ import {
   ICommandHandler,
   IQueryHandler,
   IEventHandler,
+  ConflictException,
+  ServiceUnavailableException,
+  UnprocessableEntityException,
+  WsException,
+  RpcException,
+  IsUUID,
+  Min,
+  Max,
+  IsBoolean,
+  Length,
+  ValidationCompiler,
+  registerAs,
+  ConfigModule,
+  SequelizeModule,
+  SequelizeModel,
+  BullModule,
+  UnhandledExceptionBus,
+  EventPublisher,
+  AggregateRoot,
+  Saga,
+  MemoryHealthIndicator,
+  TypeOrmHealthIndicator,
 } from '../src/index.ts';
 
 @Injectable()
@@ -269,4 +293,235 @@ describe('NestJS Parity Extensions', () => {
 
     await moduleRef.close();
   });
+
+  test('HTTP Exceptions: check new status codes', () => {
+    const exc1 = new ConflictException();
+    expect(exc1.getStatus()).toBe(409);
+
+    const exc2 = new ServiceUnavailableException();
+    expect(exc2.getStatus()).toBe(503);
+
+    const exc3 = new UnprocessableEntityException();
+    expect(exc3.getStatus()).toBe(422);
+
+    const wsExc = new WsException('error');
+    expect(wsExc.getError()).toBe('error');
+
+    const rpcExc = new RpcException('error');
+    expect(rpcExc.getError()).toBe('error');
+  });
+
+  test('JIT Validation: check advanced decorators', () => {
+    class DTO {
+      @IsUUID()
+      uuid!: string;
+
+      @Min(10)
+      minVal!: number;
+
+      @Max(50)
+      maxVal!: number;
+
+      @IsBoolean()
+      boolVal!: boolean;
+
+      @Length(3, 8)
+      strLen!: string;
+    }
+
+    const validate = ValidationCompiler.compile(DTO);
+
+    const errs1 = validate({
+      uuid: 'abc',
+      minVal: 5,
+      maxVal: 60,
+      boolVal: 'not-bool' as any,
+      strLen: 'hi',
+    });
+    expect(errs1).not.toBeNull();
+    expect(errs1!.length).toBe(5);
+
+    const errs2 = validate({
+      uuid: '123e4567-e89b-12d3-a456-426614174000',
+      minVal: 15,
+      maxVal: 40,
+      boolVal: true,
+      strLen: 'hello',
+    });
+    expect(errs2).toBeNull();
+  });
+
+  test('ConfigNamespaces: registerAs and dot-notation', () => {
+    const dbConfig = registerAs('database', () => ({
+      host: 'my-host',
+      port: 5432,
+    }));
+
+    const module = ConfigModule.forRoot({
+      load: [dbConfig],
+    });
+
+    const service = (module.providers[0] as any).useValue;
+    expect(service.get('database.host')).toBe('my-host');
+    expect(service.get('database.port')).toBe(5432);
+  });
+
+  test('SequelizeModule: check database fallback model', async () => {
+    class User extends SequelizeModel {
+      name!: string;
+    }
+
+    const moduleRef = await Test.createTestingModule({
+      imports: [
+        SequelizeModule.forRoot({ storage: ':memory:' }),
+        SequelizeModule.forFeature([User]),
+      ],
+    }).compile();
+
+    const injectedModel = moduleRef.get('Sequelize_Model_User') as any;
+    expect(injectedModel).toBeDefined();
+
+    const user = await User.create({ name: 'Alice' });
+    expect(user.id).toBeDefined();
+    expect(user.name).toBe('Alice');
+
+    const found = await User.findByPk(user.id);
+    expect(found).not.toBeNull();
+    expect(found.name).toBe('Alice');
+
+    await user.update({ name: 'Bob' });
+    const found2 = await User.findByPk(user.id);
+    expect(found2.name).toBe('Bob');
+
+    await user.destroy();
+    const found3 = await User.findByPk(user.id);
+    expect(found3).toBeNull();
+
+    await moduleRef.close();
+  });
+
+  test('BullModule: check root registry and compatibility methods', async () => {
+    const moduleRef = await Test.createTestingModule({
+      imports: [
+        BullModule.forRoot({}),
+        BullModule.registerQueue({ name: 'audio' }),
+      ],
+    }).compile();
+
+    const queue = moduleRef.get('Queue_audio') as any;
+    expect(queue).toBeDefined();
+    expect(queue.pause).toBeDefined();
+    expect(queue.resume).toBeDefined();
+
+    await queue.pause();
+    expect(await queue.isPaused()).toBe(true);
+    await queue.resume();
+    expect(await queue.isPaused()).toBe(false);
+
+    const job = await queue.add('test-job', { foo: 'bar' });
+    expect(job.id).toBeDefined();
+    expect(await queue.count()).toBe(1);
+
+    await queue.drain();
+    expect(await queue.count()).toBe(0);
+
+    await moduleRef.close();
+  });
+
+  test('CQRS Saga & AggregateRoot & ExceptionBus', async () => {
+    class MyCommand implements ICommand {
+      constructor(public readonly val: string) {}
+    }
+    class MyEvent implements IEvent {
+      constructor(public readonly val: string) {}
+    }
+
+    let commandVal = '';
+
+    @CommandHandler(MyCommand)
+    class MyCommandHandler implements ICommandHandler<MyCommand> {
+      async execute(command: MyCommand) {
+        commandVal = command.val;
+        if (command.val === 'throw') {
+          throw new Error('command-failed');
+        }
+        return 'ok';
+      }
+    }
+
+    class OrderAggregate extends AggregateRoot {
+      createOrder(val: string) {
+        this.apply(new MyEvent(val));
+      }
+    }
+
+    @Injectable()
+    class OrderSagas {
+      @Saga()
+      orderCreated = (events$: Observable<any>): Observable<ICommand> => {
+        return events$.pipe(
+          filter((e: any) => e instanceof MyEvent),
+          map((e: any) => new MyCommand(e.val))
+        );
+      }
+    }
+
+    const moduleRef = await Test.createTestingModule({
+      imports: [CqrsModule],
+      providers: [MyCommandHandler, OrderSagas],
+    }).compile();
+
+    const eventBus = moduleRef.get(EventBus);
+    const exceptionBus = moduleRef.get(UnhandledExceptionBus);
+    const commandBus = moduleRef.get(CommandBus);
+
+    const cqrs = moduleRef.get(CqrsModule);
+    (cqrs as any).onModuleInit();
+
+    const agg = new OrderAggregate();
+    agg.createOrder('hello-saga');
+    expect(agg.getUncommittedEvents().length).toBe(1);
+
+    const publisher = moduleRef.get(EventPublisher);
+    const boundAgg = publisher.mergeObjectContext(agg);
+    boundAgg.commit();
+    expect(agg.getUncommittedEvents().length).toBe(0);
+
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    expect(commandVal).toBe('hello-saga');
+
+    let caughtErr: any = null;
+    exceptionBus.subscribe((err) => {
+      caughtErr = err;
+    });
+
+    try {
+      await commandBus.execute(new MyCommand('throw'));
+    } catch {
+      // expected
+    }
+
+    expect(caughtErr).not.toBeNull();
+    expect(caughtErr.error.message).toBe('command-failed');
+
+    await moduleRef.close();
+  });
+
+  test('Terminus health check indicators', async () => {
+    const moduleRef = await Test.createTestingModule({
+      imports: [TerminusModule],
+    }).compile();
+
+    const memIndicator = moduleRef.get(MemoryHealthIndicator);
+    const dbIndicator = moduleRef.get(TypeOrmHealthIndicator);
+
+    const memRes = await memIndicator.checkHeap('heap', 1000 * 1024 * 1024);
+    expect(memRes.heap.status).toBe('up');
+
+    const dbRes = await dbIndicator.pingCheck('db');
+    expect(dbRes.db.status).toBe('up');
+
+    await moduleRef.close();
+  });
 });
+