raffel 0.1.2

package/dist/adapters/jsonrpc.int.test.js

@@ -0,0 +1,640 @@
+/**
+ * JSON-RPC 2.0 Adapter Tests
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { createJsonRpcAdapter, JsonRpcErrorCode, HttpMetadataKey, } from './jsonrpc.js';
+import { createRegistry } from '../core/registry.js';
+import { createRouter, RaffelError } from '../core/router.js';
+import { getExtension } from '../types/context.js';
+// Helper to make JSON-RPC HTTP requests
+async function jsonRpcRequest(port, body, options = {}) {
+    const { path = '/', contentType = 'application/json', method = 'POST' } = options;
+    const response = await fetch(`http://localhost:${port}${path}`, {
+        method,
+        headers: contentType ? { 'Content-Type': contentType } : {},
+        body: method !== 'OPTIONS' ? JSON.stringify(body) : undefined,
+    });
+    let responseBody;
+    const text = await response.text();
+    if (text) {
+        try {
+            responseBody = JSON.parse(text);
+        }
+        catch {
+            responseBody = text;
+        }
+    }
+    return { status: response.status, body: responseBody, headers: response.headers };
+}
+function resolvePort(adapter) {
+    const server = adapter.getServer();
+    if (!server) {
+        throw new Error('JSON-RPC server not started');
+    }
+    const address = server.address();
+    if (!address || typeof address === 'string') {
+        throw new Error('Unable to resolve JSON-RPC server port');
+    }
+    return address.port;
+}
+describe('JSON-RPC 2.0 Adapter', () => {
+    let registry;
+    let router;
+    let port;
+    beforeEach(() => {
+        registry = createRegistry();
+        router = createRouter(registry);
+        port = 0;
+    });
+    afterEach(async () => {
+        // Allow cleanup time
+        await new Promise((resolve) => setTimeout(resolve, 50));
+    });
+    describe('Basic Requests', () => {
+        it('should handle a simple procedure call', async () => {
+            registry.procedure('greet', async (input) => ({
+                message: `Hello, ${input.name}!`,
+            }));
+            const adapter = createJsonRpcAdapter(router, { port: 0 });
+            await adapter.start();
+            port = resolvePort(adapter);
+            try {
+                const request = {
+                    jsonrpc: '2.0',
+                    method: 'greet',
+                    params: { name: 'World' },
+                    id: 1,
+                };
+                const { status, body } = await jsonRpcRequest(port, request);
+                expect(status).toBe(200);
+                const response = body;
+                expect(response.jsonrpc).toBe('2.0');
+                expect(response.id).toBe(1);
+                expect(response.result).toEqual({ message: 'Hello, World!' });
+                expect(response.error).toBeUndefined();
+            }
+            finally {
+                await adapter.stop();
+            }
+        });
+        it('should handle procedure with no params', async () => {
+            registry.procedure('ping', async () => ({ pong: true }));
+            const adapter = createJsonRpcAdapter(router, { port: 0 });
+            await adapter.start();
+            port = resolvePort(adapter);
+            try {
+                const request = {
+                    jsonrpc: '2.0',
+                    method: 'ping',
+                    id: 'test-id',
+                };
+                const { status, body } = await jsonRpcRequest(port, request);
+                expect(status).toBe(200);
+                const response = body;
+                expect(response.id).toBe('test-id');
+                expect(response.result).toEqual({ pong: true });
+            }
+            finally {
+                await adapter.stop();
+            }
+        });
+        it('should handle positional params (array)', async () => {
+            registry.procedure('add', async (input) => ({
+                sum: input.reduce((a, b) => a + b, 0),
+            }));
+            const adapter = createJsonRpcAdapter(router, { port: 0 });
+            await adapter.start();
+            port = resolvePort(adapter);
+            try {
+                const request = {
+                    jsonrpc: '2.0',
+                    method: 'add',
+                    params: [1, 2, 3, 4, 5],
+                    id: 1,
+                };
+                const { body } = await jsonRpcRequest(port, request);
+                const response = body;
+                expect(response.result).toEqual({ sum: 15 });
+            }
+            finally {
+                await adapter.stop();
+            }
+        });
+        it('should handle single positional param', async () => {
+            registry.procedure('double', async (input) => ({
+                result: input * 2,
+            }));
+            const adapter = createJsonRpcAdapter(router, { port: 0 });
+            await adapter.start();
+            port = resolvePort(adapter);
+            try {
+                const request = {
+                    jsonrpc: '2.0',
+                    method: 'double',
+                    params: [5],
+                    id: 1,
+                };
+                const { body } = await jsonRpcRequest(port, request);
+                const response = body;
+                expect(response.result).toEqual({ result: 10 });
+            }
+            finally {
+                await adapter.stop();
+            }
+        });
+    });
+    describe('Notifications', () => {
+        it('should not return response for notifications', async () => {
+            let called = false;
+            registry.procedure('log', async () => {
+                called = true;
+                return { ok: true };
+            });
+            const adapter = createJsonRpcAdapter(router, { port: 0 });
+            await adapter.start();
+            port = resolvePort(adapter);
+            try {
+                const request = {
+                    jsonrpc: '2.0',
+                    method: 'log',
+                    // No id = notification
+                };
+                const { status, body } = await jsonRpcRequest(port, request);
+                expect(status).toBe(204);
+                expect(body).toBeFalsy();
+                // Give it time to process
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                expect(called).toBe(true);
+            }
+            finally {
+                await adapter.stop();
+            }
+        });
+        it('should handle notification with params', async () => {
+            let receivedData;
+            registry.procedure('store', async (input) => {
+                receivedData = input.data;
+                return { ok: true };
+            });
+            const adapter = createJsonRpcAdapter(router, { port: 0 });
+            await adapter.start();
+            port = resolvePort(adapter);
+            try {
+                const request = {
+                    jsonrpc: '2.0',
+                    method: 'store',
+                    params: { data: 'test-value' },
+                };
+                const { status } = await jsonRpcRequest(port, request);
+                expect(status).toBe(204);
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                expect(receivedData).toBe('test-value');
+            }
+            finally {
+                await adapter.stop();
+            }
+        });
+    });
+    describe('Batch Requests', () => {
+        it('should handle batch requests', async () => {
+            registry.procedure('greet', async (input) => ({
+                message: `Hello, ${input.name}!`,
+            }));
+            registry.procedure('ping', async () => ({ pong: true }));
+            const adapter = createJsonRpcAdapter(router, { port: 0 });
+            await adapter.start();
+            port = resolvePort(adapter);
+            try {
+                const batch = [
+                    { jsonrpc: '2.0', method: 'greet', params: { name: 'Alice' }, id: 1 },
+                    { jsonrpc: '2.0', method: 'ping', id: 2 },
+                    { jsonrpc: '2.0', method: 'greet', params: { name: 'Bob' }, id: 3 },
+                ];
+                const { status, body } = await jsonRpcRequest(port, batch);
+                expect(status).toBe(200);
+                const responses = body;
+                expect(responses).toHaveLength(3);
+                const sorted = responses.sort((a, b) => Number(a.id) - Number(b.id));
+                expect(sorted[0].result).toEqual({ message: 'Hello, Alice!' });
+                expect(sorted[1].result).toEqual({ pong: true });
+                expect(sorted[2].result).toEqual({ message: 'Hello, Bob!' });
+            }
+            finally {
+                await adapter.stop();
+            }
+        });
+        it('should handle batch with mixed requests and notifications', async () => {
+            registry.procedure('greet', async (input) => ({
+                message: `Hello, ${input.name}!`,
+            }));
+            registry.procedure('log', async () => ({ ok: true }));
+            const adapter = createJsonRpcAdapter(router, { port: 0 });
+            await adapter.start();
+            port = resolvePort(adapter);
+            try {
+                const batch = [
+                    { jsonrpc: '2.0', method: 'greet', params: { name: 'Alice' }, id: 1 },
+                    { jsonrpc: '2.0', method: 'log' }, // notification
+                    { jsonrpc: '2.0', method: 'greet', params: { name: 'Bob' }, id: 2 },
+                ];
+                const { status, body } = await jsonRpcRequest(port, batch);
+                expect(status).toBe(200);
+                const responses = body;
+                // Only 2 responses (notifications don't return responses)
+                expect(responses).toHaveLength(2);
+            }
+            finally {
+                await adapter.stop();
+            }
+        });
+        it('should return 204 for batch of only notifications', async () => {
+            registry.procedure('log', async () => ({ ok: true }));
+            const adapter = createJsonRpcAdapter(router, { port: 0 });
+            await adapter.start();
+            port = resolvePort(adapter);
+            try {
+                const batch = [
+                    { jsonrpc: '2.0', method: 'log' },
+                    { jsonrpc: '2.0', method: 'log' },
+                ];
+                const { status, body } = await jsonRpcRequest(port, batch);
+                expect(status).toBe(204);
+                expect(body).toBeFalsy();
+            }
+            finally {
+                await adapter.stop();
+            }
+        });
+        it('should reject empty batch', async () => {
+            const adapter = createJsonRpcAdapter(router, { port: 0 });
+            await adapter.start();
+            port = resolvePort(adapter);
+            try {
+                const { status, body } = await jsonRpcRequest(port, []);
+                expect(status).toBe(200);
+                const response = body;
+                expect(response.error?.code).toBe(JsonRpcErrorCode.INVALID_REQUEST);
+                expect(response.error?.message).toContain('Empty batch');
+            }
+            finally {
+                await adapter.stop();
+            }
+        });
+    });
+    describe('Error Handling', () => {
+        it('should return METHOD_NOT_FOUND for unknown procedure', async () => {
+            const adapter = createJsonRpcAdapter(router, { port: 0 });
+            await adapter.start();
+            port = resolvePort(adapter);
+            try {
+                const request = {
+                    jsonrpc: '2.0',
+                    method: 'unknown',
+                    id: 1,
+                };
+                const { status, body } = await jsonRpcRequest(port, request);
+                expect(status).toBe(200);
+                const response = body;
+                expect(response.error?.code).toBe(JsonRpcErrorCode.METHOD_NOT_FOUND);
+                expect(response.id).toBe(1);
+            }
+            finally {
+                await adapter.stop();
+            }
+        });
+        it('should return INVALID_REQUEST for wrong JSON-RPC version', async () => {
+            const adapter = createJsonRpcAdapter(router, { port: 0 });
+            await adapter.start();
+            port = resolvePort(adapter);
+            try {
+                const request = {
+                    jsonrpc: '1.0',
+                    method: 'test',
+                    id: 1,
+                };
+                const { body } = await jsonRpcRequest(port, request);
+                const response = body;
+                expect(response.error?.code).toBe(JsonRpcErrorCode.INVALID_REQUEST);
+                expect(response.error?.message).toContain('Invalid JSON-RPC version');
+            }
+            finally {
+                await adapter.stop();
+            }
+        });
+        it('should return INVALID_REQUEST for missing method', async () => {
+            const adapter = createJsonRpcAdapter(router, { port: 0 });
+            await adapter.start();
+            port = resolvePort(adapter);
+            try {
+                const request = {
+                    jsonrpc: '2.0',
+                    id: 1,
+                };
+                const { body } = await jsonRpcRequest(port, request);
+                const response = body;
+                expect(response.error?.code).toBe(JsonRpcErrorCode.INVALID_REQUEST);
+                expect(response.error?.message).toContain('Method must be a non-empty string');
+            }
+            finally {
+                await adapter.stop();
+            }
+        });
+        it('should return INVALID_REQUEST for empty method', async () => {
+            const adapter = createJsonRpcAdapter(router, { port: 0 });
+            await adapter.start();
+            port = resolvePort(adapter);
+            try {
+                const request = {
+                    jsonrpc: '2.0',
+                    method: '',
+                    id: 1,
+                };
+                const { body } = await jsonRpcRequest(port, request);
+                const response = body;
+                expect(response.error?.code).toBe(JsonRpcErrorCode.INVALID_REQUEST);
+            }
+            finally {
+                await adapter.stop();
+            }
+        });
+        it('should return PARSE_ERROR for invalid JSON', async () => {
+            const adapter = createJsonRpcAdapter(router, { port: 0 });
+            await adapter.start();
+            port = resolvePort(adapter);
+            try {
+                const response = await fetch(`http://localhost:${port}/`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: '{invalid json}',
+                });
+                const body = (await response.json());
+                expect(body.error?.code).toBe(JsonRpcErrorCode.PARSE_ERROR);
+            }
+            finally {
+                await adapter.stop();
+            }
+        });
+        it('should return INTERNAL_ERROR for handler exceptions', async () => {
+            registry.procedure('fail', async () => {
+                throw new Error('Something went wrong');
+            });
+            const adapter = createJsonRpcAdapter(router, { port: 0 });
+            await adapter.start();
+            port = resolvePort(adapter);
+            try {
+                const request = {
+                    jsonrpc: '2.0',
+                    method: 'fail',
+                    id: 1,
+                };
+                const { body } = await jsonRpcRequest(port, request);
+                const response = body;
+                expect(response.error?.code).toBe(JsonRpcErrorCode.INTERNAL_ERROR);
+                expect(response.error?.message).toBe('Something went wrong');
+            }
+            finally {
+                await adapter.stop();
+            }
+        });
+        it('should map RaffelError VALIDATION_ERROR to INVALID_PARAMS', async () => {
+            registry.procedure('validate', async () => {
+                throw new RaffelError('VALIDATION_ERROR', 'Invalid input');
+            });
+            const adapter = createJsonRpcAdapter(router, { port: 0 });
+            await adapter.start();
+            port = resolvePort(adapter);
+            try {
+                const request = {
+                    jsonrpc: '2.0',
+                    method: 'validate',
+                    id: 1,
+                };
+                const { body } = await jsonRpcRequest(port, request);
+                const response = body;
+                expect(response.error?.code).toBe(JsonRpcErrorCode.INVALID_PARAMS);
+            }
+            finally {
+                await adapter.stop();
+            }
+        });
+        it('should handle null id in request', async () => {
+            registry.procedure('test', async () => ({ ok: true }));
+            const adapter = createJsonRpcAdapter(router, { port: 0 });
+            await adapter.start();
+            port = resolvePort(adapter);
+            try {
+                const request = {
+                    jsonrpc: '2.0',
+                    method: 'test',
+                    id: null,
+                };
+                const { body } = await jsonRpcRequest(port, request);
+                const response = body;
+                expect(response.id).toBeNull();
+                expect(response.result).toEqual({ ok: true });
+            }
+            finally {
+                await adapter.stop();
+            }
+        });
+    });
+    describe('HTTP Layer', () => {
+        it('should reject non-POST requests', async () => {
+            const adapter = createJsonRpcAdapter(router, { port: 0 });
+            await adapter.start();
+            port = resolvePort(adapter);
+            try {
+                const response = await fetch(`http://localhost:${port}/`, {
+                    method: 'GET',
+                });
+                expect(response.status).toBe(405);
+                const body = (await response.json());
+                expect(body.error?.code).toBe(JsonRpcErrorCode.INVALID_REQUEST);
+            }
+            finally {
+                await adapter.stop();
+            }
+        });
+        it('should reject wrong content-type', async () => {
+            const adapter = createJsonRpcAdapter(router, { port: 0 });
+            await adapter.start();
+            port = resolvePort(adapter);
+            try {
+                const response = await fetch(`http://localhost:${port}/`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/xml' },
+                    body: '{"jsonrpc":"2.0","method":"test","id":1}',
+                });
+                expect(response.status).toBe(415);
+            }
+            finally {
+                await adapter.stop();
+            }
+        });
+        it('should return 404 for wrong path', async () => {
+            const adapter = createJsonRpcAdapter(router, { port: 0, path: '/rpc' });
+            await adapter.start();
+            port = resolvePort(adapter);
+            try {
+                const response = await fetch(`http://localhost:${port}/wrong`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: '{"jsonrpc":"2.0","method":"test","id":1}',
+                });
+                expect(response.status).toBe(404);
+            }
+            finally {
+                await adapter.stop();
+            }
+        });
+        it('should handle custom path', async () => {
+            registry.procedure('test', async () => ({ ok: true }));
+            const adapter = createJsonRpcAdapter(router, { port: 0, path: '/api/jsonrpc' });
+            await adapter.start();
+            port = resolvePort(adapter);
+            try {
+                const request = {
+                    jsonrpc: '2.0',
+                    method: 'test',
+                    id: 1,
+                };
+                const { status, body } = await jsonRpcRequest(port, request, { path: '/api/jsonrpc' });
+                expect(status).toBe(200);
+                const response = body;
+                expect(response.result).toEqual({ ok: true });
+            }
+            finally {
+                await adapter.stop();
+            }
+        });
+    });
+    describe('CORS', () => {
+        it('should handle OPTIONS preflight', async () => {
+            const adapter = createJsonRpcAdapter(router, { port: 0, cors: true });
+            await adapter.start();
+            port = resolvePort(adapter);
+            try {
+                const response = await fetch(`http://localhost:${port}/`, {
+                    method: 'OPTIONS',
+                });
+                expect(response.status).toBe(204);
+                expect(response.headers.get('Access-Control-Allow-Origin')).toBe('*');
+                expect(response.headers.get('Access-Control-Allow-Methods')).toContain('POST');
+            }
+            finally {
+                await adapter.stop();
+            }
+        });
+        it('should include CORS headers in response', async () => {
+            registry.procedure('test', async () => ({ ok: true }));
+            const adapter = createJsonRpcAdapter(router, { port: 0, cors: true });
+            await adapter.start();
+            port = resolvePort(adapter);
+            try {
+                const request = {
+                    jsonrpc: '2.0',
+                    method: 'test',
+                    id: 1,
+                };
+                const { headers } = await jsonRpcRequest(port, request);
+                expect(headers.get('Access-Control-Allow-Origin')).toBe('*');
+            }
+            finally {
+                await adapter.stop();
+            }
+        });
+    });
+    describe('Server Lifecycle', () => {
+        it('should start and stop cleanly', async () => {
+            const adapter = createJsonRpcAdapter(router, { port: 0 });
+            expect(adapter.getServer()).toBeNull();
+            await adapter.start();
+            port = resolvePort(adapter);
+            expect(adapter.getServer()).not.toBeNull();
+            await adapter.stop();
+            expect(adapter.getServer()).toBeNull();
+        });
+        it('should allow restart', async () => {
+            registry.procedure('test', async () => ({ ok: true }));
+            const adapter = createJsonRpcAdapter(router, { port: 0 });
+            await adapter.start();
+            port = resolvePort(adapter);
+            await adapter.stop();
+            await adapter.start();
+            port = resolvePort(adapter);
+            try {
+                const request = {
+                    jsonrpc: '2.0',
+                    method: 'test',
+                    id: 1,
+                };
+                const { status, body } = await jsonRpcRequest(port, request);
+                expect(status).toBe(200);
+                expect(body.result).toEqual({ ok: true });
+            }
+            finally {
+                await adapter.stop();
+            }
+        });
+    });
+    describe('Body Size Limit', () => {
+        it('should reject requests exceeding maxBodySize', async () => {
+            const adapter = createJsonRpcAdapter(router, { port: 0, maxBodySize: 100 });
+            await adapter.start();
+            port = resolvePort(adapter);
+            try {
+                // Create a large payload
+                const largePayload = {
+                    jsonrpc: '2.0',
+                    method: 'test',
+                    params: { data: 'x'.repeat(200) },
+                    id: 1,
+                };
+                const response = await fetch(`http://localhost:${port}/`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(largePayload),
+                });
+                expect(response.status).toBe(413);
+            }
+            finally {
+                await adapter.stop();
+            }
+        });
+    });
+    describe('Metadata', () => {
+        it('should pass HTTP headers as metadata via context extension', async () => {
+            let receivedMetadata;
+            registry.procedure('checkHeaders', async (_input, ctx) => {
+                receivedMetadata = getExtension(ctx, HttpMetadataKey);
+                return { ok: true };
+            });
+            const adapter = createJsonRpcAdapter(router, { port: 0 });
+            await adapter.start();
+            port = resolvePort(adapter);
+            try {
+                const response = await fetch(`http://localhost:${port}/`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'X-Custom-Header': 'custom-value',
+                        'Authorization': 'Bearer token123',
+                    },
+                    body: JSON.stringify({
+                        jsonrpc: '2.0',
+                        method: 'checkHeaders',
+                        id: 1,
+                    }),
+                });
+                expect(response.status).toBe(200);
+                expect(receivedMetadata).toBeDefined();
+                expect(receivedMetadata['x-custom-header']).toBe('custom-value');
+                expect(receivedMetadata['authorization']).toBe('Bearer token123');
+            }
+            finally {
+                await adapter.stop();
+            }
+        });
+    });
+});
+//# sourceMappingURL=jsonrpc.int.test.js.map