@derivation/rpc 0.3.3 → 0.3.5

package/dist/tests/context.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/context.test.js

@@ -0,0 +1,252 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { createServer } from 'http';
+import { WebSocket } from 'ws';
+import { Graph, inputValue } from 'derivation';
+import { StreamSourceAdapter } from '../index.js';
+import { setupWebSocketServer } from '../web-socket-server.js';
+import { id } from '../iso.js';
+describe('Context', () => {
+    let server;
+    let graph;
+    let port;
+    let receivedContexts = [];
+    beforeEach((ctx) => {
+        return new Promise((resolve) => {
+            graph = new Graph();
+            server = createServer();
+            receivedContexts = [];
+            // Create test endpoints that capture context
+            const streamEndpoints = {
+                testStream: async (args, ctx) => {
+                    receivedContexts.push(ctx);
+                    const input = inputValue(graph, { value: `Hello from ${ctx.userId}` });
+                    return new StreamSourceAdapter(input, id());
+                },
+            };
+            const mutationEndpoints = {
+                testMutation: async (args, ctx) => {
+                    receivedContexts.push(ctx);
+                    return {
+                        success: true,
+                        value: {
+                            output: `Processed: ${args.input}`,
+                            userId: ctx.userId,
+                            role: ctx.role,
+                        },
+                    };
+                },
+            };
+            // Setup server with createContext
+            setupWebSocketServer(graph, server, streamEndpoints, mutationEndpoints, {
+                createContext: (ws, req) => {
+                    // Parse userId from query params
+                    const url = new URL(req.url, `http://${req.headers.host}`);
+                    const userId = url.searchParams.get('userId') || 'anonymous';
+                    const role = url.searchParams.get('role') || 'user';
+                    return { userId, role };
+                },
+            });
+            server.listen(0, () => {
+                const addr = server.address();
+                if (addr && typeof addr === 'object') {
+                    port = addr.port;
+                    resolve();
+                }
+            });
+        });
+    });
+    it('should pass context to stream endpoints', async () => {
+        const ws = new WebSocket(`ws://localhost:${port}/api/ws?userId=test-user&role=admin`);
+        await new Promise((resolve) => {
+            ws.on('open', () => {
+                ws.send(JSON.stringify({
+                    type: 'subscribe',
+                    id: 1,
+                    name: 'testStream',
+                    args: {},
+                }));
+            });
+            ws.on('message', (data) => {
+                const msg = JSON.parse(data.toString());
+                if (msg.type === 'snapshot') {
+                    expect(receivedContexts).toHaveLength(1);
+                    expect(receivedContexts[0]).toEqual({
+                        userId: 'test-user',
+                        role: 'admin',
+                    });
+                    ws.close();
+                    resolve();
+                }
+            });
+        });
+        server.close();
+    });
+    it('should pass context to mutation endpoints', async () => {
+        const ws = new WebSocket(`ws://localhost:${port}/api/ws?userId=alice&role=user`);
+        await new Promise((resolve) => {
+            ws.on('open', () => {
+                ws.send(JSON.stringify({
+                    type: 'call',
+                    id: 1,
+                    name: 'testMutation',
+                    args: { input: 'test data' },
+                }));
+            });
+            ws.on('message', (data) => {
+                const msg = JSON.parse(data.toString());
+                if (msg.type === 'result') {
+                    expect(msg.success).toBe(true);
+                    expect(msg.value).toEqual({
+                        output: 'Processed: test data',
+                        userId: 'alice',
+                        role: 'user',
+                    });
+                    expect(receivedContexts).toHaveLength(1);
+                    expect(receivedContexts[0]).toEqual({
+                        userId: 'alice',
+                        role: 'user',
+                    });
+                    ws.close();
+                    resolve();
+                }
+            });
+        });
+        server.close();
+    });
+    it('should use default context when no query params', async () => {
+        const ws = new WebSocket(`ws://localhost:${port}/api/ws`);
+        await new Promise((resolve) => {
+            ws.on('open', () => {
+                ws.send(JSON.stringify({
+                    type: 'subscribe',
+                    id: 1,
+                    name: 'testStream',
+                    args: {},
+                }));
+            });
+            ws.on('message', (data) => {
+                const msg = JSON.parse(data.toString());
+                if (msg.type === 'snapshot') {
+                    expect(receivedContexts).toHaveLength(1);
+                    expect(receivedContexts[0]).toEqual({
+                        userId: 'anonymous',
+                        role: 'user',
+                    });
+                    ws.close();
+                    resolve();
+                }
+            });
+        });
+        server.close();
+    });
+    it('should create separate context for each connection', async () => {
+        const ws1 = new WebSocket(`ws://localhost:${port}/api/ws?userId=user1`);
+        const ws2 = new WebSocket(`ws://localhost:${port}/api/ws?userId=user2`);
+        const contexts = await Promise.all([
+            new Promise((resolve) => {
+                ws1.on('open', () => {
+                    ws1.send(JSON.stringify({
+                        type: 'call',
+                        id: 1,
+                        name: 'testMutation',
+                        args: { input: 'from user1' },
+                    }));
+                });
+                ws1.on('message', (data) => {
+                    const msg = JSON.parse(data.toString());
+                    if (msg.type === 'result') {
+                        ws1.close();
+                        resolve({ userId: msg.value.userId, role: msg.value.role });
+                    }
+                });
+            }),
+            new Promise((resolve) => {
+                ws2.on('open', () => {
+                    ws2.send(JSON.stringify({
+                        type: 'call',
+                        id: 1,
+                        name: 'testMutation',
+                        args: { input: 'from user2' },
+                    }));
+                });
+                ws2.on('message', (data) => {
+                    const msg = JSON.parse(data.toString());
+                    if (msg.type === 'result') {
+                        ws2.close();
+                        resolve({ userId: msg.value.userId, role: msg.value.role });
+                    }
+                });
+            }),
+        ]);
+        expect(contexts[0]).toEqual({ userId: 'user1', role: 'user' });
+        expect(contexts[1]).toEqual({ userId: 'user2', role: 'user' });
+        expect(receivedContexts).toHaveLength(2);
+        server.close();
+    });
+    it('should handle async createContext and process messages', async () => {
+        await new Promise((resolve) => server.close(() => resolve()));
+        // Create new server with async context creation
+        const newServer = createServer();
+        const newGraph = new Graph();
+        let capturedContext = null;
+        const streamEndpoints = {
+            testStream: async (args, ctx) => {
+                capturedContext = ctx;
+                const input = inputValue(newGraph, { value: 'test' });
+                return new StreamSourceAdapter(input, id());
+            },
+        };
+        const mutationEndpoints = {
+            testMutation: async (args, ctx) => ({
+                success: true,
+                value: { output: args.input, userId: ctx.userId, role: ctx.role },
+            }),
+        };
+        setupWebSocketServer(newGraph, newServer, streamEndpoints, mutationEndpoints, {
+            createContext: async (ws, req) => {
+                // Simulate async auth validation (e.g., database lookup)
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                return { userId: 'async-user', role: 'admin' };
+            },
+        });
+        const newPort = await new Promise((resolve) => {
+            newServer.listen(0, () => {
+                const addr = newServer.address();
+                if (addr && typeof addr === 'object') {
+                    resolve(addr.port);
+                }
+            });
+        });
+        const ws = new WebSocket(`ws://localhost:${newPort}/api/ws`);
+        await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject(new Error('Test timed out - async context creation may have race condition'));
+            }, 2000);
+            ws.on('open', () => {
+                // Send subscribe message immediately - this tests if async context works
+                ws.send(JSON.stringify({
+                    type: 'subscribe',
+                    id: 1,
+                    name: 'testStream',
+                    args: {},
+                }));
+            });
+            ws.on('message', (data) => {
+                const msg = JSON.parse(data.toString());
+                if (msg.type === 'snapshot') {
+                    clearTimeout(timeout);
+                    // Verify the async context was actually used
+                    expect(capturedContext).not.toBeNull();
+                    expect(capturedContext === null || capturedContext === void 0 ? void 0 : capturedContext.userId).toBe('async-user');
+                    expect(capturedContext === null || capturedContext === void 0 ? void 0 : capturedContext.role).toBe('admin');
+                    ws.close();
+                    newServer.close(() => resolve());
+                }
+            });
+            ws.on('error', (err) => {
+                clearTimeout(timeout);
+                reject(err);
+            });
+        });
+    });
+});

package/dist/tests/iso.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/iso.test.js

@@ -0,0 +1,186 @@
+import { describe, it, expect } from 'vitest';
+import { ZSet, ZMap } from '@derivation/composable';
+import * as iso from '../iso.js';
+describe('iso', () => {
+    describe('id', () => {
+        it('should return the same value for to and from', () => {
+            const identity = iso.id();
+            expect(identity.to(42)).toBe(42);
+            expect(identity.from(42)).toBe(42);
+        });
+        it('should work with objects', () => {
+            const identity = iso.id();
+            const obj = { x: 10 };
+            expect(identity.to(obj)).toBe(obj);
+            expect(identity.from(obj)).toBe(obj);
+        });
+    });
+    describe('unknown', () => {
+        it('should convert to unknown and back', () => {
+            const unknownIso = iso.unknown();
+            expect(unknownIso.to('hello')).toBe('hello');
+            expect(unknownIso.from('world')).toBe('world');
+        });
+    });
+    describe('flip', () => {
+        it('should reverse the direction of an isomorphism', () => {
+            const original = {
+                to: (n) => n.toString(),
+                from: (s) => parseInt(s, 10),
+            };
+            const flipped = iso.flip(original);
+            expect(flipped.to('42')).toBe(42);
+            expect(flipped.from(42)).toBe('42');
+        });
+    });
+    describe('compose', () => {
+        it('should compose two isomorphisms', () => {
+            const numToString = {
+                to: (n) => n.toString(),
+                from: (s) => parseInt(s, 10),
+            };
+            const stringToUpper = {
+                to: (s) => s.toUpperCase(),
+                from: (s) => s.toLowerCase(),
+            };
+            const composed = iso.compose(numToString, stringToUpper);
+            expect(composed.to(42)).toBe('42');
+            expect(composed.from('42')).toBe(42);
+        });
+    });
+    describe('array', () => {
+        it('should map over array elements', () => {
+            const numToString = {
+                to: (n) => n.toString(),
+                from: (s) => parseInt(s, 10),
+            };
+            const arrayIso = iso.array(numToString);
+            expect(arrayIso.to([1, 2, 3])).toEqual(['1', '2', '3']);
+            expect(arrayIso.from(['1', '2', '3'])).toEqual([1, 2, 3]);
+        });
+        it('should work with empty arrays', () => {
+            const arrayIso = iso.array(iso.id());
+            expect(arrayIso.to([])).toEqual([]);
+            expect(arrayIso.from([])).toEqual([]);
+        });
+    });
+    describe('zset', () => {
+        it('should convert ZSet elements', () => {
+            const numToString = {
+                to: (n) => n.toString(),
+                from: (s) => parseInt(s, 10),
+            };
+            const zsetIso = iso.zset(numToString);
+            let inputZSet = new ZSet();
+            inputZSet = inputZSet.add(1, 2).add(2, 3);
+            const outputZSet = zsetIso.to(inputZSet);
+            expect([...outputZSet.getEntries()]).toEqual([['1', 2], ['2', 3]]);
+            const roundTrip = zsetIso.from(outputZSet);
+            expect([...roundTrip.getEntries()]).toEqual([...inputZSet.getEntries()]);
+        });
+    });
+    describe('zsetToArray', () => {
+        it('should convert ZSet to array of [item, weight] tuples', () => {
+            const zsetToArrayIso = iso.zsetToArray();
+            let zset = new ZSet();
+            zset = zset.add('a', 1).add('b', 2);
+            const array = zsetToArrayIso.to(zset);
+            expect(array).toEqual([['a', 1], ['b', 2]]);
+            const backToZSet = zsetToArrayIso.from(array);
+            expect([...backToZSet.getEntries()]).toEqual([...zset.getEntries()]);
+        });
+    });
+    describe('object', () => {
+        it('should convert object properties', () => {
+            const objIso = iso.object({
+                x: iso.id(),
+                y: iso.id(),
+            });
+            const result = objIso.to({ x: 42, y: 'hello' });
+            expect(result).toEqual({ x: 42, y: 'hello' });
+            const reverse = objIso.from({ x: 42, y: 'hello' });
+            expect(reverse).toEqual({ x: 42, y: 'hello' });
+        });
+        it('should transform object properties', () => {
+            const numToString = {
+                to: (n) => n.toString(),
+                from: (s) => parseInt(s, 10),
+            };
+            const objIso = iso.object({
+                age: numToString,
+                name: iso.id(),
+            });
+            expect(objIso.to({ age: 30, name: 'Alice' })).toEqual({ age: '30', name: 'Alice' });
+            expect(objIso.from({ age: '30', name: 'Alice' })).toEqual({ age: 30, name: 'Alice' });
+        });
+    });
+    describe('shallowRecord', () => {
+        it('should convert between Immutable Record and plain object', () => {
+            const recordIso = iso.shallowRecord();
+            const plain = { name: 'Bob', age: 25 };
+            const record = recordIso.from(plain);
+            expect(record.get('name')).toBe('Bob');
+            expect(record.get('age')).toBe(25);
+            const backToPlain = recordIso.to(record);
+            expect(backToPlain).toEqual(plain);
+        });
+    });
+    describe('record', () => {
+        it('should convert Immutable Record with property transformations', () => {
+            const numToString = {
+                to: (n) => n.toString(),
+                from: (s) => parseInt(s, 10),
+            };
+            const recordIso = iso.record({
+                name: iso.id(),
+                age: numToString,
+            });
+            const serialized = { name: 'Charlie', age: '35' };
+            const record = recordIso.from(serialized);
+            expect(record.get('name')).toBe('Charlie');
+            expect(record.get('age')).toBe(35);
+            const backToSerialized = recordIso.to(record);
+            expect(backToSerialized).toEqual({ name: 'Charlie', age: '35' });
+        });
+    });
+    describe('tuple', () => {
+        it('should convert tuple elements', () => {
+            const numToString = {
+                to: (n) => n.toString(),
+                from: (s) => parseInt(s, 10),
+            };
+            const tupleIso = iso.tuple(numToString, iso.id(), iso.id());
+            expect(tupleIso.to([42, true, 'test'])).toEqual(['42', true, 'test']);
+            expect(tupleIso.from(['42', true, 'test'])).toEqual([42, true, 'test']);
+        });
+    });
+    describe('map', () => {
+        it('should convert Map to array of entries with transformed keys and values', () => {
+            const numToString = {
+                to: (n) => n.toString(),
+                from: (s) => parseInt(s, 10),
+            };
+            const mapIso = iso.map(numToString, iso.id());
+            const inputMap = new Map([[1, 'one'], [2, 'two']]);
+            const array = mapIso.to(inputMap);
+            expect(array).toEqual([['1', 'one'], ['2', 'two']]);
+            const backToMap = mapIso.from(array);
+            expect([...backToMap.entries()]).toEqual([...inputMap.entries()]);
+        });
+    });
+    describe('zmap', () => {
+        it('should convert ZMap to array with weights', () => {
+            const numToString = {
+                to: (n) => n.toString(),
+                from: (s) => parseInt(s, 10),
+            };
+            const zmapIso = iso.zmap(numToString, iso.id());
+            let zmap = new ZMap();
+            zmap = zmap.add(1, 'one', 5).add(2, 'two', 3);
+            const array = zmapIso.to(zmap);
+            expect(array).toEqual([['1', 'one', 5], ['2', 'two', 3]]);
+            const backToZMap = zmapIso.from(array);
+            expect([...backToZMap.getEntries()]).toEqual([...zmap.getEntries()]);
+        });
+    });
+});

package/dist/tests/messages.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/messages.test.js

@@ -0,0 +1,152 @@
+import { describe, it, expect } from 'vitest';
+import { ClientMessage, parseClientMessage, SubscribeMessageSchema, UnsubscribeMessageSchema, HeartbeatMessageSchema as ClientHeartbeatMessageSchema, } from '../client-message.js';
+import { ServerMessage, HeartbeatMessageSchema as ServerHeartbeatMessageSchema, SubscribedSchema, DeltaMessageSchema, } from '../server-message.js';
+describe('ClientMessage', () => {
+    describe('subscribe', () => {
+        it('should create a valid subscribe message', () => {
+            const msg = ClientMessage.subscribe(1, 'testStream', { foo: 'bar' });
+            expect(msg).toEqual({
+                type: 'subscribe',
+                id: 1,
+                name: 'testStream',
+                args: { foo: 'bar' },
+            });
+        });
+        it('should validate against schema', () => {
+            const msg = ClientMessage.subscribe(42, 'myStream', { x: 10 });
+            expect(() => SubscribeMessageSchema.parse(msg)).not.toThrow();
+        });
+    });
+    describe('unsubscribe', () => {
+        it('should create a valid unsubscribe message', () => {
+            const msg = ClientMessage.unsubscribe(5);
+            expect(msg).toEqual({
+                type: 'unsubscribe',
+                id: 5,
+            });
+        });
+        it('should validate against schema', () => {
+            const msg = ClientMessage.unsubscribe(99);
+            expect(() => UnsubscribeMessageSchema.parse(msg)).not.toThrow();
+        });
+    });
+    describe('heartbeat', () => {
+        it('should create a valid heartbeat message', () => {
+            const msg = ClientMessage.heartbeat();
+            expect(msg).toEqual({
+                type: 'heartbeat',
+            });
+        });
+        it('should validate against schema', () => {
+            const msg = ClientMessage.heartbeat();
+            expect(() => ClientHeartbeatMessageSchema.parse(msg)).not.toThrow();
+        });
+    });
+    describe('parseClientMessage', () => {
+        it('should parse valid subscribe messages', () => {
+            const data = {
+                type: 'subscribe',
+                id: 1,
+                name: 'stream1',
+                args: { key: 'value' },
+            };
+            const result = parseClientMessage(data);
+            expect(result).toEqual(data);
+            expect(result.type).toBe('subscribe');
+        });
+        it('should parse valid unsubscribe messages', () => {
+            const data = {
+                type: 'unsubscribe',
+                id: 10,
+            };
+            const result = parseClientMessage(data);
+            expect(result).toEqual(data);
+            expect(result.type).toBe('unsubscribe');
+        });
+        it('should parse valid heartbeat messages', () => {
+            const data = {
+                type: 'heartbeat',
+            };
+            const result = parseClientMessage(data);
+            expect(result).toEqual(data);
+            expect(result.type).toBe('heartbeat');
+        });
+        it('should reject invalid messages', () => {
+            const invalidData = {
+                type: 'invalid',
+                foo: 'bar',
+            };
+            expect(() => parseClientMessage(invalidData)).toThrow();
+        });
+        it('should reject subscribe without required fields', () => {
+            const invalidData = {
+                type: 'subscribe',
+                id: 1,
+                // missing name and args
+            };
+            expect(() => parseClientMessage(invalidData)).toThrow();
+        });
+        it('should reject unsubscribe without id', () => {
+            const invalidData = {
+                type: 'unsubscribe',
+            };
+            expect(() => parseClientMessage(invalidData)).toThrow();
+        });
+    });
+});
+describe('ServerMessage', () => {
+    describe('heartbeat', () => {
+        it('should create a valid heartbeat message', () => {
+            const msg = ServerMessage.heartbeat();
+            expect(msg).toEqual({
+                type: 'heartbeat',
+            });
+        });
+        it('should validate against schema', () => {
+            const msg = ServerMessage.heartbeat();
+            expect(() => ServerHeartbeatMessageSchema.parse(msg)).not.toThrow();
+        });
+    });
+    describe('subscribed', () => {
+        it('should create a valid subscribed message with snapshot', () => {
+            const snapshot = { data: [1, 2, 3] };
+            const msg = ServerMessage.subscribed(7, snapshot);
+            expect(msg).toEqual({
+                type: 'snapshot',
+                id: 7,
+                snapshot,
+            });
+        });
+        it('should validate against schema', () => {
+            const msg = ServerMessage.subscribed(1, { foo: 'bar' });
+            expect(() => SubscribedSchema.parse(msg)).not.toThrow();
+        });
+        it('should handle null snapshot', () => {
+            const msg = ServerMessage.subscribed(1, null);
+            expect(msg.snapshot).toBe(null);
+            expect(() => SubscribedSchema.parse(msg)).not.toThrow();
+        });
+    });
+    describe('delta', () => {
+        it('should create a valid delta message', () => {
+            const changes = {
+                1: { add: ['a', 'b'] },
+                2: { remove: ['c'] },
+            };
+            const msg = ServerMessage.delta(changes);
+            expect(msg).toEqual({
+                type: 'delta',
+                changes,
+            });
+        });
+        it('should validate against schema', () => {
+            const msg = ServerMessage.delta({ 1: { x: 10 }, 2: { y: 20 } });
+            expect(() => DeltaMessageSchema.parse(msg)).not.toThrow();
+        });
+        it('should handle empty changes', () => {
+            const msg = ServerMessage.delta({});
+            expect(msg.changes).toEqual({});
+            expect(() => DeltaMessageSchema.parse(msg)).not.toThrow();
+        });
+    });
+});

package/dist/tests/mutations.test.d.ts

@@ -0,0 +1 @@
+export {};