@xxxaz/json-rpc-schema-typing 0.10.20 → 0.10.22

package/src/WebSocketWrapper.ts

@@ -0,0 +1,130 @@
+import { type WebSocket as NodeWebSocket, type RawData } from 'ws';
+import { type JsonSerializable } from "@xxxaz/stream-api-json";
+
+export type WrapableWebSocket = WebSocket|NodeWebSocket;
+export function wrapWebSocket(socket: WrapableWebSocket, listener: SocketListener, closedListener: ScokcetClosedListener) {
+    if ('WebSocket' in globalThis && socket instanceof WebSocket) {
+        return new BrowserWebSocketWrapper(socket, listener, closedListener);
+    }
+    return new NodeWebSocketWrapper(socket as NodeWebSocket, listener, closedListener);
+}
+
+type ClosedData = {
+    code: number;
+    reason: string;
+    wasClean?: boolean;
+    wrapper: WebSocketWrapper;
+};
+
+type SocketListener = (data: JsonSerializable) => void;
+type ScokcetClosedListener = (data: ClosedData) => void;
+
+type ConnectionState = 'CONNECTING'|'OPEN'|'CLOSING'|'CLOSED';
+export type WebSocketState = (typeof WebSocket)[ConnectionState];
+
+export interface WebSocketWrapper<Socket extends WrapableWebSocket = WrapableWebSocket> {
+    readonly socket: Socket;
+    readonly listener: SocketListener;
+    readonly readyState: WebSocketState;
+    send(data: JsonSerializable): void;
+    detach(): void;
+    close(): void;
+}
+
+export class NodeWebSocketWrapper implements WebSocketWrapper<NodeWebSocket> {
+    constructor(
+        readonly socket: NodeWebSocket,
+        readonly listener: SocketListener,
+        readonly closedListener: ScokcetClosedListener
+    ) {
+        socket.on('message', this.#onMessage);
+        socket.on('close', (code, reasonBuffer) => {
+            const reason = reasonBuffer.toString();
+            this.closedListener({ code, reason, wrapper: this });
+            this.socket.off('message', this.#onMessage);
+        });
+    }
+
+    get readyState(): WebSocketState {
+        return this.socket.readyState;
+    }
+
+    send(data: JsonSerializable): void {
+        this.socket.send(JSON.stringify(data));
+    }
+
+    detach(): void {
+        this.socket.off('message', this.#onMessage);
+    }
+
+    close(): void {
+        this.detach();
+        this.socket.close();
+    }
+
+    readonly #onMessage = async (data: RawData) => {
+        const parsed = await this.#parseMessage(data);
+        this.listener(parsed);
+    };
+
+    async #parseMessage(data: RawData) : Promise<JsonSerializable> {
+        if (data instanceof ArrayBuffer) {
+            return JSON.parse(await new Blob([data]).text());
+        }
+        const json
+            = data instanceof Array
+            ? data.map(d=>JSON.parse(d.toString())).join('')
+            : data.toString()
+        return JSON.parse(json);
+    }
+}
+
+export class BrowserWebSocketWrapper implements WebSocketWrapper<WebSocket> {
+    constructor(
+        readonly socket: WebSocket,
+        readonly listener: SocketListener,
+        readonly closedListener: ScokcetClosedListener
+    ) {
+        socket.addEventListener('message', this.#onMessage);
+        socket.addEventListener('close', ev => {
+            closedListener({ code: ev.code, reason: ev.reason, wasClean: ev.wasClean, wrapper: this });
+            this.socket.removeEventListener('message', this.#onMessage);
+        });
+    }
+
+    get readyState(): WebSocketState {
+        return this.socket.readyState as WebSocketState;
+    }
+
+    readonly #onMessage = async (ev: MessageEvent) => {
+        const parsed = await this.#parseMessage(ev.data);
+        this.listener(parsed);
+    };
+
+    async #parseMessage(data: ArrayBuffer|string|object) : Promise<JsonSerializable> {
+        if (data instanceof ArrayBuffer) {
+            return JSON.parse(await new Blob([data]).text());
+        }
+        try {
+            if (typeof data === 'string') {
+                return JSON.parse(data);
+            }
+        } catch (e) {
+            console.error('failed to parse message', data, e);
+        }
+        return data as JsonSerializable;
+    }
+
+    send(data: JsonSerializable): void {
+        this.socket.send(JSON.stringify(data));
+    }
+
+    detach(): void {
+        this.socket.removeEventListener('message', this.#onMessage);
+    }
+
+    close(): void {
+        this.detach();
+        this.socket.close();
+    }
+}

package/src/client/JsonRpcClient.ts

@@ -0,0 +1,269 @@
+import { JsonStreamingParser, ParsingJsonArray } from '@xxxaz/stream-api-json';
+import { ClientUncaughtError, InvalidParams, JsonRpcException } from "../JsonRpcException.js";
+import { JsonRpcMethodSchema, ParameterSchema, Params, Return } from "../JsonRpcMethod.js";
+import { JsonRpcValidator } from "../JsonRpcValidator.js";
+import { type JsonRpcSchema } from "../router/JsonRpcRouter.js";
+import { JsonRpcRequest, JsonRpcResponse } from "../types.js";
+import { LazyResolvers } from '@xxxaz/stream-api-json/utility';
+import { stringifyStream } from '../utility.js';
+
+
+type PostRpc = (request: ReadableStream<string>) => Promise<ReadableStream<string>>;
+export type GenereteId = () => Promise<string|number>;
+
+type JsonRpcClientOptions<Sch extends JsonRpcSchema> = {
+    schema: Sch;
+    post: PostRpc;
+    batch?: PostRpc;
+    generateId?: GenereteId;
+};
+
+const $generateId: unique symbol = Symbol('GenereteId');
+const $requestStack: unique symbol = Symbol('RequestsStack');
+const $methodPath: unique symbol = Symbol('MethodPath');
+
+type TriggerFunction<ParamSch extends ParameterSchema, RtnSch> = {
+    (...args: Params<ParamSch>): Promise<Return<RtnSch>>;
+    notice(...args: Params<ParamSch>): void;
+};
+
+type JsonRpcCaller<Schema extends JsonRpcSchema> = {
+    readonly [K in keyof Schema]
+        : Schema[K] extends JsonRpcMethodSchema<infer P, infer R>
+            ? TriggerFunction<P, R>
+        : Schema[K] extends JsonRpcSchema
+            ? JsonRpcCaller<Schema[K]>
+        : never;
+} & { 
+    readonly [$requestStack]: RequestsStack;
+    readonly [$methodPath]: string[];
+};
+
+type RpcWait = {
+    request: JsonRpcRequest;
+    promise: PromiseWithResolvers<JsonRpcResponse<any>|void>;
+};
+
+export class JsonRpcClient<Schema extends JsonRpcSchema> {
+    readonly #schema: Schema;
+    readonly #postRpc: PostRpc;
+    readonly #postBatch: PostRpc;
+    readonly [$generateId]: GenereteId;
+
+    constructor(options: JsonRpcClientOptions<Schema>) {
+        this.#schema = options.schema;
+        this.#postRpc = options.post;
+        this.#postBatch = options.batch ?? options.post;
+        this[$generateId] = options.generateId ?? JsonRpcClient.defaultIdGenerator;
+    }
+
+    static async defaultIdGenerator() {
+        return crypto.randomUUID();
+    }
+
+    async postRpc(request: JsonRpcRequest) {
+        const response = await this.#postRpc(stringifyStream(request));
+        const streamJson = await JsonStreamingParser.readFrom(response).root();
+        const result = await streamJson.all();
+        if ('error' in result) {
+            throw JsonRpcException.deserialize(result.error);
+        }
+        if (request.id == null) return;
+        return result as JsonRpcResponse<any>;
+    }
+
+    async postBatch(requests: RpcWait[]) {
+        const waits = new Map(
+            requests
+                .filter(({ request: { id } }) => id != null)
+                .map(({ request, promise }) => [request.id as string, { request, promise }])
+        );
+        const noWaits = new Set(requests.filter(({ request: { id } }) => id == null));
+
+        try {
+            const requestList = requests.map(({ request: r }) => r);
+            const response = await this.#postBatch(stringifyStream(requestList));
+            const streamJson = await JsonStreamingParser.readFrom(response).root();
+            if (streamJson instanceof ParsingJsonArray) {
+                const results = [] as JsonRpcResponse<any>[];
+                for await (const responseStream of streamJson) {
+                    const res: JsonRpcResponse<any> = await responseStream.all() ?? {};
+                    results.push(res);
+    
+                    const { id, error } = res as any;
+                    const { promise } = waits.get(id) ?? {};
+                    waits.delete(id);
+    
+                    if (!promise) {
+                        console.warn('Orphan rpc response.', res)
+                        continue;
+                    }
+                    if (error) {
+                        promise.reject(JsonRpcException.deserialize(error));
+                        continue;
+                    }
+                    promise.resolve(res);
+                }
+                return results;
+            }
+
+            const singleResult = await streamJson.all();
+            const { id, error } = singleResult ?? {};
+            if (id != null) {
+                const { promise } = waits.get(id) ?? {};
+                if (promise) {
+                    if (error) {
+                        promise.reject(JsonRpcException.deserialize(error));
+                    } else {
+                        promise.resolve(singleResult);
+                    }
+                } else {
+                    console.warn('Orphan rpc response.', singleResult);
+                }
+                return [singleResult];
+            }
+
+            const exceptin = error
+                ? JsonRpcException.deserialize(error)
+                : new ClientUncaughtError('Unexpected response.', singleResult);
+            for (const { promise } of waits.values()) promise.reject(exceptin);
+            for (const { promise } of noWaits) promise.reject(exceptin);
+            noWaits.clear();
+            return [];
+        } catch (e) {
+            console.error(e);
+            throw e;
+        } finally {
+            for(const { promise, request } of waits.values()) {
+                promise.reject(new ClientUncaughtError('Orphan rpc request.', request));
+            }
+            noWaits.forEach(({ promise }) => promise.resolve());
+        }
+    }
+
+    #rpc?: JsonRpcCaller<Schema>;
+    get rpc(): JsonRpcCaller<Schema> {
+        return this.#rpc ??= proxyRpc(new NoStack(this), this.#schema);
+    }
+    
+    #batch?: JsonRpcCaller<Schema>;
+    get batch(): JsonRpcCaller<Schema> {
+        return this.#batch ??= proxyRpc(new BatchStack(this), this.#schema);
+    }
+    kickBatch() {
+        return (this.batch[$requestStack] as BatchStack).kick();
+    }
+
+    lazy(delayMs: number = 0): JsonRpcCaller<Schema> {
+        return proxyRpc(new LazyStack(this, delayMs), this.#schema);
+    }
+}
+
+abstract class RequestsStack {
+    abstract stack(id: boolean, method: string[], params: any): Promise<JsonRpcResponse<any>|void>;
+
+    constructor(readonly client: JsonRpcClient<any>) {}
+    protected async buildRequest(requireId: boolean, methodPath: string[], params: any) : Promise<JsonRpcRequest> {
+        const jsonrpc = '2.0' as const;
+        const method = methodPath.join('.');
+        const id = requireId ? await this.client[$generateId]() : null;
+        return id ? { jsonrpc, id, method, params }: { jsonrpc, method, params };
+    }
+}
+
+class NoStack extends RequestsStack {
+    async stack(requireId: boolean, methodPath: string[], params: any) {
+        const request = await this.buildRequest(requireId, methodPath, params);
+        return this.client.postRpc(request);
+    }
+}
+
+class BatchStack extends RequestsStack {
+    #requests: Promise<RpcWait>[] = [];
+    get currentSize() {
+        return this.#requests.length;
+    }
+
+    stack(requireId: boolean, methodPath: string[], params: any) {
+        const resolver = new LazyResolvers<JsonRpcResponse<any>|void>();
+        const wait
+            = this.buildRequest(requireId, methodPath, params)
+            .then((request)=> ({ request, promise: resolver }));
+        this.#requests.push(wait);
+        return resolver.promise;
+    }
+
+    async kick() {
+        if (!this.#requests.length) return [];
+        const requestsPromises = this.#requests;
+        this.#requests = [];
+        const requests = await Promise.all(requestsPromises);
+        return this.client.postBatch(requests);
+    }
+}
+
+class LazyStack extends BatchStack {
+    constructor(client: JsonRpcClient<any>, readonly delayMs: number) {
+        super(client);
+    }
+
+    stack(requireId: boolean, methodPath: string[], params: any) {
+        if (!this.currentSize) {
+            setTimeout(() => this.kick(), this.delayMs);
+        }
+        return super.stack(requireId, methodPath, params);
+    }
+}
+
+function proxyRpc<Sch extends JsonRpcSchema>(stack: RequestsStack, schema: Sch, methodPath: string[] = []) : JsonRpcCaller<Sch> {
+    type Property = TriggerFunction<any, any>|JsonRpcCaller<any>|undefined;
+    const pickProperty = (key: string): Property => {
+        const route = schema[key];
+        if(!route) return undefined;
+        const path = [...methodPath, key];
+        if('$params' in route || '$return' in route) {
+            const fn = triggerFunction(stack, route as JsonRpcMethodSchema<any, any>, path);
+            return fn;
+        }
+        return proxyRpc(stack, route as JsonRpcSchema, path) as JsonRpcCaller<any>;
+    };
+
+    const cache = { [$requestStack]: stack } as Record<string, Property>;
+    return new Proxy(schema as any, {
+        get(_, key: string) {
+            return cache[key] ??= pickProperty(key);
+        }
+    });
+}
+
+
+function triggerFunction<Sch extends JsonRpcMethodSchema<any, any>>(stack: RequestsStack, schema: Sch, methodPath: string[]) : TriggerFunction<Sch['$params'], Sch['$return']> {
+    const validator = new JsonRpcValidator(schema);
+    const validateParams = (params: any[]) => {
+        if(schema.$params?.type === 'object') {
+            if (params instanceof Array && params.length === 1) {
+                validator.validateParams(params[0]);
+                return params[0];
+            } else {
+                throw new InvalidParams('Expected params to be an object but received multiple parameters.');
+            }
+        }
+        validator.validateParams(params);
+        return params;
+    };
+
+    const fn = async (...params: any[]) => {
+        params = validateParams(params);
+        const response = await stack.stack(true, methodPath, params) ?? {} as JsonRpcResponse<any>;
+        if ('error' in response) {
+            throw JsonRpcException.deserialize(response.error);
+        }
+        validator.validateReturn(response.result);
+        return response.result;
+    };
+    fn.notice = (...params: any[]) => {
+        params = validateParams(params);
+        stack.stack(false, methodPath, params);
+    };
+    return fn;
+}

package/src/client/JsonRpcHttp2Client.ts

@@ -0,0 +1,114 @@
+import http2, { OutgoingHttpHeaders } from 'http2';
+import { ClientHttpError } from "../JsonRpcException.js";
+import { JsonRpcSchema } from "../router/JsonRpcRouter.js";
+import { GenereteId, JsonRpcClient } from "./JsonRpcClient.js";
+import { readStreamAll } from "../utility.js";
+
+type HeadersGenerator = (body: Blob) => Promise<HeadersInit>|HeadersInit;
+
+type JsonRpcHttpClientOptions<Sch extends JsonRpcSchema> = {
+    schema: Sch;
+    generateId?: GenereteId;
+    postUrl: string|URL;
+    batchUrl?: string|URL;
+    requestConverter?: (request: ReadableStream<string>) => ReadableStream<Uint8Array>;
+    responseConverter?: (response: ReadableStream<Uint8Array>, contentType: string|null) => ReadableStream<string>;
+    headers?: HeadersGenerator|HeadersInit;
+    init?: OutgoingHttpHeaders;
+};
+
+export class JsonRpcHttp2Client<Sch extends JsonRpcSchema> extends JsonRpcClient<Sch> {
+
+    constructor(options: JsonRpcHttpClientOptions<Sch>) {
+        const { schema, generateId, postUrl, batchUrl } = options;
+        super({
+            schema,
+            generateId,
+            post: (request) => this.#post(postUrl, request),
+            batch: (request) => this.#post(batchUrl ?? postUrl, request),
+        });
+        this.postUrl = postUrl;
+        this.batchUrl = batchUrl ?? postUrl;
+
+        this.#requestConverter = options.requestConverter;
+        this.#responseConverter = options.responseConverter;
+        this.#initGenerator = async (body) => {
+            const init = options.headers;
+            const headers = (typeof init === 'function')
+                ? new Headers(await init(body))
+                : new Headers(init);
+            if (!headers.has('Content-Type')) {
+                headers.set('Content-Type', 'application/json');
+            }
+            return {
+                ...options.init,
+                ...Object.fromEntries(headers.entries()),
+            };
+        };
+    }
+
+    readonly postUrl: string|URL;
+    readonly batchUrl: string|URL;
+    readonly #requestConverter?: (request: ReadableStream<string>) => ReadableStream<any>;
+    readonly #responseConverter?: (response: ReadableStream<any>, contentType: string|null) => ReadableStream<string>;
+    readonly #initGenerator: (body: Blob) => Promise<OutgoingHttpHeaders>;
+
+    async #post(url: string|URL, request: ReadableStream<string>) {
+        if (this.#requestConverter) request = this.#requestConverter(request);
+        url = new URL(url);
+        const body = await readStreamAll(request);
+        const init = await this.#initGenerator(body);
+
+        const client = http2.connect(url.origin, {
+            protocol: url.protocol === 'http:' ? 'http:' : undefined,
+        });
+        const clientError = new Promise<void>((_, reject) => {
+            client.on('error', (err) => reject(err));
+        });
+
+        const {
+            HTTP2_HEADER_METHOD,
+            HTTP2_HEADER_PATH,
+            HTTP2_HEADER_STATUS,
+        } = http2.constants;
+
+        try{
+            const req = client.request({
+                ...init,
+                [HTTP2_HEADER_METHOD]: 'POST',
+                [HTTP2_HEADER_PATH]: url.pathname + url.search,
+            });
+
+            const headerPromise = Promise.race([
+                new Promise((resolve, reject) => {
+                    req.on('error', reject);
+                    req.on('response', resolve);
+                }),
+                clientError,
+            ]);
+
+            req.setEncoding('utf8');
+            req.write(new Uint8Array(await body.arrayBuffer()));
+            req.end();
+
+            const headers = await headerPromise as Record<string, string|string[]>;
+            const status = Number(headers[HTTP2_HEADER_STATUS] instanceof Array ? headers[HTTP2_HEADER_STATUS][0] : headers[HTTP2_HEADER_STATUS]);
+            if (Math.floor(status / 100) !== 2) {
+                const message = `${status} Satus Code is not OK`;
+                console.warn(new ClientHttpError(message, { headers }));
+            }
+            const stream = new ReadableStream({
+                start(controller) {
+                    req.on('error', (error) => controller.error(error));
+                    req.on('data', (chunk) => controller.enqueue(chunk));
+                    req.on('end', () => controller.close());
+                }
+            });
+            return this.#responseConverter
+                ? this.#responseConverter(stream, headers['content-type'] as string)
+                : stream;
+        } finally {
+            client.close();
+        }
+    }
+}

package/src/client/JsonRpcHttpClient.ts

@@ -0,0 +1,71 @@
+import { responseToTextStream } from "@xxxaz/stream-api-json/helpers-browser";
+import { ClientHttpError } from "../JsonRpcException.js";
+import { JsonRpcSchema } from "../router/JsonRpcRouter.js";
+import { GenereteId, JsonRpcClient } from "./JsonRpcClient.js";
+import { emptyStrem, readStreamAll } from "../utility.js";
+
+type HeadersGenerator = (body: Blob) => Promise<HeadersInit>|HeadersInit;
+
+type JsonRpcHttpClientOptions<Sch extends JsonRpcSchema> = {
+    schema: Sch;
+    generateId?: GenereteId;
+    postUrl: string|URL;
+    batchUrl?: string|URL;
+    requestConverter?: (request: ReadableStream<string>) => ReadableStream<Uint8Array>;
+    responseConverter?: (response: ReadableStream<Uint8Array>, contentType: string|null) => ReadableStream<string>;
+    headers?: HeadersGenerator|HeadersInit;
+    init?: Pick<RequestInit, 'credentials'|'keepalive'|'mode'|'priority'|'redirect'|'referrer'|'referrerPolicy'>;
+};
+
+export class JsonRpcHttpClient<Sch extends JsonRpcSchema> extends JsonRpcClient<Sch> {
+
+    constructor(options: JsonRpcHttpClientOptions<Sch>) {
+        const { schema, generateId, postUrl, batchUrl } = options;
+        super({
+            schema,
+            generateId,
+            post: (request) => this.#post(postUrl, request),
+            batch: (request) => this.#post(batchUrl ?? postUrl, request),
+        });
+        this.postUrl = postUrl;
+        this.batchUrl = batchUrl ?? postUrl;
+
+        this.#requestConverter = options.requestConverter;
+        this.#responseConverter = options.responseConverter;
+        this.#initGenerator = async (body) => {
+            const init = options.headers;
+            const headers = (typeof init === 'function')
+                ? new Headers(await init(body))
+                : new Headers(init);
+            if (!headers.has('Content-Type')) {
+                headers.set('Content-Type', 'application/json');
+            }
+            return {
+                ...options.init,
+                method: 'POST',
+                headers,
+            };
+        };
+    }
+
+    readonly postUrl: string|URL;
+    readonly batchUrl: string|URL;
+    readonly #requestConverter?: (request: ReadableStream<string>) => ReadableStream<any>;
+    readonly #responseConverter?: (response: ReadableStream<any>, contentType: string|null) => ReadableStream<string>;
+    readonly #initGenerator: (body: Blob) => Promise<RequestInit>;
+
+    async #post(url: string|URL, request: ReadableStream<string>) {
+        if (this.#requestConverter) request = this.#requestConverter(request);
+        const body = await readStreamAll(request);
+        const init = await this.#initGenerator(body);
+        const response = await fetch(url, { ...init, body });
+        if (!response.ok) {
+            const message = `${response.status} ${response.statusText}`;
+            const headers = Object.fromEntries(response.headers.entries());
+            console.warn(new ClientHttpError(message, { headers }));
+        }
+        return this.#responseConverter
+            ? this.#responseConverter(response.body ?? emptyStrem(), response.headers.get('Content-Type'))
+            : responseToTextStream(response);
+    }
+}