@x-oasis/async-call-rpc-misc 0.1.38

package/src/channel-protocol/middlewares/prepareRequestData.ts

@@ -0,0 +1,137 @@
+import AbstractChannelProtocol from '../AbstractChannelProtocol';
+import {
+  SendingProps,
+  RequestEntryHeader,
+  HostRequestEntryHeader,
+  RequestType,
+  SendMiddlewareLifecycle,
+} from '../../types';
+
+export const preparePortData = (channel: AbstractChannelProtocol) => {
+  const fn = (props: string | SendingProps, ...args: any[]) => {
+    let requestPath = '';
+    let fnName = '';
+    let params = [] as any[];
+    let transfer = [];
+    let isOptionsRequest = false;
+
+    const seqId = channel.seqId;
+
+    if (typeof props === 'string') {
+      requestPath = props;
+      fnName = args[0];
+      params = args.slice(1);
+    } else {
+      requestPath = props.requestPath;
+      fnName = props.fnName;
+      isOptionsRequest = props.isOptionsRequest;
+      // args will convert to array on default
+      params = [].concat(props.args);
+      transfer = args[0] ? args[0] : [];
+    }
+
+    const header: RequestEntryHeader = [
+      RequestType.PromiseRequest,
+      seqId,
+      requestPath,
+      fnName,
+    ];
+
+    const body = params;
+    return {
+      seqId,
+      transfer,
+      isOptionsRequest,
+      data: [header, body],
+    };
+  };
+
+  fn.lifecycle = SendMiddlewareLifecycle.Prepare;
+  return fn;
+};
+
+export const prepareHostPortData = (channel: AbstractChannelProtocol) => {
+  const fn = (props: string | SendingProps, ...args: any[]) => {
+    let requestPath = '';
+    let fnName = '';
+    let params = [] as any[];
+    let transfer = [];
+    const seqId = channel.seqId;
+    let isOptionsRequest = false;
+
+    if (typeof props === 'string') {
+      requestPath = props;
+      fnName = args[0];
+      params = args.slice(1);
+    } else {
+      requestPath = props.requestPath;
+      fnName = props.fnName;
+      isOptionsRequest = props.isOptionsRequest;
+      // args will convert to array on default
+      params = [].concat(props.args);
+      transfer = args[0] ? args[0] : [];
+    }
+
+    const header: HostRequestEntryHeader = [
+      RequestType.PromiseRequest,
+      seqId,
+      requestPath,
+      fnName,
+      // @ts-ignore
+      channel.channelName,
+    ];
+
+    const body = params;
+
+    return {
+      seqId,
+      transfer,
+      isOptionsRequest,
+      data: [header, body],
+    };
+  };
+
+  fn.lifecycle = SendMiddlewareLifecycle.Prepare;
+  return fn;
+};
+
+export const prepareNormalData = (channel: AbstractChannelProtocol) => {
+  const fn = (props: string | SendingProps, ...args: any[]) => {
+    let requestPath = '';
+    let fnName = '';
+    let params = [] as any[];
+    const seqId = channel.seqId;
+    let isOptionsRequest = false;
+
+    if (typeof props === 'string') {
+      requestPath = props;
+      fnName = args[0];
+      params = args.slice(1);
+    } else {
+      requestPath = props.requestPath;
+      fnName = props.fnName;
+      isOptionsRequest = props.isOptionsRequest;
+      // args will convert to array on default
+      params = [].concat(props.args);
+    }
+
+    const header: RequestEntryHeader = [
+      RequestType.PromiseRequest,
+      seqId,
+      requestPath,
+      fnName,
+    ];
+
+    const body = params;
+
+    return {
+      seqId,
+      isOptionsRequest,
+      data: [header, body],
+    };
+  };
+
+  fn.lifecycle = SendMiddlewareLifecycle.Prepare;
+
+  return fn;
+};

package/src/channel-protocol/middlewares/sendRequest.ts

@@ -0,0 +1,15 @@
+import { SenderMiddlewareOutput, SendMiddlewareLifecycle } from '../../types';
+import AbstractChannelProtocol from '../AbstractChannelProtocol';
+
+export const sendRequest = (channelProtocol: AbstractChannelProtocol) => {
+  const fn = (value: SenderMiddlewareOutput) => {
+    const { data, transfer } = value;
+    if (transfer) channelProtocol.channel.send(data, transfer);
+    else channelProtocol.channel.send(data);
+
+    return value;
+  };
+
+  fn.lifecycle = SendMiddlewareLifecycle.Send;
+  return fn;
+};

package/src/channel-protocol/middlewares/updateSeqInfo.ts

@@ -0,0 +1,27 @@
+import { createDeferred } from '@x-oasis/deferred';
+import { isEventMethod } from '../../common';
+import { SenderMiddlewareOutput, SendMiddlewareLifecycle } from '../../types';
+import AbstractChannelProtocol from '../AbstractChannelProtocol';
+
+export const updateSeqInfo = (channelProtocol: AbstractChannelProtocol) => {
+  const fn = (value: SenderMiddlewareOutput) => {
+    const { data, seqId } = value;
+    const header = data[0];
+    const body = data[1];
+    const fnName = header[3];
+
+    // 如果说是event method的话，需要将body重制一下
+    if (fnName && isEventMethod(fnName)) {
+      channelProtocol.requestEvents.set(`${seqId}`, body[0]);
+      data[1] = [];
+    } else {
+      const returnValue = createDeferred();
+      channelProtocol.ongoingRequests.set(`${seqId}`, returnValue);
+      value.returnValue = returnValue;
+    }
+    return value;
+  };
+
+  fn.lifecycle = SendMiddlewareLifecycle.Transfrom;
+  return fn;
+};

package/src/channel-protocol/middlewares/utils.ts

@@ -0,0 +1,67 @@
+import {
+  MiddlewareContext,
+  PendingSendEntry,
+  MiddlewareFunction,
+  SendMiddlewareLifecycle,
+} from '../../types';
+
+export const resumeMiddlewares = (
+  middlewares: any,
+  entry: PendingSendEntry
+) => {
+  let start = false;
+
+  return middlewares.reduce((a: any, b: MiddlewareFunction) => {
+    if (!b.lifecycle) return a;
+    if (a.lifecycle >= b.lifecycle && b.displayName === a.fnName) {
+      start = true;
+    }
+    if (!start) return a;
+
+    const targetLifecycle = a?.middlewareContext?.minLifecycle;
+    const currentLifecycle = b?.lifecycle;
+
+    // @ts-ignore
+    if (
+      targetLifecycle &&
+      currentLifecycle &&
+      currentLifecycle < targetLifecycle
+    ) {
+      return a;
+    }
+
+    return b(a);
+  }, entry);
+};
+
+export const runMiddlewares = (
+  middlewares: any,
+  args: any[],
+  _context?: MiddlewareContext
+) => {
+  const context = {
+    isResumed: false,
+    startLifecycle: SendMiddlewareLifecycle.Initial,
+    minLifecycle: SendMiddlewareLifecycle.Initial,
+    ...(_context || {}),
+  };
+
+  return middlewares.reduce((a: any, b: MiddlewareFunction, index: number) => {
+    if (!index) return b(...a);
+    if (index === 1) {
+      a.middlewareContext = context;
+    }
+
+    const targetLifecycle = a?.middlewareContext?.minLifecycle;
+    const currentLifecycle = b?.lifecycle;
+
+    if (
+      targetLifecycle &&
+      currentLifecycle &&
+      currentLifecycle < targetLifecycle
+    ) {
+      return a;
+    }
+    return b(a);
+  }, args);
+};

package/src/common.ts

@@ -0,0 +1,20 @@
+import { isUpperAsciiLetter } from '@x-oasis/is-ascii';
+
+export const isEventMethod = (name: string) => {
+  if (typeof name !== 'string') return false;
+  return (
+    name[0] === 'o' && name[1] === 'n' && isUpperAsciiLetter(name.charCodeAt(2))
+  );
+};
+
+export const isAssignPassingPortMethod = (name: string) => {
+  return /^assignPassingPort$/.test(name);
+};
+
+export const isAcquirePortMethod = (name: string) => {
+  return /^acquire.*Port$/.test(name);
+};
+
+export const isOptionsMethod = (name: string) => {
+  return /Options$/.test(name) || /OptionsRequest$/.test(name);
+};

package/src/error.ts

@@ -0,0 +1,32 @@
+/* eslint-disable no-param-reassign */
+
+export interface ErrorResponseDetail<Error = unknown> {
+  readonly code: number;
+  readonly message: string;
+  readonly data?: Error;
+}
+
+export type ID = string | number | null | undefined;
+
+export interface ErrorResponse<Error = unknown> {
+  readonly jsonrpc: '2.0';
+  readonly id?: ID;
+  readonly error: ErrorResponseDetail<Error>;
+}
+
+export const makeErrorResponse = <T>(
+  id: ID,
+  code: number,
+  message: string,
+  data?: T
+): ErrorResponse<T> => {
+  if (id === undefined) id = null;
+  code = Math.floor(code);
+  if (Number.isNaN(code)) code = -1;
+  const x: ErrorResponse<T> = {
+    jsonrpc: '2.0',
+    id,
+    error: { code, message, data },
+  };
+  return x;
+};

package/src/index.ts

@@ -0,0 +1,5 @@
+export { default as RPCServiceHost } from './rpc-service/RPCServiceHost';
+export { default as rpcServiceProvider } from './rpc-service/RPCServiceProvider';
+export { default as ProxyRPCClient } from './rpc-service/ProxyRPCClient';
+export * from './types';
+export { isEventMethod } from './common';

package/src/rpc-service/ProxyRPCClient.ts

@@ -0,0 +1,82 @@
+import {
+  isEventMethod,
+  isAssignPassingPortMethod,
+  isOptionsMethod,
+} from '../common';
+import { ProxyRPCClientProps, ProxyRPCClientChannel } from '../types';
+
+class ProxyRPCClient {
+  private requestPath: string;
+
+  private _channelProtocol: ProxyRPCClientChannel;
+
+  constructor(props: ProxyRPCClientProps) {
+    this._channelProtocol = props.channel;
+    this.requestPath = props.requestPath;
+  }
+
+  get channelProtocol() {
+    if (typeof this._channelProtocol === 'function')
+      return this._channelProtocol();
+    return this._channelProtocol;
+  }
+
+  createProxy<T = object>(): T {
+    return new Proxy(
+      {},
+      {
+        get: (target, key) => {
+          return (...args: any[]) => {
+            const fnName = key.toString();
+            if (!this.channelProtocol) {
+              throw new Error(
+                `[ProxyRPCClient error] \`this.channelProtocol\` is null, when invoke function ${fnName}`
+              );
+            }
+
+            if (isAssignPassingPortMethod(fnName)) {
+              const ports = args.pop();
+              this.channelProtocol.send(
+                {
+                  requestPath: this.requestPath,
+                  fnName,
+                  args,
+                },
+                [].concat(ports)
+              );
+            } else if (isEventMethod(fnName)) {
+              this.channelProtocol.send({
+                requestPath: this.requestPath,
+                fnName,
+                args,
+              });
+            } else if (
+              /**
+               * 主要是为了解决刚开始channel connected状态是待确定，而所有的rpc 原则上都是先
+               * 过isConnected的判断；但是想要确保是否通的，这个时候其实还是要发rpc确认的，
+               * 那么这个时候这个就不能够受 isConnected约束；否则你就一直没有请求能够发出去了。
+               */
+              isOptionsMethod(fnName)
+            ) {
+              this.channelProtocol.send({
+                isOptionsRequest: true,
+                requestPath: this.requestPath,
+                fnName,
+                args,
+              });
+            } else {
+              this.channelProtocol.send({
+                requestPath: this.requestPath,
+                fnName,
+                args,
+                // @ts-ignore
+              }).promise;
+            }
+          };
+        },
+      }
+    ) as any as T;
+  }
+}
+
+export default ProxyRPCClient;

package/src/rpc-service/RPCServiceHost.ts

@@ -0,0 +1,35 @@
+import { IService, ServiceHandlerPath } from '../types';
+
+class RPCServiceHost {
+  protected readonly hostPath: string;
+
+  handlersMap = new Map<ServiceHandlerPath, IService>();
+
+  constructor(hostPath: string) {
+    this.hostPath = hostPath;
+  }
+
+  registerServiceHandler(handlerPath: ServiceHandlerPath, service: IService) {
+    this.handlersMap.set(handlerPath, service);
+  }
+
+  getHandlers(handlerPath: ServiceHandlerPath) {
+    const handlers = this.handlersMap.get(handlerPath);
+    return handlers;
+  }
+
+  getHandler(handlerPath: ServiceHandlerPath, fnName: string) {
+    const handlers = this.handlersMap.get(handlerPath);
+    // should bind to current service object
+    if (handlers && handlers[fnName]) return handlers[fnName].bind(handlers);
+    return null;
+  }
+
+  merge(serviceHost: RPCServiceHost) {
+    for (const [key, value] of serviceHost.handlersMap) {
+      this.registerServiceHandler(key, value);
+    }
+  }
+}
+
+export default RPCServiceHost;

package/src/rpc-service/RPCServiceProvider.ts

@@ -0,0 +1,22 @@
+import RPCServiceHandler from './RPCServiceHost';
+
+class RPCServiceProvider {
+  private hostMap = new Map<string, RPCServiceHandler>();
+
+  getHost(hostPath: string) {
+    return this.hostMap.get(hostPath);
+  }
+
+  registerHost(hostPath: string) {
+    const host = this.hostMap.get(hostPath);
+    if (host) return host;
+    this.hostMap.set(hostPath, new RPCServiceHandler(hostPath));
+    return this.hostMap.get(hostPath);
+  }
+
+  resetHost(hostPath: string) {
+    this.hostMap.set(hostPath, new RPCServiceHandler(hostPath));
+  }
+}
+
+export default new RPCServiceProvider();

package/src/types/buffer.ts

@@ -0,0 +1,5 @@
+export type DataBuffer = {
+  // refer to theia/packages/core/src/common/messaging/socket-write-buffer.ts
+  flush: () => void;
+  drain: () => void;
+};

package/src/types/channel.ts

@@ -0,0 +1,24 @@
+export type IMessageChannelOnClose = () => void;
+export type IMessageChannelOnError = () => void;
+export type IMessageChannelOnMessage = (message: any) => void;
+export type IMessageChannelSend = (
+  requestPath: string,
+  fnName: string,
+  ...args: any[]
+) => void;
+export type IMessageChannelDisconnect = () => void;
+
+/**
+ * A channel is a bidirectional communications channel
+ */
+export type IMessageChannel = {
+  onClose?: IMessageChannelOnClose;
+
+  onError?: IMessageChannelOnError;
+
+  onMessage: IMessageChannelOnMessage;
+
+  send: IMessageChannelSend;
+
+  disconnect: IMessageChannelDisconnect;
+};

package/src/types/index.ts

@@ -0,0 +1,6 @@
+export * from './channel';
+export * from './messageChannel';
+export * from './rpc';
+export * from './proxyChannel';
+export * from './proxyService';
+export * from './middleware';

package/src/types/messageChannel.ts

@@ -0,0 +1,134 @@
+import { IpcRenderer, UtilityProcess, WebContents } from 'electron';
+import MessageChannelProtocol from '../channel-protocol/MessageChannelProtocol';
+import RPCServiceHost from '../rpc-service/RPCServiceHost';
+
+export interface ChannelPort {
+  on(event: 'message', listener: (messageEvent: MessageEvent) => void): this;
+  removeListener(
+    event: 'message',
+    listener: (messageEvent: MessageEvent) => void
+  ): this;
+  postMessage(message: any, transfer?: MainPort[]): void;
+}
+
+export type UtilityMessageChannelPortStoreProps = {
+  name: string;
+  port: ParentPort;
+  masterProcessName: string;
+  clientMiddlewares?: ClientMiddleware[];
+  senderMiddlewares?: SenderMiddleware[];
+};
+
+export type OnMessageEntry = {
+  data: any;
+  ports: any;
+};
+export type SenderEntry = any;
+
+export type ClientMiddleware = (
+  channel?: MessageChannelProtocol
+) => (v: OnMessageEntry) => OnMessageEntry;
+
+export type SenderMiddleware = (
+  channel?: MessageChannelProtocol
+) => (data: SenderEntry) => SenderEntry;
+
+export type AbstractChannelProtocolProps = {
+  serviceHost?: RPCServiceHost;
+  connected?: boolean;
+  description?: string;
+  masterProcessName?: string;
+  clientMiddlewares?: ClientMiddleware[];
+  senderMiddlewares?: SenderMiddleware[];
+};
+
+export type DeferredMessageChannelProtocolProps =
+  AbstractChannelProtocolProps & {
+    port?: MainPort;
+  };
+
+export type MessageChannelProtocolProps = AbstractChannelProtocolProps & {
+  port?: MainPort;
+};
+
+export type ProcessChannelProtocolProps = {
+  process: UtilityProcess;
+} & AbstractChannelProtocolProps;
+
+export type IPCMainGlobalChannelProtocolProps = AbstractChannelProtocolProps & {
+  channelName: string;
+};
+
+export type IPCMainChannelProtocolProps = {
+  channelName: string;
+  webContents: WebContents;
+} & AbstractChannelProtocolProps;
+
+export type IPCRendererChannelProtocolProps = {
+  channelName: string;
+  ipcRenderer: IpcRenderer;
+  projectName: string;
+} & AbstractChannelProtocolProps;
+
+export interface ParentPort extends NodeJS.EventEmitter {
+  on(event: 'message', listener: (messageEvent: MessageEvent) => void): this;
+  once(event: 'message', listener: (messageEvent: MessageEvent) => void): this;
+  addListener(
+    event: 'message',
+    listener: (messageEvent: MessageEvent) => void
+  ): this;
+  removeListener(
+    event: 'message',
+    listener: (messageEvent: MessageEvent) => void
+  ): this;
+  postMessage(message: any): void;
+}
+
+export type UtilityNodeJSProcess = NodeJS.Process;
+
+export interface MainPort extends NodeJS.EventEmitter {
+  // Docs: https://electronjs.org/docs/api/message-port-main
+
+  /**
+   * Emitted when the remote end of a MessagePortMain object becomes disconnected.
+   */
+  /**
+   * Emitted when a MessagePortMain object receives a message.
+   */
+  on(event: 'close', listener: Function): this;
+  on(event: 'message', listener: (messageEvent: MessageEvent) => void): this;
+  off(event: 'close', listener: Function): this;
+  off(event: 'message', listener: (messageEvent: MessageEvent) => void): this;
+  once(event: 'close', listener: Function): this;
+  once(event: 'message', listener: (messageEvent: MessageEvent) => void): this;
+  addListener(event: 'close', listener: Function): this;
+  addListener(
+    event: 'message',
+    listener: (messageEvent: MessageEvent) => void
+  ): this;
+  removeListener(event: 'close', listener: Function): this;
+  removeListener(
+    event: 'message',
+    listener: (messageEvent: MessageEvent) => void
+  ): this;
+  /**
+   * Disconnects the port, so it is no longer active.
+   */
+  close(): void;
+  /**
+   * Sends a message from the port, and optionally, transfers ownership of objects to
+   * other browsing contexts.
+   */
+  postMessage(message: any, transfer?: MainPort[]): void;
+  /**
+   * Starts the sending of messages queued on the port. Messages will be queued until
+   * this method is called.
+   */
+  start(): void;
+}
+
+export function isUtilityProcess(
+  process: NodeJS.Process
+): process is UtilityNodeJSProcess {
+  return !!(process as UtilityNodeJSProcess).parentPort;
+}

package/src/types/middleware.ts

@@ -0,0 +1,53 @@
+import { Deferred } from '@x-oasis/deferred';
+
+import { HostRequestEntry, RequestEntry } from './rpc';
+
+export type MiddlewareFunction = {
+  (...args: any[]): any;
+  displayName?: string;
+  lifecycle?: SendMiddlewareLifecycle;
+};
+
+export type MessageOutput = {
+  event: any;
+  ports: any;
+};
+
+export type NormalizedRawMessageOutput = MessageOutput & {
+  data: string;
+};
+
+export type DeserializedMessageOutput = MessageOutput & {
+  data: HostRequestEntry | RequestEntry;
+};
+
+export type SenderMiddlewareOutput = {
+  data: any;
+  transfer: any;
+  seqId: number;
+  returnValue: Deferred;
+  isOptionsRequest: boolean;
+  middlewareContext: MiddlewareContext;
+};
+
+export type PendingSendEntry = SenderMiddlewareOutput & {
+  fnName: string;
+  lifecycle: SendMiddlewareLifecycle;
+  middlewareContext: MiddlewareContext;
+};
+
+export type MiddlewareContext = {
+  isResumed?: boolean;
+  startLifecycle: SendMiddlewareLifecycle;
+  minLifecycle: SendMiddlewareLifecycle;
+  reserved: PendingSendEntry;
+};
+
+export enum SendMiddlewareLifecycle {
+  Initial = 0,
+  Prepare = 10,
+  Transfrom = 20,
+  DataOperation = 30,
+  Send = 40,
+  Aborted = 100,
+}

package/src/types/proxyChannel.ts

@@ -0,0 +1,3 @@
+export type ProxyChannelProps = {
+  name: string;
+};