@celljs/rpc 3.0.0

package/src/common/factory/proxy-factory.ts

@@ -0,0 +1,219 @@
+import { MessageConnection, ResponseError, Emitter, Event } from 'vscode-jsonrpc';
+import { ApplicationError, Disposable, Logger, getTargetClass, getPropertyNames } from '@celljs/core';
+import { ErrorConverter } from '../converter';
+import { ConnectionHandler } from '../handler';
+import { PipeManager } from '@celljs/web';
+
+export type JsonRpcServer<Client> = Disposable & {
+    /**
+     * If this server is a proxy to a remote server then
+     * a client is used as a local object
+     * to handle JSON-RPC messages from the remote server.
+     */
+    setClient(client: Client | undefined): void;
+};
+
+export interface JsonRpcConnectionEventEmitter {
+    readonly onDidOpenConnection: Event<void> ;
+    readonly onDidCloseConnection: Event<void>;
+}
+export type JsonRpcProxy<T> = T & JsonRpcConnectionEventEmitter;
+
+export class JsonRpcConnectionHandler<T extends object> implements ConnectionHandler {
+    constructor(
+        readonly path: string,
+        readonly targetFactory: (proxy: JsonRpcProxy<T>) => any,
+        readonly errorConverters: ErrorConverter[],
+        readonly pipeManager: PipeManager,
+        readonly logger: Logger
+    ) { }
+
+    onConnection(connection: MessageConnection): void {
+        const factory = new JsonRpcProxyFactory<T>(undefined, this.errorConverters, this.pipeManager, this.logger);
+        const proxy = factory.createProxy();
+        factory.target = this.targetFactory(proxy);
+        factory.listen(connection);
+    }
+}
+
+export class JsonRpcProxyFactory<T extends object> implements ProxyHandler<T> {
+
+    private static SET_CLIENT = 'setClient';
+    private static ON_DID_OPEN_CONNECTION = 'onDidOpenConnection';
+    private static ON_DID_CLOSE_CONNECTION = 'onDidCloseConnection';
+    private readonly onDidOpenConnectionEmitter = new Emitter<void>();
+    private readonly onDidCloseConnectionEmitter = new Emitter<void>();
+    protected internalMethods: Map<string, () => any>;
+
+    protected connectionPromiseResolve: (connection: MessageConnection) => void;
+    protected connectionPromise: Promise<MessageConnection>;
+
+    constructor(
+        public target?: any,
+        protected errorConverters?: ErrorConverter[],
+        protected pipeManager?: PipeManager,
+        protected logger?: Logger) {
+        this.waitForConnection();
+    }
+
+    protected waitForConnection(): void {
+        this.connectionPromise = new Promise(resolve =>
+            this.connectionPromiseResolve = resolve
+        );
+        this.connectionPromise.then(connection => {
+            connection.onClose(() =>
+                this.onDidCloseConnectionEmitter.fire(undefined)
+            );
+            this.onDidOpenConnectionEmitter.fire(undefined);
+        });
+    }
+
+    protected getRequestHander(prop: string) {
+        return (...args: any[]) => this.onRequest(prop, ...args);
+    }
+
+    protected getNotificationHander(prop: string) {
+        return (...args: any[]) => this.onNotification(prop, ...args);
+    }
+
+    protected registerMethods(connection: MessageConnection) {
+        if (this.target) {
+            for (const prop of getPropertyNames(this.target)) {
+                if (typeof this.target[prop] === 'function') {
+                    connection.onRequest(prop, this.getRequestHander(prop));
+                    connection.onNotification(prop, this.getNotificationHander(prop));
+                }
+            }
+        }
+    }
+
+    listen(connection: MessageConnection) {
+        this.registerMethods(connection);
+        connection.onDispose(() => this.waitForConnection());
+        connection.listen();
+        this.connectionPromiseResolve(connection);
+    }
+
+    protected async onRequest(method: string, ...args: any[]): Promise<any> {
+        const now = Date.now();
+        const message = `${getTargetClass(this.target).name}.${method}`;
+        // eslint-disable-next-line no-unused-expressions
+        this.logger?.info(`starting ${message}`);
+        try {
+            // eslint-disable-next-line no-unused-expressions
+            await this.pipeManager?.apply({ target: this.target, method: method }, args);
+
+            return await this.target[method](...args);
+        } catch (error) {
+            const e = this.serializeError(error);
+            if (e instanceof ResponseError) {
+                throw e;
+            }
+            const reason = e.message || '';
+            const stack = e.stack || '';
+            // eslint-disable-next-line no-unused-expressions
+            this.logger?.error(`Request ${method} failed with error: ${reason}`, stack);
+            throw e;
+        } finally {
+            // eslint-disable-next-line no-unused-expressions
+            this.logger?.info(`ending ${message}, cost ${Date.now() - now}ms`);
+
+        }
+    }
+
+    protected onNotification(method: string, ...args: any[]): void {
+        this.target[method](...args);
+    }
+
+    createProxy(): JsonRpcProxy<T> {
+        const proxy = new Proxy<T>(this as any, this);
+        return proxy as any;
+    }
+
+    get(target: T, p: PropertyKey, receiver: any): any {
+        const method = this.getInternalMethod(p.toString());
+        if (method) {
+            return method;
+        }
+        return this.createProxyMethod(p.toString());
+    }
+
+    protected getInternalMethod(method: string) {
+        if (method === JsonRpcProxyFactory.SET_CLIENT) {
+            return  (client: any) => this.target = client;
+        }
+        if (method === JsonRpcProxyFactory.ON_DID_OPEN_CONNECTION) {
+            return this.onDidOpenConnectionEmitter.event;
+        }
+        if (method === JsonRpcProxyFactory.ON_DID_CLOSE_CONNECTION) {
+            return this.onDidCloseConnectionEmitter.event;
+        }
+    }
+
+    protected createProxyMethod(method: string) {
+        if (method === 'then') {
+            return undefined;
+        }
+        const isNotify = this.isNotification(method);
+        return async (...args: any[]) => {
+            const capturedError = new Error(`Request '${method}' failed`);
+            const connection =  await this.connectionPromise;
+            if (isNotify) {
+                connection.sendNotification(method, ...args);
+            } else {
+                try {
+                    return await connection.sendRequest(method, ...args) as Promise<any>;
+                } catch (err) {
+                    throw this.deserializeError(capturedError, err);
+                }
+            }
+        };
+    }
+
+    protected isNotification(p: PropertyKey): boolean {
+        return p.toString().startsWith('notify') || p.toString().startsWith('on');
+    }
+
+    protected serializeError(e: any): any {
+        if (this.errorConverters) {
+            for (const converter of this.errorConverters) {
+                const serialized = converter.serialize(e);
+                if (serialized) {
+                    e = serialized;
+                    break;
+                }
+            }
+        }
+        if (ApplicationError.is(e)) {
+            return new ResponseError(e.code, '',
+                Object.assign({ kind: 'application' }, e.toJson())
+            );
+        }
+        return e;
+    }
+    protected deserializeError(capturedError: Error, e: any): any {
+        if (e instanceof ResponseError) {
+            const capturedStack = capturedError.stack || '';
+            if (e.data && e.data.kind === 'application') {
+                const { stack, data, message } = e.data;
+                e = ApplicationError.fromJson(e.code, {
+                    message: message || capturedError.message,
+                    data,
+                    stack: `${capturedStack}\nCaused by: ${stack}`
+                });
+            } else {
+                e.stack = capturedStack;
+            }
+        }
+        if (this.errorConverters) {
+            for (const converter of this.errorConverters) {
+                const deserialized = converter.deserialize(e);
+                if (deserialized) {
+                    return deserialized;
+                }
+            }
+        }
+        return e;
+    }
+
+}

package/src/common/factory/reader.ts

@@ -0,0 +1,50 @@
+import { DataCallback, AbstractMessageReader, Disposable } from 'vscode-jsonrpc';
+import { Channel } from '../channal/channel-protocol';
+
+export class ChannelMessageReader extends AbstractMessageReader {
+
+    protected state: 'initial' | 'listening' | 'closed' = 'initial';
+    protected callback: DataCallback | undefined;
+    protected readonly events: { message?: any, error?: any }[] = [];
+
+    constructor(protected readonly channel: Channel) {
+        super();
+        this.channel.onMessage(message =>
+            this.readMessage(message)
+        );
+    }
+
+    listen(callback: DataCallback): Disposable {
+        if (this.state === 'initial') {
+            this.state = 'listening';
+            this.callback = callback;
+            while (this.events.length !== 0) {
+                const event = this.events.pop()!;
+                if (event.message) {
+                    this.readMessage(event.message);
+                } else if (event.error) {
+                    this.fireError(event.error);
+                }
+            }
+        }
+        return Disposable.create(() => {});
+    }
+
+    protected readMessage(message: any): void {
+        if (this.state === 'initial') {
+            this.events.splice(0, 0, { message });
+        } else if (this.state === 'listening') {
+            const data = JSON.parse(message);
+            this.callback!(data);
+        }
+    }
+
+    protected override fireError(error: any): void {
+        if (this.state === 'initial') {
+            this.events.splice(0, 0, { error });
+        } else if (this.state === 'listening') {
+            super.fireError(error);
+        }
+    }
+
+}

package/src/common/factory/writer.ts

@@ -0,0 +1,26 @@
+import { Message, AbstractMessageWriter } from 'vscode-jsonrpc';
+import { Channel } from '../channal';
+
+export class ChannelMessageWriter extends AbstractMessageWriter {
+
+    protected errorCount = 0;
+
+    constructor(protected readonly channel: Channel) {
+        super();
+    }
+
+    async write(msg: Message): Promise<void> {
+        try {
+            const content = JSON.stringify(msg);
+            this.channel.send(content);
+        } catch (e) {
+            this.errorCount++;
+            this.fireError(e, msg, this.errorCount);
+        }
+    }
+
+    end() {
+
+    }
+
+}

package/src/common/handler/connection-handler.ts

@@ -0,0 +1,7 @@
+import { MessageConnection } from 'vscode-jsonrpc';
+import { ConnectionHandler } from './handler-protocol';
+
+export class NoOpConnectionHandler implements ConnectionHandler {
+    readonly path: string;
+    onConnection(connection: MessageConnection): void {}
+}

package/src/common/handler/handler-protocol.ts

@@ -0,0 +1,8 @@
+import { MessageConnection } from 'vscode-jsonrpc';
+
+export const ConnectionHandler = Symbol('ConnectionHandler');
+
+export interface ConnectionHandler {
+    readonly path: string;
+    onConnection(connection: MessageConnection): void;
+}

package/src/common/handler/index.ts

@@ -0,0 +1,2 @@
+export * from './connection-handler';
+export * from './handler-protocol';

package/src/common/index.ts

@@ -0,0 +1,11 @@
+export * from './annotation';
+export * from './channal';
+export * from './endpoint';
+export * from './error';
+export * from './factory';
+export * from './handler';
+export * from './proxy';
+export * from './utils';
+export * from './constants';
+export * from './converter';
+export * from './processor';

package/src/common/module.ts

@@ -0,0 +1,21 @@
+import { autoBind } from '@celljs/core';
+import { ProxyProvider } from './proxy';
+import { ID_KEY, RPC } from './annotation';
+import { RpcUtil, ConverterUtil } from './utils';
+import './index';
+
+export default autoBind(bind => {
+
+    bind(RPC).toDynamicValue(ctx => {
+        const id = ctx.currentRequest.target.getCustomTags()?.find(m => m.key === ID_KEY)!.value;
+        const path = RpcUtil.toPath(id);
+        const proxyProvider = ctx.container.get<ProxyProvider>(ProxyProvider);
+        const errorConverters = ConverterUtil.getGlobalErrorConverters(ctx.container);
+        const errorConverter = ConverterUtil.getErrorConverters(id, ctx.container);
+        if (errorConverter) {
+            errorConverters.push(errorConverter);
+        }
+        return proxyProvider.provide(path, errorConverters);
+    });
+
+});

package/src/common/processor/client-config-processor.ts

@@ -0,0 +1,12 @@
+import { Component } from '@celljs/core';
+import { ClientConfigProcessor } from './processor-protocol';
+import { AxiosRequestConfig } from 'axios';
+
+@Component(ClientConfigProcessor)
+export class NoOpClientConfigProcessor implements ClientConfigProcessor {
+
+    async process(config: AxiosRequestConfig): Promise<void> {
+
+    }
+
+}

package/src/common/processor/index.ts

@@ -0,0 +1,2 @@
+export * from './processor-protocol';
+export * from './client-config-processor';

package/src/common/processor/processor-protocol.ts

@@ -0,0 +1,7 @@
+import { AxiosRequestConfig } from 'axios';
+
+export const ClientConfigProcessor = Symbol('ClientConfigProcessor');
+
+export interface ClientConfigProcessor {
+    process(config: AxiosRequestConfig): Promise<void>;
+}

package/src/common/proxy/delegating-http-proxy-creator.ts

@@ -0,0 +1,68 @@
+import { Component, Autowired, Value, PostConstruct } from '@celljs/core';
+import { RestOperations } from '@celljs/http';
+import { ProxyCreator } from './proxy-protocol';
+import { EndpointResolver } from '../endpoint';
+import { ConnnectionFactory, JsonRpcProxy } from '../factory';
+import { Channel } from '../channal';
+import { ErrorConverter } from '../converter';
+import { AxiosRequestConfig } from 'axios';
+import { ClientConfigProcessor } from '../processor';
+import { HttpProxyCreator } from './http-proxy-creator';
+
+@Component(ProxyCreator)
+export class DelegatingHttpProxyCreator implements ProxyCreator {
+
+    @Autowired(ConnnectionFactory)
+    protected connnectionFactory: ConnnectionFactory<Channel>;
+
+    @Autowired(EndpointResolver)
+    protected endpointResolver: EndpointResolver;
+
+    @Autowired(RestOperations)
+    protected restOperations: RestOperations;
+
+    @Autowired(ClientConfigProcessor)
+    protected clientConfigProcessor: ClientConfigProcessor;
+
+    @Value('cell.rpc.client.config')
+    protected readonly clientConfig: AxiosRequestConfig;
+
+    @Value('cell.rpc.merge.maxCount')
+    protected readonly maxCount: number;
+
+    @Value('cell.rpc.merge.maxLength')
+    protected readonly maxLength: number;
+
+    @Value('cell.rpc.merge.timerDelay')
+    protected readonly timerDelay: number;
+
+    @Value('cell.rpc.merge.enabled')
+    protected readonly enabled: boolean;
+
+    protected delegate: ProxyCreator;
+
+    @PostConstruct()
+    protected init() {
+        this.delegate = new HttpProxyCreator({
+            connnectionFactory: this.connnectionFactory,
+            endpointResolver: this.endpointResolver,
+            restOperations: this.restOperations,
+            clientConfigProcessor: this.clientConfigProcessor,
+            clientConfig: this.clientConfig,
+            merge: {
+                maxCount: this.maxCount,
+                maxLength: this.maxLength,
+                timerDelay: this.timerDelay,
+                enabled: this.enabled
+            }
+        });
+    }
+
+    create<T extends object>(path: string, errorConverters?: ErrorConverter[], target?: object | undefined): JsonRpcProxy<T> {
+        return this.delegate.create(path, errorConverters, target);
+    }
+
+    support(path: string): number {
+        return this.delegate.support(path);
+    }
+}

package/src/common/proxy/http-proxy-creator.ts

@@ -0,0 +1,179 @@
+import { HttpHeaders, HttpMethod, MediaType, XML_HTTP_REQUEST, RestOperations, DefaultRestOperationsFactory } from '@celljs/http';
+import { Logger } from 'vscode-jsonrpc';
+import { ProxyCreator, ConnectionOptions, RequestTaskMeta } from './proxy-protocol';
+import { EndpointResolver } from '../endpoint';
+import { ConnnectionFactory, ConnnectionFactoryImpl, JsonRpcProxy, JsonRpcProxyFactory } from '../factory';
+import { Channel, HttpChannel } from '../channal';
+import { ErrorConverter } from '../converter';
+import { ConnectionHandler } from '../handler';
+import { AxiosRequestConfig } from 'axios';
+import { ClientConfigProcessor } from '../processor';
+import { ConsoleLogger } from '../utils';
+
+export interface MergeOptions {
+        maxCount: number;
+        maxLength: number;
+        timerDelay: number;
+        enabled: boolean;
+}
+
+export interface HttpProxyCreatorOptions<T> {
+
+    connnectionFactory: ConnnectionFactory<Channel>;
+    endpointResolver: EndpointResolver;
+    restOperations: RestOperations;
+    clientConfigProcessor?: ClientConfigProcessor;
+    clientConfig: AxiosRequestConfig;
+    merge: T;
+}
+
+const DEFAULT_OPTIONS: Omit<HttpProxyCreatorOptions<MergeOptions>, 'endpointResolver'> = {
+    connnectionFactory: new ConnnectionFactoryImpl(),
+    restOperations: new DefaultRestOperationsFactory().create(),
+    clientConfig: {},
+    merge: {
+        maxCount: 100,
+        maxLength: 5242880,
+        timerDelay: 35,
+        enabled: false
+    }
+
+};
+
+export class HttpProxyCreator implements ProxyCreator {
+
+    protected channelIdSeq = 0;
+
+    protected requestMap = new Map<string, RequestTaskMeta>();
+    protected channelMap = new Map<number, Channel>();
+    protected options: HttpProxyCreatorOptions<MergeOptions>;
+
+    constructor(
+        options: Partial<Omit<HttpProxyCreatorOptions<Partial<MergeOptions>>, 'endpointResolver'>> & Pick<HttpProxyCreatorOptions<Partial<MergeOptions>>, 'endpointResolver'>) {
+        this.options = { ...DEFAULT_OPTIONS, ...options, merge: { ...DEFAULT_OPTIONS.merge, ...options.merge } };
+    }
+
+    create<T extends object>(path: string, errorConverters?: ErrorConverter[], target?: object | undefined): JsonRpcProxy<T> {
+        const factory = new JsonRpcProxyFactory<T>(target, errorConverters);
+        this.options.endpointResolver.resolve(path).then(endpoint => this.listen({
+            path: endpoint,
+            onConnection: c => factory.listen(c)
+        }));
+        return factory.createProxy();
+    }
+
+    support(path: string): number {
+        return 500;
+    }
+
+    listen(handler: ConnectionHandler, options?: ConnectionOptions): void {
+        this.openChannel(handler.path, channel => {
+            const connection = this.options.connnectionFactory.create(channel, this.createLogger());
+            handler.onConnection(connection);
+        }, options);
+    }
+
+    openChannel(path: string, handler: (channel: Channel) => void, options?: ConnectionOptions): void {
+        this.doOpenChannel(path, handler, options);
+    }
+
+    protected doOpenChannel(path: string, handler: (channel: Channel) => void, options?: ConnectionOptions): void {
+        const id = this.channelIdSeq++;
+        const channel = this.createChannel(id, path);
+        handler(channel);
+    }
+
+    protected createChannel(id: number, path: string): Channel {
+        const parts = path.split('/');
+        const serviceName = parts.pop();
+        const endpoint = parts.join('/');
+        const channel = new HttpChannel(id, async content => {
+            if (this.options.merge.enabled) {
+                if (this.canMerge(endpoint, content)) {
+                    this.pushContent(endpoint, content);
+                } else {
+                    this.executeTask(endpoint);
+                    this.pushContent(endpoint, content);
+                }
+            } else {
+                this.pushContent(endpoint, content);
+                this.executeTask(endpoint);
+            }
+
+        }, serviceName);
+        this.channelMap.set(id, channel);
+        return channel;
+    }
+
+    protected executeTask(endpoint: string) {
+        const meta = this.requestMap.get(endpoint);
+        if (meta) {
+            return meta.task();
+        }
+    }
+
+    protected canMerge(endpoint: string, content: string) {
+        const meta = this.requestMap.get(endpoint);
+        if (meta) {
+            if (meta.contentLength + content.length > this.options.merge.maxLength ||
+                meta.contents.length + 1 > this.options.merge.maxCount) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    protected pushContent(endpoint: string, content: string) {
+        let meta = this.requestMap.get(endpoint);
+        if (!meta) {
+            const task = this.createTask(endpoint);
+            meta = {
+                id: setTimeout(task, this.options.merge.timerDelay),
+                contents: [],
+                contentLength: 0,
+                task
+            };
+            this.requestMap.set(endpoint, meta);
+        }
+        meta.contents.push(content);
+        meta.contentLength += content.length;
+        return meta;
+    }
+
+    protected createTask(endpoint: string) {
+        return async () => {
+            const meta = this.requestMap.get(endpoint);
+            if (!meta) {
+                return;
+            }
+            clearTimeout(meta.id as any);
+            const contents = meta.contents;
+            this.requestMap.delete(endpoint);
+            const config: AxiosRequestConfig = {
+                url: endpoint,
+                method: HttpMethod.POST,
+                data: contents.length > 1 ? JSON.stringify(contents) : contents[0],
+                headers: {
+                    [HttpHeaders.CONTENT_TYPE]: MediaType.APPLICATION_JSON_UTF8,
+                    [HttpHeaders.X_REQUESTED_WITH]: XML_HTTP_REQUEST
+                },
+                ...this.options.clientConfig
+            };
+            await this.options.clientConfigProcessor?.process(config);
+            const { data } = await this.options.restOperations.request(config);
+            if (Array.isArray(data)) {
+                for (const message of data) {
+                    const parsed = JSON.parse(message);
+                    this.channelMap.get(parsed.id)!.handleMessage(parsed);
+                }
+            } else {
+                this.channelMap.get(data.id)!.handleMessage(data);
+            }
+        };
+    }
+
+    protected createLogger(): Logger {
+        return new ConsoleLogger();
+    }
+
+}

package/src/common/proxy/index.ts

@@ -0,0 +1,5 @@
+export * from './proxy-provider';
+export * from './proxy-protocol';
+export * from './http-proxy-creator';
+export * from './delegating-http-proxy-creator';
+

package/src/common/proxy/proxy-protocol.ts

@@ -0,0 +1,26 @@
+import { ErrorConverter } from '../converter';
+import { JsonRpcProxy } from '../factory';
+
+export const ProxyProvider = Symbol('ProxyProvider');
+
+export interface ProxyProvider {
+    provide<T extends object>(path: string, errorConverters?: ErrorConverter[], target?: object): JsonRpcProxy<T>;
+}
+
+export const ProxyCreator = Symbol('ProxyCreator');
+
+export interface ProxyCreator {
+    create<T extends object>(path: string, errorConverters?: ErrorConverter[], target?: object): JsonRpcProxy<T>;
+    support(path: string): number
+}
+
+export interface ConnectionOptions {
+    reconnecting?: boolean;
+}
+
+export interface RequestTaskMeta {
+    id: number | NodeJS.Timeout;
+    contentLength: number;
+    contents: string[];
+    task: () => Promise<void>;
+}