@derivation/rpc 0.1.6 → 0.1.7

package/dist/client-handler.d.ts

@@ -1,10 +1,11 @@
-import { RawData, WebSocket } from "ws";
 import { ClientMessage } from "./client-message";
 import { ServerMessage } from "./server-message";
 import { StreamEndpoints, MutationEndpoints, RPCDefinition } from "./stream-types";
 import { PresenceHandler } from "./presence-manager";
-export declare class ClientHandler<Defs extends RPCDefinition> {
-    private readonly ws;
+import { Transport } from "./transport";
+export declare class ClientHandler<Defs extends RPCDefinition, Ctx = void> {
+    private readonly transport;
+    private readonly context;
     private readonly streamEndpoints;
     private readonly mutationEndpoints;
     private readonly presenceHandler?;
@@ -14,13 +15,13 @@ export declare class ClientHandler<Defs extends RPCDefinition> {
     private heartbeatTimeout;
     private inactivityTimeout;
     private readonly rateLimiter;
-    constructor(ws: WebSocket, streamEndpoints: StreamEndpoints<Defs["streams"]>, mutationEndpoints: MutationEndpoints<Defs["mutations"]>, presenceHandler?: PresenceHandler);
+    constructor(transport: Transport, context: Ctx, streamEndpoints: StreamEndpoints<Defs["streams"], Ctx>, mutationEndpoints: MutationEndpoints<Defs["mutations"], Ctx>, presenceHandler?: PresenceHandler);
     private resetHeartbeat;
     private resetInactivity;
-    handleMessage(message: RawData): void;
-    handleClientMessage(message: ClientMessage): void;
+    handleMessage(message: string): void;
+    handleClientMessage(message: ClientMessage): Promise<void>;
     handleStep(): void;
     sendMessage(message: ServerMessage): void;
-    handleDisconnect(): void;
+    private handleDisconnect;
     close(): void;
 }

package/dist/client-handler.js

@@ -2,15 +2,19 @@ import { parseClientMessage } from "./client-message";
 import { ServerMessage } from "./server-message";
 import { RateLimiter } from "./rate-limiter";
 export class ClientHandler {
-    constructor(ws, streamEndpoints, mutationEndpoints, presenceHandler) {
+    constructor(transport, context, streamEndpoints, mutationEndpoints, presenceHandler) {
         this.closed = false;
         this.streams = new Map();
-        this.ws = ws;
+        this.transport = transport;
+        this.context = context;
         this.streamEndpoints = streamEndpoints;
         this.mutationEndpoints = mutationEndpoints;
         this.presenceHandler = presenceHandler;
         this.rateLimiter = new RateLimiter(100, 300); // 100 messages over 5 minutes
         console.log("new client connected");
+        // Set up transport handlers
+        this.transport.onMessage((data) => this.handleMessage(data));
+        this.transport.onClose(() => this.handleDisconnect());
         this.resetHeartbeat();
         this.resetInactivity();
     }
@@ -40,10 +44,10 @@ export class ClientHandler {
         }
         let data;
         try {
-            data = JSON.parse(message.toString());
+            data = JSON.parse(message);
         }
         catch (_a) {
-            console.error("Invalid JSON received:", message.toString());
+            console.error("Invalid JSON received:", message);
             return this.close();
         }
         let parsed;
@@ -56,7 +60,7 @@ export class ClientHandler {
         }
         this.handleClientMessage(parsed);
     }
-    handleClientMessage(message) {
+    async handleClientMessage(message) {
         switch (message.type) {
             case "subscribe": {
                 const { id, name, args } = message;
@@ -67,7 +71,7 @@ export class ClientHandler {
                 }
                 const endpoint = this.streamEndpoints[name];
                 try {
-                    const source = endpoint(args);
+                    const source = await endpoint(args, this.context);
                     this.streams.set(id, source);
                     this.sendMessage(ServerMessage.subscribed(id, source.Snapshot));
                     console.log(`Client subscribed to \"${name}\" (${id})`);
@@ -92,7 +96,7 @@ export class ClientHandler {
                     return;
                 }
                 const endpoint = this.mutationEndpoints[name];
-                endpoint(args)
+                endpoint(args, this.context)
                     .then((result) => {
                     if (result.success) {
                         this.sendMessage(ServerMessage.resultSuccess(id, result.value));
@@ -146,13 +150,15 @@ export class ClientHandler {
     sendMessage(message) {
         this.resetHeartbeat();
         if (!this.closed) {
-            if (this.ws.bufferedAmount > 100 * 1024) {
+            // Check buffer if available (WebSocket provides this, MessagePort doesn't)
+            if (this.transport.bufferedAmount !== undefined &&
+                this.transport.bufferedAmount > 100 * 1024) {
                 console.log("Send buffer exceeded 100KB, closing connection");
                 this.close();
                 return;
             }
             try {
-                this.ws.send(JSON.stringify(message));
+                this.transport.send(JSON.stringify(message));
             }
             catch (err) {
                 console.error("Failed to send message:", err);
@@ -174,7 +180,7 @@ export class ClientHandler {
             this.presenceHandler.remove(this.currentPresence);
         }
         try {
-            this.ws.close();
+            this.transport.close();
         }
         catch (_a) { }
     }

package/dist/client.d.ts

@@ -1,7 +1,8 @@
 import type { Graph } from "derivation";
 import type { StreamSinks, RPCDefinition, MutationResult } from "./stream-types";
+import { Transport } from "./transport";
 export declare class Client<Defs extends RPCDefinition> {
-    private ws;
+    private transport;
     private sinks;
     private graph;
     private nextId;
@@ -13,7 +14,7 @@ export declare class Client<Defs extends RPCDefinition> {
     private registry;
     private resetHeartbeat;
     private resetInactivity;
-    constructor(ws: WebSocket, sinks: StreamSinks<Defs["streams"]>, graph: Graph);
+    constructor(transport: Transport, sinks: StreamSinks<Defs["streams"]>, graph: Graph);
     private handleMessage;
     private sendMessage;
     run<Key extends keyof Defs["streams"]>(key: Key, args: Defs["streams"][Key]["args"]): Promise<Defs["streams"][Key]["returnType"]>;

package/dist/client.js

@@ -24,8 +24,8 @@ export class Client {
             this.close();
         }, 30000);
     }
-    constructor(ws, sinks, graph) {
-        this.ws = ws;
+    constructor(transport, sinks, graph) {
+        this.transport = transport;
         this.sinks = sinks;
         this.graph = graph;
         this.nextId = 1;
@@ -37,10 +37,10 @@ export class Client {
             this.sendMessage(ClientMessage.unsubscribe(id));
             this.activeStreams.delete(id);
         });
-        this.ws.onmessage = (event) => {
-            const message = JSON.parse(event.data);
+        this.transport.onMessage((data) => {
+            const message = JSON.parse(data);
             this.handleMessage(message);
-        };
+        });
         this.resetHeartbeat();
         this.resetInactivity();
     }
@@ -93,7 +93,7 @@ export class Client {
     }
     sendMessage(message) {
         this.resetHeartbeat();
-        this.ws.send(JSON.stringify(message));
+        this.transport.send(JSON.stringify(message));
     }
     async run(key, args) {
         console.log(`Running stream ${String(key)} with args ${JSON.stringify(args)}`);
@@ -123,7 +123,7 @@ export class Client {
         clearTimeout(this.heartbeatTimeout);
         clearTimeout(this.inactivityTimeout);
         try {
-            this.ws.close();
+            this.transport.close();
         }
         catch (_a) { }
     }

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export * from "./client";
 export * from "./stream-types";
-export { ReactiveSetSourceAdapter, ReactiveSetSinkAdapter, sink as setSink } from "./reactive-set-adapter";
-export { ReactiveMapSourceAdapter, ReactiveMapSinkAdapter, sink as mapSink } from "./reactive-map-adapter";
-export { StreamSourceAdapter, StreamSinkAdapter, sink as streamSink } from "./stream-adapter";
-export { setupWebSocketServer } from "./websocket-server";
+export { ReactiveSetSourceAdapter, ReactiveSetSinkAdapter, sink as setSink, } from "./reactive-set-adapter";
+export { ReactiveMapSourceAdapter, ReactiveMapSinkAdapter, sink as mapSink, } from "./reactive-map-adapter";
+export { StreamSourceAdapter, StreamSinkAdapter, sink as streamSink, } from "./stream-adapter";
+export type { Transport } from "./transport";
 export type { PresenceHandler } from "./presence-manager";

package/dist/index.js

@@ -1,6 +1,6 @@
+// Main index only exports isomorphic code that works in both browser and Node.js
 export * from "./client";
 export * from "./stream-types";
-export { ReactiveSetSourceAdapter, ReactiveSetSinkAdapter, sink as setSink } from "./reactive-set-adapter";
-export { ReactiveMapSourceAdapter, ReactiveMapSinkAdapter, sink as mapSink } from "./reactive-map-adapter";
-export { StreamSourceAdapter, StreamSinkAdapter, sink as streamSink } from "./stream-adapter";
-export { setupWebSocketServer } from "./websocket-server";
+export { ReactiveSetSourceAdapter, ReactiveSetSinkAdapter, sink as setSink, } from "./reactive-set-adapter";
+export { ReactiveMapSourceAdapter, ReactiveMapSinkAdapter, sink as mapSink, } from "./reactive-map-adapter";
+export { StreamSourceAdapter, StreamSinkAdapter, sink as streamSink, } from "./stream-adapter";

package/dist/iso.d.ts

@@ -1,5 +1,5 @@
 import { RecordOf } from "immutable";
-import { ZSet, ZMap } from "derivation";
+import { ZSet, ZMap } from "@derivation/relational";
 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";
+import { ZSet, ZMap } from "@derivation/relational";
 export function id() {
     return {
         to: (x) => x,

package/dist/messageport-transport.d.ts

@@ -0,0 +1,13 @@
+import { Transport } from "./transport";
+/**
+ * Transport implementation for MessagePort (SharedWorker communication).
+ */
+export declare class MessagePortTransport implements Transport {
+    private port;
+    constructor(port: MessagePort);
+    send(data: string): void;
+    onMessage(handler: (data: string) => void): void;
+    onClose(handler: () => void): void;
+    close(): void;
+    get bufferedAmount(): undefined;
+}

package/dist/messageport-transport.js

@@ -0,0 +1,28 @@
+/**
+ * Transport implementation for MessagePort (SharedWorker communication).
+ */
+export class MessagePortTransport {
+    constructor(port) {
+        this.port = port;
+    }
+    send(data) {
+        this.port.postMessage(data);
+    }
+    onMessage(handler) {
+        this.port.onmessage = (event) => {
+            handler(event.data);
+        };
+    }
+    onClose(handler) {
+        // MessagePort doesn't have a reliable close event
+        // We'll use messageerror as a signal, though it's not perfect
+        this.port.onmessageerror = handler;
+    }
+    close() {
+        this.port.close();
+    }
+    // MessagePort doesn't provide bufferedAmount
+    get bufferedAmount() {
+        return undefined;
+    }
+}

package/dist/node-web-socket-transport.d.ts

@@ -0,0 +1,16 @@
+import { WebSocket } from "ws";
+import { Transport } from "./transport";
+/**
+ * Transport implementation for Node.js WebSocket (server-side using 'ws' library).
+ */
+export declare class NodeWebSocketTransport implements Transport {
+    private ws;
+    private messageHandlerSet;
+    private closeHandlerSet;
+    constructor(ws: WebSocket);
+    send(data: string): void;
+    onMessage(handler: (data: string) => void): void;
+    onClose(handler: () => void): void;
+    close(): void;
+    get bufferedAmount(): number;
+}

package/dist/node-web-socket-transport.js

@@ -0,0 +1,33 @@
+/**
+ * Transport implementation for Node.js WebSocket (server-side using 'ws' library).
+ */
+export class NodeWebSocketTransport {
+    constructor(ws) {
+        this.ws = ws;
+        this.messageHandlerSet = false;
+        this.closeHandlerSet = false;
+    }
+    send(data) {
+        this.ws.send(data);
+    }
+    onMessage(handler) {
+        if (!this.messageHandlerSet) {
+            this.ws.on("message", (data) => {
+                handler(data.toString());
+            });
+            this.messageHandlerSet = true;
+        }
+    }
+    onClose(handler) {
+        if (!this.closeHandlerSet) {
+            this.ws.on("close", handler);
+            this.closeHandlerSet = true;
+        }
+    }
+    close() {
+        this.ws.close();
+    }
+    get bufferedAmount() {
+        return this.ws.bufferedAmount;
+    }
+}

package/dist/queue.d.ts

@@ -0,0 +1,9 @@
+export declare class Queue<T> {
+    private front;
+    private back;
+    get length(): number;
+    isEmpty(): boolean;
+    push(item: T): void;
+    peek(): T | undefined;
+    pop(): T | undefined;
+}

package/dist/queue.js

@@ -0,0 +1,32 @@
+export class Queue {
+    constructor() {
+        this.front = [];
+        this.back = [];
+    }
+    get length() {
+        return this.front.length + this.back.length;
+    }
+    isEmpty() {
+        return this.front.length === 0 && this.back.length === 0;
+    }
+    push(item) {
+        this.front.push(item);
+    }
+    peek() {
+        if (this.back.length === 0) {
+            if (this.front.length === 0) {
+                return undefined;
+            }
+            return this.front[0];
+        }
+        return this.back[this.back.length - 1];
+    }
+    pop() {
+        if (this.back.length === 0) {
+            // Reverse front and swap to back
+            this.back = this.front.reverse();
+            this.front = [];
+        }
+        return this.back.pop();
+    }
+}

package/dist/rate-limiter.d.ts

@@ -1,5 +1,5 @@
 export declare class RateLimiter {
-    private timestamps;
+    private readonly timestamps;
     private readonly maxOccurrences;
     private readonly windowNanos;
     constructor(maxOccurrences: number, windowSeconds: number);

package/dist/rate-limiter.js

@@ -1,19 +1,24 @@
+import { Queue } from "./queue.js";
 export class RateLimiter {
     constructor(maxOccurrences, windowSeconds) {
-        this.timestamps = [];
+        this.timestamps = new Queue();
         this.maxOccurrences = maxOccurrences;
         this.windowNanos = BigInt(windowSeconds) * BigInt(1000000000);
     }
     trigger() {
         const now = process.hrtime.bigint();
-        // Add current timestamp
-        this.timestamps.push(now);
-        // Remove expired timestamps from front
         const cutoff = now - this.windowNanos;
-        while (this.timestamps.length > 0 && this.timestamps[0] < cutoff) {
-            this.timestamps.shift();
+        while (!this.timestamps.isEmpty()) {
+            const oldest = this.timestamps.peek();
+            if (oldest === undefined || oldest >= cutoff) {
+                break;
+            }
+            this.timestamps.pop();
+        }
+        if (this.timestamps.length >= this.maxOccurrences) {
+            return true;
         }
-        // Return true if we've exceeded the limit
-        return this.timestamps.length > this.maxOccurrences;
+        this.timestamps.push(now);
+        return false;
     }
 }

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

@@ -1,4 +1,5 @@
-import { Graph, ReactiveMap, ReactiveMapSource, ZMapChangeInput } from "derivation";
+import { Graph } from "derivation";
+import { ReactiveMap, ReactiveMapSource, ZMapChangeInput } from "@derivation/relational";
 import { Source, Sink } from "./stream-types";
 import { Iso } from "./iso";
 export declare class ReactiveMapSourceAdapter<K, V> implements Source<ReactiveMap<K, V>> {

package/dist/reactive-map-adapter.js

@@ -1,3 +1,4 @@
+import { inputMap, } from "@derivation/relational";
 import { zmap } from "./iso";
 export class ReactiveMapSourceAdapter {
     constructor(map, keyIso, valueIso) {
@@ -30,7 +31,7 @@ export class ReactiveMapSinkAdapter {
         }
     }
     build() {
-        const stream = this.graph.inputMap(this.initialMap);
+        const stream = inputMap(this.graph, this.initialMap);
         return { stream, input: stream.changes };
     }
 }

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

@@ -1,4 +1,5 @@
-import { ZSet, Graph, ReactiveSet, ReactiveSetSource, ZSetChangeInput } from "derivation";
+import { Graph } from "derivation";
+import { ZSet, ReactiveSet, ReactiveSetSource, ZSetChangeInput } from "@derivation/relational";
 import { Source, Sink } from "./stream-types";
 import { Iso } from "./iso";
 export declare class ReactiveSetSourceAdapter<T> implements Source<ReactiveSet<T>> {

package/dist/reactive-set-adapter.js

@@ -1,3 +1,4 @@
+import { inputSet, } from "@derivation/relational";
 import { zset, zsetToArray, compose } from "./iso";
 export class ReactiveSetSourceAdapter {
     constructor(set, iso) {
@@ -27,7 +28,7 @@ export class ReactiveSetSinkAdapter {
         input.push(this.iso.from(change));
     }
     build() {
-        const stream = this.graph.inputSet(this.initialSet);
+        const stream = inputSet(this.graph, this.initialSet);
         return { stream, input: stream.changes };
     }
 }

package/dist/shared-worker-client-handler.d.ts

@@ -0,0 +1,27 @@
+import { ClientMessage } from "./client-message";
+import { ServerMessage } from "./server-message";
+import { StreamEndpoints, MutationEndpoints, RPCDefinition } from "./stream-types";
+import { PresenceHandler } from "./presence-manager";
+import { Transport } from "./transport";
+/**
+ * Client handler for SharedWorker connections (browser-only).
+ * Simplified version without rate limiting, heartbeats, or inactivity timeouts.
+ * Designed for same-origin trusted connections.
+ */
+export declare class SharedWorkerClientHandler<Defs extends RPCDefinition, Ctx = void> {
+    private readonly transport;
+    private readonly context;
+    private readonly streamEndpoints;
+    private readonly mutationEndpoints;
+    private readonly presenceHandler?;
+    private currentPresence?;
+    private closed;
+    private readonly streams;
+    constructor(transport: Transport, context: Ctx, streamEndpoints: StreamEndpoints<Defs["streams"], Ctx>, mutationEndpoints: MutationEndpoints<Defs["mutations"], Ctx>, presenceHandler?: PresenceHandler);
+    handleMessage(message: string): void;
+    handleClientMessage(message: ClientMessage): Promise<void>;
+    handleStep(): void;
+    sendMessage(message: ServerMessage): void;
+    private handleDisconnect;
+    close(): void;
+}

package/dist/shared-worker-client-handler.js

@@ -0,0 +1,149 @@
+import { parseClientMessage } from "./client-message";
+import { ServerMessage } from "./server-message";
+/**
+ * Client handler for SharedWorker connections (browser-only).
+ * Simplified version without rate limiting, heartbeats, or inactivity timeouts.
+ * Designed for same-origin trusted connections.
+ */
+export class SharedWorkerClientHandler {
+    constructor(transport, context, streamEndpoints, mutationEndpoints, presenceHandler) {
+        this.closed = false;
+        this.streams = new Map();
+        this.transport = transport;
+        this.context = context;
+        this.streamEndpoints = streamEndpoints;
+        this.mutationEndpoints = mutationEndpoints;
+        this.presenceHandler = presenceHandler;
+        console.log("new client connected");
+        // Set up transport handlers
+        this.transport.onMessage((data) => this.handleMessage(data));
+        this.transport.onClose(() => this.handleDisconnect());
+    }
+    handleMessage(message) {
+        let data;
+        try {
+            data = JSON.parse(message);
+        }
+        catch (_a) {
+            console.error("Invalid JSON received:", message);
+            return this.close();
+        }
+        let parsed;
+        try {
+            parsed = parseClientMessage(data);
+        }
+        catch (error) {
+            console.error("Invalid client message:", error);
+            return this.close();
+        }
+        this.handleClientMessage(parsed);
+    }
+    async handleClientMessage(message) {
+        switch (message.type) {
+            case "subscribe": {
+                const { id, name, args } = message;
+                if (!(name in this.streamEndpoints)) {
+                    console.error(`Unknown stream: ${name}`);
+                    this.close();
+                    return;
+                }
+                const endpoint = this.streamEndpoints[name];
+                try {
+                    const source = await endpoint(args, this.context);
+                    this.streams.set(id, source);
+                    this.sendMessage(ServerMessage.subscribed(id, source.Snapshot));
+                    console.log(`Client subscribed to "${name}" (${id})`);
+                }
+                catch (err) {
+                    console.error(`Error building stream ${name}:`, err);
+                    this.close();
+                }
+                break;
+            }
+            case "unsubscribe": {
+                const { id } = message;
+                this.streams.delete(id);
+                console.log(`Client unsubscribed from ${id}`);
+                break;
+            }
+            case "call": {
+                const { id, name, args } = message;
+                if (!(name in this.mutationEndpoints)) {
+                    console.error(`Unknown mutation: ${name}`);
+                    this.close();
+                    return;
+                }
+                const endpoint = this.mutationEndpoints[name];
+                endpoint(args, this.context)
+                    .then((result) => {
+                    if (result.success) {
+                        this.sendMessage(ServerMessage.resultSuccess(id, result.value));
+                        console.log(`Mutation "${name}" (${id}) completed successfully`);
+                    }
+                    else {
+                        this.sendMessage(ServerMessage.resultError(id, result.error));
+                        console.log(`Mutation "${name}" (${id}) returned error: ${result.error}`);
+                    }
+                })
+                    .catch((err) => {
+                    console.error(`Unhandled exception in mutation "${name}" (${id}):`, err);
+                    this.close();
+                });
+                break;
+            }
+            case "heartbeat":
+                break;
+            case "presence": {
+                if (!this.presenceHandler) {
+                    console.error("Presence not configured");
+                    this.close();
+                    return;
+                }
+                const { data } = message;
+                if (this.currentPresence !== undefined) {
+                    this.presenceHandler.update(this.currentPresence, data);
+                }
+                else {
+                    this.presenceHandler.add(data);
+                }
+                this.currentPresence = data;
+                break;
+            }
+        }
+    }
+    handleStep() {
+        if (this.closed)
+            return;
+        const changes = {};
+        for (const [id, source] of this.streams) {
+            const change = source.LastChange;
+            if (change === null)
+                continue;
+            changes[id] = change;
+        }
+        if (Object.keys(changes).length > 0) {
+            this.sendMessage(ServerMessage.delta(changes));
+        }
+    }
+    sendMessage(message) {
+        if (this.closed)
+            return;
+        this.transport.send(JSON.stringify(message));
+    }
+    handleDisconnect() {
+        this.close();
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        if (this.presenceHandler && this.currentPresence) {
+            this.presenceHandler.remove(this.currentPresence);
+        }
+        this.streams.clear();
+        try {
+            this.transport.close();
+        }
+        catch (_a) { }
+    }
+}

package/dist/shared-worker-client.d.ts

@@ -0,0 +1,22 @@
+import { Graph } from "derivation";
+import { Client } from "./client";
+import { StreamSinks, RPCDefinition } from "./stream-types";
+/**
+ * Create a client connected to a SharedWorker.
+ *
+ * @example
+ * ```typescript
+ * // main.ts
+ * const graph = new Graph();
+ * const worker = new SharedWorker('/worker.js');
+ *
+ * const client = createSharedWorkerClient(worker.port, {
+ *   streams: {
+ *     todos: setSink(graph, todoIso),
+ *   },
+ * }, graph);
+ *
+ * const todos = await client.run('todos', { filter: 'active' });
+ * ```
+ */
+export declare function createSharedWorkerClient<Defs extends RPCDefinition>(port: MessagePort, sinks: StreamSinks<Defs["streams"]>, graph: Graph): Client<Defs>;