@derivation/rpc 0.3.5 → 0.5.0

package/dist/tests/mutations.test.js

@@ -1,122 +0,0 @@
-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

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

package/dist/tests/queue.test.js

@@ -1,84 +0,0 @@
-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

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

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

@@ -1,190 +0,0 @@
-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

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

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

@@ -1,157 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Graph } from 'derivation';
-import { ZSet, Reactive, ZSetOperations, ZSetChangeInput } from '@derivation/composable';
-import { ReactiveSetSourceAdapter, ReactiveSetSinkAdapter, sink } from '../reactive-set-adapter.js';
-import * as iso from '../iso.js';
-describe('ReactiveSetSourceAdapter', () => {
-    it('should provide snapshot as array of [item, weight] tuples', () => {
-        const graph = new Graph();
-        let zset = new ZSet();
-        zset = zset.add('a', 1).add('b', 2);
-        const reactiveSet = Reactive.create(graph, new ZSetOperations(), new ZSetChangeInput(graph), zset);
-        const adapter = new ReactiveSetSourceAdapter(reactiveSet, iso.id());
-        const snapshot = adapter.Snapshot;
-        expect(snapshot).toEqual([['a', 1], ['b', 2]]);
-    });
-    it('should transform elements using isomorphism', () => {
-        const graph = new Graph();
-        let zset = new ZSet();
-        zset = zset.add(1, 2).add(3, 4);
-        const reactiveSet = Reactive.create(graph, new ZSetOperations(), new ZSetChangeInput(graph), zset);
-        const numToString = {
-            to: (n) => n.toString(),
-            from: (s) => parseInt(s, 10),
-        };
-        const adapter = new ReactiveSetSourceAdapter(reactiveSet, numToString);
-        const snapshot = adapter.Snapshot;
-        expect(snapshot).toEqual([['1', 2], ['3', 4]]);
-    });
-    it('should provide last change after modifications', () => {
-        const graph = new Graph();
-        const input = new ZSetChangeInput(graph);
-        const reactiveSet = Reactive.create(graph, new ZSetOperations(), input, new ZSet());
-        const adapter = new ReactiveSetSourceAdapter(reactiveSet, iso.id());
-        // Push a change
-        let zset = new ZSet();
-        zset = zset.add('x', 1);
-        input.push(zset);
-        graph.step();
-        const lastChange = adapter.LastChange;
-        expect(lastChange).toEqual([['x', 1]]);
-    });
-    it('should return the underlying reactive set', () => {
-        const graph = new Graph();
-        const reactiveSet = Reactive.create(graph, new ZSetOperations(), new ZSetChangeInput(graph), new ZSet());
-        const adapter = new ReactiveSetSourceAdapter(reactiveSet, iso.id());
-        expect(adapter.Stream).toBe(reactiveSet);
-    });
-    it('should handle empty sets', () => {
-        const graph = new Graph();
-        const reactiveSet = Reactive.create(graph, new ZSetOperations(), new ZSetChangeInput(graph), new ZSet());
-        const adapter = new ReactiveSetSourceAdapter(reactiveSet, iso.id());
-        expect(adapter.Snapshot).toEqual([]);
-    });
-});
-describe('ReactiveSetSinkAdapter', () => {
-    it('should build a reactive set source', () => {
-        const graph = new Graph();
-        const adapter = new ReactiveSetSinkAdapter(graph, iso.compose(iso.zset(iso.id()), iso.zsetToArray()), []);
-        const { stream: source } = adapter.build();
-        expect(source).toBeDefined();
-        expect([...source.snapshot.getEntries()]).toEqual([]);
-    });
-    it('should apply changes to a reactive set', () => {
-        const graph = new Graph();
-        const isoComposed = iso.compose(iso.zset(iso.id()), iso.zsetToArray());
-        const adapter = new ReactiveSetSinkAdapter(graph, isoComposed, []);
-        const { stream: source, input } = adapter.build();
-        // Apply a change to add items
-        const change = [['a', 1], ['b', 2]];
-        adapter.apply(change, input);
-        graph.step();
-        // Check snapshot after change
-        const entries = [...source.snapshot.getEntries()];
-        expect(entries).toContainEqual(['a', 1]);
-        expect(entries).toContainEqual(['b', 2]);
-    });
-    it('should transform elements using isomorphism', () => {
-        const graph = new Graph();
-        const numToString = {
-            to: (n) => n.toString(),
-            from: (s) => parseInt(s, 10),
-        };
-        const isoComposed = iso.compose(iso.zset(numToString), iso.zsetToArray());
-        const adapter = new ReactiveSetSinkAdapter(graph, isoComposed, []);
-        const { stream: source, input } = adapter.build();
-        // Apply change with string values
-        const change = [['5', 1], ['10', 2]];
-        adapter.apply(change, input);
-        graph.step();
-        // Should be converted to numbers
-        const entries = [...source.snapshot.getEntries()];
-        expect(entries).toContainEqual([5, 1]);
-        expect(entries).toContainEqual([10, 2]);
-    });
-});
-describe('sink function', () => {
-    it('should create a sink initialized with snapshot', () => {
-        const graph = new Graph();
-        const sinkFn = sink(graph, iso.id());
-        const snapshot = [['item1', 1], ['item2', 2]];
-        const sinkAdapter = sinkFn(snapshot);
-        const { stream: source } = sinkAdapter.build();
-        const entries = [...source.snapshot.getEntries()];
-        expect(entries).toContainEqual(['item1', 1]);
-        expect(entries).toContainEqual(['item2', 2]);
-    });
-    it('should allow applying changes after initialization', () => {
-        const graph = new Graph();
-        const sinkFn = sink(graph, iso.id());
-        const snapshot = [['a', 1]];
-        const sinkAdapter = sinkFn(snapshot);
-        const { stream: source, input } = sinkAdapter.build();
-        // Apply a change
-        const change = [['b', 2], ['c', 3]];
-        sinkAdapter.apply(change, input);
-        graph.step();
-        const entries = [...source.snapshot.getEntries()];
-        expect(entries.length).toBeGreaterThan(1);
-        expect(entries).toContainEqual(['b', 2]);
-        expect(entries).toContainEqual(['c', 3]);
-    });
-    it('should transform snapshot using isomorphism', () => {
-        const graph = new Graph();
-        const stringToNum = {
-            to: (n) => n.toString(),
-            from: (s) => parseInt(s, 10),
-        };
-        const sinkFn = sink(graph, stringToNum);
-        // Snapshot with string values
-        const snapshot = [['42', 1], ['99', 2]];
-        const sinkAdapter = sinkFn(snapshot);
-        const { stream: source } = sinkAdapter.build();
-        // Should be converted to numbers
-        const entries = [...source.snapshot.getEntries()];
-        expect(entries).toContainEqual([42, 1]);
-        expect(entries).toContainEqual([99, 2]);
-    });
-    it('should handle empty snapshot', () => {
-        const graph = new Graph();
-        const sinkFn = sink(graph, 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());
-        const sinkAdapter = sinkFn([['test', 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]]);
-        expect([...source2.snapshot.getEntries()]).toEqual([['test', 1]]);
-    });
-});

package/dist/tests/stream-adapter.test.d.ts

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