@derivation/rpc 0.3.0 → 0.3.5

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

package/dist/tests/mutations.test.js

@@ -0,0 +1,122 @@
+import { describe, it, expect } from 'vitest';
+import { ClientMessage, CallMessageSchema, parseClientMessage, } from '../client-message.js';
+import { ServerMessage, ResultMessageSchema, } from '../server-message.js';
+describe('Mutation Messages', () => {
+    describe('ClientMessage.call', () => {
+        it('should create a valid call message', () => {
+            const msg = ClientMessage.call(1, 'addUser', { name: 'Alice', age: 30 });
+            expect(msg).toEqual({
+                type: 'call',
+                id: 1,
+                name: 'addUser',
+                args: { name: 'Alice', age: 30 },
+            });
+        });
+        it('should validate against schema', () => {
+            const msg = ClientMessage.call(42, 'myMutation', { x: 10 });
+            expect(() => CallMessageSchema.parse(msg)).not.toThrow();
+        });
+        it('should be parseable by parseClientMessage', () => {
+            const data = {
+                type: 'call',
+                id: 5,
+                name: 'updateUser',
+                args: { id: 123, name: 'Bob' },
+            };
+            const result = parseClientMessage(data);
+            expect(result).toEqual(data);
+            expect(result.type).toBe('call');
+        });
+        it('should reject call without required fields', () => {
+            const invalidData = {
+                type: 'call',
+                id: 1,
+                // missing name and args
+            };
+            expect(() => parseClientMessage(invalidData)).toThrow();
+        });
+    });
+    describe('ServerMessage.resultSuccess', () => {
+        it('should create a valid success result message', () => {
+            const value = { userId: 42, status: 'created' };
+            const msg = ServerMessage.resultSuccess(1, value);
+            expect(msg).toEqual({
+                type: 'result',
+                id: 1,
+                success: true,
+                value,
+            });
+        });
+        it('should validate against schema', () => {
+            const msg = ServerMessage.resultSuccess(1, { data: 'test' });
+            expect(() => ResultMessageSchema.parse(msg)).not.toThrow();
+        });
+        it('should handle null values', () => {
+            const msg = ServerMessage.resultSuccess(1, null);
+            expect(msg.value).toBe(null);
+            expect(() => ResultMessageSchema.parse(msg)).not.toThrow();
+        });
+        it('should handle primitive values', () => {
+            const msgString = ServerMessage.resultSuccess(1, 'hello');
+            expect(msgString.value).toBe('hello');
+            const msgNumber = ServerMessage.resultSuccess(2, 42);
+            expect(msgNumber.value).toBe(42);
+            const msgBoolean = ServerMessage.resultSuccess(3, true);
+            expect(msgBoolean.value).toBe(true);
+        });
+    });
+    describe('ServerMessage.resultError', () => {
+        it('should create a valid error result message', () => {
+            const msg = ServerMessage.resultError(1, 'User not found');
+            expect(msg).toEqual({
+                type: 'result',
+                id: 1,
+                success: false,
+                error: 'User not found',
+            });
+        });
+        it('should validate against schema', () => {
+            const msg = ServerMessage.resultError(1, 'Something went wrong');
+            expect(() => ResultMessageSchema.parse(msg)).not.toThrow();
+        });
+        it('should handle empty error messages', () => {
+            const msg = ServerMessage.resultError(1, '');
+            expect(msg.error).toBe('');
+            expect(() => ResultMessageSchema.parse(msg)).not.toThrow();
+        });
+    });
+});
+describe('MutationResult type', () => {
+    it('should represent successful results', () => {
+        const result = {
+            success: true,
+            value: 42,
+        };
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.value).toBe(42);
+        }
+    });
+    it('should represent error results', () => {
+        const result = {
+            success: false,
+            error: 'Failed to compute',
+        };
+        expect(result.success).toBe(false);
+        if (!result.success) {
+            expect(result.error).toBe('Failed to compute');
+        }
+    });
+    it('should work with complex types', () => {
+        const successResult = {
+            success: true,
+            value: { id: 1, name: 'Alice' },
+        };
+        const errorResult = {
+            success: false,
+            error: 'User creation failed',
+        };
+        expect(successResult.success).toBe(true);
+        expect(errorResult.success).toBe(false);
+    });
+});

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

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

package/dist/tests/queue.test.js

@@ -0,0 +1,84 @@
+import { describe, it, expect } from 'vitest';
+import { Queue } from '../queue.js';
+describe('Queue', () => {
+    it('should start empty', () => {
+        const q = new Queue();
+        expect(q.isEmpty()).toBe(true);
+        expect(q.length).toBe(0);
+    });
+    it('should push and pop single item', () => {
+        const q = new Queue();
+        q.push(1);
+        expect(q.length).toBe(1);
+        expect(q.pop()).toBe(1);
+        expect(q.isEmpty()).toBe(true);
+    });
+    it('should maintain FIFO order', () => {
+        const q = new Queue();
+        q.push(1);
+        q.push(2);
+        q.push(3);
+        expect(q.pop()).toBe(1);
+        expect(q.pop()).toBe(2);
+        expect(q.pop()).toBe(3);
+        expect(q.pop()).toBe(undefined);
+    });
+    it('should handle interleaved push and pop', () => {
+        const q = new Queue();
+        q.push('a');
+        q.push('b');
+        expect(q.pop()).toBe('a');
+        q.push('c');
+        expect(q.pop()).toBe('b');
+        expect(q.pop()).toBe('c');
+        expect(q.isEmpty()).toBe(true);
+    });
+    it('should reverse front to back when back is empty', () => {
+        const q = new Queue();
+        // Fill front
+        q.push(1);
+        q.push(2);
+        q.push(3);
+        // Pop empties back, triggers reverse
+        expect(q.pop()).toBe(1);
+        expect(q.pop()).toBe(2);
+        // Add more to front
+        q.push(4);
+        q.push(5);
+        // Continue popping - should get 3 (from back), then 4, 5 (after reverse)
+        expect(q.pop()).toBe(3);
+        expect(q.pop()).toBe(4);
+        expect(q.pop()).toBe(5);
+        expect(q.isEmpty()).toBe(true);
+    });
+    it('should handle large number of operations', () => {
+        const q = new Queue();
+        const n = 1000;
+        // Push n items
+        for (let i = 0; i < n; i++) {
+            q.push(i);
+        }
+        expect(q.length).toBe(n);
+        // Pop n items in order
+        for (let i = 0; i < n; i++) {
+            expect(q.pop()).toBe(i);
+        }
+        expect(q.isEmpty()).toBe(true);
+    });
+    it('should maintain length correctly through operations', () => {
+        const q = new Queue();
+        expect(q.length).toBe(0);
+        q.push(1);
+        expect(q.length).toBe(1);
+        q.push(2);
+        q.push(3);
+        expect(q.length).toBe(3);
+        q.pop();
+        expect(q.length).toBe(2);
+        q.pop();
+        q.pop();
+        expect(q.length).toBe(0);
+        q.pop(); // Pop from empty
+        expect(q.length).toBe(0);
+    });
+});

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

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

package/dist/tests/reactive-map-adapter.test.js

@@ -0,0 +1,190 @@
+import { describe, it, expect } from 'vitest';
+import { Graph } from 'derivation';
+import { ZMap, Reactive, ZMapOperations, ZMapChangeInput } from '@derivation/composable';
+import { ReactiveMapSourceAdapter, ReactiveMapSinkAdapter, sink } from '../reactive-map-adapter.js';
+import * as iso from '../iso.js';
+describe('ReactiveMapSourceAdapter', () => {
+    it('should provide snapshot as array of [key, value, weight] tuples', () => {
+        const graph = new Graph();
+        let zmap = new ZMap();
+        zmap = zmap.add('a', 1, 10).add('b', 2, 20);
+        const reactiveMap = Reactive.create(graph, new ZMapOperations(), new ZMapChangeInput(graph), zmap);
+        const adapter = new ReactiveMapSourceAdapter(reactiveMap, iso.id(), iso.id());
+        const snapshot = adapter.Snapshot;
+        expect(snapshot).toEqual([['a', 1, 10], ['b', 2, 20]]);
+    });
+    it('should transform keys and values using isomorphisms', () => {
+        const graph = new Graph();
+        let zmap = new ZMap();
+        zmap = zmap.add(1, 10, 5).add(2, 20, 15);
+        const reactiveMap = Reactive.create(graph, new ZMapOperations(), new ZMapChangeInput(graph), zmap);
+        const numToString = {
+            to: (n) => n.toString(),
+            from: (s) => parseInt(s, 10),
+        };
+        const adapter = new ReactiveMapSourceAdapter(reactiveMap, numToString, numToString);
+        const snapshot = adapter.Snapshot;
+        expect(snapshot).toEqual([['1', '10', 5], ['2', '20', 15]]);
+    });
+    it('should provide last change after modifications', () => {
+        const graph = new Graph();
+        const input = new ZMapChangeInput(graph);
+        const reactiveMap = Reactive.create(graph, new ZMapOperations(), input, new ZMap());
+        const adapter = new ReactiveMapSourceAdapter(reactiveMap, iso.id(), iso.id());
+        // Push a change
+        input.add('key', 'value', 1);
+        graph.step();
+        const lastChange = adapter.LastChange;
+        expect(lastChange).toEqual([['key', 'value', 1]]);
+    });
+    it('should return the underlying reactive map', () => {
+        const graph = new Graph();
+        const reactiveMap = Reactive.create(graph, new ZMapOperations(), new ZMapChangeInput(graph), new ZMap());
+        const adapter = new ReactiveMapSourceAdapter(reactiveMap, iso.id(), iso.id());
+        expect(adapter.Stream).toBe(reactiveMap);
+    });
+    it('should handle empty maps', () => {
+        const graph = new Graph();
+        const reactiveMap = Reactive.create(graph, new ZMapOperations(), new ZMapChangeInput(graph), new ZMap());
+        const adapter = new ReactiveMapSourceAdapter(reactiveMap, iso.id(), iso.id());
+        expect(adapter.Snapshot).toEqual([]);
+    });
+});
+describe('ReactiveMapSinkAdapter', () => {
+    it('should build a reactive map source', () => {
+        const graph = new Graph();
+        const adapter = new ReactiveMapSinkAdapter(graph, iso.id(), iso.id(), []);
+        const { stream: source } = adapter.build();
+        expect(source).toBeDefined();
+        expect([...source.snapshot.getEntries()]).toEqual([]);
+    });
+    it('should apply changes to a reactive map', () => {
+        const graph = new Graph();
+        const adapter = new ReactiveMapSinkAdapter(graph, iso.id(), iso.id(), []);
+        const { stream: source, input } = adapter.build();
+        // Apply changes
+        const change = [['a', 1, 5], ['b', 2, 10]];
+        adapter.apply(change, input);
+        graph.step();
+        // Check snapshot
+        const entries = [...source.snapshot.getEntries()];
+        expect(entries).toContainEqual(['a', 1, 5]);
+        expect(entries).toContainEqual(['b', 2, 10]);
+    });
+    it('should transform keys and values using isomorphisms', () => {
+        const graph = new Graph();
+        const strToNum = {
+            to: (n) => n.toString(),
+            from: (s) => parseInt(s, 10),
+        };
+        const adapter = new ReactiveMapSinkAdapter(graph, strToNum, strToNum, []);
+        const { stream: source, input } = adapter.build();
+        // Apply change with string keys and values
+        const change = [['5', '10', 1], ['15', '20', 2]];
+        adapter.apply(change, input);
+        graph.step();
+        // Should be converted to numbers
+        const entries = [...source.snapshot.getEntries()];
+        expect(entries).toContainEqual([5, 10, 1]);
+        expect(entries).toContainEqual([15, 20, 2]);
+    });
+    it('should handle adding entries with different weights', () => {
+        const graph = new Graph();
+        const adapter = new ReactiveMapSinkAdapter(graph, iso.id(), iso.id(), []);
+        const { stream: source, input } = adapter.build();
+        // Add same key with different weights
+        adapter.apply([['key', 'value1', 5]], input);
+        graph.step();
+        adapter.apply([['key', 'value2', 3]], input);
+        graph.step();
+        const entries = [...source.snapshot.getEntries()];
+        // Should contain both entries with their weights
+        expect(entries.length).toBeGreaterThan(0);
+    });
+});
+describe('sink function', () => {
+    it('should create a sink initialized with snapshot', () => {
+        const graph = new Graph();
+        const sinkFn = sink(graph, iso.id(), iso.id());
+        const snapshot = [['a', 1, 10], ['b', 2, 20]];
+        const sinkAdapter = sinkFn(snapshot);
+        const { stream: source } = sinkAdapter.build();
+        const entries = [...source.snapshot.getEntries()];
+        expect(entries).toContainEqual(['a', 1, 10]);
+        expect(entries).toContainEqual(['b', 2, 20]);
+    });
+    it('should allow applying changes after initialization', () => {
+        const graph = new Graph();
+        const sinkFn = sink(graph, iso.id(), iso.id());
+        const snapshot = [['x', 'y', 1]];
+        const sinkAdapter = sinkFn(snapshot);
+        const { stream: source, input } = sinkAdapter.build();
+        // Initial check
+        let entries = [...source.snapshot.getEntries()];
+        expect(entries).toContainEqual(['x', 'y', 1]);
+        // Apply a change
+        const change = [['a', 'b', 2], ['c', 'd', 3]];
+        sinkAdapter.apply(change, input);
+        graph.step();
+        entries = [...source.snapshot.getEntries()];
+        expect(entries.length).toBeGreaterThan(1);
+        expect(entries).toContainEqual(['a', 'b', 2]);
+        expect(entries).toContainEqual(['c', 'd', 3]);
+    });
+    it('should transform snapshot using isomorphisms', () => {
+        const graph = new Graph();
+        const strToNum = {
+            to: (n) => n.toString(),
+            from: (s) => parseInt(s, 10),
+        };
+        const sinkFn = sink(graph, strToNum, strToNum);
+        // Snapshot with string keys and values
+        const snapshot = [['10', '20', 5], ['30', '40', 10]];
+        const sinkAdapter = sinkFn(snapshot);
+        const { stream: source } = sinkAdapter.build();
+        // Should be converted to numbers
+        const entries = [...source.snapshot.getEntries()];
+        expect(entries).toContainEqual([10, 20, 5]);
+        expect(entries).toContainEqual([30, 40, 10]);
+    });
+    it('should handle empty snapshot', () => {
+        const graph = new Graph();
+        const sinkFn = sink(graph, iso.id(), iso.id());
+        const sinkAdapter = sinkFn([]);
+        const { stream: source } = sinkAdapter.build();
+        expect([...source.snapshot.getEntries()]).toEqual([]);
+    });
+    it('should create new source instances on each build call', () => {
+        const graph = new Graph();
+        const sinkFn = sink(graph, iso.id(), iso.id());
+        const sinkAdapter = sinkFn([['test', 1, 1]]);
+        const { stream: source1 } = sinkAdapter.build();
+        const { stream: source2 } = sinkAdapter.build();
+        // Each build creates a new instance - use strict equality to avoid vitest's deep comparison
+        expect(source1 === source2).toBe(false);
+        // But both have the same initial snapshot
+        expect([...source1.snapshot.getEntries()]).toEqual([['test', 1, 1]]);
+        expect([...source2.snapshot.getEntries()]).toEqual([['test', 1, 1]]);
+    });
+    it('should work with complex key and value types', () => {
+        const graph = new Graph();
+        const keyIso = iso.object({
+            id: iso.id(),
+        });
+        const valueIso = iso.object({
+            data: iso.id(),
+        });
+        const sinkFn = sink(graph, keyIso, valueIso);
+        const snapshot = [
+            [{ id: 1 }, { data: 'first' }, 5],
+            [{ id: 2 }, { data: 'second' }, 10],
+        ];
+        const sinkAdapter = sinkFn(snapshot);
+        const { stream: source } = sinkAdapter.build();
+        const entries = [...source.snapshot.getEntries()];
+        expect(entries.length).toBe(2);
+        expect(entries[0][0]).toEqual({ id: 1 });
+        expect(entries[0][1]).toEqual({ data: 'first' });
+        expect(entries[0][2]).toBe(5);
+    });
+});

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

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