@martel/calyx 1.12.0 → 1.13.1

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