@martel/calyx 0.1.0

package/tests/lifecycle.test.ts

@@ -0,0 +1,169 @@
+import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
+import {
+  Module,
+  Controller,
+  Get,
+  Post,
+  Body,
+  Query,
+  UseGuards,
+  UseInterceptors,
+  UsePipes,
+  UseFilters,
+  Catch,
+  CanActivate,
+  NestInterceptor,
+  CallHandler,
+  PipeTransform,
+  ExceptionFilter,
+  ArgumentsHost,
+  ExecutionContext,
+  calyxFactory,
+  HttpException,
+  ForbiddenException,
+  BadRequestException,
+  calyxResponse,
+} from '../src/index.ts';
+
+// 1. Guard
+class TestGuard implements CanActivate {
+  canActivate(context: ExecutionContext): boolean {
+    const req = context.switchToHttp().getRequest<Request>();
+    const authHeader = req.headers.get('Authorization');
+    return authHeader === 'allow';
+  }
+}
+
+// 2. Interceptor
+class TestInterceptor implements NestInterceptor {
+  async intercept(context: ExecutionContext, next: CallHandler): Promise<any> {
+    const res = await next.handle();
+    if (typeof res === 'object') {
+      return { ...res, intercepted: true };
+    }
+    return `${res} intercepted`;
+  }
+}
+
+// 3. Pipe
+class ParseIntPipe implements PipeTransform {
+  transform(value: any) {
+    const val = Number(value);
+    if (isNaN(val)) {
+      throw new BadRequestException('Validation failed: value must be a numeric string');
+    }
+    return val;
+  }
+}
+
+// 4. Exception Filter
+class CustomError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'CustomError';
+  }
+}
+
+@Catch(CustomError)
+class CustomExceptionFilter implements ExceptionFilter {
+  catch(exception: CustomError, host: ArgumentsHost) {
+    const res = host.switchToHttp().getResponse<calyxResponse>();
+    res.status(418).json({
+      customFilter: true,
+      errorMessage: exception.message,
+    });
+  }
+}
+
+@Controller('lifecycle')
+class TestLifecycleController {
+  @Get('guard-test')
+  @UseGuards(TestGuard)
+  guardTest() {
+    return 'access granted';
+  }
+
+  @Get('interceptor-test')
+  @UseInterceptors(TestInterceptor)
+  interceptorTest() {
+    return { success: true };
+  }
+
+  @Get('pipe-test')
+  pipeTest(@Query('num', ParseIntPipe) num: number) {
+    return { value: num, type: typeof num };
+  }
+
+  @Get('filter-test')
+  @UseFilters(CustomExceptionFilter)
+  filterTest() {
+    throw new CustomError('Teapot trigger');
+  }
+}
+
+@Module({
+  controllers: [TestLifecycleController],
+})
+class AppModule {}
+
+describe('Request Lifecycle Pipeline (Guards, Interceptors, Pipes, Filters)', () => {
+  let app: any;
+  let baseUrl: string;
+  const PORT = 3848;
+
+  beforeAll(async () => {
+    app = await calyxFactory.create(AppModule);
+    await app.listen(PORT);
+    baseUrl = `http://localhost:${PORT}`;
+  });
+
+  afterAll(async () => {
+    await app.close();
+  });
+
+  // Guard test
+  test('should return 403 Forbidden if guard returns false', async () => {
+    const res = await fetch(`${baseUrl}/lifecycle/guard-test`);
+    expect(res.status).toBe(403);
+  });
+
+  test('should return 200 if guard passes with header', async () => {
+    const res = await fetch(`${baseUrl}/lifecycle/guard-test`, {
+      headers: { Authorization: 'allow' },
+    });
+    expect(res.status).toBe(200);
+    const text = await res.text();
+    expect(text).toBe('access granted');
+  });
+
+  // Interceptor test
+  test('should transform output using NestInterceptor', async () => {
+    const res = await fetch(`${baseUrl}/lifecycle/interceptor-test`);
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body).toEqual({ success: true, intercepted: true });
+  });
+
+  // Pipe test
+  test('should transform query parameter value using PipeTransform', async () => {
+    const res = await fetch(`${baseUrl}/lifecycle/pipe-test?num=100`);
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body).toEqual({ value: 100, type: 'number' });
+  });
+
+  test('should return 400 Bad Request if PipeTransform fails validation', async () => {
+    const res = await fetch(`${baseUrl}/lifecycle/pipe-test?num=not-a-number`);
+    expect(res.status).toBe(400);
+    const body = await res.json();
+    expect(body.message).toContain('Validation failed');
+  });
+
+  // Filter test
+  test('should intercept custom error and format response using ExceptionFilter', async () => {
+    const res = await fetch(`${baseUrl}/lifecycle/filter-test`);
+    expect(res.status).toBe(418); // Teapot
+    const body = await res.json();
+    expect(body).toEqual({ customFilter: true, errorMessage: 'Teapot trigger' });
+  });
+});

package/tests/routing.test.ts

@@ -0,0 +1,155 @@
+import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
+import {
+  Module,
+  Controller,
+  Get,
+  Post,
+  Put,
+  Delete,
+  Param,
+  Query,
+  Body,
+  Headers,
+  HttpCode,
+  Header,
+  Res,
+  Redirect,
+  calyxFactory,
+  calyxResponse,
+  NotFoundException,
+  BadRequestException,
+} from '../src/index.ts';
+
+@Controller('users')
+class UsersController {
+  @Get()
+  getAll() {
+    return [{ id: 1, name: 'John' }];
+  }
+
+  @Post()
+  @HttpCode(201)
+  create(@Body() body: any) {
+    return { created: true, data: body };
+  }
+
+  @Get(':id')
+  getOne(@Param('id') id: string) {
+    return { id: Number(id) };
+  }
+
+  @Put(':id')
+  @Header('X-Updated', 'true')
+  update(@Param('id') id: string, @Body('name') name: string) {
+    return { id: Number(id), name };
+  }
+
+  @Get(':id/posts/:postId')
+  getPost(@Param('id') id: string, @Param('postId') postId: string, @Query('limit') limit?: string) {
+    return { userId: Number(id), postId: Number(postId), limit: limit ? Number(limit) : undefined };
+  }
+
+  @Get('redirect-test')
+  @Redirect('/users/dest', 301)
+  redirect() {}
+
+  @Get('dest')
+  dest() {
+    return 'destination';
+  }
+
+  @Get('manual')
+  manual(@Res() res: calyxResponse) {
+    res.status(202).json({ manual: true });
+  }
+
+  @Get('error-test')
+  error() {
+    throw new BadRequestException('Invalid request parameter');
+  }
+}
+
+@Module({
+  controllers: [UsersController],
+})
+class AppModule {}
+
+describe('HTTP Routing and Controller System', () => {
+  let app: any;
+  let baseUrl: string;
+  const PORT = 3847;
+
+  beforeAll(async () => {
+    app = await calyxFactory.create(AppModule);
+    await app.listen(PORT);
+    baseUrl = `http://localhost:${PORT}`;
+  });
+
+  afterAll(async () => {
+    await app.close();
+  });
+
+  test('should return 200 and JSON from GET /users', async () => {
+    const res = await fetch(`${baseUrl}/users`);
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body).toEqual([{ id: 1, name: 'John' }]);
+  });
+
+  test('should return 201 and parsed body from POST /users', async () => {
+    const payload = { name: 'Alice' };
+    const res = await fetch(`${baseUrl}/users`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify(payload),
+    });
+    expect(res.status).toBe(201);
+    const body = await res.json();
+    expect(body).toEqual({ created: true, data: { name: 'Alice' } });
+  });
+
+  test('should extract path parameters from GET /users/:id', async () => {
+    const res = await fetch(`${baseUrl}/users/42`);
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body).toEqual({ id: 42 });
+  });
+
+  test('should parse custom headers and body parameter from PUT /users/:id', async () => {
+    const res = await fetch(`${baseUrl}/users/42`, {
+      method: 'PUT',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ name: 'Bob' }),
+    });
+    expect(res.status).toBe(200);
+    expect(res.headers.get('x-updated')).toBe('true');
+    const body = await res.json();
+    expect(body).toEqual({ id: 42, name: 'Bob' });
+  });
+
+  test('should parse multiple path params and query params', async () => {
+    const res = await fetch(`${baseUrl}/users/42/posts/100?limit=5`);
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body).toEqual({ userId: 42, postId: 100, limit: 5 });
+  });
+
+  test('should support manual response injection using @Res()', async () => {
+    const res = await fetch(`${baseUrl}/users/manual`);
+    expect(res.status).toBe(202);
+    const body = await res.json();
+    expect(body).toEqual({ manual: true });
+  });
+
+  test('should return correct HTTP error response when HttpException thrown', async () => {
+    const res = await fetch(`${baseUrl}/users/error-test`);
+    expect(res.status).toBe(400);
+    const body = await res.json();
+    expect(body).toEqual({ statusCode: 400, message: 'Invalid request parameter' });
+  });
+
+  test('should return 404 for non-existent route', async () => {
+    const res = await fetch(`${baseUrl}/users/nonexistent/route/path`);
+    expect(res.status).toBe(404);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "types": ["bun-types"]
+  },
+  "include": ["src/**/*", "tests/**/*", "benchmarks/**/*"]
+}