@martel/calyx 1.4.0 → 1.6.0

package/tests/security.test.ts

@@ -0,0 +1,89 @@
+import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
+import {
+  Module,
+  Controller,
+  Get,
+  CalyxFactory,
+  HashingService,
+} from '../src/index.ts';
+
+@Controller('test-security')
+class SecurityController {
+  constructor(private readonly hashing: HashingService) {}
+
+  @Get('hash')
+  async testHash() {
+    const password = 'my_secure_password';
+    const hash = await this.hashing.hash(password);
+    const valid = await this.hashing.verify(password, hash);
+    const invalid = await this.hashing.verify('wrong_password', hash);
+    return { valid, invalid };
+  }
+
+  @Get('hello')
+  sayHello() {
+    return { hello: 'world' };
+  }
+}
+
+@Module({
+  controllers: [SecurityController],
+  providers: [HashingService],
+})
+class SecurityTestApp {}
+
+describe('Security Features (Hashing, CORS, Helmet)', () => {
+  let app: any;
+  let baseUrl: string;
+  const PORT = 3878;
+
+  beforeAll(async () => {
+    app = await CalyxFactory.create(SecurityTestApp);
+    app.enableCors({ origin: 'http://example.com', credentials: true });
+    app.useHelmet({ contentSecurityPolicy: false }); // Disable CSP to make tests simpler
+    await app.listen(PORT);
+    baseUrl = `http://localhost:${PORT}`;
+  });
+
+  afterAll(async () => {
+    await app.close();
+  });
+
+  test('should hash and verify passwords using native Bun.password Zig bindings', async () => {
+    const res = await fetch(`${baseUrl}/test-security/hash`);
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.valid).toBe(true);
+    expect(body.invalid).toBe(false);
+  });
+
+  test('should apply CORS headers and respond to preflight OPTIONS request', async () => {
+    // 1. Regular GET request with Origin
+    const res = await fetch(`${baseUrl}/test-security/hello`, {
+      headers: { Origin: 'http://example.com' },
+    });
+    expect(res.status).toBe(200);
+    expect(res.headers.get('access-control-allow-origin')).toBe('http://example.com');
+    expect(res.headers.get('access-control-allow-credentials')).toBe('true');
+
+    // 2. Preflight OPTIONS request
+    const preflight = await fetch(`${baseUrl}/test-security/hello`, {
+      method: 'OPTIONS',
+      headers: {
+        Origin: 'http://example.com',
+        'Access-Control-Request-Method': 'GET',
+      },
+    });
+    expect(preflight.status).toBe(204);
+    expect(preflight.headers.get('access-control-allow-origin')).toBe('http://example.com');
+    expect(preflight.headers.get('access-control-allow-methods')).toContain('GET');
+  });
+
+  test('should set Helmet secure headers', async () => {
+    const res = await fetch(`${baseUrl}/test-security/hello`);
+    expect(res.status).toBe(200);
+    expect(res.headers.get('x-content-type-options')).toBe('nosniff');
+    expect(res.headers.get('x-frame-options')).toBe('SAMEORIGIN');
+    expect(res.headers.get('referrer-policy')).toBe('no-referrer');
+  });
+});

package/tests/websockets.test.ts

@@ -0,0 +1,125 @@
+import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
+import {
+  Module,
+  CalyxFactory,
+  WebSocketGateway,
+  SubscribeMessage,
+  MessageBody,
+  ConnectedSocket,
+} from '../src/index.ts';
+
+let clientConnected = false;
+let clientDisconnected = false;
+let messageReceived: any = null;
+
+// 1. Shared Port Gateway
+@WebSocketGateway()
+class SharedEventsGateway {
+  handleConnection(client: any) {
+    clientConnected = true;
+  }
+
+  handleDisconnect(client: any) {
+    clientDisconnected = true;
+  }
+
+  @SubscribeMessage('events')
+  onEvents(@MessageBody() data: any, @ConnectedSocket() client: any) {
+    messageReceived = data;
+    return { event: 'events', data: `echo: ${data}` };
+  }
+}
+
+// 2. Dedicated Port Gateway
+let dedicatedConnected = false;
+@WebSocketGateway(3912)
+class DedicatedEventsGateway {
+  handleConnection(client: any) {
+    dedicatedConnected = true;
+  }
+
+  @SubscribeMessage('dedicated_event')
+  onDedicatedEvent(@MessageBody() data: any) {
+    return { event: 'dedicated_response', data: `dedicated echo: ${data}` };
+  }
+}
+
+@Module({
+  providers: [SharedEventsGateway, DedicatedEventsGateway],
+})
+class TestApp {}
+
+describe('WebSocket Gateways (Bun.serve, SubscribeMessage, MessageBody, ConnectedSocket)', () => {
+  let app: any;
+  const PORT = 3889;
+
+  beforeAll(async () => {
+    app = await CalyxFactory.create(TestApp);
+    await app.listen(PORT);
+  });
+
+  afterAll(async () => {
+    await app.close();
+  });
+
+  test('should connect and handle message exchange on shared port', async () => {
+    clientConnected = false;
+    clientDisconnected = false;
+    messageReceived = null;
+
+    const ws = new WebSocket(`ws://localhost:${PORT}`);
+
+    // Wait for connection to open
+    await new Promise<void>((resolve, reject) => {
+      ws.onopen = () => resolve();
+      ws.onerror = (err) => reject(err);
+    });
+
+    expect(clientConnected).toBe(true);
+
+    // Send a message
+    ws.send(JSON.stringify({ event: 'events', data: 'hello calyx' }));
+
+    // Wait for response message
+    const response = await new Promise<any>((resolve) => {
+      ws.onmessage = (event) => {
+        resolve(JSON.parse(event.data));
+      };
+    });
+
+    expect(messageReceived).toBe('hello calyx');
+    expect(response).toEqual({ event: 'events', data: 'echo: hello calyx' });
+
+    // Close connection
+    ws.close();
+
+    // Wait a tick for disconnect event
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    expect(clientDisconnected).toBe(true);
+  });
+
+  test('should connect and handle message exchange on dedicated port', async () => {
+    dedicatedConnected = false;
+
+    const ws = new WebSocket('ws://localhost:3912');
+
+    await new Promise<void>((resolve, reject) => {
+      ws.onopen = () => resolve();
+      ws.onerror = (err) => reject(err);
+    });
+
+    expect(dedicatedConnected).toBe(true);
+
+    ws.send(JSON.stringify({ event: 'dedicated_event', data: 'secure channel' }));
+
+    const response = await new Promise<any>((resolve) => {
+      ws.onmessage = (event) => {
+        resolve(JSON.parse(event.data));
+      };
+    });
+
+    expect(response).toEqual({ event: 'dedicated_response', data: 'dedicated echo: secure channel' });
+
+    ws.close();
+  });
+});