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

package/src/client/JsonRpcMessagePortClient.ts

@@ -0,0 +1,121 @@
+import { LazyResolvers } from "@xxxaz/stream-api-json/utility";
+import { JsonRpcSchema } from "../router/JsonRpcRouter.js";
+import { GenereteId, JsonRpcClient } from "./JsonRpcClient.js";
+import { isRpcResponse, readStreamAll } from "../utility.js";
+import { JsonRpcRequest, JsonRpcResponse, MessageInput, MessageOutput } from "../types.js";
+
+type JsonRpcMessagePortClientOptions<Sch extends JsonRpcSchema> = {
+    schema: Sch;
+    generateId?: GenereteId;
+    targetOrigin?: string;
+} & ({
+    input: MessageInput;
+    output: MessageOutput;
+    port?: undefined;
+}|{
+    input?: undefined;
+    output?: undefined;
+    port: MessageInput & MessageOutput;
+});
+
+type ProccessedMessage = {
+    request: JsonRpcRequest;
+    resolver: LazyResolvers<JsonRpcResponse<any>>;
+};
+
+export class JsonRpcMessagePortClient<Sch extends JsonRpcSchema> extends JsonRpcClient<Sch> {
+    readonly #targetOrigin: string;
+    readonly #input: MessageInput;
+    readonly #output: MessageOutput;
+
+    constructor(options: JsonRpcMessagePortClientOptions<Sch>) {
+        const { schema, generateId } = options;
+        super({
+            schema,
+            generateId,
+            post: (request) => this.#request(request),
+        });
+
+        this.#input = options.port ?? options.input;
+        this.#output = options.port ?? options.output;
+        this.#targetOrigin = options.targetOrigin ?? globalThis.origin ?? '*';
+
+        this.#input.addEventListener('message', this.#receive.bind(this));
+    }
+
+    async #request(stream: ReadableStream<string>) {
+        const blob = await readStreamAll(stream);
+        const request = JSON.parse(await blob.text());
+        if (request instanceof Array) {
+            return this.#batch(request);
+        }
+
+        const response = await this.#post(request);
+        return new ReadableStream({
+            async start(controller) {
+                if (response) {
+                    controller.enqueue(JSON.stringify(response));
+                }
+                controller.close();
+            }
+        });
+    }
+
+    async #batch(requests: JsonRpcRequest[]) {
+        const entries = requests
+            .map(req => [ req.id!, this.#post(req)! ] as const)
+            .filter(([ id, promise ]) => promise)
+        const promises = new Map(entries);
+
+        return new ReadableStream({
+            async start(controller) {
+                controller.enqueue('[');
+                while(promises.size > 0) {
+                    const response = await Promise.race(promises.values());
+                    controller.enqueue(JSON.stringify(response));
+                    promises.delete(response.id!);
+                }
+                controller.enqueue(']');
+                controller.close();
+            }
+        });
+    };
+
+    readonly #pool = new Map<number|string, ProccessedMessage>();
+    #post(request: JsonRpcRequest) {
+        let resolver: LazyResolvers<JsonRpcResponse<any>>|null = null;
+        if (request.id != null) {
+            resolver = new LazyResolvers<JsonRpcResponse<any>>();
+            this.#pool.set(request.id, { request, resolver });
+        }
+
+        if(this.#output instanceof Window) {
+            this.#output.postMessage(request, this.#targetOrigin);
+        } else {
+            this.#output.postMessage(request);
+        }
+
+        return resolver?.promise ?? null;
+    }
+
+    async #receive(event: MessageEvent) {
+        if (event.source && event.source !== this.#output) return;
+        const data = JSON.parse(event.data);
+        if (!isRpcResponse(data)) {
+            console.debug('message is not JsonRpcResponse', data);
+            return;
+        }
+        if (data.id == null) {
+            console.debug('Reponse message is not Unidentifiable', data);
+            return;
+        }
+        const pooled = this.#pool.get(data.id);
+        if (!pooled) {
+            console.warn('Orphan rpc response.', data)
+            return;
+        }
+        pooled.resolver.resolve(data);
+        this.#pool.delete(data.id);
+    }
+
+}

package/src/client/JsonRpcWebSocketClient.ts

@@ -0,0 +1,143 @@
+import { LazyResolvers } from "@xxxaz/stream-api-json/utility";
+import { type JsonSerializable } from "@xxxaz/stream-api-json";
+import { JsonRpcSchema } from "../router/JsonRpcRouter.js";
+import { GenereteId, JsonRpcClient } from "./JsonRpcClient.js";
+import { isRpcResponse, readStreamAll } from "../utility.js";
+import { JsonRpcError, JsonRpcRequest, JsonRpcResponse } from "../types.js";
+import { WebSocketWrapper, WrapableWebSocket, wrapWebSocket } from '../WebSocketWrapper.js';
+
+type JsonRpcWebSocketClientOptions<Sch extends JsonRpcSchema, Skt extends WrapableWebSocket> = {
+    schema: Sch;
+    socket: Skt;
+    generateId?: GenereteId;
+};
+
+type ProccessedMessage = {
+    request: JsonRpcRequest;
+    resolver: LazyResolvers<JsonRpcResponse<any>>;
+};
+
+export class JsonRpcWebSocketClient<Sch extends JsonRpcSchema, Skt extends WrapableWebSocket> extends JsonRpcClient<Sch> {
+    readonly #socket: WebSocketWrapper;
+
+    constructor(options: JsonRpcWebSocketClientOptions<Sch, Skt>) {
+        const { schema, generateId } = options;
+        super({
+            schema,
+            generateId,
+            post: (request) => this.#request(request),
+        });
+        this.#socket = wrapWebSocket(
+            options.socket,
+            this.#receive.bind(this),
+            (close) => {
+                console.debug('socket closed', close);
+                const { code, reason, wasClean } = close;
+                this.rejectAll({
+                    code: -32000,
+                    message: 'Connection closed',
+                    data: { code, reason, wasClean } as JsonSerializable,
+                });
+            }
+        );
+    }
+
+    get available() {
+        const { CLOSING, CLOSED } = WebSocket;
+        const state = this.#socket.readyState;
+        return state !== CLOSING && state !== CLOSED;
+    }
+
+    async #request(stream: ReadableStream<string>) {
+        const blob = await readStreamAll(stream);
+        const request = JSON.parse(await blob.text());
+        if (request instanceof Array) {
+            return this.#batch(request);
+        }
+
+        const response = await this.#post(request);
+        return new ReadableStream({
+            async start(controller) {
+                if (response) {
+                    controller.enqueue(JSON.stringify(response));
+                }
+                controller.close();
+            }
+        });
+    }
+
+    async #batch(requests: JsonRpcRequest[]) {
+        const entries = requests
+            .map(req => [ req.id!, this.#post(req)! ] as const)
+            .filter(([ id, promise ]) => promise)
+        const promises = new Map(entries);
+
+        return new ReadableStream({
+            async start(controller) {
+                const initialCount = promises.size;
+                controller.enqueue('[');
+                while(promises.size > 0) {
+                    if (promises.size < initialCount) {
+                        controller.enqueue(',');
+                    }
+                    const response = await Promise.race(promises.values());
+                    controller.enqueue(JSON.stringify(response));
+                    promises.delete(response.id!);
+                }
+                controller.enqueue(']');
+                controller.close();
+            }
+        });
+    };
+
+    readonly #pool = new Map<number|string, ProccessedMessage>();
+    #post(request: JsonRpcRequest) {
+        if (!this.available) {
+            return Promise.resolve<JsonRpcResponse<any>>({
+                jsonrpc: '2.0',
+                id: request.id!,
+                error: {
+                    code: -32000,
+                    message: 'Connection is not available',
+                    data: null,
+                },
+            });
+        }
+        let resolver: LazyResolvers<JsonRpcResponse<any>>|null = null;
+        if (request.id != null) {
+            resolver = new LazyResolvers<JsonRpcResponse<any>>();
+            this.#pool.set(request.id, { request, resolver });
+        }
+        this.#socket.send(request);
+        return resolver?.promise ?? null;
+    }
+
+    async #receive(data: JsonSerializable) {
+        if (!isRpcResponse(data)) {
+            console.debug('message is not JsonRpcResponse', data);
+            return;
+        }
+        if (data.id == null) {
+            console.debug('Reponse message is not Unidentifiable', data);
+            return;
+        }
+        const pooled = this.#pool.get(data.id);
+        if (!pooled) {
+            console.warn('Orphan rpc response.', data)
+            return;
+        }
+        pooled.resolver.resolve(data);
+        this.#pool.delete(data.id);
+    }
+
+    rejectAll(reason: JsonRpcError) {
+        for (const { request: { id }, resolver } of this.#pool.values()) {
+            resolver.resolve({
+                jsonrpc: '2.0',
+                id: id!,
+                error: reason,
+            });
+        }
+        this.#pool.clear();
+    }
+}

package/src/client/index.ts

@@ -0,0 +1,3 @@
+export * from './JsonRpcClient.js';
+export * from './JsonRpcHttpClient.js';
+export * from './JsonRpcHttp2Client.js';

package/src/index.ts

@@ -0,0 +1,11 @@
+
+export * from './JsonRpcException.js';
+export * from './JsonRpcMethod.js';
+export * from './JsonSchemaValidator.js';
+
+export * from './types.js';
+
+export * from './client/index.js';
+export * from './schemas/index.js';
+export * from './router/index.js';
+export * from './server/index.js';

package/src/router/FileSystemRouter.ts

@@ -0,0 +1,78 @@
+import { lstatSync, readdirSync, existsSync } from 'fs';
+import { JsonRpcMethodDefinition } from "../JsonRpcMethod.js";
+import { JsonRpcRouter } from "./JsonRpcRouter.js";
+
+type RouteCache<Ctx> = {
+    [path: string]: FileSystemRouter<Ctx>|JsonRpcMethodDefinition<Ctx, any, any>|null;
+};
+
+export class FileSystemRouter<Ctx> extends JsonRpcRouter<Ctx> {
+    constructor(private readonly rootDir: string) {
+        super();
+        if (!existsSync(rootDir)) throw new Error(`Not found: ${rootDir}`);
+        const stat = lstatSync(rootDir);
+        if (!stat.isDirectory()) throw new Error(`Not a directory: ${rootDir}`);
+    }
+
+    // instanceof JsonRpcMethodDefinition だと参照先モジュールが複数存在した際に一致しなくなる
+    static #isDefinition(obj: any): obj is JsonRpcMethodDefinition<any, any, any> {
+        const key = obj?.constructor?.method;
+        return typeof key === 'symbol' && obj[key] instanceof Function;
+    }
+
+    #cache = {} as RouteCache<Ctx>;
+    async resolveChild(methodPath: string) {
+        if (methodPath in this.#cache) return this.#cache[methodPath];
+        const path = `${this.rootDir}/${methodPath}`;
+        if (existsSync(path)) {
+            if (lstatSync(path).isDirectory()) {
+                return this.#cache[methodPath] = new FileSystemRouter<Ctx>(path);
+            }
+        }
+
+        const filePath
+            = existsSync(`${path}.js`)
+                ? `${path}.js`
+            : existsSync(`${path}.ts`)
+                ? `${path}.ts`
+                : null;
+        if (!filePath) return this.#cache[methodPath] = null;
+        
+        try {
+            const module = await import(filePath);
+            if (FileSystemRouter.#isDefinition(module.default)) {
+                return this.#cache[methodPath] = module.default;
+            }
+        } catch(e) {
+            console.error(`Invalid routing: ${path}`, e);
+        }
+
+        return null;
+    }
+
+    async resolve(methodPath: string|string[]): Promise<JsonRpcRouter<Ctx>|JsonRpcMethodDefinition<Ctx, any, any>|null> {
+        if (!methodPath || methodPath.length === 0) return this;
+        if (typeof methodPath === 'string') methodPath = methodPath.split('.');
+        const [head, ...tail] = methodPath;
+
+        const child = await this.resolveChild(head);
+        if (tail.length === 0) return child;
+        if (!child) {
+            console.warn(`Route not found: ${head}`);
+            return null;
+        }
+
+        if (FileSystemRouter.#isDefinition(child)) {
+            console.warn(`Method appear middle in route : ${head}`);
+            return null;
+        }
+
+        return child.resolve(tail);
+    }
+
+    async * enumerate(): AsyncIterable<string> {
+        for(const name of readdirSync(this.rootDir)) {
+            yield name.replace(/\.(js|ts)$/, '');
+        }
+    }
+}

package/src/router/JsonRpcRouter.ts

@@ -0,0 +1,62 @@
+import { type JsonSerializable } from "@xxxaz/stream-api-json";
+import { JsonRpcMethodDefinition, JsonRpcMethodSchema, ParameterSchema, Params, Return } from "../JsonRpcMethod.js";
+import { hashObject } from "./hashObject.js";
+
+type AsyncFunction<P, R> = P extends ParameterSchema ? (...params: Params<P>) => Promise<Return<R>> : never;
+type NoticeFunction<P> = P extends ParameterSchema ? (...params: Params<P>) => void : never;
+
+export abstract class JsonRpcRouter<Context = {}> {
+    abstract resolve(methodPath: string): Promise<JsonRpcRouter<Context>|JsonRpcMethodDefinition<Context, any, any>|null>;
+    abstract resolveChild(methodPath: string): Promise<JsonRpcRouter<Context>|JsonRpcMethodDefinition<Context, any, any>|null>;
+    abstract enumerate(): AsyncIterable<string>;
+
+    async schema(): Promise<JsonRpcSchema> {
+        const entries = [] as [string, JsonRpcMethodSchema<any, any>|JsonRpcSchema][];
+        for await (const key of this.enumerate()) {
+            const child = await this.resolveChild(key);
+            if (!child) continue;
+            if (child instanceof JsonRpcRouter) {
+                const schema = await child.schema();
+                if (Object.keys(schema).length > 0) {
+                    entries.push([key, schema]);
+                }
+                continue;
+            }
+            const { $params, $return } = child;
+            entries.push([key, { $params, $return }]);
+        }
+        return Object.fromEntries(entries) as JsonRpcSchema;
+    }
+    
+
+    async schemaTypeScript() {
+        const schema = await this.schema();
+        const hash = await hashObject(schema);
+        return [
+            `export default ${JSON.stringify(schema)} as const;`,
+            `export const hash = ${JSON.stringify(hash)} as const;`,
+        ].join('\n');
+    }
+}
+
+export type JsonRpcSchema = JsonSerializable & {
+    readonly [path: string]: JsonRpcMethodSchema<any, any>|JsonRpcSchema;
+};
+
+export type JsonRpcAccessor<Router extends JsonRpcRouter|JsonRpcSchema> = {
+    readonly [Key in keyof Router]
+        : Router[Key] extends JsonRpcRouter|JsonRpcSchema
+            ? JsonRpcAccessor<Router[Key]>
+        : Router[Key] extends JsonRpcMethodSchema<any, any>
+            ? AsyncFunction<Router[Key]['$params'], Router[Key]['$return']>
+        : never;
+}
+
+export type JsonRpcNotice<Router extends JsonRpcRouter|JsonRpcSchema> = {
+    readonly [Key in keyof Router]
+        : Router[Key] extends JsonRpcRouter|JsonRpcSchema
+            ? JsonRpcNotice<Router[Key]>
+        : Router[Key] extends JsonRpcMethodSchema<any, any>
+            ? NoticeFunction<Router[Key]['$params']>
+        : never;
+}

package/src/router/StaticRouter.ts

@@ -0,0 +1,51 @@
+import { JsonRpcMethodDefinition, JsonRpcMethodSchema } from "../JsonRpcMethod.js";
+import { JsonRpcRouter, JsonRpcSchema } from "./JsonRpcRouter.js";
+
+type RouteMap<Ctx> = {
+    readonly [path: string]: RouteMap<Ctx>|JsonRpcMethodDefinition<Ctx, any, any>|Promise<RouteMap<Ctx>|JsonRpcMethodDefinition<Ctx, any, any>|undefined>;
+};
+
+type RouteCache<Ctx> = {
+    [path: string]: StaticRouter<Ctx>|JsonRpcMethodDefinition<Ctx, any, any>|null;
+};
+
+export class StaticRouter<Ctx> extends JsonRpcRouter<Ctx> {
+    constructor(private readonly routeMap: RouteMap<Ctx>) {
+        super();
+    }
+
+    #cache = {} as RouteCache<Ctx>;
+    async resolveChild(methodPath: string) {
+        if (methodPath in this.#cache) return this.#cache[methodPath];
+        const child = await this.routeMap[methodPath];
+        if (!child) return this.#cache[methodPath] = null;
+        if (child instanceof JsonRpcMethodDefinition) return this.#cache[methodPath] = child;
+        return this.#cache[methodPath] = new StaticRouter<Ctx>(child);
+    }
+
+    async resolve(methodPath: string|string[]): Promise<JsonRpcRouter<Ctx>|JsonRpcMethodDefinition<Ctx, any, any>|null> {
+        if (!methodPath || methodPath.length === 0) return this;
+        if (typeof methodPath === 'string') methodPath = methodPath.split('.');
+        const [head, ...tail] = methodPath;
+
+        const child = await this.resolveChild(head);
+        if (tail.length === 0) return child;
+        if (!child) {
+            console.warn(`Route not found: ${head}`);
+            return null;
+        }
+
+        if (child instanceof JsonRpcMethodDefinition) {
+            console.warn(`Method appear middle in route : ${head}`);
+            return null;
+        }
+
+        return child.resolve(tail);
+    }
+
+    async * enumerate(): AsyncIterable<string> {
+        for(const key in this.routeMap) {
+            yield key;
+        }
+    }
+}

package/src/router/hashObject.ts

@@ -0,0 +1,31 @@
+import { type JsonSerializable } from "@xxxaz/stream-api-json";
+
+export async function hashObject(src: JsonSerializable): Promise<string> {
+    const json = orderGuaranteeJson(src);
+    const srcBuffer = await new Blob([json]).arrayBuffer();
+    const hashBuffer = await crypto.subtle.digest("SHA-256", srcBuffer);
+    return [...new Uint8Array(hashBuffer)].map(b => b.toString(16).padStart(2, '0')).join('');
+}
+
+function orderGuaranteeJson(src: JsonSerializable): string {
+    if (src === undefined) return 'null';
+    if (src === null) return 'null';
+    switch (typeof src) {
+        case 'string':
+        case 'number':
+        case 'boolean':
+            return JSON.stringify(src);
+        case 'object':
+            if (Array.isArray(src)) {
+                const stringfied = src.map(orderGuaranteeJson);
+                return `[${stringfied.join(',')}]`;
+            }
+            const stringfied = Object.entries(src)
+                .filter(([k, v]) => v !== undefined)
+                .sort(([k1], [k2]) => k1 < k2 ? -1 : 1)
+                .map(([k, v]) => JSON.stringify(k) + ':' + orderGuaranteeJson(v));
+            return `{${stringfied.join(',')}}`;
+        default:
+            throw new TypeError('Unexpected type');
+    }
+}

package/src/router/index.ts

@@ -0,0 +1,3 @@
+export * from './FileSystemRouter.js';
+export * from './JsonRpcRouter.js';
+export * from './StaticRouter.js';

package/src/schemas/Complex.ts

@@ -0,0 +1,92 @@
+import { type Primitive } from "@xxxaz/stream-api-json";
+import { JSONSchema } from "../types.js";
+
+export function $Enum<T extends (null|boolean|number|string)[]>(...elements: T) {
+    return {
+        enum: elements
+    } as const;
+}
+
+export function $EnumKeys<T extends object>(obj: T) {
+    return {
+        enum: Object.keys(obj) as [(keyof T)]
+    } as const;
+}
+
+export function $EnumValues<T extends { [key: string]: Primitive }>(obj: T) {
+    return {
+        enum: Object.values(obj) as [T[keyof T]],
+    } as const;
+};
+
+export function $Expand<Src extends JSONSchema, Ex extends Partial<JSONSchema>>(source: Src, expand: Ex) {
+    return {
+        ...source,
+        ...expand,
+    } as const;
+}
+
+type Optional<T> = { oneOf: (T|false)[] } | { anyOf: (T|false)[] };
+export function $Optional<T extends JSONSchema>(item: T) {
+    return {
+        oneOf: [item, false]
+    } as const;
+}
+
+$Optional.is = (item: unknown): item is Optional<any> => {
+    const lits = (item as any)?.oneOf ?? (item as any)?.anyOf ?? null;
+    if (!lits) return false;
+    return (lits.some((i: any) => i === false));
+};
+
+type Unwrapped<T> = T extends Optional<infer U> ? U : T;
+$Optional.unwrap = <T extends JSONSchema|undefined>(item: T): Unwrapped<T> => {
+    const optionalList = item?.oneOf ?? item?.anyOf ?? null;
+    if (!optionalList) return item as Unwrapped<T>;
+    const list = optionalList.filter(i => i !== false);
+    if (list.length === 1) return list[0] as Unwrapped<T>;
+    return item?.oneOf
+        ? { oneOf: list } as Unwrapped<T>
+        : { anyOf: list } as Unwrapped<T>;
+};
+
+export function $And<Schemas extends JSONSchema[]>(...allOf: Schemas) {
+    return {
+        allOf
+    } as const;
+}
+
+export function $Or<Schemas extends JSONSchema[]>(...anyOf: Schemas) {
+    return {
+        anyOf
+    } as const;
+}
+
+export function $Xor<Schemas extends JSONSchema[]>(...oneOf: Schemas) {
+    return {
+        oneOf
+    } as const;
+}
+
+export function $Omit<
+    T extends JSONSchema & { type: 'object' },
+    K extends keyof T['properties'] & string,
+>(schema: T, keys: readonly K[]) {
+    const properties = Object.fromEntries(
+        Object.entries(schema.properties ?? {}).filter(
+            ([key]) => !keys.includes(key as K)
+        )
+    );
+    const required = (schema.required ?? []).filter(
+        (k) => !keys.includes(k as K)
+    );
+    return {
+        type: 'object',
+        properties: properties as Omit<T['properties'], K>,
+        required: required as T['required'] extends (infer R)[]
+            ? [Exclude<R, K>]
+            : never,
+        additionalProperties:
+            schema.additionalProperties as T['additionalProperties'],
+    } as const;
+}

package/src/schemas/Primitive.ts

@@ -0,0 +1,21 @@
+
+export const $Null = {
+    type: 'null',
+    nullable: true,
+} as const;
+
+export const $Boolean = {
+    type: 'boolean',
+} as const;
+
+export const $Number = {
+    type: 'number',
+} as const;
+
+export const $Integer = {
+    type: 'integer',
+} as const;
+
+export const $String = {
+    type: 'string',
+} as const;

package/src/schemas/Structure.ts

@@ -0,0 +1,42 @@
+import { IsOptionalSchema, JSONSchema, Max, RequiredKeys } from "../types.js";
+import { $Optional } from "./Complex.js";
+
+export function $Array<T extends JSONSchema>(items: T) {
+    return {
+        type: 'array',
+        items
+    } as const;
+}
+
+export type ExcludeOptional<T extends readonly any[]>
+    = T extends [...infer A, infer L]
+    ? IsOptionalSchema<L, ExcludeOptional<A>, T>
+    : T;
+
+export function $Tuple<T extends readonly JSONSchema[]>(...items: T) {
+    // NOTE: Optionalを含む場合、Ajvが以下のような通知を吐きます
+    // strict mode: "items" is 2-tuple, but minItems or maxItems/additionalItems are not specified or different at path "#"
+    const optionalNumber = [...items].reverse().findIndex((i: JSONSchema) => $Optional.is(i)) + 1;
+    return {
+        type: 'array',
+        items: items.map(item => $Optional.unwrap(item)!) as any as T,
+        minItems: items.length - optionalNumber as ExcludeOptional<T>['length'],
+        maxItems: items.length as Max<T['length']>,
+        additionalItems: false,
+    } as const;
+}
+
+type ObjectDefine = {
+    [key: string]: JSONSchema;
+};
+export function $Object<T extends ObjectDefine>(properties: T) {
+    const required = Object.entries(properties)
+        .filter(([key, value]) => !$Optional.is(value))
+        .map(([key]) => key) as [RequiredKeys<T>];
+    return {
+        type: 'object',
+        additionalProperties: false,
+        required,
+        properties: properties as T
+    } as const;
+}

package/src/schemas/index.ts

@@ -0,0 +1,3 @@
+export * from './Primitive.js';
+export * from './Complex.js';
+export * from './Structure.js';