@martel/calyx 1.7.0 → 1.9.0

package/src/validation/pipe.ts

@@ -3,25 +3,94 @@ import { Injectable } from '../core/decorators.ts';
 import { HttpException } from '../http/exceptions.ts';
 import { ValidationCompiler } from './compiler.ts';
 
+// Dynamic detection of class-validator and class-transformer
+let classValidator: any = null;
+let classTransformer: any = null;
+try {
+  require.resolve('class-validator');
+  require.resolve('class-transformer');
+  classValidator = require('class-validator');
+  classTransformer = require('class-transformer');
+} catch {
+  // ignore
+}
+
+export interface ValidationPipeOptions {
+  transform?: boolean;
+  disableErrorMessages?: boolean;
+  whitelist?: boolean;
+  forbidNonWhitelisted?: boolean;
+  groups?: string[];
+  dismissDefaultMessages?: boolean;
+  validationError?: {
+    target?: boolean;
+    value?: boolean;
+  };
+}
+
 @Injectable()
 export class ValidationPipe implements PipeTransform {
+  private transformOption: boolean;
+  private whitelistOption: boolean;
+  private forbidNonWhitelistedOption: boolean;
+
+  constructor(options: ValidationPipeOptions = {}) {
+    this.transformOption = options.transform ?? true;
+    this.whitelistOption = options.whitelist ?? false;
+    this.forbidNonWhitelistedOption = options.forbidNonWhitelisted ?? false;
+  }
+
   async transform(value: any, metadata: ArgumentMetadata) {
     const metatype = metadata.metatype;
     if (!metatype || this.toValidate(metatype)) {
       return value;
     }
 
-    const validate = ValidationCompiler.compile(metatype);
-    const errors = validate(value);
-    if (errors) {
-      throw new HttpException({
-        statusCode: 400,
-        message: 'Validation failed',
-        errors,
-      }, 400);
-    }
+    if (classValidator && classTransformer) {
+      try {
+        const object = classTransformer.plainToInstance(metatype, value);
+        const errors = await classValidator.validate(object, {
+          whitelist: this.whitelistOption,
+          forbidNonWhitelisted: this.forbidNonWhitelistedOption,
+        });
+
+        if (errors.length > 0) {
+          const errorMessages = errors.flatMap((err: any) => {
+            return err.constraints ? Object.values(err.constraints) : [];
+          });
+          throw new HttpException({
+            statusCode: 400,
+            message: 'Validation failed',
+            errors: errorMessages,
+          }, 400);
+        }
 
-    return value;
+        return this.transformOption ? object : value;
+      } catch (err) {
+        // Fallback to JIT if dynamic call fails
+        const validate = ValidationCompiler.compile(metatype);
+        const errors = validate(value);
+        if (errors) {
+          throw new HttpException({
+            statusCode: 400,
+            message: 'Validation failed',
+            errors,
+          }, 400);
+        }
+        return value;
+      }
+    } else {
+      const validate = ValidationCompiler.compile(metatype);
+      const errors = validate(value);
+      if (errors) {
+        throw new HttpException({
+          statusCode: 400,
+          message: 'Validation failed',
+          errors,
+        }, 400);
+      }
+      return value;
+    }
   }
 
   private toValidate(metatype: Function): boolean {

package/src/versioning/versioning.ts

@@ -0,0 +1,46 @@
+import 'reflect-metadata';
+import { SetMetadata } from '../core/decorators.ts';
+
+export enum VersioningType {
+  URI = 'uri',
+  HEADER = 'header',
+  MEDIA_TYPE = 'media-type',
+}
+
+export interface VersioningOptions {
+  type: VersioningType;
+  defaultVersion?: string | string[];
+  header?: string; // For HEADER type, e.g., 'X-API-Version'
+  key?: string;    // For MEDIA_TYPE type, e.g., 'v'
+}
+
+export const VERSION_METADATA_KEY = 'calyx:version';
+
+export function Version(version: string | string[]): MethodDecorator & ClassDecorator {
+  return (target: any, key?: string | symbol, descriptor?: any) => {
+    if (descriptor) {
+      Reflect.defineMetadata(VERSION_METADATA_KEY, version, descriptor.value);
+      return descriptor;
+    }
+    Reflect.defineMetadata(VERSION_METADATA_KEY, version, target);
+    return target;
+  };
+}
+
+export class VersionExtractor {
+  static extract(req: Request, type: VersioningType, options: VersioningOptions): string | undefined {
+    if (type === VersioningType.HEADER) {
+      const headerName = options.header ?? 'x-api-version';
+      return req.headers.get(headerName.toLowerCase()) || undefined;
+    }
+
+    if (type === VersioningType.MEDIA_TYPE) {
+      const accept = req.headers.get('accept') || '';
+      const key = options.key ?? 'v';
+      const match = accept.match(new RegExp(`${key}=([a-zA-Z0-9_-]+)`));
+      return match ? match[1] : undefined;
+    }
+
+    return undefined;
+  }
+}

package/tests/graphql.test.ts

@@ -0,0 +1,176 @@
+import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
+import { Module, CalyxFactory } from '../src/index.ts';
+import {
+  Resolver,
+  Query,
+  Mutation,
+  ResolveField,
+  Args,
+  Parent,
+  ObjectType,
+  InputType,
+  ArgsType,
+  Field,
+  GraphQLModule,
+} from '../src/graphql/index.ts';
+
+// 1. GraphQL Object Type DTOs
+@ObjectType()
+class Author {
+  @Field()
+  id!: number;
+
+  @Field()
+  name!: string;
+}
+
+@ObjectType()
+class PostGql {
+  @Field()
+  id!: number;
+
+  @Field()
+  title!: string;
+
+  @Field(() => Author)
+  author!: Author;
+}
+
+// 2. GraphQL Input Type DTO
+@InputType()
+class CreatePostInput {
+  @Field()
+  title!: string;
+
+  @Field()
+  authorId!: number;
+}
+
+// 3. GraphQL Args Type DTO (Flattened Args)
+@ArgsType()
+class GetPostArgs {
+  @Field()
+  id!: number;
+}
+
+// 4. Resolver Class
+@Resolver(PostGql)
+class PostResolver {
+  @Query(() => PostGql)
+  getPost(@Args() args: GetPostArgs) {
+    return {
+      id: args.id,
+      title: `Calyx: GraphQL JIT Performance`,
+      authorId: 456, // to be resolved by ResolveField
+    };
+  }
+
+  @Mutation(() => PostGql)
+  createPost(@Args('input') input: CreatePostInput) {
+    return {
+      id: 999,
+      title: input.title,
+      authorId: input.authorId,
+    };
+  }
+
+  @ResolveField(() => Author)
+  author(@Parent() post: any) {
+    return {
+      id: post.authorId,
+      name: 'Jane Doe',
+    };
+  }
+}
+
+@Module({
+  imports: [GraphQLModule],
+  providers: [PostResolver],
+})
+class TestApp {}
+
+describe('Native Code-First GraphQL Module', () => {
+  let app: any;
+  let baseUrl: string;
+  const PORT = 3928;
+
+  beforeAll(async () => {
+    app = await CalyxFactory.create(TestApp);
+    await app.listen(PORT);
+    baseUrl = `http://localhost:${PORT}`;
+  });
+
+  afterAll(async () => {
+    await app.close();
+  });
+
+  test('should execute Query and ResolveField successfully using native graphql adapter', async () => {
+    const res = await fetch(`${baseUrl}/graphql`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        query: `
+          query {
+            getPost(id: 123) {
+              id
+              title
+              author {
+                id
+                name
+              }
+            }
+          }
+        `,
+      }),
+    });
+
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.errors).toBeUndefined();
+    expect(body.data).toEqual({
+      getPost: {
+        id: 123,
+        title: 'Calyx: GraphQL JIT Performance',
+        author: {
+          id: 456,
+          name: 'Jane Doe',
+        },
+      },
+    });
+  });
+
+  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',
+        },
+      },
+    });
+  });
+});

package/tests/openapi.test.ts

@@ -0,0 +1,162 @@
+import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
+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. DTO Model
+class Item {
+  @ApiProperty({ description: 'The unique identifier', type: Number })
+  id!: number;
+
+  @ApiProperty({ description: 'The item name', type: String })
+  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 })
+  @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({
+  controllers: [ItemsController],
+})
+class TestApp {}
+
+describe('OpenAPI (Swagger) Generation', () => {
+  let app: any;
+  let baseUrl: string;
+  const PORT = 3932;
+
+  beforeAll(async () => {
+    app = await CalyxFactory.create(TestApp);
+    
+    // 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);
+    SwaggerModule.setup('api', app, document);
+
+    await app.listen(PORT);
+    baseUrl = `http://localhost:${PORT}`;
+  });
+
+  afterAll(async () => {
+    await app.close();
+  });
+
+  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.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 () => {
+    const res = await fetch(`${baseUrl}/api`);
+    expect(res.status).toBe(200);
+    const html = await res.text();
+    expect(html).toContain('swagger-ui');
+    expect(html).toContain('window.ui = SwaggerUIBundle');
+  });
+});