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

package/src/channel-protocol/MessageChannelProtocol.ts

@@ -0,0 +1,63 @@
+import AbstractChannelProtocol from './AbstractChannelProtocol';
+import { MainPort, MessageChannelProtocolProps } from '../types';
+import {
+  serialize,
+  deserialize,
+  handleRequest,
+  handleResponse,
+  updateSeqInfo,
+  sendRequest,
+  prepareNormalData,
+  handleDisconnectedRequest,
+  normalizeMessageChannelRawMessage,
+} from './middlewares';
+import { Channel } from './Channel';
+
+export default class MessageChannelProtocol extends AbstractChannelProtocol {
+  private readonly port: MainPort;
+
+  constructor(props: MessageChannelProtocolProps) {
+    super(props);
+    const { clientMiddlewares, senderMiddlewares, port } = props;
+    this.port = port;
+
+    this.applySendMiddleware(
+      [].concat(
+        prepareNormalData,
+        updateSeqInfo,
+        handleDisconnectedRequest,
+        serialize,
+        senderMiddlewares,
+        sendRequest
+      )
+    );
+    this.applyOnMessageMiddleware(
+      [].concat(
+        normalizeMessageChannelRawMessage,
+        deserialize,
+        clientMiddlewares,
+        handleRequest,
+        handleResponse
+      )
+    );
+
+    this.channel = new Channel({
+      send: (...args) => this.port.postMessage(...args),
+      initListener: (emitter) => {
+        emitter.register('message');
+        this.port.on('message', (...args: any[]) => {
+          this.onMessage(...args);
+          emitter.getEvent('message').fire(...args);
+        });
+      },
+    });
+
+    this.port.start();
+  }
+
+  disconnect() {
+    this.dispose();
+    this.port.close();
+    super.disconnect();
+  }
+}

package/src/channel-protocol/ProcessChannelProtocol.ts

@@ -0,0 +1,60 @@
+import { UtilityProcess } from 'electron';
+
+import AbstractChannelProtocol from './AbstractChannelProtocol';
+import { ProcessChannelProtocolProps } from '../types';
+import {
+  serialize,
+  deserialize,
+  handleRequest,
+  handleResponse,
+  updateSeqInfo,
+  sendRequest,
+  prepareHostPortData,
+  processClientRawMessage,
+  handleDisconnectedRequest,
+} from './middlewares';
+import { Channel } from './Channel';
+
+export default class ProcessChannelProtocol extends AbstractChannelProtocol {
+  private readonly process: UtilityProcess;
+
+  constructor(props: ProcessChannelProtocolProps) {
+    super(props);
+    const { clientMiddlewares, senderMiddlewares, process } = props;
+    this.process = process;
+
+    this.applySendMiddleware(
+      [].concat(
+        prepareHostPortData,
+        updateSeqInfo,
+        handleDisconnectedRequest,
+        serialize,
+        senderMiddlewares,
+        sendRequest
+      )
+    );
+    this.applyOnMessageMiddleware(
+      [].concat(
+        processClientRawMessage,
+        deserialize,
+        clientMiddlewares,
+        handleRequest,
+        handleResponse
+      )
+    );
+
+    this.channel = new Channel({
+      send: (...args) => this.process.postMessage(...args),
+      initListener: (emitter) => {
+        this.process.on('message', (...args: any[]) => {
+          this.onMessage(...args);
+        });
+      },
+    });
+  }
+
+  disconnect() {
+    this.dispose();
+    super.disconnect();
+  }
+}

package/src/channel-protocol/ProcessClientChannelProtocol.ts

@@ -0,0 +1,59 @@
+import AbstractChannelProtocol from './AbstractChannelProtocol';
+import { MainPort, MessageChannelProtocolProps } from '../types';
+import {
+  serialize,
+  deserialize,
+  handleRequest,
+  handleResponse,
+  updateSeqInfo,
+  sendRequest,
+  prepareNormalData,
+  handleDisconnectedRequest,
+  normalizeMessageChannelRawMessage,
+} from './middlewares';
+import { Channel } from './Channel';
+
+export default class ProcessClientChannelProtocol extends AbstractChannelProtocol {
+  private readonly port: MainPort;
+
+  constructor(props: MessageChannelProtocolProps) {
+    super(props);
+    const { clientMiddlewares, senderMiddlewares, port } = props;
+    this.port = port;
+    this.applySendMiddleware(
+      [].concat(
+        prepareNormalData,
+        updateSeqInfo,
+        handleDisconnectedRequest,
+        serialize,
+        senderMiddlewares,
+        sendRequest
+      )
+    );
+    this.applyOnMessageMiddleware(
+      [].concat(
+        normalizeMessageChannelRawMessage,
+        deserialize,
+        clientMiddlewares,
+        handleRequest,
+        handleResponse
+      )
+    );
+
+    this.channel = new Channel({
+      send: (...args) => this.port.postMessage(...args),
+      initListener: (emitter) => {
+        emitter.register('message');
+        this.port.on('message', (...args: any[]) => {
+          this.onMessage(...args);
+          emitter.getEvent('message').fire(...args);
+        });
+      },
+    });
+  }
+
+  disconnect() {
+    this.dispose();
+    super.disconnect();
+  }
+}

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

@@ -0,0 +1,33 @@
+import {
+  NormalizedRawMessageOutput,
+  SenderMiddlewareOutput,
+  SendMiddlewareLifecycle,
+} from '../../types';
+import AbstractChannelProtocol from '../AbstractChannelProtocol';
+
+export const serialize = (channel: AbstractChannelProtocol) => {
+  const fn = (value: SenderMiddlewareOutput) => ({
+    ...value,
+    data: channel.writeBuffer.encode(value.data),
+  });
+
+  fn.lifecycle = SendMiddlewareLifecycle.DataOperation;
+  return fn;
+};
+
+export const deserialize =
+  (channel: AbstractChannelProtocol) => (value: NormalizedRawMessageOutput) => {
+    const { data } = value;
+    let decoded = data;
+
+    try {
+      decoded = channel.readBuffer.decode(data);
+    } catch (err) {
+      console.error('[decode error]', data, err);
+    }
+
+    return {
+      ...value,
+      data: decoded,
+    };
+  };

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

@@ -0,0 +1,30 @@
+import { SenderMiddlewareOutput, SendMiddlewareLifecycle } from '../../types';
+import AbstractChannelProtocol from '../AbstractChannelProtocol';
+
+export const handleDisconnectedRequest = (
+  protocol: AbstractChannelProtocol
+) => {
+  const fn = (value: SenderMiddlewareOutput) => {
+    const isConnected = protocol.isConnected();
+
+    if (!isConnected && !value.isOptionsRequest) {
+      protocol.addPendingSendEntry({
+        fnName: fn.displayName,
+        lifecycle: SendMiddlewareLifecycle.Prepare,
+        ...value,
+        middlewareContext: {
+          ...value.middlewareContext,
+        },
+      });
+
+      value.middlewareContext.minLifecycle = SendMiddlewareLifecycle.Aborted;
+    }
+
+    return value;
+  };
+
+  fn.displayName = 'handleDisconnectedRequest';
+  fn.lifecycle = SendMiddlewareLifecycle.Prepare;
+
+  return fn;
+};

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

@@ -0,0 +1,118 @@
+import isPromise from '@x-oasis/is-promise';
+import { ResponseType, DeserializedMessageOutput } from '../../types';
+import AbstractChannelProtocol from '../AbstractChannelProtocol';
+import { isEventMethod } from '../../common';
+
+export const handlePortRequest =
+  (protocol: AbstractChannelProtocol) =>
+  (message: DeserializedMessageOutput) => {
+    const serviceHost = protocol.serviceHost;
+
+    const { data, event: messageEvent } = message;
+    const header = data[0];
+    const channelName = header[4];
+
+    const body = data[1];
+    const type = header[0] as any;
+
+    if (Object.values(ResponseType).includes(type)) {
+      return message;
+    }
+
+    const seqId = header[1];
+    const requestPath = header[2];
+    const fnName = header[3];
+    const args = body[0];
+
+    if (serviceHost) {
+      if (isEventMethod(fnName)) {
+        // const event = serviceHost.getHandler(requestPath, fnName)
+        // const fn = (...args: any[]) => {
+        //   const responseHeader = [ResponseType.ReturnSuccess, seqId]
+        //   let responseBody = []
+        //   let sendData = null
+        //   try {
+        //     responseBody = args
+        //     sendData = protocol.writeBuffer.encode([responseHeader, responseBody])
+        //   } catch (err) {
+        //     sendData = protocol.writeBuffer.encode([responseHeader, []])
+        //     console.error(`[handleRequest sendReply encode error ] ${requestPath} ${fnName}`, err)
+        //   }
+
+        //   // TODO: temp; main <=> project renderer...
+        //   if (messageEvent?.sender) {
+        //     messageEvent.sender.send(channelName, sendData)
+        //     return
+        //   }
+
+        //   protocol.sendReply(sendData)
+        // }
+
+        // event(fn)
+        return message;
+      }
+
+      const handler = serviceHost.getHandler(requestPath, fnName);
+
+      // todo
+      const result = Promise.resolve(handler?.(args));
+
+      if (handler && isPromise(result)) {
+        result.then(
+          (port: any) => {
+            const responseHeader = [ResponseType.PortSuccess, seqId];
+            let responseBody: any[] = [];
+            let sendData = null;
+            try {
+              responseBody = [];
+              sendData = protocol.writeBuffer.encode([
+                responseHeader,
+                responseBody,
+              ]);
+            } catch (err) {
+              sendData = protocol.writeBuffer.encode([responseHeader, []]);
+              console.error(
+                `[handleRequest sendReply encode error ] ${requestPath} ${fnName}`,
+                err
+              );
+            }
+
+            // TODO: temp; main <=> project renderer...
+            if (messageEvent?.sender) {
+              messageEvent.sender.postMessage(channelName, sendData, [port]);
+              return;
+            }
+
+            protocol.sendReply(sendData);
+          },
+          (err: Error) => {
+            const responseHeader = [ResponseType.ReturnFail, seqId];
+            const responseBody = [
+              {
+                message: err.message,
+                name: err.name,
+                // eslint-disable-next-line
+                stack: err.stack
+                  ? err.stack.split
+                    ? err.stack.split('\n')
+                    : err.stack
+                  : undefined,
+              },
+            ];
+
+            if (messageEvent?.sender) {
+              messageEvent.sender.send(
+                protocol.channelName,
+                protocol.writeBuffer.encode([responseHeader, responseBody])
+              );
+              return;
+            }
+
+            protocol.sendReply(
+              protocol.writeBuffer.encode([responseHeader, responseBody])
+            );
+          }
+        );
+      }
+    }
+  };

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

@@ -0,0 +1,163 @@
+import isPromise from '@x-oasis/is-promise';
+import { ResponseType, DeserializedMessageOutput } from '../../types';
+import AbstractChannelProtocol from '../AbstractChannelProtocol';
+import {
+  isEventMethod,
+  isAssignPassingPortMethod,
+  isAcquirePortMethod,
+} from '../../common';
+import { handleAcquirePort } from './handleRequestUtils';
+
+export const handleRequest =
+  (protocol: AbstractChannelProtocol) =>
+  (message: DeserializedMessageOutput) => {
+    const serviceHost = protocol.serviceHost;
+
+    const { data, event: messageEvent, ports } = message;
+    const header = data[0];
+
+    // TODO: protocol.channelName will cause error, check `acquirePortMain.ts#171`
+    const channelName = header[4] || protocol.channelName;
+
+    const body = data[1];
+    const type = header[0] as any;
+
+    if (Object.values(ResponseType).includes(type)) {
+      return message;
+    }
+
+    const seqId = header[1];
+    const requestPath = header[2];
+    const fnName = header[3];
+    const args = body[0];
+
+    if (serviceHost) {
+      if (isEventMethod(fnName)) {
+        const event = serviceHost.getHandler(requestPath, fnName);
+
+        const fn = (...args: any[]) => {
+          const responseHeader = [ResponseType.ReturnSuccess, seqId];
+          let responseBody = [];
+          let sendData = null;
+          try {
+            responseBody = args;
+            sendData = protocol.writeBuffer.encode([
+              responseHeader,
+              responseBody,
+            ]);
+          } catch (err) {
+            sendData = protocol.writeBuffer.encode([responseHeader, []]);
+            console.error(
+              `[handleRequest sendReply encode error ] ${requestPath} ${fnName}`,
+              err
+            );
+          }
+
+          // TODO: temp; main <=> project renderer...
+          if (messageEvent?.sender) {
+            messageEvent.sender.send(channelName, sendData);
+            return;
+          }
+
+          protocol.sendReply(sendData);
+        };
+
+        event?.(fn);
+        return message;
+      }
+
+      /**
+       * AssignPassingPort
+       */
+      if (isAssignPassingPortMethod(fnName)) {
+        const handler = serviceHost.getHandler(requestPath, fnName);
+
+        if (handler) args ? handler(args, ports?.[0]) : handler(ports?.[0]);
+        // no need send reply
+        return;
+      }
+
+      if (isAcquirePortMethod(fnName)) {
+        const result = handleAcquirePort({
+          protocol,
+          serviceHost,
+          fnName,
+          seqId,
+          args,
+          requestPath,
+        });
+
+        // 目前简单处理，只有port的时候才返回，其实是需要返回PortFail的；进入
+        // client的catch
+        if (result) {
+          protocol.sendReply(...result);
+        }
+        return;
+      }
+
+      const handler = serviceHost.getHandler(requestPath, fnName);
+
+      const _result = handler?.(args);
+
+      // todo
+      const result = Promise.resolve(_result);
+
+      if (isPromise(result)) {
+        result.then(
+          (response: any) => {
+            const responseHeader = [ResponseType.ReturnSuccess, seqId];
+            let responseBody = [];
+            let sendData = null;
+            try {
+              responseBody = [response];
+              sendData = protocol.writeBuffer.encode([
+                responseHeader,
+                responseBody,
+              ]);
+            } catch (err) {
+              sendData = protocol.writeBuffer.encode([responseHeader, []]);
+              console.error(
+                `[handleRequest sendReply encode error ] ${requestPath} ${fnName}`,
+                err
+              );
+            }
+
+            // TODO: temp; main <=> project renderer...
+            if (messageEvent?.sender) {
+              messageEvent.sender.send(channelName, sendData);
+              return;
+            }
+
+            protocol.sendReply(sendData);
+          },
+          (err: Error) => {
+            const responseHeader = [ResponseType.ReturnFail, seqId];
+            const responseBody = [
+              {
+                message: err.message,
+                name: err.name,
+                // eslint-disable-next-line
+                stack: err.stack
+                  ? err.stack.split
+                    ? err.stack.split('\n')
+                    : err.stack
+                  : undefined,
+              },
+            ];
+
+            if (messageEvent?.sender) {
+              messageEvent.sender.send(
+                protocol.channelName,
+                protocol.writeBuffer.encode([responseHeader, responseBody])
+              );
+              return;
+            }
+
+            protocol.sendReply(
+              protocol.writeBuffer.encode([responseHeader, responseBody])
+            );
+          }
+        );
+      }
+    }
+  };

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

@@ -0,0 +1,42 @@
+import RPCServiceHost from '../../rpc-service/RPCServiceHost';
+import AbstractChannelProtocol from '../AbstractChannelProtocol';
+import { ResponseType } from '../../types';
+
+export const handleAcquirePort = (props: {
+  protocol: AbstractChannelProtocol;
+  serviceHost: RPCServiceHost;
+  requestPath: string;
+  fnName: string;
+  seqId: string;
+  args: any[];
+}) => {
+  const { serviceHost, requestPath, fnName, protocol, seqId, args } = props;
+
+  const handler = serviceHost.getHandler(requestPath, fnName);
+
+  const port = handler?.(args);
+
+  // 比如port process它监听的是message；你用process创建一个ProcessChannelProtocol
+  // 都会触发监听，这个时候并不一定有值返回，其实正常是否考虑将on message这种
+  // emitter收敛了，即使你new了，但其实是一个实例
+  if (!port) {
+    // console.error('may trigger message listener', protocol)
+  }
+
+  let responseHeader = [ResponseType.PortSuccess, seqId];
+  let responseBody: any[] = [];
+  let sendData = null;
+  try {
+    responseBody = [];
+    sendData = protocol.writeBuffer.encode([responseHeader, responseBody]);
+  } catch (err) {
+    responseHeader = [ResponseType.PortFail, seqId];
+    sendData = protocol.writeBuffer.encode([responseHeader, []]);
+    console.error(
+      `[handleRequest sendReply encode error ] ${requestPath} ${fnName}`,
+      err
+    );
+  }
+
+  return port ? [sendData, [port]] : null;
+};

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

@@ -0,0 +1,38 @@
+import {
+  RequestType,
+  ResponseType,
+  DeserializedMessageOutput,
+} from '../../types';
+import AbstractChannelProtocol from '../AbstractChannelProtocol';
+
+export const handleResponse =
+  (protocol: AbstractChannelProtocol) =>
+  (message: DeserializedMessageOutput) => {
+    if (!message) return message;
+    const { data } = message;
+    const header = data[0];
+    const body = data[1];
+    const type = header[0] as any;
+
+    if (Object.values(RequestType).includes(type)) {
+      return message;
+    }
+
+    const seqId = header[1];
+
+    const findDefer = protocol.ongoingRequests.get(`${seqId}`);
+    if (findDefer) {
+      protocol.ongoingRequests.delete(`${seqId}`);
+      if (type === ResponseType.PortSuccess) {
+        findDefer.resolve(message.ports[0]);
+      } else if (type === ResponseType.ReturnFail) {
+        findDefer.reject(body[0]);
+      } else findDefer.resolve(body[0]);
+    } else {
+      const findListener = protocol.requestEvents.get(`${seqId}`);
+
+      if (findListener) {
+        findListener(...body);
+      }
+    }
+  };

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

@@ -0,0 +1,11 @@
+export * from './buffer';
+export * from './handleRequest';
+export * from './normalize';
+export * from './handleResponse';
+export * from './prepareRequestData';
+export * from './updateSeqInfo';
+export * from './handlePortRequest';
+export * from './sendRequest';
+export * from './handleDisconnectedRequest';
+
+export { runMiddlewares } from './utils';

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

@@ -0,0 +1,22 @@
+import AbstractChannelProtocol from '../AbstractChannelProtocol';
+import { NormalizedRawMessageOutput } from '../../types';
+
+export const createSenderLogger =
+  (logService: any) =>
+  (channel: AbstractChannelProtocol) =>
+  (value: NormalizedRawMessageOutput) => {
+    logService.info(`${channel.masterProcessName} send message`, value.data);
+    return value;
+  };
+
+export const createClientLogger =
+  (logService: any) =>
+  (channel: AbstractChannelProtocol) =>
+  (value: NormalizedRawMessageOutput) => {
+    const { data } = value;
+    logService.info(
+      `${channel.masterProcessName} receive message from ${channel.description}`,
+      data
+    );
+    return value;
+  };

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

@@ -0,0 +1,28 @@
+import { NormalizedRawMessageOutput } from '../../types';
+
+export const normalizeMessageChannelRawMessage =
+  () =>
+  (event: MessageEvent): NormalizedRawMessageOutput => {
+    return {
+      event,
+      data: event.data,
+      ports: event.ports || [],
+    };
+  };
+
+export const normalizeIPCChannelRawMessage =
+  () => (event: MessageEvent, data: string) => {
+    return {
+      event,
+      data,
+      ports: event.ports || [],
+    };
+  };
+
+export const processClientRawMessage = () => (data: string) => {
+  return {
+    event: null,
+    data,
+    ports: [],
+  };
+};