@martel/calyx 1.11.0 → 1.13.0

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

@@ -0,0 +1,527 @@
+import { expect, test, describe } from 'bun:test';
+import { filter, map } from 'rxjs/operators';
+import { Observable } from 'rxjs';
+import {
+  Test,
+  LazyModuleLoader,
+  Injectable,
+  Module,
+  ParseIntPipe,
+  ParseBoolPipe,
+  CalyxResponse,
+  SchedulerRegistry,
+  ScheduleModule,
+  Cron,
+  Interval,
+  CacheKey,
+  CacheTTL,
+  Client,
+  ClientsModule,
+  HealthCheckService,
+  TerminusModule,
+  CqrsModule,
+  CommandBus,
+  QueryBus,
+  EventBus,
+  CommandHandler,
+  QueryHandler,
+  EventsHandler,
+  ICommand,
+  IQuery,
+  IEvent,
+  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()
+class DummyService {
+  getValue() { return 'dummy'; }
+}
+
+@Injectable()
+class AliasService {
+  constructor(public readonly dummy: DummyService) {}
+}
+
+@Module({
+  providers: [
+    DummyService,
+    {
+      provide: 'ALIAS_TOKEN',
+      useExisting: DummyService,
+    },
+    AliasService,
+  ],
+})
+class TestParityModule {}
+
+describe('NestJS Parity Extensions', () => {
+
+  test('DI: useExisting alias provider resolution', async () => {
+    const moduleRef = await Test.createTestingModule({
+      imports: [TestParityModule],
+    }).compile();
+
+    const dummy = moduleRef.get(DummyService);
+    const alias = moduleRef.get('ALIAS_TOKEN');
+    expect(dummy).toBe(alias);
+    expect(dummy.getValue()).toBe('dummy');
+    await moduleRef.close();
+  });
+
+  test('DI: Test/TestingModule overrides', async () => {
+    const moduleRef = await Test.createTestingModule({
+      imports: [TestParityModule],
+    })
+    .overrideProvider(DummyService)
+    .useValue({ getValue: () => 'mocked' })
+    .compile();
+
+    const dummy = moduleRef.get(DummyService);
+    expect(dummy.getValue()).toBe('mocked');
+    await moduleRef.close();
+  });
+
+  test('DI: LazyModuleLoader', async () => {
+    const moduleRef = await Test.createTestingModule({
+      imports: [],
+      providers: [LazyModuleLoader],
+    }).compile();
+
+    const loader = moduleRef.get(LazyModuleLoader);
+    const lazyModuleRef = await loader.load(() => Promise.resolve(TestParityModule));
+    expect(lazyModuleRef).toBeDefined();
+
+    const dummy = lazyModuleRef.get(DummyService);
+    expect(dummy.getValue()).toBe('dummy');
+    await moduleRef.close();
+  });
+
+  test('Pipes: built-in parsing pipes', () => {
+    const intPipe = new ParseIntPipe();
+    expect(intPipe.transform('42', { type: 'query', data: 'id' })).toBe(42);
+    expect(() => intPipe.transform('abc', { type: 'query', data: 'id' })).toThrow();
+
+    const boolPipe = new ParseBoolPipe();
+    expect(boolPipe.transform('true', { type: 'query', data: 'flag' })).toBe(true);
+    expect(boolPipe.transform('false', { type: 'query', data: 'flag' })).toBe(false);
+    expect(() => boolPipe.transform('abc', { type: 'query', data: 'flag' })).toThrow();
+  });
+
+  test('CalyxResponse compatibility methods', () => {
+    const res = new CalyxResponse();
+    res.header('X-Test', 'value')
+       .type('text/html')
+       .cookie('cookie_name', 'cookie_val')
+       .append('X-Test', 'another');
+
+    expect(res.get('x-test')).toBe('value, another');
+    expect(res.get('content-type')).toBe('text/html');
+  });
+
+  test('SchedulerRegistry named dynamic tasks', async () => {
+    @Injectable()
+    class ScheduledTasks {
+      @Cron('* * * * * *', { name: 'my-cron' })
+      runCron() {}
+
+      @Interval('my-interval', 1000)
+      runInterval() {}
+    }
+
+    @Module({
+      imports: [ScheduleModule.forRoot()],
+      providers: [ScheduledTasks],
+    })
+    class RootScheduleModule {}
+
+    const moduleRef = await Test.createTestingModule({
+      imports: [RootScheduleModule],
+    }).compile();
+
+    const app = moduleRef.createCalyxApplication();
+    await app.init();
+
+    const registry = moduleRef.get(SchedulerRegistry);
+    expect(registry.getCronJob('my-cron')).toBeDefined();
+    expect(registry.getInterval('my-interval')).toBeDefined();
+
+    registry.deleteCronJob('my-cron');
+    registry.deleteInterval('my-interval');
+
+    expect(() => registry.getCronJob('my-cron')).toThrow();
+    expect(() => registry.getInterval('my-interval')).toThrow();
+
+    await app.close();
+    await moduleRef.close();
+  });
+
+  test('CacheInterceptor key/ttl retrieval', () => {
+    class Target {
+      @CacheKey('custom_key')
+      @CacheTTL(100)
+      handler() {}
+    }
+
+    const t = new Target();
+    const key = Reflect.getMetadata('cache_metadata_key', t.handler);
+    const ttl = Reflect.getMetadata('cache_metadata_ttl', t.handler);
+
+    expect(key).toBe('custom_key');
+    expect(ttl).toBe(100);
+  });
+
+  test('Microservice clients: @Client and ClientsModule', async () => {
+    class Target {
+      @Client({ options: { host: '127.0.0.1', port: 1234 } })
+      client: any;
+    }
+
+    const target = new Target();
+    expect(target.client).toBeDefined();
+
+    const moduleRef = await Test.createTestingModule({
+      imports: [
+        ClientsModule.register([
+          { name: 'TEST_SERVICE', options: { host: 'localhost', port: 5000 } },
+        ]),
+      ],
+    }).compile();
+
+    const service = moduleRef.get('TEST_SERVICE');
+    expect(service).toBeDefined();
+    await moduleRef.close();
+  });
+
+  test('CQRS command/query/event buses', async () => {
+    class MyCommand implements ICommand {}
+    class MyQuery implements IQuery {}
+    class MyEvent implements IEvent {}
+
+    let commandHandled = false;
+    let queryHandled = false;
+    let eventHandledCount = 0;
+
+    @CommandHandler(MyCommand)
+    class MyCommandHandler implements ICommandHandler<MyCommand> {
+      async execute(command: MyCommand) {
+        commandHandled = true;
+        return 'command-result';
+      }
+    }
+
+    @QueryHandler(MyQuery)
+    class MyQueryHandler implements IQueryHandler<MyQuery> {
+      async execute(query: MyQuery) {
+        queryHandled = true;
+        return 'query-result';
+      }
+    }
+
+    @EventsHandler(MyEvent)
+    class MyEventHandler implements IEventHandler<MyEvent> {
+      handle(event: MyEvent) {
+        eventHandledCount++;
+      }
+    }
+
+    const moduleRef = await Test.createTestingModule({
+      imports: [CqrsModule],
+      providers: [MyCommandHandler, MyQueryHandler, MyEventHandler],
+    }).compile();
+
+    const commandBus = moduleRef.get(CommandBus);
+    const queryBus = moduleRef.get(QueryBus);
+    const eventBus = moduleRef.get(EventBus);
+
+    const cqrsModule = moduleRef.get(CqrsModule);
+    (cqrsModule as any).onModuleInit();
+
+    const cmdRes = await commandBus.execute(new MyCommand());
+    expect(cmdRes).toBe('command-result');
+    expect(commandHandled).toBe(true);
+
+    const qryRes = await queryBus.execute(new MyQuery());
+    expect(qryRes).toBe('query-result');
+    expect(queryHandled).toBe(true);
+
+    eventBus.publish(new MyEvent());
+    expect(eventHandledCount).toBe(1);
+
+    await moduleRef.close();
+  });
+
+  test('Terminus health check service', async () => {
+    const moduleRef = await Test.createTestingModule({
+      imports: [TerminusModule],
+    }).compile();
+
+    const health = moduleRef.get(HealthCheckService);
+    const res = await health.check([
+      () => ({ db: { status: 'up' } }),
+    ]);
+
+    expect(res.status).toBe('ok');
+    expect(res.details.db.status).toBe('up');
+
+    expect(health.check([
+      () => { throw new Error('DB connection lost'); }
+    ])).rejects.toThrow();
+
+    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();
+  });
+});
+