@derivation/rpc 0.3.0 → 0.3.5

package/dist/iso.d.ts

@@ -1,5 +1,5 @@
 import { RecordOf } from "immutable";
-import { ZSet, ZMap } from "@derivation/relational";
+import { ZSet, ZMap } from "@derivation/composable";
 export interface Iso<In, Out> {
     to(x: In): Out;
     from(x: Out): In;

package/dist/iso.js

@@ -1,5 +1,5 @@
 import { Record as ImmutableRecord } from "immutable";
-import { ZSet, ZMap } from "@derivation/relational";
+import { ZSet, ZMap } from "@derivation/composable";
 export function id() {
     return {
         to: (x) => x,

package/dist/reactive-map-adapter.d.ts

@@ -1,24 +1,24 @@
 import { Graph } from "derivation";
-import { ReactiveMap, ReactiveMapSource, ZMapChangeInput } from "@derivation/relational";
+import { ZMap, Reactive, ZMapChangeInput } from "@derivation/composable";
 import { Source, Sink } from "./stream-types.js";
 import { Iso } from "./iso.js";
-export declare class ReactiveMapSourceAdapter<K, V> implements Source<ReactiveMap<K, V>> {
+export declare class ReactiveMapSourceAdapter<K, V> implements Source<Reactive<ZMap<K, V>>> {
     private readonly map;
     private readonly iso;
-    constructor(map: ReactiveMap<K, V>, keyIso: Iso<K, unknown>, valueIso: Iso<V, unknown>);
+    constructor(map: Reactive<ZMap<K, V>>, keyIso: Iso<K, unknown>, valueIso: Iso<V, unknown>);
     get Snapshot(): object;
     get LastChange(): object | null;
-    get Stream(): ReactiveMap<K, V>;
+    get Stream(): Reactive<ZMap<K, V>>;
 }
-export declare class ReactiveMapSinkAdapter<K, V> implements Sink<ReactiveMapSource<K, V>, ZMapChangeInput<K, V>> {
+export declare class ReactiveMapSinkAdapter<K, V> implements Sink<Reactive<ZMap<K, V>>, ZMapChangeInput<K, V>> {
     private readonly graph;
     private readonly iso;
     private readonly initialMap;
     constructor(graph: Graph, keyIso: Iso<K, unknown>, valueIso: Iso<V, unknown>, snapshot: object);
     apply(change: object, input: ZMapChangeInput<K, V>): void;
     build(): {
-        stream: ReactiveMapSource<K, V>;
+        stream: Reactive<ZMap<K, V>>;
         input: ZMapChangeInput<K, V>;
     };
 }
-export declare function sink<K, V>(graph: Graph, keyIso: Iso<K, unknown>, valueIso: Iso<V, unknown>): (snapshot: object) => Sink<ReactiveMapSource<K, V>, ZMapChangeInput<K, V>>;
+export declare function sink<K, V>(graph: Graph, keyIso: Iso<K, unknown>, valueIso: Iso<V, unknown>): (snapshot: object) => Sink<Reactive<ZMap<K, V>>, ZMapChangeInput<K, V>>;

package/dist/reactive-map-adapter.js

@@ -1,4 +1,4 @@
-import { inputMap, } from "@derivation/relational";
+import { Reactive, ZMapOperations, ZMapChangeInput } from "@derivation/composable";
 import { zmap } from "./iso.js";
 export class ReactiveMapSourceAdapter {
     constructor(map, keyIso, valueIso) {
@@ -31,8 +31,9 @@ export class ReactiveMapSinkAdapter {
         }
     }
     build() {
-        const stream = inputMap(this.graph, this.initialMap);
-        return { stream, input: stream.changes };
+        const input = new ZMapChangeInput(this.graph);
+        const stream = Reactive.create(this.graph, new ZMapOperations(), input, this.initialMap);
+        return { stream, input };
     }
 }
 export function sink(graph, keyIso, valueIso) {

package/dist/reactive-set-adapter.d.ts

@@ -1,24 +1,24 @@
 import { Graph } from "derivation";
-import { ZSet, ReactiveSet, ReactiveSetSource, ZSetChangeInput } from "@derivation/relational";
+import { ZSet, Reactive, ZSetChangeInput } from "@derivation/composable";
 import { Source, Sink } from "./stream-types.js";
 import { Iso } from "./iso.js";
-export declare class ReactiveSetSourceAdapter<T> implements Source<ReactiveSet<T>> {
+export declare class ReactiveSetSourceAdapter<T> implements Source<Reactive<ZSet<T>>> {
     private readonly set;
     private readonly iso;
-    constructor(set: ReactiveSet<T>, iso: Iso<T, unknown>);
+    constructor(set: Reactive<ZSet<T>>, iso: Iso<T, unknown>);
     get Snapshot(): object;
     get LastChange(): object | null;
-    get Stream(): ReactiveSet<T>;
+    get Stream(): Reactive<ZSet<T>>;
 }
-export declare class ReactiveSetSinkAdapter<T> implements Sink<ReactiveSetSource<T>, ZSetChangeInput<T>> {
+export declare class ReactiveSetSinkAdapter<T> implements Sink<Reactive<ZSet<T>>, ZSetChangeInput<T>> {
     private readonly graph;
     private readonly iso;
     private readonly initialSet;
     constructor(graph: Graph, iso: Iso<ZSet<T>, unknown>, snapshot: object);
     apply(change: object, input: ZSetChangeInput<T>): void;
     build(): {
-        stream: ReactiveSetSource<T>;
+        stream: Reactive<ZSet<T>>;
         input: ZSetChangeInput<T>;
     };
 }
-export declare function sink<T>(graph: Graph, iso: Iso<T, unknown>): (snapshot: object) => Sink<ReactiveSetSource<T>, ZSetChangeInput<T>>;
+export declare function sink<T>(graph: Graph, iso: Iso<T, unknown>): (snapshot: object) => Sink<Reactive<ZSet<T>>, ZSetChangeInput<T>>;

package/dist/reactive-set-adapter.js

@@ -1,4 +1,4 @@
-import { inputSet, } from "@derivation/relational";
+import { Reactive, ZSetOperations, ZSetChangeInput } from "@derivation/composable";
 import { zset, zsetToArray, compose } from "./iso.js";
 export class ReactiveSetSourceAdapter {
     constructor(set, iso) {
@@ -28,8 +28,9 @@ export class ReactiveSetSinkAdapter {
         input.push(this.iso.from(change));
     }
     build() {
-        const stream = inputSet(this.graph, this.initialSet);
-        return { stream, input: stream.changes };
+        const input = new ZSetChangeInput(this.graph);
+        const stream = Reactive.create(this.graph, new ZSetOperations(), input, this.initialSet);
+        return { stream, input };
     }
 }
 export function sink(graph, iso) {

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 {};