@celljs/rpc 3.0.0

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

@@ -0,0 +1,29 @@
+import { Prioritizeable, Component, Autowired } from '@celljs/core';
+import { ErrorConverter } from '../converter';
+import { JsonRpcProxy } from '../factory';
+import { ProxyProvider, ProxyCreator } from './proxy-protocol';
+
+@Component(ProxyProvider)
+export class ProxyProviderImpl implements ProxyProvider {
+
+    constructor(
+        @Autowired(ProxyCreator)
+        protected readonly proxyCreators: ProxyCreator[]
+    ) { }
+
+    provide<T extends object>(path: string, errorConverters?: ErrorConverter[], target?: object): JsonRpcProxy<T>  {
+        return this.prioritize(path)[0].create(path, errorConverters, target);
+    }
+
+    protected prioritize(path: string): ProxyCreator[] {
+        const prioritized = Prioritizeable.prioritizeAllSync(this.proxyCreators, proxyCreator => {
+            try {
+                return proxyCreator.support(path);
+            } catch {
+                return 0;
+            }
+        });
+        return prioritized.map(p => p.value);
+    }
+
+}

package/src/common/utils/converter-util.ts

@@ -0,0 +1,29 @@
+import { ContainerUtil, Container } from '@celljs/core';
+import { ErrorConverter, GlobalConverter } from '../converter';
+import { RpcUtil } from './rpc-util';
+
+export namespace ConverterUtil {
+
+    export function getErrorConverterIgnoreNoMatching<T>(task: () => T): T | undefined {
+        try {
+            return task();
+        } catch (error) {
+            if (!error?.message.startsWith('No matching bindings found for serviceIdentifier: Symbol(ErrorConverter)')) {
+                throw error;
+            }
+        }
+    }
+
+    export function getGlobalErrorConverters(container?: Container) {
+        return getErrorConverterIgnoreNoMatching(() =>
+            container ? container.getAllNamed<ErrorConverter>(ErrorConverter, GlobalConverter) :
+                ContainerUtil.getAllNamed<ErrorConverter>(ErrorConverter, GlobalConverter)) || [];
+    }
+
+    export function getErrorConverters(serviceIdentifier: any, container?: Container) {
+        const name = RpcUtil.toName(serviceIdentifier);
+        return getErrorConverterIgnoreNoMatching(() =>
+            container ? container.getNamed<ErrorConverter>(ErrorConverter, name) :
+                ContainerUtil.getNamed<ErrorConverter>(ErrorConverter, name));
+    }
+}

package/src/common/utils/index.ts

@@ -0,0 +1,3 @@
+export * from './rpc-util';
+export * from './converter-util';
+export * from './logger';

package/src/common/utils/logger.ts

@@ -0,0 +1,23 @@
+import { Logger as ILoger } from 'vscode-jsonrpc';
+
+export class ConsoleLogger implements ILoger {
+    public error(message: string): void {
+        console.error(message);
+    }
+
+    public warn(message: string): void {
+        console.warn(message);
+    }
+
+    public info(message: string): void {
+        console.info(message);
+    }
+
+    public log(message: string): void {
+        console.log(message);
+    }
+
+    public debug(message: string): void {
+        console.debug(message);
+    }
+}

package/src/common/utils/rpc-util.ts

@@ -0,0 +1,46 @@
+import { ContainerUtil, ComponentId, UrlUtil } from '@celljs/core';
+import { ID_KEY, RPC } from '../annotation';
+import { HttpProxyCreator, HttpProxyCreatorOptions, MergeOptions } from '../proxy/http-proxy-creator';
+import { ProxyCreator } from '../proxy/proxy-protocol';
+
+let defaultProxyCreator: ProxyCreator | undefined;
+
+export namespace RpcUtil {
+    export function get<T extends object>(rpcServiceIdentifier: ComponentId<T>): T {
+        if (defaultProxyCreator) {
+            return defaultProxyCreator.create<T>(toPath(rpcServiceIdentifier));
+        }
+        return ContainerUtil.getTagged(RPC, ID_KEY, rpcServiceIdentifier);
+    }
+
+    export function getDefaultProxyCreator(endpoint: string, options?: Partial<HttpProxyCreatorOptions<Partial<MergeOptions>>>) {
+        return defaultProxyCreator;
+    }
+
+    export function setDefaultProxyCreator(endpoint: string, options?: Partial<HttpProxyCreatorOptions<Partial<MergeOptions>>>) {
+        defaultProxyCreator = createProxyCreator(endpoint, options);
+    }
+
+    export function createProxyCreator(endpoint: string, options?: Partial<HttpProxyCreatorOptions<Partial<MergeOptions>>>) {
+        return new HttpProxyCreator({ ...options, endpointResolver: {
+            resolve(serviceIdentifier: string) {
+                return Promise.resolve(UrlUtil.join(endpoint, serviceIdentifier));
+            }
+        }});
+    }
+
+    export function create<T extends object>(endpoint: string, rpcServiceIdentifier: ComponentId<T>,
+        options?: Partial<HttpProxyCreatorOptions<Partial<MergeOptions>>>): T {
+        return createProxyCreator(endpoint, options).create<T>(toPath(rpcServiceIdentifier));
+    }
+
+    export function toPath(serviceIdentifier: any) {
+        return typeof serviceIdentifier !== 'function' ? serviceIdentifier.toString() : serviceIdentifier.name || serviceIdentifier.toString();
+
+    }
+
+    export function toName(serviceIdentifier: any) {
+        return typeof serviceIdentifier !== 'function' ? <symbol | string>serviceIdentifier : serviceIdentifier.name || serviceIdentifier.toString();
+
+    }
+}

package/src/node/channel/channel-manager.ts

@@ -0,0 +1,44 @@
+import { Context, NotFoundError } from '@celljs/web/lib/node';
+import { ConnectionHandler, ConnnectionFactory, Channel, ConsoleLogger } from '../../common';
+import { Component, Autowired, Deferred, Optional } from '@celljs/core';
+import { CURRENT_CHANNEL_STRATEGY_REQUEST_KEY, ChannelStrategy } from './channel-protocol';
+
+// tslint:disable:no-any
+@Component()
+export class ChannelManager {
+
+    protected _handlers = new Map<string, ConnectionHandler>();
+
+    constructor(
+        @Autowired(ConnectionHandler) @Optional()
+        protected readonly handlers: ConnectionHandler[],
+        @Autowired(ConnnectionFactory) protected connnectionFactory: ConnnectionFactory<Channel>
+    ) {
+        for (const handler of handlers) {
+            this._handlers.set(handler.path, handler);
+        }
+    }
+
+    async handleChannels(): Promise<void> {
+        const channelStrategy: ChannelStrategy = Context.getAttr(CURRENT_CHANNEL_STRATEGY_REQUEST_KEY);
+        Context.getResponse().body = new Deferred<any>();
+        for (const message of await channelStrategy.getMessages()) {
+            const { id, path } = message as any;
+            if (path) {
+                const handler = this._handlers.get(this.getRealPath(path));
+                if (handler) {
+                    const channel = await channelStrategy.createChannel(id);
+                    handler.onConnection(this.connnectionFactory.create(channel, new ConsoleLogger()));
+                    channel.handleMessage(message);
+                }
+                continue;
+            }
+            throw new NotFoundError(`Cannot find a service for the path: ${path}`);
+        }
+    }
+
+    protected getRealPath(path: string): string {
+        return <string>path.split(':').pop();
+    }
+
+}

package/src/node/channel/channel-middleware.ts

@@ -0,0 +1,27 @@
+import { Middleware, Context } from '@celljs/web/lib/node';
+import { Component, Autowired } from '@celljs/core';
+import { ChannelStrategy, CHANNEL_MIDDLEWARE_PRIORITY, CURRENT_CHANNEL_STRATEGY_REQUEST_KEY } from './channel-protocol';
+import { HttpHeaders, MediaType } from '@celljs/http';
+
+@Component(Middleware)
+export class ChannelMiddleware implements Middleware {
+
+    @Autowired(ChannelStrategy)
+    protected readonly channelStrategies: ChannelStrategy[];
+
+    async handle(ctx: Context, next: () => Promise<void>): Promise<void> {
+        for (const channelStrategy of this.channelStrategies) {
+            if (await channelStrategy.support()) {
+                Context.setAttr(CURRENT_CHANNEL_STRATEGY_REQUEST_KEY, channelStrategy);
+                break;
+            }
+        }
+
+        ctx.response.setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_UTF8);
+
+        await next();
+    }
+
+    readonly priority = CHANNEL_MIDDLEWARE_PRIORITY;
+
+}

package/src/node/channel/channel-protocol.ts

@@ -0,0 +1,21 @@
+import { Channel } from '../../common';
+
+export const ChannelStrategy = Symbol('ChannelStrategy');
+
+export const CHANNEL_MIDDLEWARE_PRIORITY = 2100;
+
+export const CURRENT_CHANNEL_STRATEGY_REQUEST_KEY = 'CurrentChannelStrategyRequest';
+export const CURRENT_MESSAGE_COUNT_REQUEST_KEY = 'CurrentMessageCountRequest';
+export const CURRENT_RESPONSE_MESSAGE_REQUEST_KEY = 'CurrentResponseMessageRequest';
+
+export interface ChannelStrategy {
+
+    getMessages(): Promise<Channel.Message[]>;
+
+    handleMessage(message: any): Promise<void>;
+
+    createChannel(id: number): Promise<Channel>
+
+    support(): Promise<boolean>;
+
+}

package/src/node/channel/channel-strategy.ts

@@ -0,0 +1,56 @@
+import { Channel, HttpChannel } from '../../common/channal';
+import { ChannelStrategy, CURRENT_MESSAGE_COUNT_REQUEST_KEY, CURRENT_RESPONSE_MESSAGE_REQUEST_KEY } from './channel-protocol';
+import { Component } from '@celljs/core';
+import { Context } from '@celljs/web/lib/node';
+
+@Component(ChannelStrategy)
+export class HttpChannelStrategy implements ChannelStrategy {
+    async getMessages(): Promise<Channel.Message[]> {
+        let message = await Context.getRequest().body;
+        if (!Array.isArray(message)) {
+            message = [ message ];
+        } else {
+            const parsed: Channel.Message[] = [];
+            for (const m of message) {
+                parsed.push(JSON.parse(m));
+            }
+            message = parsed;
+        }
+        Context.setAttr(CURRENT_MESSAGE_COUNT_REQUEST_KEY, message.length);
+        return message;
+    }
+
+    async createChannel(id: number): Promise<Channel> {
+        return new HttpChannel(id, async content => {
+            this.handleMessage(content);
+        });
+    }
+
+    async handleMessage(message: string): Promise<void> {
+        if (!this.consumeMessage(message)) {
+            const deferred = Context.getResponse().body;
+            const messages = Context.getAttr<string[]>(CURRENT_RESPONSE_MESSAGE_REQUEST_KEY);
+            deferred.resolve(messages.length > 1 ? JSON.stringify(messages) : message);
+        }
+    }
+
+    protected consumeMessage(message: string) {
+        const messageCount = Context.getAttr<number>(CURRENT_MESSAGE_COUNT_REQUEST_KEY);
+        Context.setAttr(CURRENT_MESSAGE_COUNT_REQUEST_KEY, messageCount - 1);
+        let messages = Context.getAttr<string[]>(CURRENT_RESPONSE_MESSAGE_REQUEST_KEY);
+        if (!messages) {
+            messages = [];
+            Context.setAttr(CURRENT_RESPONSE_MESSAGE_REQUEST_KEY, messages);
+        }
+        messages.push(message);
+        if (messageCount - 1 <= 0) {
+            return false;
+        }
+        return true;
+    }
+
+    async support(): Promise<boolean> {
+        return Context.getCurrent() instanceof Context;
+    }
+
+}

package/src/node/channel/index.ts

@@ -0,0 +1,4 @@
+export * from './channel-manager';
+export * from './channel-protocol';
+export * from './channel-strategy';
+export * from './channel-middleware';

package/src/node/handler/handler-adapter.ts

@@ -0,0 +1,38 @@
+import { Component, Autowired, Value, Deferred } from '@celljs/core';
+import { ChannelManager } from '../channel';
+import { RPC_HANDLER_ADAPTER_PRIORITY } from './handler-protocol';
+import { RequestMatcher, HandlerAdapter, Context } from '@celljs/web/lib/node';
+import { PathResolver } from '@celljs/web';
+import { RPC_PATH } from '../../common';
+
+export const PATH_PARMAS_ATTR = 'pathParams';
+
+@Component(HandlerAdapter)
+export class RpcHandlerAdapter implements HandlerAdapter {
+    readonly priority = RPC_HANDLER_ADAPTER_PRIORITY;
+
+    @Autowired(ChannelManager)
+    protected readonly channelManager: ChannelManager;
+
+    @Autowired(RequestMatcher)
+    protected readonly requestMatcher: RequestMatcher;
+
+    @Autowired(PathResolver)
+    protected readonly pathResolver: PathResolver;
+
+    @Value(RPC_PATH)
+    protected readonly rpcPath: string;
+
+    async handle(): Promise<void> {
+        await this.channelManager.handleChannels();
+        const response = Context.getResponse();
+        if (response.body instanceof Deferred) {
+            response.body = await response.body.promise;
+        }
+    }
+
+    async canHandle(): Promise<boolean> {
+        return this.requestMatcher.match(await this.pathResolver.resolve(this.rpcPath));
+    }
+
+}

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

@@ -0,0 +1 @@
+export const RPC_HANDLER_ADAPTER_PRIORITY = 1000;

package/src/node/handler/index.ts

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

package/src/node/index.ts

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

package/src/node/module.ts

@@ -0,0 +1,4 @@
+import { autoBind } from '@celljs/core';
+import './index';
+
+export default autoBind();

package/src/package.spec.ts

@@ -0,0 +1,4 @@
+describe('rpc package', () => {
+
+    it('support code coverage statistics', () => {});
+});