@x-oasis/async-call-rpc 0.1.38

package/src/endpoint/RPCClientHost.ts

@@ -0,0 +1,45 @@
+import ProxyRPCClient from './ProxyRPCClient';
+import AbstractChannelProtocol from '../protocol/AbstractChannelProtocol';
+
+class RPCClientHost {
+  protected readonly hostPath: string;
+
+  private hostMap = new Map<string, ProxyRPCClient>();
+
+  // handlersMap = new Map<ServiceHandlerPath, IService>();
+
+  registerClient(
+    requestPath: string,
+    options?: {
+      channel?: AbstractChannelProtocol;
+    }
+  ) {
+    const client = new ProxyRPCClient(requestPath, options);
+    this.hostMap.set(requestPath, client);
+    return client;
+  }
+
+  // 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: RPCClientHost) {
+  //   for (const [key, value] of serviceHost.handlersMap) {
+  //     this.registerServiceHandler(key, value);
+  //   }
+  // }
+}
+export { RPCClientHost };
+export default new RPCClientHost();

package/src/endpoint/RPCService.ts

@@ -0,0 +1,54 @@
+import AbstractChannelProtocol from '../protocol/AbstractChannelProtocol';
+import { RPCServiceHost } from './RPCServiceHost';
+import { ServiceHandlers } from '../types/proxyService';
+
+class RPCService {
+  private channel: AbstractChannelProtocol;
+  readonly serviceHost: RPCServiceHost;
+  readonly servicePath: string;
+  readonly handlersMap = new Map<string, (...args: any[]) => any>();
+
+  constructor(
+    servicePath: string,
+    options?: {
+      channel?: AbstractChannelProtocol;
+      handlers: ServiceHandlers;
+      serviceHost?: RPCServiceHost;
+    }
+  ) {
+    const { channel, handlers, serviceHost } = options || {};
+    this.servicePath = servicePath;
+    this.serviceHost = serviceHost;
+    if (channel) {
+      this.setChannel(channel);
+    }
+    this.registerHandlers(handlers);
+  }
+
+  setChannel(channel: AbstractChannelProtocol) {
+    this.channel = channel;
+    this.channel.setService(this);
+    this.channel.on(this.handleMessage.bind(this));
+  }
+
+  registerHandlers(handlers: Record<string, (...args: any[]) => any>) {
+    if (!handlers) return;
+    for (const [methodName, handler] of Object.entries(handlers)) {
+      this.registerHandler(methodName, handler);
+    }
+  }
+
+  handleMessage(...args: any[]) {
+    this.channel.onMessage(...args);
+  }
+
+  registerHandler(methodName: string, handler: (...args: any[]) => any) {
+    this.handlersMap.set(methodName, handler);
+  }
+
+  getHandler(methodName: string) {
+    return this.handlersMap.get(methodName);
+  }
+}
+
+export default RPCService;

package/src/endpoint/RPCServiceHost.ts

@@ -0,0 +1,18 @@
+import { ServiceHandlers } from '../types/proxyService';
+import RPCService from './RPCService';
+
+class RPCServiceHost {
+  protected readonly hostPath: string;
+
+  private hostMap = new Map<string, RPCService>();
+
+  // handlersMap = new Map<ServiceHandlerPath, IService>();
+
+  registerService(servicePath: string, serviceHandlers: ServiceHandlers) {
+    const service = new RPCService(servicePath, { handlers: serviceHandlers });
+    this.hostMap.set(servicePath, service);
+    return service;
+  }
+}
+export { RPCServiceHost };
+export default new RPCServiceHost();

package/src/error.ts

@@ -0,0 +1,98 @@
+/* eslint-disable no-param-reassign */
+
+/**
+ * JSONRPC Error Response Detail
+ * Based on JSONRPC 2.0 specification
+ */
+export interface ErrorResponseDetail<Error = unknown> {
+  readonly code: number;
+  readonly message: string;
+  readonly data?: Error;
+}
+
+/**
+ * JSONRPC Request/Response ID type
+ * Can be string, number, null, or undefined (for notifications)
+ */
+export type ID = string | number | null | undefined;
+
+/**
+ * JSONRPC Error Response
+ * Based on JSONRPC 2.0 specification
+ */
+export interface ErrorResponse<Error = unknown> {
+  readonly jsonrpc: '2.0';
+  readonly id?: ID;
+  readonly error: ErrorResponseDetail<Error>;
+}
+
+/**
+ * Standard JSONRPC 2.0 Error Codes
+ * Based on JSONRPC 2.0 specification section 5.1
+ */
+export enum JSONRPCErrorCode {
+  /**
+   * Parse error (-32700)
+   * Invalid JSON was received by the server.
+   * An error occurred on the server while parsing the JSON text.
+   */
+  ParseError = -32700,
+
+  /**
+   * Invalid Request (-32600)
+   * The JSON sent is not a valid Request object.
+   */
+  InvalidRequest = -32600,
+
+  /**
+   * Method not found (-32601)
+   * The method does not exist / is not available.
+   */
+  MethodNotFound = -32601,
+
+  /**
+   * Invalid params (-32602)
+   * Invalid method parameter(s).
+   */
+  InvalidParams = -32602,
+
+  /**
+   * Internal error (-32603)
+   * Internal JSON-RPC error.
+   */
+  InternalError = -32603,
+
+  /**
+   * Server error (-32000 to -32099)
+   * Reserved for implementation-defined server-errors.
+   * The remainder of the space is available for application defined errors.
+   */
+  ServerErrorStart = -32000,
+  ServerErrorEnd = -32099,
+}
+
+/**
+ * Create a JSONRPC error response object
+ * This function is kept for backward compatibility.
+ * For new code, prefer using functions from utils/jsonrpc.ts
+ */
+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 },
+  };
+  // Remove undefined data field
+  if (x.error.data === undefined) {
+    delete (x.error as any).data;
+  }
+  return x;
+};

package/src/index.ts

@@ -0,0 +1,16 @@
+import clientHost from './endpoint/RPCClientHost';
+import ProxyRPCClient from './endpoint/ProxyRPCClient';
+import RPCService from './endpoint/RPCService';
+import serviceHost from './endpoint/RPCServiceHost';
+
+export { default as MessageChannel } from './protocol/MessageChannel';
+export { default as WorkerChannel } from './protocol/WorkerChannel';
+export { default as WebSocketChannel } from './protocol/WebSocketChannel';
+
+export { ProxyRPCClient, RPCService, clientHost, serviceHost };
+
+// Export JSONRPC utilities and types
+export * from './utils';
+// Export error types but not makeErrorResponse to avoid conflict (it's in utils/jsonrpc.ts)
+export type { ErrorResponse, ErrorResponseDetail, ID } from './error';
+export { JSONRPCErrorCode } from './error';

package/src/middlewares/buffer.ts

@@ -0,0 +1,33 @@
+import {
+  NormalizedRawMessageOutput,
+  SenderMiddlewareOutput,
+  SendMiddlewareLifecycle,
+} from '../types';
+import AbstractChannelProtocol from '../protocol/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/middlewares/handleDisconnectedRequest.ts

@@ -0,0 +1,30 @@
+import { SenderMiddlewareOutput, SendMiddlewareLifecycle } from '../types';
+import AbstractChannelProtocol from '../protocol/AbstractChannelProtocol';
+
+export const handleDisconnectedRequest = (
+  protocol: AbstractChannelProtocol
+) => {
+  const fn = (value: SenderMiddlewareOutput) => {
+    const isConnected = protocol.isConnected();
+
+    if (!isConnected && !value.isOptionsRequest) {
+      protocol.addPendingSendEntry({
+        methodName: 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/middlewares/handlePortRequest.ts

@@ -0,0 +1,141 @@
+import isPromise from '@x-oasis/is-promise';
+import { ResponseType, DeserializedMessageOutput } from '../types';
+import AbstractChannelProtocol from '../protocol/AbstractChannelProtocol';
+import { isEventMethod } from '../common';
+import {
+  defaultErrorMapper,
+  ErrorResponseMapped,
+  makeRequest,
+} from '../utils/jsonrpc';
+import { JSONRPCErrorCode } from '../error';
+
+export const handlePortRequest =
+  (protocol: AbstractChannelProtocol) =>
+  (message: DeserializedMessageOutput) => {
+    const serviceHost = protocol.service;
+
+    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 methodName = header[3];
+    const args = body[0];
+
+    if (serviceHost) {
+      if (isEventMethod(methodName)) {
+        // const event = serviceHost.getHandler(requestPath, methodName)
+        // 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} ${methodName}`, 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(methodName);
+
+      // Create JSONRPC request object for error context
+      const jsonrpcRequest = makeRequest(seqId, methodName, args);
+
+      // 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) {
+              // Encoding error - use standardized error format
+              const mapper = defaultErrorMapper(
+                err instanceof Error ? err.stack : '',
+                JSONRPCErrorCode.InternalError
+              );
+              const errorResponse = ErrorResponseMapped(
+                jsonrpcRequest,
+                err,
+                mapper
+              );
+              responseBody = [errorResponse.error];
+              sendData = protocol.writeBuffer.encode([
+                responseHeader,
+                responseBody,
+              ]);
+              console.error(
+                `[handleRequest sendReply encode error ] ${requestPath} ${methodName}`,
+                err
+              );
+            }
+
+            // TODO: temp; main <=> project renderer...
+            if (messageEvent?.sender) {
+              messageEvent.sender.postMessage(channelName, sendData, [port]);
+              return;
+            }
+
+            protocol.sendReply(sendData);
+          },
+          (err: unknown) => {
+            // Use standardized JSONRPC error format
+            const mapper = defaultErrorMapper(
+              err instanceof Error ? err.stack : '',
+              JSONRPCErrorCode.InternalError
+            );
+            const errorResponse = ErrorResponseMapped(
+              jsonrpcRequest,
+              err,
+              mapper
+            );
+            const responseHeader = [ResponseType.ReturnFail, seqId];
+            const responseBody = [errorResponse.error];
+
+            if (messageEvent?.sender) {
+              messageEvent.sender.send(
+                (protocol as any).channelName,
+                protocol.writeBuffer.encode([responseHeader, responseBody])
+              );
+              return;
+            }
+
+            protocol.sendReply(
+              protocol.writeBuffer.encode([responseHeader, responseBody])
+            );
+          }
+        );
+      }
+    }
+    return message;
+  };

package/src/middlewares/handleRequest.ts

@@ -0,0 +1,128 @@
+import isPromise from '@x-oasis/is-promise';
+import { ResponseType, DeserializedMessageOutput } from '../types';
+import AbstractChannelProtocol from '../protocol/AbstractChannelProtocol';
+import {
+  ErrorResponseMethodNotFound,
+  defaultErrorMapper,
+  ErrorResponseMapped,
+  makeRequest,
+  Request,
+  AsyncCallErrorDetail,
+} from '../utils/jsonrpc';
+import { JSONRPCErrorCode } from '../error';
+
+/**
+ * Create standardized error response body
+ */
+const createErrorResponseBody = (
+  error: unknown,
+  request?: Request
+): {
+  code: number;
+  message: string;
+  data?: AsyncCallErrorDetail;
+} => {
+  const mapper = defaultErrorMapper(
+    error instanceof Error ? error.stack : '',
+    JSONRPCErrorCode.InternalError
+  );
+
+  if (request) {
+    const errorResponse = ErrorResponseMapped(request, error, mapper);
+    return errorResponse.error;
+  }
+
+  // Fallback when no request context is available
+  const { code, message, data } = mapper(error, {} as Request);
+  return { code, message, data };
+};
+
+export const handleRequest =
+  (protocol: AbstractChannelProtocol) =>
+  (message: DeserializedMessageOutput) => {
+    const service = protocol.service;
+
+    const { data } = message;
+    const header = data[0];
+
+    const body = data[1];
+    const type = header[0] as any;
+
+    /**
+     * if the message is a response, do nothing and return the message
+     */
+    if (Object.values(ResponseType).includes(type)) {
+      return message;
+    }
+
+    const seqId = header[1];
+    const requestPath = header[2];
+    const methodName = header[3];
+    const args = body[0];
+
+    // Create JSONRPC request object for error context
+    const jsonrpcRequest = makeRequest(seqId, methodName, args);
+
+    const handler = service.getHandler(methodName);
+
+    // Check if method exists
+    if (!handler) {
+      const errorResponse = ErrorResponseMethodNotFound(seqId);
+      const responseHeader = [ResponseType.ReturnFail, seqId];
+      const responseBody = [errorResponse.error];
+
+      protocol.sendReply(
+        protocol.writeBuffer.encode([responseHeader, responseBody])
+      );
+      return message;
+    }
+
+    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) {
+            // Encoding error - use standardized error format
+            const errorBody = createErrorResponseBody(err, jsonrpcRequest);
+            responseBody = [errorBody];
+            sendData = protocol.writeBuffer.encode([
+              responseHeader,
+              responseBody,
+            ]);
+            console.error(
+              `[handleRequest sendReply encode error ] ${requestPath} ${methodName}`,
+              err
+            );
+          }
+
+          protocol.sendReply(sendData);
+        },
+        (err: unknown) => {
+          // Use standardized JSONRPC error format
+          const errorBody = createErrorResponseBody(err, jsonrpcRequest);
+          const responseHeader = [ResponseType.ReturnFail, seqId];
+          const responseBody = [errorBody];
+
+          protocol.sendReply(
+            protocol.writeBuffer.encode([responseHeader, responseBody])
+          );
+        }
+      );
+    }
+    // 其实这儿不应该这么处理，应该返回一个空值，但是为了方便，还是返回原来的消息
+    // 因为假如说是一个request的话，到这一步就算处理完了
+    return message;
+  };

package/src/middlewares/handleRequestUtils.ts

@@ -0,0 +1,43 @@
+import AbstractChannelProtocol from '../protocol/AbstractChannelProtocol';
+import { ResponseType } from '../types';
+import RPCService from '../endpoint/RPCService';
+
+export const handleAcquirePort = (props: {
+  protocol: AbstractChannelProtocol;
+  // serviceHost: RPCServiceHost;
+  service: RPCService;
+  requestPath: string;
+  methodName: string;
+  seqId: string;
+  args: any[];
+}) => {
+  const { service, requestPath, methodName, protocol, seqId, args } = props;
+
+  // const handler = serviceHost.getHandler(requestPath, methodName);
+  const handler = service.getHandler(methodName);
+  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} ${methodName}`,
+      err
+    );
+  }
+
+  return port ? [sendData, [port]] : null;
+};

package/src/middlewares/handleResponse.ts

@@ -0,0 +1,36 @@
+import { RequestType, ResponseType, DeserializedMessageOutput } from '../types';
+import AbstractChannelProtocol from '../protocol/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);
+      }
+    }
+    return null;
+  };

package/src/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/middlewares/logger.ts

@@ -0,0 +1,22 @@
+import AbstractChannelProtocol from '../protocol/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;
+  };