@derivation/rpc 0.1.5 → 0.1.7

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

package/dist/shared-worker-client.js

@@ -0,0 +1,25 @@
+import { Client } from "./client";
+import { MessagePortTransport } from "./messageport-transport";
+/**
+ * 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 function createSharedWorkerClient(port, sinks, graph) {
+    const transport = new MessagePortTransport(port);
+    port.start();
+    return new Client(transport, sinks, graph);
+}

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

@@ -0,0 +1,28 @@
+import { Graph } from "derivation";
+import { StreamEndpoints, MutationEndpoints, RPCDefinition } from "./stream-types";
+import { PresenceHandler } from "./presence-manager";
+export type SharedWorkerServerOptions<Defs extends RPCDefinition, Ctx = void> = {
+    streams: StreamEndpoints<Defs["streams"], Ctx>;
+    mutations: MutationEndpoints<Defs["mutations"], Ctx>;
+    createContext: (port: MessagePort) => Ctx | Promise<Ctx>;
+    presenceHandler?: PresenceHandler;
+};
+/**
+ * Set up a SharedWorker server for RPC communication.
+ * This creates a shared Graph that all connected tabs can interact with.
+ *
+ * @example
+ * ```typescript
+ * // worker.ts
+ * const { graph } = setupSharedWorker({
+ *   streams: {
+ *     todos: async (args, ctx) => new ReactiveSetSourceAdapter(source),
+ *   },
+ *   mutations: {
+ *     addTodo: async (args, ctx) => ({ success: true, value: newTodo }),
+ *   },
+ *   createContext: (port) => ({ portId: crypto.randomUUID() }),
+ * });
+ * ```
+ */
+export declare function setupSharedWorker<Defs extends RPCDefinition, Ctx = void>(options: SharedWorkerServerOptions<Defs, Ctx>, graph: Graph): void;

package/dist/shared-worker-server.js

@@ -0,0 +1,62 @@
+import { SharedWorkerClientHandler } from "./shared-worker-client-handler";
+import WeakList from "./weak-list";
+import { MessagePortTransport } from "./messageport-transport";
+/**
+ * Set up a SharedWorker server for RPC communication.
+ * This creates a shared Graph that all connected tabs can interact with.
+ *
+ * @example
+ * ```typescript
+ * // worker.ts
+ * const { graph } = setupSharedWorker({
+ *   streams: {
+ *     todos: async (args, ctx) => new ReactiveSetSourceAdapter(source),
+ *   },
+ *   mutations: {
+ *     addTodo: async (args, ctx) => ({ success: true, value: newTodo }),
+ *   },
+ *   createContext: (port) => ({ portId: crypto.randomUUID() }),
+ * });
+ * ```
+ */
+export function setupSharedWorker(options, graph) {
+    const { streams, mutations, createContext, presenceHandler } = options;
+    const clients = new WeakList();
+    // After each graph step, broadcast deltas to all connected clients
+    graph.afterStep(() => {
+        for (const client of clients) {
+            client.handleStep();
+        }
+    });
+    // Handle SharedWorker connections
+    const globalScope = self;
+    globalScope.onconnect = (event) => {
+        const port = event.ports[0];
+        const messageBuffer = [];
+        let client = null;
+        // Set up temporary message handler to buffer messages
+        const tempMessageHandler = (e) => {
+            messageBuffer.push(e.data);
+        };
+        port.onmessage = tempMessageHandler;
+        // Create context (handle both sync and async)
+        Promise.resolve(createContext(port))
+            .then((context) => {
+            // Create transport and client handler
+            const transport = new MessagePortTransport(port);
+            client = new SharedWorkerClientHandler(transport, context, streams, mutations, presenceHandler);
+            clients.add(client);
+            // Process buffered messages
+            for (const msg of messageBuffer) {
+                client.handleMessage(msg);
+            }
+            messageBuffer.length = 0;
+            // Start the port
+            port.start();
+        })
+            .catch((err) => {
+            console.error("Error creating context:", err);
+            port.close();
+        });
+    };
+}

package/dist/stream-adapter.js

@@ -1,3 +1,4 @@
+import { inputValue } from "derivation";
 export class StreamSourceAdapter {
     constructor(stream, iso) {
         this.stream = stream;
@@ -23,7 +24,7 @@ export class StreamSinkAdapter {
         input.push(this.iso.from(change));
     }
     build() {
-        const stream = this.graph.inputValue(this.initialValue);
+        const stream = inputValue(this.graph, this.initialValue);
         return { stream, input: stream };
     }
 }

package/dist/stream-types.d.ts

@@ -10,15 +10,15 @@ export interface Sink<SinkType, InputType> {
         input: InputType;
     };
 }
-export type StreamDefinition<ReturnType extends object, SinkType extends ReturnType, InputType extends object> = {
-    args: Record<string, unknown>;
+export type StreamDefinition<Args extends object, ReturnType extends object, SinkType extends ReturnType, InputType extends object> = {
+    args: Args;
     returnType: ReturnType;
     sinkType: SinkType;
     inputType: InputType;
 };
-export type StreamDefinitions = Record<string, StreamDefinition<object, object, object>>;
-export type StreamEndpoints<Definitions extends StreamDefinitions> = {
-    [K in keyof Definitions]: (args: Definitions[K]["args"]) => Source<Definitions[K]["returnType"]>;
+export type StreamDefinitions = Record<string, StreamDefinition<object, object, object, object>>;
+export type StreamEndpoints<Definitions extends StreamDefinitions, Ctx = void> = {
+    [K in keyof Definitions]: (args: Definitions[K]["args"], ctx: Ctx) => Promise<Source<Definitions[K]["returnType"]>>;
 };
 export type StreamSinks<Definitions extends StreamDefinitions> = {
     [K in keyof Definitions]: (snapshot: object) => Sink<Definitions[K]["sinkType"], Definitions[K]["inputType"]>;
@@ -35,8 +35,8 @@ export type MutationDefinition<Args, Result> = {
     result: Result;
 };
 export type MutationDefinitions = Record<string, MutationDefinition<unknown, unknown>>;
-export type MutationEndpoints<Definitions extends MutationDefinitions> = {
-    [K in keyof Definitions]: (args: Definitions[K]["args"]) => Promise<MutationResult<Definitions[K]["result"]>>;
+export type MutationEndpoints<Definitions extends MutationDefinitions, Ctx = void> = {
+    [K in keyof Definitions]: (args: Definitions[K]["args"], ctx: Ctx) => Promise<MutationResult<Definitions[K]["result"]>>;
 };
 export type RPCDefinition = {
     streams: StreamDefinitions;

package/dist/transport.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Transport abstraction for RPC communication.
+ * Allows the same RPC system to work over WebSocket or MessagePort.
+ */
+export interface Transport {
+    /**
+     * Send a string message through the transport.
+     */
+    send(data: string): void;
+    /**
+     * Register a handler for incoming messages.
+     */
+    onMessage(handler: (data: string) => void): void;
+    /**
+     * Register a handler for transport closure/disconnection.
+     */
+    onClose(handler: () => void): void;
+    /**
+     * Close the transport connection.
+     */
+    close(): void;
+    /**
+     * Number of bytes buffered to be sent (optional, used for flow control).
+     * MessagePort doesn't provide this, so it's optional.
+     */
+    readonly bufferedAmount?: number;
+}

package/dist/transport.js

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