@martel/calyx 1.10.1 → 1.12.0

package/tests/nestjs-parity.test.ts

@@ -0,0 +1,272 @@
+import { expect, test, describe } from 'bun:test';
+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,
+} 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();
+  });
+});

package/tests/openapi.test.ts

@@ -19,6 +19,10 @@ import {
   DocumentBuilder,
   SwaggerModule,
   PartialType,
+  IsString,
+  IsNumber,
+  IsOptional,
+  IsEmail,
 } from '../src/index.ts';
 
 // 1. DTO Model
@@ -42,6 +46,22 @@ class CreateItemDto {
 // 3. Partial DTO using mapped type
 class UpdateItemDto extends PartialType(CreateItemDto) {}
 
+// 4. Validation-rich DTO (without explicit @ApiProperty)
+class ValidationRichDto {
+  @IsString()
+  title!: string;
+
+  @IsNumber()
+  amount!: number;
+
+  @IsOptional()
+  @IsString()
+  note?: string;
+
+  @IsEmail()
+  contactEmail!: string;
+}
+
 @ApiTags('Items')
 @ApiBearerAuth('jwt')
 @Controller('items')
@@ -66,6 +86,12 @@ class ItemsController {
   updateItem(@Body() body: UpdateItemDto) {
     return { id: 3, ...body };
   }
+
+  @Post('validate')
+  @ApiOperation({ summary: 'Validation endpoint' })
+  validateDto(@Body() body: ValidationRichDto) {
+    return body;
+  }
 }
 
 @Module({
@@ -150,6 +176,21 @@ describe('OpenAPI (Swagger) Generation', () => {
     expect(spec.components.schemas.UpdateItemDto).toBeDefined();
     expect(spec.components.schemas.UpdateItemDto.required).toBeUndefined(); // all optional
     expect(spec.components.schemas.UpdateItemDto.properties.name.type).toBe('string');
+
+    // 6. Validation Decorator Schema Auto-enrichment
+    expect(spec.components.schemas.ValidationRichDto).toBeDefined();
+    const richSchema = spec.components.schemas.ValidationRichDto;
+    expect(richSchema.properties.title.type).toBe('string');
+    expect(richSchema.properties.amount.type).toBe('number');
+    expect(richSchema.properties.note.type).toBe('string');
+    expect(richSchema.properties.contactEmail.type).toBe('string');
+    expect(richSchema.properties.contactEmail.format).toBe('email');
+
+    // Ensure note is optional, but others are required
+    expect(richSchema.required).toContain('title');
+    expect(richSchema.required).toContain('amount');
+    expect(richSchema.required).toContain('contactEmail');
+    expect(richSchema.required).not.toContain('note');
   });
 
   test('should serve Swagger UI html wrapper', async () => {