@martel/calyx 1.8.0 → 1.10.0

package/tests/graphql.test.ts

@@ -1,17 +1,30 @@
 import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
-import { Module, CalyxFactory } from '../src/index.ts';
+import {
+  Module,
+  CalyxFactory,
+  UseGuards,
+  UseInterceptors,
+  CanActivate,
+  NestInterceptor,
+  CallHandler,
+  ExecutionContext,
+} from '../src/index.ts';
 import {
   Resolver,
   Query,
+  Mutation,
+  Subscription,
   ResolveField,
   Args,
   Parent,
   ObjectType,
+  InputType,
+  ArgsType,
   Field,
   GraphQLModule,
 } from '../src/graphql/index.ts';
 
-// 1. GraphQL Object Type DTO
+// 1. DTOs
 @ObjectType()
 class Author {
   @Field()
@@ -33,15 +46,96 @@ class PostGql {
   author!: Author;
 }
 
-// 2. Resolver Class
+@InputType()
+class CreatePostInput {
+  @Field()
+  title!: string;
+
+  @Field()
+  authorId!: number;
+}
+
+@ArgsType()
+class GetPostArgs {
+  @Field()
+  id!: number;
+}
+
+// 2. Enhancers (Guard & Interceptor)
+class GqlGuard implements CanActivate {
+  canActivate(context: ExecutionContext): boolean {
+    const gqlContext = context.getArgByIndex(2);
+    const req = gqlContext?.req;
+    const auth = req?.headers?.get('Authorization');
+    return auth === 'allow';
+  }
+}
+
+class GqlInterceptor implements NestInterceptor {
+  async intercept(context: ExecutionContext, next: CallHandler): Promise<any> {
+    const res = await next.handle();
+    if (res && typeof res === 'object') {
+      return { ...res, title: res.title + ' [intercepted]' };
+    }
+    return res;
+  }
+}
+
+// 3. Resolver Class
 @Resolver(PostGql)
 class PostResolver {
   @Query(() => PostGql)
-  getPost(@Args('id') id: number) {
+  getPost(@Args() args: GetPostArgs) {
     return {
-      id,
+      id: args.id,
       title: `Calyx: GraphQL JIT Performance`,
-      authorId: 456, // to be resolved by ResolveField
+      authorId: 456,
+    };
+  }
+
+  @Query(() => PostGql)
+  @UseGuards(GqlGuard)
+  @UseInterceptors(GqlInterceptor)
+  getPostSecured(@Args() args: GetPostArgs) {
+    return {
+      id: args.id,
+      title: `Calyx Secure`,
+      authorId: 111,
+    };
+  }
+
+  @Mutation(() => PostGql)
+  createPost(@Args('input') input: CreatePostInput) {
+    return {
+      id: 999,
+      title: input.title,
+      authorId: input.authorId,
+    };
+  }
+
+  @Subscription(() => PostGql)
+  postAdded() {
+    return {
+      [Symbol.asyncIterator]() {
+        let index = 0;
+        return {
+          async next() {
+            if (index < 1) {
+              index++;
+              return {
+                value: {
+                  postAdded: {
+                    id: 777,
+                    title: 'New Post Added',
+                  },
+                },
+                done: false,
+              };
+            }
+            return { value: undefined, done: true };
+          },
+        };
+      },
     };
   }
 
@@ -109,4 +203,149 @@ describe('Native Code-First GraphQL Module', () => {
       },
     });
   });
+
+  test('should execute Mutation with InputType successfully', async () => {
+    const res = await fetch(`${baseUrl}/graphql`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        query: `
+          mutation {
+            createPost(input: { title: "Calyx Rocks", authorId: 789 }) {
+              id
+              title
+              author {
+                id
+                name
+              }
+            }
+          }
+        `,
+      }),
+    });
+
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.errors).toBeUndefined();
+    expect(body.data).toEqual({
+      createPost: {
+        id: 999,
+        title: 'Calyx Rocks',
+        author: {
+          id: 789,
+          name: 'Jane Doe',
+        },
+      },
+    });
+  });
+
+  test('should run Guards and deny access if guard denies', async () => {
+    const res = await fetch(`${baseUrl}/graphql`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        query: `
+          query {
+            getPostSecured(id: 456) {
+              id
+              title
+            }
+          }
+        `,
+      }),
+    });
+
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.errors).toBeDefined();
+    expect(body.errors[0].message).toContain('Forbidden resource');
+  });
+
+  test('should run Guards and Interceptors successfully if guard approves', async () => {
+    const res = await fetch(`${baseUrl}/graphql`, {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        'Authorization': 'allow',
+      },
+      body: JSON.stringify({
+        query: `
+          query {
+            getPostSecured(id: 456) {
+              id
+              title
+            }
+          }
+        `,
+      }),
+    });
+
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.errors).toBeUndefined();
+    expect(body.data.getPostSecured).toEqual({
+      id: 456,
+      title: 'Calyx Secure [intercepted]',
+    });
+  });
+
+  test('should execute subscription over WebSocket using graphql-ws protocol', async () => {
+    const ws = new WebSocket(`ws://localhost:${PORT}/graphql`);
+    const messages: any[] = [];
+    ws.onmessage = (event) => {
+      messages.push(JSON.parse(event.data));
+    };
+
+    await new Promise((resolve) => {
+      ws.onopen = resolve;
+    });
+
+    // Send connection_init
+    ws.send(JSON.stringify({ type: 'connection_init' }));
+
+    // Wait for connection_ack
+    await new Promise((resolve) => {
+      const check = setInterval(() => {
+        if (messages.some((m) => m.type === 'connection_ack')) {
+          clearInterval(check);
+          resolve(null);
+        }
+      }, 5);
+    });
+
+    // Send subscribe
+    ws.send(JSON.stringify({
+      type: 'subscribe',
+      id: '1',
+      payload: {
+        query: `
+          subscription {
+            postAdded {
+              id
+              title
+            }
+          }
+        `,
+      },
+    }));
+
+    // Wait for next message
+    await new Promise((resolve) => {
+      const check = setInterval(() => {
+        if (messages.some((m) => m.type === 'next' && m.id === '1')) {
+          clearInterval(check);
+          resolve(null);
+        }
+      }, 5);
+    });
+
+    const nextMsg = messages.find((m) => m.type === 'next' && m.id === '1');
+    expect(nextMsg).toBeDefined();
+    expect(nextMsg.payload.data.postAdded).toEqual({
+      id: 777,
+      title: 'New Post Added',
+    });
+
+    ws.close();
+  });
 });

package/tests/openapi.test.ts

@@ -3,17 +3,25 @@ import {
   Module,
   Controller,
   Get,
+  Post,
   Param,
+  Query,
+  Body,
   CalyxFactory,
   ApiTags,
   ApiOperation,
   ApiResponse,
   ApiProperty,
+  ApiBody,
+  ApiQuery,
+  ApiHeader,
+  ApiBearerAuth,
   DocumentBuilder,
   SwaggerModule,
+  PartialType,
 } from '../src/index.ts';
 
-// 1. Model class
+// 1. DTO Model
 class Item {
   @ApiProperty({ description: 'The unique identifier', type: Number })
   id!: number;
@@ -22,15 +30,42 @@ class Item {
   name!: string;
 }
 
+// 2. Request Body DTO
+class CreateItemDto {
+  @ApiProperty({ description: 'The name of the item', type: String, required: true })
+  name!: string;
+
+  @ApiProperty({ description: 'The item price', type: Number, required: true })
+  price!: number;
+}
+
+// 3. Partial DTO using mapped type
+class UpdateItemDto extends PartialType(CreateItemDto) {}
+
 @ApiTags('Items')
+@ApiBearerAuth('jwt')
 @Controller('items')
 class ItemsController {
   @Get(':id')
   @ApiOperation({ summary: 'Get item by id', description: 'Returns a single item' })
   @ApiResponse({ status: 200, description: 'Item found successfully', type: Item })
-  getItem(@Param('id') id: string) {
+  @ApiHeader({ name: 'x-request-id', description: 'Correlation identifier' })
+  getItem(@Param('id') id: string, @Query('fields') fields?: string) {
     return { id: 1, name: 'Gadget' };
   }
+
+  @Post()
+  @ApiOperation({ summary: 'Create a new item' })
+  @ApiResponse({ status: 201, description: 'Item created successfully', type: Item })
+  createItem(@Body() body: CreateItemDto) {
+    return { id: 2, ...body };
+  }
+
+  @Post('update')
+  @ApiOperation({ summary: 'Partial update' })
+  updateItem(@Body() body: UpdateItemDto) {
+    return { id: 3, ...body };
+  }
 }
 
 @Module({
@@ -46,11 +81,12 @@ describe('OpenAPI (Swagger) Generation', () => {
   beforeAll(async () => {
     app = await CalyxFactory.create(TestApp);
     
-    // Build OpenAPI config
+    // Build OpenAPI config with bearer authentication
     const config = new DocumentBuilder()
       .setTitle('My Test API')
       .setDescription('OpenAPI description')
       .setVersion('2.0.0')
+      .addBearerAuth({ type: 'http', scheme: 'bearer', bearerFormat: 'JWT' }, 'jwt')
       .build();
     
     const document = SwaggerModule.createDocument(app, config);
@@ -64,25 +100,56 @@ describe('OpenAPI (Swagger) Generation', () => {
     await app.close();
   });
 
-  test('should serve OpenAPI JSON specification with paths and components', async () => {
+  test('should serve OpenAPI JSON specification with correct types and schemas', async () => {
     const res = await fetch(`${baseUrl}/api-json`);
     expect(res.status).toBe(200);
     const spec = await res.json();
 
+    // 1. Basic Specs
     expect(spec.openapi).toBe('3.0.0');
     expect(spec.info.title).toBe('My Test API');
     expect(spec.info.version).toBe('2.0.0');
+
+    // 2. Security Setup
+    expect(spec.components.securitySchemes.jwt).toBeDefined();
+    expect(spec.components.securitySchemes.jwt.scheme).toBe('bearer');
+
+    // 3. GET /items/{id} endpoint parameters (path, query, header)
     expect(spec.paths['/items/{id}']).toBeDefined();
-    
     const getOp = spec.paths['/items/{id}'].get;
     expect(getOp.summary).toBe('Get item by id');
     expect(getOp.tags).toContain('Items');
-    expect(getOp.parameters[0].name).toBe('id');
-    expect(getOp.parameters[0].in).toBe('path');
-    
-    expect(spec.components.schemas.Item).toBeDefined();
-    expect(spec.components.schemas.Item.properties.name.type).toBe('string');
-    expect(spec.components.schemas.Item.properties.id.type).toBe('number');
+    expect(getOp.security).toEqual([{ jwt: [] }]);
+
+    const params = getOp.parameters;
+    const pathP = params.find((p: any) => p.in === 'path');
+    const queryP = params.find((p: any) => p.in === 'query');
+    const headerP = params.find((p: any) => p.in === 'header');
+
+    expect(pathP).toBeDefined();
+    expect(pathP.name).toBe('id');
+
+    expect(queryP).toBeDefined();
+    expect(queryP.name).toBe('fields');
+
+    expect(headerP).toBeDefined();
+    expect(headerP.name).toBe('x-request-id');
+
+    // 4. POST /items request body and schema DTO definition
+    expect(spec.paths['/items']).toBeDefined();
+    const postOp = spec.paths['/items'].post;
+    expect(postOp.requestBody).toBeDefined();
+    expect(postOp.requestBody.content['application/json'].schema.$ref).toBe('#/components/schemas/CreateItemDto');
+
+    expect(spec.components.schemas.CreateItemDto).toBeDefined();
+    expect(spec.components.schemas.CreateItemDto.required).toContain('name');
+    expect(spec.components.schemas.CreateItemDto.properties.name.type).toBe('string');
+    expect(spec.components.schemas.CreateItemDto.properties.price.type).toBe('number');
+
+    // 5. Mapped Type (PartialType)
+    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');
   });
 
   test('should serve Swagger UI html wrapper', async () => {