@wishcore/wish-rpc 0.6.14 → 0.6.16

package/dist/index.d.ts

@@ -0,0 +1,71 @@
+export interface MethodMap {
+    [endpoint: string]: any;
+}
+export interface EndpointConfig {
+    doc?: string;
+    args?: string;
+    validate?: (args: any[], context: any) => any;
+    validateResult?: (result: any) => any;
+    fullname?: string;
+    [key: string]: any;
+}
+export interface BaseEndpointConfig {
+    doc?: string;
+    args?: string;
+    fullname?: string;
+    [key: string]: any;
+}
+export interface EndpointHandler {
+    (req: RpcRequest, res: RpcResponse, context?: any): any;
+}
+export interface RpcRequest {
+    args: any[];
+    id?: number;
+    op?: string;
+    context?: any;
+    end?: any;
+    send?: any;
+}
+export interface RpcResponse {
+    send(data?: any): void;
+    emit(data?: any): void;
+    error(data?: any): void;
+    close(data?: any): void;
+}
+export interface RequestMessage {
+    op: string;
+    args?: any[];
+    id?: number;
+    push?: number;
+    sig?: number;
+    data?: any;
+    end?: number;
+    stream?: any;
+}
+export interface ResponseMessage {
+    ack?: number;
+    err?: number;
+    sig?: number;
+    end?: number;
+    push?: number;
+    data?: any;
+    fin?: number;
+}
+export interface RequestContext {
+    id?: number;
+    op?: string;
+    args?: any[];
+    context?: any;
+    end?: any;
+    send?: any;
+    data?: any;
+}
+export interface RequestMap {
+    [clientId: string]: {
+        [requestId: string]: RequestContext;
+    };
+}
+export * from './rpc-client';
+export * from './rpc-server';
+export * from './rpc-protocol';
+export * from './method-registry';

package/dist/{src/index.js → index.js}

@@ -12,4 +12,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./rpc-client"), exports);
 __exportStar(require("./rpc-server"), exports);
+__exportStar(require("./rpc-protocol"), exports);
+__exportStar(require("./method-registry"), exports);
 //# sourceMappingURL=index.js.map

package/dist/method-registry.d.ts

@@ -0,0 +1,60 @@
+import { EndpointConfig, EndpointHandler, MethodMap, BaseEndpointConfig } from './index';
+/**
+ * Manages RPC method registration and retrieval
+ */
+export declare class MethodRegistry<T extends BaseEndpointConfig = EndpointConfig> {
+    private modules;
+    private methods;
+    /**
+     * Register a new endpoint with modern syntax
+     */
+    registerEndpoint(name: string, config: T, handler: EndpointHandler): void;
+    /**
+     * Register methods using legacy underscore-prefixed structure
+     */
+    registerLegacyMethods(methodMap: MethodMap): void;
+    /**
+     * Get all registered modules
+     */
+    getModules(): Record<string, T>;
+    /**
+     * Get all registered methods
+     */
+    getMethods(): Record<string, EndpointHandler>;
+    /**
+     * Get a specific method by name
+     */
+    getMethod(name: string): EndpointHandler | undefined;
+    /**
+     * Get a specific module config by name
+     */
+    getModule(name: string): T | undefined;
+    /**
+     * Check if a method exists
+     */
+    hasMethod(name: string): boolean;
+    /**
+     * Get method listing excluding internal fields
+     */
+    getMethodListing(): Record<string, Partial<T>>;
+    /**
+     * Recursively processes method map with underscore-prefixed descriptors
+     */
+    private processMethodMap;
+    /**
+     * Registers a single method using legacy format
+     */
+    private registerLegacyMethod;
+    /**
+     * Creates a copy of config object excluding specified fields
+     */
+    private copyConfig;
+    /**
+     * Checks if a key represents module metadata
+     */
+    private isModuleMeta;
+    /**
+     * Checks if a key is a descriptor (starts with underscore)
+     */
+    private isDescriptor;
+}

package/dist/method-registry.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MethodRegistry = void 0;
+/**
+ * Manages RPC method registration and retrieval
+ */
+class MethodRegistry {
+    constructor() {
+        this.modules = {};
+        this.methods = {};
+    }
+    /**
+     * Register a new endpoint with modern syntax
+     */
+    registerEndpoint(name, config, handler) {
+        if (!name || typeof name !== 'string') {
+            throw new Error('Endpoint name must be a non-empty string');
+        }
+        if (typeof handler !== 'function') {
+            throw new Error('Endpoint handler must be a function');
+        }
+        this.modules[name] = Object.assign(Object.assign({}, config), { fullname: name });
+        this.methods[name] = handler;
+    }
+    /**
+     * Register methods using legacy underscore-prefixed structure
+     */
+    registerLegacyMethods(methodMap) {
+        this.processMethodMap('', methodMap);
+    }
+    /**
+     * Get all registered modules
+     */
+    getModules() {
+        return Object.assign({}, this.modules);
+    }
+    /**
+     * Get all registered methods
+     */
+    getMethods() {
+        return Object.assign({}, this.methods);
+    }
+    /**
+     * Get a specific method by name
+     */
+    getMethod(name) {
+        return this.methods[name];
+    }
+    /**
+     * Get a specific module config by name
+     */
+    getModule(name) {
+        return this.modules[name];
+    }
+    /**
+     * Check if a method exists
+     */
+    hasMethod(name) {
+        return name in this.methods;
+    }
+    /**
+     * Get method listing excluding internal fields
+     */
+    getMethodListing() {
+        const result = {};
+        const excludeFields = new Set(['fullname']);
+        for (const methodName in this.modules) {
+            const config = this.modules[methodName];
+            result[methodName] = this.copyConfig(config, excludeFields);
+        }
+        return result;
+    }
+    /**
+     * Recursively processes method map with underscore-prefixed descriptors
+     */
+    processMethodMap(path, methodMap) {
+        const prefix = path ? `${path}.` : '';
+        for (const key in methodMap) {
+            if (this.isModuleMeta(key) || this.isDescriptor(key)) {
+                continue;
+            }
+            const descriptor = methodMap[`_${key}`];
+            if (!descriptor) {
+                continue;
+            }
+            const item = methodMap[key];
+            if (typeof item === 'function') {
+                this.registerLegacyMethod(prefix, key, descriptor, item);
+            }
+            else if (typeof item === 'object' && item !== null) {
+                this.processMethodMap(`${prefix}${key}`, item);
+            }
+        }
+    }
+    /**
+     * Registers a single method using legacy format
+     */
+    registerLegacyMethod(prefix, name, descriptor, handler) {
+        const fullName = prefix + (descriptor.name || name);
+        const config = Object.assign(Object.assign({}, descriptor), { fullname: fullName });
+        try {
+            this.modules[fullName] = config;
+            this.methods[fullName] = handler;
+        }
+        catch (error) {
+            console.error(`Failed to register method ${fullName}:`, error);
+        }
+    }
+    /**
+     * Creates a copy of config object excluding specified fields
+     */
+    copyConfig(source, excludeFields) {
+        const result = {};
+        for (const key in source) {
+            if (!excludeFields.has(key) && Object.prototype.hasOwnProperty.call(source, key)) {
+                result[key] = source[key];
+            }
+        }
+        return result;
+    }
+    /**
+     * Checks if a key represents module metadata
+     */
+    isModuleMeta(key) {
+        return key === '_';
+    }
+    /**
+     * Checks if a key is a descriptor (starts with underscore)
+     */
+    isDescriptor(key) {
+        return key.startsWith('_');
+    }
+}
+exports.MethodRegistry = MethodRegistry;
+//# sourceMappingURL=method-registry.js.map

package/dist/rpc-client.d.ts

@@ -0,0 +1,59 @@
+import { ResponseMessage } from './index';
+export declare class Client {
+    private write;
+    private requests;
+    private id;
+    private mtu;
+    constructor(write: (msg: ResponseMessage) => void, opts?: {
+        mtu: number;
+    });
+    destroy(): void;
+    messageReceived(msg: any): void;
+    /**
+     * @deprecated Use request() without callback instead - it now returns a Promise
+     */
+    requestAsync(op: string, args: any[]): Promise<any>;
+    /**
+     * Make an RPC request.
+     *
+     * Without callback: Returns a Promise that resolves with the response.
+     * With callback: Returns request ID for streaming/signal subscriptions.
+     *
+     * @example
+     * // Promise style (recommended for one-shot requests)
+     * const result = await client.request('method', [arg1, arg2]);
+     *
+     * // Callback style (for streaming responses or signals)
+     * client.request('signals', [], (err, data, end) => {
+     *     if (data) console.log('Signal:', data);
+     * });
+     */
+    request(op: string, args: any[]): Promise<any>;
+    request(op: string, args: any[], cb: (err: any, data: any, end?: boolean) => any): number;
+    private requestWithCallback;
+    /**
+     * Subscribe to signals from the server.
+     *
+     * @param event - Signal event name to filter (e.g., 'document.changed'), or null for all signals
+     * @param callback - Called when a matching signal is received
+     * @param endpoint - RPC endpoint to subscribe to (default: 'signals')
+     * @returns Unsubscribe function
+     *
+     * @example
+     * // Subscribe to specific signal
+     * const unsub = client.subscribe('document.changed', (data) => {
+     *     console.log('Document changed:', data);
+     * });
+     *
+     * // Subscribe to all signals
+     * const unsub = client.subscribe(null, (event, data) => {
+     *     console.log('Signal:', event, data);
+     * });
+     *
+     * // Unsubscribe when done
+     * unsub();
+     */
+    subscribe(event: string | null, callback: (eventOrData: any, data?: any) => void, endpoint?: string): () => void;
+    send(id: number, data: any): void;
+    end(id: number): void;
+}

package/dist/rpc-client.js

@@ -0,0 +1,176 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+class Client {
+    constructor(write, opts) {
+        this.write = write;
+        this.requests = {};
+        this.id = 0;
+        this.mtu = 65535;
+        if (opts && opts.mtu) {
+            this.mtu = opts.mtu;
+        }
+    }
+    destroy() {
+        // Reject all pending requests with disconnect error
+        if (this.requests) {
+            for (const id of Object.keys(this.requests)) {
+                const request = this.requests[id];
+                if (request && typeof request.cb === 'function' && !request.canceled) {
+                    request.cb.call(request.context, { code: 'DISCONNECTED', msg: 'Connection closed' }, null, true);
+                }
+            }
+        }
+        this.requests = null;
+        this.write = null;
+        this.id = 0;
+    }
+    messageReceived(msg) {
+        //console.log("RpcClient received message", msg);
+        const end = !!(msg.err || msg.ack || msg.fin);
+        const id = msg.ack || msg.err || msg.sig || msg.fin;
+        const request = this.requests[id];
+        let retval;
+        if (request && typeof request.cb === 'function') {
+            let err;
+            if (msg.fin) {
+                // This request closed gracefully
+                request.cb.call(request.context, null, null, true);
+            }
+            else {
+                if (request.canceled) {
+                    console.log('This request is canceled. Not calling the callback.');
+                }
+                else {
+                    // all is good, call the callback function
+                    err = msg.err ? msg.data : null;
+                    retval = request.cb.call(request.context, err, msg.data, end);
+                }
+            }
+        }
+        if (end) {
+            //console.log("deleting this request", id);
+            delete this.requests[id];
+        }
+        return retval;
+    }
+    /**
+     * @deprecated Use request() without callback instead - it now returns a Promise
+     */
+    requestAsync(op, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request(op, args);
+        });
+    }
+    request(op, args, cb) {
+        // Promise mode when no callback provided
+        if (!cb) {
+            return new Promise((resolve, reject) => {
+                this.requestWithCallback(op, args, (err, data) => {
+                    if (err) {
+                        reject(data);
+                    }
+                    else {
+                        resolve(data);
+                    }
+                });
+            });
+        }
+        // Callback mode
+        return this.requestWithCallback(op, args, cb);
+    }
+    requestWithCallback(op, args, cb) {
+        this.id++;
+        const msg = { op };
+        if (Array.isArray(args)) {
+            msg.args = args;
+        }
+        msg.id = this.id;
+        this.requests[msg.id] = {
+            cb,
+            context: {
+                id: msg.id,
+                cancel: () => {
+                    setTimeout(((id) => {
+                        return () => {
+                            if (this.requests[id]) {
+                                console.log('rpc-client.js: timeout, the request has not been removed while it was canceled', id, this.requests[id]);
+                            }
+                        };
+                    })(msg.id), 1500);
+                    this.requests[msg.id].canceled = true;
+                    this.write({ end: msg.id });
+                },
+                emit: (data) => {
+                    return this.write({ sig: msg.id, data: data });
+                }
+            }
+        };
+        this.write(msg);
+        return msg.id;
+    }
+    /**
+     * Subscribe to signals from the server.
+     *
+     * @param event - Signal event name to filter (e.g., 'document.changed'), or null for all signals
+     * @param callback - Called when a matching signal is received
+     * @param endpoint - RPC endpoint to subscribe to (default: 'signals')
+     * @returns Unsubscribe function
+     *
+     * @example
+     * // Subscribe to specific signal
+     * const unsub = client.subscribe('document.changed', (data) => {
+     *     console.log('Document changed:', data);
+     * });
+     *
+     * // Subscribe to all signals
+     * const unsub = client.subscribe(null, (event, data) => {
+     *     console.log('Signal:', event, data);
+     * });
+     *
+     * // Unsubscribe when done
+     * unsub();
+     */
+    subscribe(event, callback, endpoint = 'signals') {
+        const requestId = this.request(endpoint, [], (err, signalData, end) => {
+            if (err || end)
+                return;
+            if (!signalData || !Array.isArray(signalData))
+                return;
+            const [signalEvent, ...args] = signalData;
+            if (event === null) {
+                // Pass all signals: callback(event, data)
+                callback(signalEvent, args.length === 1 ? args[0] : args);
+            }
+            else if (signalEvent === event) {
+                // Pass only matching signals: callback(data)
+                callback(args.length === 1 ? args[0] : args);
+            }
+        });
+        // Return unsubscribe function
+        return () => {
+            if (this.requests && this.requests[requestId]) {
+                this.requests[requestId].canceled = true;
+                this.write({ end: requestId });
+                delete this.requests[requestId];
+            }
+        };
+    }
+    send(id, data) {
+        this.write({ push: id, data });
+    }
+    end(id) {
+        this.write({ end: id });
+    }
+}
+exports.Client = Client;
+//# sourceMappingURL=rpc-client.js.map

package/dist/rpc-protocol.d.ts

@@ -0,0 +1,35 @@
+import { Server } from './rpc-server';
+import { EndpointConfig, EndpointHandler } from './index';
+/**
+ * Base class for P2P protocol handlers.
+ *
+ * Subclass to define endpoints and peer lifecycle:
+ *
+ * ```typescript
+ * class NotesProtocol extends Protocol {
+ *     constructor() {
+ *         super();
+ *         this.endpoint('list', { doc: 'List notes' }, async (req, res) => {
+ *             res.send(myNotes);
+ *         });
+ *     }
+ *
+ *     online(peer: Peer, client: Client) {
+ *         console.log('Peer online:', peer.toString());
+ *     }
+ * }
+ * ```
+ *
+ * Generic parameters allow typed peer/client when re-exported from wish-sdk:
+ * - P = Peer type (defaults to any for wish-rpc standalone use)
+ * - C = Client type (defaults to any for wish-rpc standalone use)
+ */
+export declare class Protocol<P = any, C = any> {
+    server: Server<EndpointConfig>;
+    /** Register an RPC endpoint */
+    endpoint(name: string, config: EndpointConfig, handler: EndpointHandler): void;
+    /** Called when a peer comes online */
+    online(peer: P, client: C): void;
+    /** Called when a peer goes offline */
+    offline(peer: P): void;
+}

package/dist/rpc-protocol.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Protocol = void 0;
+const rpc_server_1 = require("./rpc-server");
+/**
+ * Base class for P2P protocol handlers.
+ *
+ * Subclass to define endpoints and peer lifecycle:
+ *
+ * ```typescript
+ * class NotesProtocol extends Protocol {
+ *     constructor() {
+ *         super();
+ *         this.endpoint('list', { doc: 'List notes' }, async (req, res) => {
+ *             res.send(myNotes);
+ *         });
+ *     }
+ *
+ *     online(peer: Peer, client: Client) {
+ *         console.log('Peer online:', peer.toString());
+ *     }
+ * }
+ * ```
+ *
+ * Generic parameters allow typed peer/client when re-exported from wish-sdk:
+ * - P = Peer type (defaults to any for wish-rpc standalone use)
+ * - C = Client type (defaults to any for wish-rpc standalone use)
+ */
+class Protocol {
+    constructor() {
+        this.server = new rpc_server_1.Server();
+    }
+    /** Register an RPC endpoint */
+    endpoint(name, config, handler) {
+        this.server.endpoint(name, config, handler);
+    }
+    /** Called when a peer comes online */
+    online(peer, client) { }
+    /** Called when a peer goes offline */
+    offline(peer) { }
+}
+exports.Protocol = Protocol;
+//# sourceMappingURL=rpc-protocol.js.map