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

package/src/server/JsonRpcHttpReceiver.ts

@@ -0,0 +1,126 @@
+import http from 'http';
+import http2 from 'http2';
+import stream from 'stream';
+
+type HttpServerRequest = http.IncomingMessage | http2.Http2ServerRequest;
+type HttpServerResponse = http.ServerResponse | http2.Http2ServerResponse;
+type OutgoingHttpHeaders = http.OutgoingHttpHeaders | http2.OutgoingHttpHeaders;
+
+import { JsonStreamingParser, ParsingJsonArray, ParsingJsonTypes, StringifyingJsonArray } from '@xxxaz/stream-api-json';
+import { JsonRpcServer } from './JsonRpcServer.js';
+import { InternalError, JsonRpcException } from '../JsonRpcException.js';
+import { JsonRpcRouter } from '../router/JsonRpcRouter.js';
+import { isRpcRequest, stringifyStream, readStreamAll } from '../utility.js';
+import { JsonRpcRequest } from '../types.js';
+
+type HttpServeOptions = {
+    requestConverter?: (request: ReadableStream<string|Uint8Array>) => ReadableStream<string>;
+    responseConverter?: (response: ReadableStream<string>) => ReadableStream<Uint8Array|string>;
+    headers?: OutgoingHttpHeaders;
+};
+
+export class JsonRpcHttpReceiver<Ctx> extends JsonRpcServer<Ctx> {
+    constructor(router: JsonRpcRouter<Ctx>, options: HttpServeOptions = {}) {
+        super(router);
+        this.#requestConverter = options.requestConverter;
+        this.#responseConverter = options.responseConverter;
+        this.#headers = {
+            'Content-Type': 'application/json',
+            ...options.headers,
+        };
+    }
+    readonly #requestConverter?: (request: ReadableStream<string|Uint8Array>) => ReadableStream<string>;
+    readonly #responseConverter?: (response: ReadableStream<string>) => ReadableStream<Uint8Array|string>;
+    readonly #headers: OutgoingHttpHeaders;
+
+    #convertRequesrt(request: HttpServerRequest) {
+        const stream = new ReadableStream({
+            start(controller) {
+                request.on('error', (error) => controller.error(error));
+                request.on('data', (chunk) => controller.enqueue(chunk));
+                request.on('end', () => controller.close());
+            }
+        });
+        return this.#requestConverter?.(stream) ?? stream;
+    }
+
+    #convertResponse(response: ReadableStream<string>) {
+        if (!this.#responseConverter) return response;
+        return this.#responseConverter(response);
+    }
+
+    async serve(context: Ctx, request: HttpServerRequest, response: HttpServerResponse): Promise<void> {
+        try {
+            const contentLegth = request.headers['content-length'];
+            const reqStream = this.#convertRequesrt(request);
+            const root = contentLegth
+                ? JSON.parse(await (await readStreamAll(reqStream)).text())
+                : await JsonStreamingParser.readFrom(reqStream).root();
+            const { status, stream } = await this.#invoke(context, root);
+            const nodeStream = toNodeReadable(this.#convertResponse(stream));
+            const headers = response instanceof http.ServerResponse
+                ? {
+                    ...this.#headers,
+                    'Transfer-Encoding': 'chunked',
+                }
+                : this.#headers;
+            response.writeHead(status, headers);
+            nodeStream.pipe(response);
+    
+        } catch (err: unknown) {
+            response.writeHead(500);
+            response.end(JSON.stringify({ jsonrpc: "2.0", error: new InternalError(String(err)).serialize() }));
+        }
+    }
+
+    async #invoke(context: Ctx, req: JsonRpcRequest|JsonRpcRequest[]|ParsingJsonTypes) {
+        try {
+            if (isRpcRequest(req)) {
+                const result = await this.call(context, req);
+                return { status: 200, stream: stringifyStream(result) };
+            }
+            if (req instanceof Array) {
+                const result = this.batch(context, req);
+                const stream = new StringifyingJsonArray(result);
+                return { status: 200, stream };
+            }
+            if(req instanceof ParsingJsonArray) {
+                async function * iterateReq() {
+                    for await (const m of req as ParsingJsonArray<any>) {
+                        yield await m.all();
+                    }
+                }
+                const result = this.batch(context, iterateReq());
+                const stream = new StringifyingJsonArray(result);
+                return { status: 200, stream };
+            }
+            const result = await this.call(context, await req.all());
+            return { status: 200, stream: stringifyStream(result) };
+        } catch (err: unknown) {
+            if(err instanceof JsonRpcException) {
+                const status = err instanceof InternalError ? 500 : 400;
+                const result = { jsonrpc: "2.0", error: err.serialize() };
+                return { status, stream: stringifyStream(result) };
+            }
+            throw err;
+        }
+    }
+}
+
+export function toNodeReadable<T>(source: ReadableStream<T>) : stream.Readable {
+    const reader = source.getReader();
+    return new stream.Readable({
+        async destroy(error, callback) {
+            if (error) await reader.cancel(error);
+            callback(error);
+        },
+        async read() {
+            const { done, value } = await reader.read();
+            if (done) {
+                this.push(null);
+            } else {
+                this.push(value);
+            }
+        }
+    });
+}

package/src/server/JsonRpcMessagePortReceiver.ts

@@ -0,0 +1,72 @@
+import { JsonRpcServer } from './JsonRpcServer.js';
+import { JsonRpcRouter } from '../router/JsonRpcRouter.js';
+import { JsonRpcRequest, MessageInput, MessageListener, MessageOutput } from '../types.js';
+import { isRpcRequest } from '../utility.js';
+
+type MessagePortReceiverOprions = {
+    validator?: (event: MessageEvent) => boolean;
+};
+
+export class JsonRpcMessagePortReceiver<Ctx> extends JsonRpcServer<Ctx> {
+    readonly #input: MessageInput;
+    readonly #validator: (event: MessageEvent) => boolean;
+
+    constructor(router: JsonRpcRouter<Ctx>, messageInput: MessageInput, options: MessagePortReceiverOprions = {}) {
+        super(router);
+        this.#input = messageInput;
+        this.#validator = options.validator ?? defaultValidator;
+    }
+    
+    async #onMessage(context: Ctx, output: MessageOutput, event: MessageEvent) {
+        if (event.source && event.source !== output) return;
+        const { data } = event;
+        const request
+            = (data instanceof Array && data.some(isRpcRequest))
+                ? data as JsonRpcRequest[]
+            : isRpcRequest(data)
+                ? data
+                : null;
+
+        if (!request) {
+            console.debug('message is not JsonRpcRequest', request);
+            return;
+        }
+        if (!this.#validator(event)) {
+            console.warn('Invalid Message:', event);
+            return;
+        }
+
+        const response
+            = request instanceof Array
+                ? await Promise.all(request.map(req => this.call(context, req)))
+                : await this.call(context, request);
+        
+        if (event.source instanceof Window) {
+            event.source.postMessage(response, event.origin);
+        } else {
+            (event.source ?? output).postMessage(response);
+        }
+    };
+
+    readonly #listeners = new WeakMap<MessageOutput, MessageListener>();
+    serve(context: Ctx, output: MessageOutput) {
+        if (this.#listeners.has(output)) return;
+        const listener = this.#onMessage.bind(this, context, output);
+        this.#listeners.set(output, listener);
+        this.#input.addEventListener('message', listener);
+    }
+
+    unservce(output: MessageOutput) {
+        const listener = this.#listeners.get(output);
+        if (!listener) return;
+        this.#input.removeEventListener('message', listener);
+        this.#listeners.delete(output);
+    }
+}
+
+function defaultValidator(event: MessageEvent) {
+    if (event.source instanceof Window) {
+        return event.origin === globalThis.origin;
+    }
+    return true;
+}

package/src/server/JsonRpcServer.ts

@@ -0,0 +1,101 @@
+import { LazyResolvers } from "@xxxaz/stream-api-json/utility";
+import { JsonRpcException, MethodNotFound, InternalError, InvalidRequest } from "../JsonRpcException.js";
+import { JsonRpcMethodDefinition } from "../JsonRpcMethod.js";
+import { type JsonRpcRouter } from "../router/JsonRpcRouter.js";
+import { type JsonRpcRequest, type JsonRpcResponse } from "../types.js";
+import { JsonRpcValidator } from "../JsonRpcValidator.js";
+
+type MethodDef<Context> = JsonRpcMethodDefinition<Context, any, any>;
+
+export class JsonRpcServer<Context> {
+    constructor(readonly router: JsonRpcRouter<Context>) {
+    }
+
+    private validateRequest(request: JsonRpcRequest): void {
+        const { jsonrpc, method, params } = request;
+        if(jsonrpc as string !== '2.0') throw new InvalidRequest('jsonrpc must be "2.0"');
+        if(!method) throw new InvalidRequest('method is required.');
+    }
+
+    private async pickMethodDefine(methodPath: string): Promise<MethodDef<Context>> {
+        const picked = await this.router.resolve(methodPath) as MethodDef<Context>|null;
+        if (!picked) {
+            throw new MethodNotFound(`Definition of method ${methodPath} is not Found.`);
+        }
+        const methodKey = (picked.constructor as typeof JsonRpcMethodDefinition).method as keyof MethodDef<Context>;
+        if (picked[methodKey] instanceof Function) {
+            return picked;
+        }
+        throw new MethodNotFound(`Definition ${methodPath} dose not have method.`);
+    }
+
+    private async execute(ctx: Context, request: JsonRpcRequest) {
+        try {
+            this.validateRequest(request);
+            const { method, params } = request;
+
+            const picked = await this.pickMethodDefine(method);
+            const validator = new JsonRpcValidator(picked);
+
+            validator.validateParams(params);
+            const result = await picked.$apply(ctx, params);
+            try {
+                validator.validateReturn(result);
+            } catch (e) {
+                console.warn(`Invalid Result: ${method}`, e);
+            }
+            return result;
+        } catch (err: unknown) {
+            console.error(err);
+            if(err instanceof JsonRpcException) throw err;
+            throw new InternalError(String(err));
+        }
+    }
+
+    async call(ctx: Context, request: JsonRpcRequest): Promise<JsonRpcResponse<any>> {
+        const jsonrpc = '2.0';
+        const id = request.id! ?? null;
+        try {
+            const result = await this.execute(ctx, request);
+            return { jsonrpc, id, result };
+        } catch (err: unknown) {
+            const error = err instanceof JsonRpcException
+                ? err.serialize()
+                : new InternalError(String(err)).serialize();
+            return { jsonrpc, id, error };
+        }
+    };
+
+    async * batch(ctx: Context, requests: AsyncIterable<JsonRpcRequest>|Iterable<JsonRpcRequest>) {
+        const promises: { [id: number|string]: Promise<JsonRpcResponse<any>>} = {};
+        let loading: LazyResolvers<void> = new LazyResolvers();
+        let loadedAll = false;
+        (async () => {
+            for await (const request of requests) {
+                const id = request.id;
+                if (id == null) {
+                    this.execute(ctx, request);
+                    continue;
+                }
+                promises[id] = this.call(ctx, request);
+                loading.resolve();
+                loading = new LazyResolvers();
+            }
+            loadedAll = true;
+            loading.resolve();
+        })();
+
+        while(true) {
+            const list = Object.values(promises);
+            if(!list.length) {
+                if (loadedAll) break;
+                await loading.promise;
+                continue;
+            }
+            const response = await Promise.race(list);
+            yield response;
+            delete promises[response.id!];
+        }
+    };
+
+}

package/src/server/JsonRpcWebSocketReceiver.ts

@@ -0,0 +1,49 @@
+import { JsonRpcServer } from './JsonRpcServer.js';
+import { JsonRpcRequest } from '../types.js';
+import { isRpcRequest } from '../utility.js';
+import { WebSocketWrapper, WrapableWebSocket, wrapWebSocket } from '../WebSocketWrapper.js';
+import { type JsonSerializable } from '@xxxaz/stream-api-json';
+
+export class JsonRpcWebSocketReceiver<Ctx> extends JsonRpcServer<Ctx> {
+    async #onMessage(context: Ctx, socket: WebSocketWrapper, data: JsonSerializable) {
+        const request
+            = (data instanceof Array && data.some(isRpcRequest))
+                ? data as JsonRpcRequest[]
+            : isRpcRequest(data)
+                ? data
+                : null;
+
+        if (!request) {
+            console.debug('message is not JsonRpcRequest', request);
+            return;
+        }
+        
+        const response
+            = request instanceof Array
+                ? await Promise.all(request.map(req => this.call(context, req)))
+                : await this.call(context, request);
+
+        socket.send(response);
+    };
+
+    readonly #sockets = new Map<WrapableWebSocket, WebSocketWrapper>();
+    serve(context: Ctx, socket: WrapableWebSocket) {
+        if (this.#sockets.has(socket)) return;
+        const listener = (data: JsonSerializable) => this.#onMessage(context, wrapper, data);
+        const wrapper = wrapWebSocket(
+            socket,
+            listener,
+            (close) => {
+                console.debug('socket closed', close);
+                this.unservce(socket);
+            }
+        );
+        this.#sockets.set(socket, wrapper);
+    }
+
+    unservce(socket: WrapableWebSocket) {
+        const wrapper = this.#sockets.get(socket);
+        wrapper?.close();
+        this.#sockets.delete(socket);
+    }
+}

package/src/server/index.ts

@@ -0,0 +1,2 @@
+export * from './JsonRpcServer.js';
+export * from './JsonRpcHttpReceiver.js';

package/src/types.ts

@@ -0,0 +1,81 @@
+import { FromSchema as ToTsFromSchema, type JSONSchema as ToTsSchema } from 'json-schema-to-ts';
+import { type JsonSerializable } from "@xxxaz/stream-api-json";
+
+export type TupleSchema<T extends JSONSchema[]> = {
+    type: 'array';
+    items: T;
+    minItems: number;
+    maxItems: number;
+};
+
+export type IsOptionalSchema<Sch, T, F> = false extends (Sch extends { oneOf: readonly ToTsSchema[] } ? Sch['oneOf'][number] : never) ? T : F;
+type FromTuples<Schemas> = 
+    Schemas extends [infer Head extends JSONSchema, ...infer Tail]
+        ? (
+            IsOptionalSchema<Head,
+                [t?: ToTsFromSchema<Head>, ...FromTuples<Tail>],
+                [ToTsFromSchema<Head>, ...FromTuples<Tail>]
+            >
+        ) : [];
+
+export type FromSchema<T extends JSONSchema>
+= (
+    T extends TupleSchema<infer U>
+        ? FromTuples<U>
+        : ToTsFromSchema<T>
+) | IsOptionalSchema<T,  undefined, never>;
+
+type SchemaObject = ToTsSchema & object;
+type SchemaTypeSymbol = Exclude<keyof SchemaObject, string|number>;
+export type JSONSchema = Omit<SchemaObject, SchemaTypeSymbol>;
+
+export type JsonRpcRequest = {
+    jsonrpc: '2.0';
+    id?: number|string;
+    method: string;
+    params: any;
+};
+
+
+export type JsonRpcError = Readonly<{
+    code: number;
+    message?: string;
+    data?: JsonSerializable;
+}>;
+
+
+export type JsonRpcResponse<Result extends JsonSerializable> = {
+    readonly jsonrpc: '2.0';
+    readonly id: number|string;
+    readonly result: Result;
+}|{
+    readonly jsonrpc: '2.0';
+    readonly id: number|string|null;
+    readonly error: JsonRpcError;
+};
+
+
+export type MessageListener = (ev: MessageEvent) => void;
+export type MessageInput = {
+    addEventListener(type: 'message', listener: MessageListener): void;
+    removeEventListener(type: 'message', listener: MessageListener): void;
+};
+export type MessageOutput = {
+    postMessage(message: any): void;
+};
+
+type FitMin<N extends number, C extends void[] = []> = C['length'] extends N ? C : FitMin<N, [void, ...C]>;
+type FitMax<N extends number, C extends void[] = FitMin<N>> = [void, ...C]['length'] extends N ? FitMax<N, [void, ...C]> : C;
+
+export type Min<NumLiteral extends number> = FitMin<NumLiteral> extends any[] ? FitMin<NumLiteral>['length']: never;
+export type Max<NumLiteral extends number> = FitMax<NumLiteral> extends any[] ? FitMax<NumLiteral>['length'] : never;
+
+export type IsOptional<A, T, F = never> = A extends { oneOf: readonly [...any, false, ...any] } ? T : A|undefined extends A ? T : F;
+export type IsNever<A, T, F = never> = [A] extends [never] ? T : F;
+export type PerfectMatch<A, B, T, F = never> = [A] extends [B] ? ([B] extends [A] ? T : F) : F;
+
+export type OptionalKeys<T> = Exclude<{ [K in keyof T]: IsOptional<T[K], K, never> }[keyof T], undefined>;
+export type RequiredKeys<T> = Exclude<keyof T, OptionalKeys<T>>;
+
+declare const InvalidRef: unique symbol;
+export type InvalidRef<Msg> = Omit<Msg&[never], keyof Msg|keyof [never]>;

package/src/utility.ts

@@ -0,0 +1,54 @@
+import { type JsonSerializable } from "@xxxaz/stream-api-json";
+import { JsonRpcRequest, JsonRpcResponse } from "./types.js";
+
+export function toStream<T>(src: T) {
+    return new ReadableStream<T>({
+        start(controller) {
+            controller.enqueue(src);
+            controller.close();
+        }
+    });
+}
+
+export function stringifyStream(json: JsonSerializable) {
+    return toStream(JSON.stringify(json));
+}
+
+export function emptyStrem() {
+    return new ReadableStream({ start: c => c.close() });
+}
+
+export async function readStreamAll(stream: ReadableStream<string|ArrayBuffer>) : Promise<Blob> {
+    const reader = stream.getReader();
+    const result = [] as (ArrayBuffer|string)[];
+    while (true) {
+        const { done, value } = await reader.read();
+        if (value) result.push(value);
+        if (done) break;
+    }
+    return new Blob(result);
+}
+
+export function isRpcRequest(data: any): data is JsonRpcRequest {
+    return (
+        data instanceof Object
+        &&
+        data.jsonrpc === '2.0'
+        &&
+        typeof data.method === 'string'
+    );
+}
+
+export function isRpcResponse(data: any): data is JsonRpcResponse<any> {
+    return (
+        data instanceof Object
+        &&
+        data.jsonrpc === '2.0'
+        &&
+        (
+            'id' in data
+            ||
+            'error' in data
+        )
+    );
+}