@derivation/rpc 0.3.5 → 0.5.0

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

@@ -1,33 +0,0 @@
-/**
- * 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/presence-manager.js

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

package/dist/queue.d.ts

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

@@ -1,32 +0,0 @@
-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,7 +0,0 @@
-export declare class RateLimiter {
-    private readonly timestamps;
-    private readonly maxOccurrences;
-    private readonly windowNanos;
-    constructor(maxOccurrences: number, windowSeconds: number);
-    trigger(): boolean;
-}

package/dist/rate-limiter.js

@@ -1,24 +0,0 @@
-import { Queue } from "./queue.js";
-export class RateLimiter {
-    constructor(maxOccurrences, windowSeconds) {
-        this.timestamps = new Queue();
-        this.maxOccurrences = maxOccurrences;
-        this.windowNanos = BigInt(windowSeconds) * BigInt(1000000000);
-    }
-    trigger() {
-        const now = process.hrtime.bigint();
-        const cutoff = now - this.windowNanos;
-        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;
-        }
-        this.timestamps.push(now);
-        return false;
-    }
-}

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

@@ -1,24 +0,0 @@
-import { Graph } from "derivation";
-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<Reactive<ZMap<K, V>>> {
-    private readonly map;
-    private readonly iso;
-    constructor(map: Reactive<ZMap<K, V>>, keyIso: Iso<K, unknown>, valueIso: Iso<V, unknown>);
-    get Snapshot(): object;
-    get LastChange(): object | null;
-    get Stream(): Reactive<ZMap<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: 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<Reactive<ZMap<K, V>>, ZMapChangeInput<K, V>>;

package/dist/reactive-map-adapter.js

@@ -1,43 +0,0 @@
-import { Reactive, ZMapOperations, ZMapChangeInput } from "@derivation/composable";
-import { zmap } from "./iso.js";
-export class ReactiveMapSourceAdapter {
-    constructor(map, keyIso, valueIso) {
-        this.map = map;
-        this.iso = zmap(keyIso, valueIso);
-    }
-    get Snapshot() {
-        return this.iso.to(this.map.snapshot);
-    }
-    get LastChange() {
-        const change = this.iso.to(this.map.changes.value);
-        if (change.length === 0)
-            return null;
-        return change;
-    }
-    get Stream() {
-        return this.map;
-    }
-}
-export class ReactiveMapSinkAdapter {
-    constructor(graph, keyIso, valueIso, snapshot) {
-        this.graph = graph;
-        this.iso = zmap(keyIso, valueIso);
-        this.initialMap = this.iso.from(snapshot);
-    }
-    apply(change, input) {
-        const zmapChange = this.iso.from(change);
-        for (const [key, value, weight] of zmapChange.getEntries()) {
-            input.add(key, value, weight);
-        }
-    }
-    build() {
-        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) {
-    return (snapshot) => {
-        return new ReactiveMapSinkAdapter(graph, keyIso, valueIso, snapshot);
-    };
-}

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

@@ -1,24 +0,0 @@
-import { Graph } from "derivation";
-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<Reactive<ZSet<T>>> {
-    private readonly set;
-    private readonly iso;
-    constructor(set: Reactive<ZSet<T>>, iso: Iso<T, unknown>);
-    get Snapshot(): object;
-    get LastChange(): object | null;
-    get Stream(): Reactive<ZSet<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: Reactive<ZSet<T>>;
-        input: 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,41 +0,0 @@
-import { Reactive, ZSetOperations, ZSetChangeInput } from "@derivation/composable";
-import { zset, zsetToArray, compose } from "./iso.js";
-export class ReactiveSetSourceAdapter {
-    constructor(set, iso) {
-        this.set = set;
-        this.iso = compose(zset(iso), zsetToArray());
-    }
-    get Snapshot() {
-        return this.iso.to(this.set.snapshot);
-    }
-    get LastChange() {
-        const change = this.iso.to(this.set.changes.value);
-        if (change.length === 0)
-            return null;
-        return change;
-    }
-    get Stream() {
-        return this.set;
-    }
-}
-export class ReactiveSetSinkAdapter {
-    constructor(graph, iso, snapshot) {
-        this.graph = graph;
-        this.iso = iso;
-        this.initialSet = iso.from(snapshot);
-    }
-    apply(change, input) {
-        input.push(this.iso.from(change));
-    }
-    build() {
-        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) {
-    const wholeIso = compose(zset(iso), zsetToArray());
-    return (snapshot) => {
-        return new ReactiveSetSinkAdapter(graph, wholeIso, snapshot);
-    };
-}

package/dist/server-message.d.ts

@@ -1,48 +0,0 @@
-import { z } from "zod";
-export declare const HeartbeatMessageSchema: z.ZodObject<{
-    type: z.ZodLiteral<"heartbeat">;
-}, z.core.$strip>;
-export type HeartbeatMessage = z.infer<typeof HeartbeatMessageSchema>;
-export declare const SubscribedSchema: z.ZodObject<{
-    type: z.ZodLiteral<"snapshot">;
-    id: z.ZodNumber;
-    snapshot: z.ZodUnknown;
-}, z.core.$strip>;
-export type SubscribedMessage = z.infer<typeof SubscribedSchema>;
-export declare const DeltaMessageSchema: z.ZodObject<{
-    type: z.ZodLiteral<"delta">;
-    changes: z.ZodRecord<z.ZodNumber, z.ZodUnknown>;
-}, z.core.$strip>;
-export type DeltaMessage = z.infer<typeof DeltaMessageSchema>;
-export declare const ResultMessageSchema: z.ZodObject<{
-    type: z.ZodLiteral<"result">;
-    id: z.ZodNumber;
-    success: z.ZodBoolean;
-    value: z.ZodOptional<z.ZodUnknown>;
-    error: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type ResultMessage = z.infer<typeof ResultMessageSchema>;
-export declare const ServerMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    type: z.ZodLiteral<"heartbeat">;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"snapshot">;
-    id: z.ZodNumber;
-    snapshot: z.ZodUnknown;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"delta">;
-    changes: z.ZodRecord<z.ZodNumber, z.ZodUnknown>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"result">;
-    id: z.ZodNumber;
-    success: z.ZodBoolean;
-    value: z.ZodOptional<z.ZodUnknown>;
-    error: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>], "type">;
-export type ServerMessage = z.infer<typeof ServerMessageSchema>;
-export declare const ServerMessage: {
-    heartbeat: () => HeartbeatMessage;
-    subscribed: (id: number, snapshot: unknown) => SubscribedMessage;
-    delta: (changes: Record<string, unknown>) => DeltaMessage;
-    resultSuccess: (id: number, value: unknown) => ResultMessage;
-    resultError: (id: number, error: string) => ResultMessage;
-};

package/dist/server-message.js

@@ -1,52 +0,0 @@
-import { z } from "zod";
-export const HeartbeatMessageSchema = z.object({
-    type: z.literal("heartbeat"),
-});
-export const SubscribedSchema = z.object({
-    type: z.literal("snapshot"),
-    id: z.number(),
-    snapshot: z.unknown(),
-});
-export const DeltaMessageSchema = z.object({
-    type: z.literal("delta"),
-    changes: z.record(z.number(), z.unknown()),
-});
-export const ResultMessageSchema = z.object({
-    type: z.literal("result"),
-    id: z.number(),
-    success: z.boolean(),
-    value: z.unknown().optional(),
-    error: z.string().optional(),
-});
-export const ServerMessageSchema = z.discriminatedUnion("type", [
-    HeartbeatMessageSchema,
-    SubscribedSchema,
-    DeltaMessageSchema,
-    ResultMessageSchema,
-]);
-export const ServerMessage = {
-    heartbeat: () => ({
-        type: "heartbeat",
-    }),
-    subscribed: (id, snapshot) => ({
-        type: "snapshot",
-        id,
-        snapshot,
-    }),
-    delta: (changes) => ({
-        type: "delta",
-        changes: changes,
-    }),
-    resultSuccess: (id, value) => ({
-        type: "result",
-        id,
-        success: true,
-        value,
-    }),
-    resultError: (id, error) => ({
-        type: "result",
-        id,
-        success: false,
-        error,
-    }),
-};

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

@@ -1,27 +0,0 @@
-import { ClientMessage } from "./client-message.js";
-import { ServerMessage } from "./server-message.js";
-import { StreamEndpoints, MutationEndpoints, RPCDefinition } from "./stream-types.js";
-import { PresenceHandler } from "./presence-manager.js";
-import { Transport } from "./transport.js";
-/**
- * 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

@@ -1,149 +0,0 @@
-import { parseClientMessage } from "./client-message.js";
-import { ServerMessage } from "./server-message.js";
-/**
- * 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/stream-adapter.d.ts

@@ -1,23 +0,0 @@
-import { Graph, ReactiveValue, Input } from "derivation";
-import { Source, Sink } from "./stream-types.js";
-import { Iso } from "./iso.js";
-export declare class StreamSourceAdapter<T extends object> implements Source<ReactiveValue<T>> {
-    private readonly stream;
-    private readonly iso;
-    constructor(stream: ReactiveValue<T>, iso: Iso<T, object>);
-    get Snapshot(): object;
-    get LastChange(): object | null;
-    get Stream(): ReactiveValue<T>;
-}
-export declare class StreamSinkAdapter<T extends object> implements Sink<Input<T>, Input<T>> {
-    private readonly graph;
-    private readonly iso;
-    private readonly initialValue;
-    constructor(graph: Graph, iso: Iso<T, object>, snapshot: object);
-    apply(change: object, input: Input<T>): void;
-    build(): {
-        stream: Input<T>;
-        input: Input<T>;
-    };
-}
-export declare function sink<T extends object>(graph: Graph, iso: Iso<T, object>): (snapshot: object) => Sink<Input<T>, Input<T>>;

package/dist/stream-adapter.js

@@ -1,35 +0,0 @@
-import { inputValue } from "derivation";
-export class StreamSourceAdapter {
-    constructor(stream, iso) {
-        this.stream = stream;
-        this.iso = iso;
-    }
-    get Snapshot() {
-        return this.iso.to(this.stream.value);
-    }
-    get LastChange() {
-        return this.iso.to(this.stream.value);
-    }
-    get Stream() {
-        return this.stream;
-    }
-}
-export class StreamSinkAdapter {
-    constructor(graph, iso, snapshot) {
-        this.graph = graph;
-        this.iso = iso;
-        this.initialValue = iso.from(snapshot);
-    }
-    apply(change, input) {
-        input.push(this.iso.from(change));
-    }
-    build() {
-        const stream = inputValue(this.graph, this.initialValue);
-        return { stream, input: stream };
-    }
-}
-export function sink(graph, iso) {
-    return (snapshot) => {
-        return new StreamSinkAdapter(graph, iso, snapshot);
-    };
-}

package/dist/stream-types.d.ts

@@ -1,44 +0,0 @@
-export interface Source<ReturnType> {
-    get Snapshot(): object;
-    get LastChange(): object | null;
-    get Stream(): ReturnType;
-}
-export interface Sink<SinkType, InputType> {
-    apply(change: object, input: InputType): void;
-    build(): {
-        stream: SinkType;
-        input: InputType;
-    };
-}
-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, 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"]>;
-};
-export type MutationResult<T> = {
-    success: true;
-    value: T;
-} | {
-    success: false;
-    error: string;
-};
-export type MutationDefinition<Args, Result> = {
-    args: Args;
-    result: Result;
-};
-export type MutationDefinitions = Record<string, MutationDefinition<unknown, unknown>>;
-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;
-    mutations: MutationDefinitions;
-};

package/dist/stream-types.js

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

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

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