@x-oasis/async-call-rpc 0.1.38

package/src/middlewares/normalize.ts

@@ -0,0 +1,167 @@
+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: [],
+  };
+};
+
+/**
+ * Helper function to check if Buffer is available (Node.js environment)
+ */
+function isBufferAvailable(): boolean {
+  return typeof Buffer !== 'undefined' && Buffer.isBuffer !== undefined;
+}
+
+/**
+ * Helper function to check if value is a Buffer (works in both browser and Node.js)
+ */
+function isBuffer(value: any): boolean {
+  if (!isBufferAvailable()) {
+    return false;
+  }
+  return Buffer.isBuffer(value);
+}
+
+/**
+ * Helper function to convert ArrayBuffer to string (works in both browser and Node.js)
+ */
+function arrayBufferToString(buffer: ArrayBuffer): string {
+  if (isBufferAvailable()) {
+    return Buffer.from(buffer).toString('utf8');
+  } else {
+    // Browser environment: use TextDecoder
+    try {
+      return new TextDecoder('utf-8').decode(buffer);
+    } catch (e) {
+      // Fallback: convert Uint8Array to string
+      const uint8Array = new Uint8Array(buffer);
+      return String.fromCharCode.apply(null, Array.from(uint8Array));
+    }
+  }
+}
+
+/**
+ * Helper function to convert Buffer to string (Node.js only)
+ */
+function bufferToString(buffer: any): string {
+  if (isBufferAvailable() && Buffer.isBuffer(buffer)) {
+    return buffer.toString('utf8');
+  }
+  return String(buffer);
+}
+
+/**
+ * Normalize WebSocket raw message
+ * Handles both browser MessageEvent and Node.js ws library format
+ */
+export const normalizeWebSocketRawMessage =
+  () =>
+  (
+    eventOrData: MessageEvent | Buffer | string | any,
+    ...args: any[]
+  ): NormalizedRawMessageOutput => {
+    // Handle undefined or null
+    if (eventOrData === undefined || eventOrData === null) {
+      console.warn(
+        '[normalizeWebSocketRawMessage] Received undefined or null data'
+      );
+      return {
+        event: null,
+        data: '',
+        ports: [],
+      };
+    }
+
+    let normalizedData = '';
+    let event: MessageEvent | null = null;
+    let ports: MessagePort[] = [];
+
+    // Check if this is a MessageEvent (browser or ws library with EventTarget)
+    if (
+      eventOrData &&
+      typeof eventOrData === 'object' &&
+      'data' in eventOrData
+    ) {
+      event = eventOrData as MessageEvent;
+      const data = event.data;
+      // Create a new array to avoid readonly type issues
+      ports = event.ports ? [...event.ports] : [];
+
+      // Handle different data types in MessageEvent
+      if (data === undefined || data === null) {
+        normalizedData = '';
+      } else if (typeof data === 'string') {
+        normalizedData = data;
+      } else if (isBuffer(data)) {
+        normalizedData = bufferToString(data);
+      } else if (data instanceof ArrayBuffer) {
+        normalizedData = arrayBufferToString(data);
+      } else if (data instanceof Blob) {
+        // For Blob, we'd need async handling, but for now return empty
+        // In practice, WebSocket text frames should be strings
+        normalizedData = '';
+      } else {
+        normalizedData = String(data);
+      }
+    } else {
+      // Node.js ws library: direct data (Buffer or string)
+      // The ws library may pass data directly, or as (data, isBinary) tuple
+      // If args[0] exists and eventOrData is not an object with 'data',
+      // then args might contain the actual data
+      let actualData = eventOrData;
+
+      // Check if this might be a tuple (data, isBinary) from ws library
+      if (
+        args.length > 0 &&
+        (typeof eventOrData === 'string' || isBuffer(eventOrData))
+      ) {
+        // This is likely (data, isBinary) format, use eventOrData as data
+        actualData = eventOrData;
+      }
+
+      // Convert Buffer to string if needed
+      if (isBuffer(actualData)) {
+        normalizedData = bufferToString(actualData);
+      } else if (typeof actualData === 'string') {
+        normalizedData = actualData;
+      } else if (actualData instanceof ArrayBuffer) {
+        normalizedData = arrayBufferToString(actualData);
+      } else {
+        // Fallback: try to stringify
+        normalizedData = String(actualData);
+      }
+    }
+
+    // Ensure normalizedData is never undefined or null
+    if (normalizedData === undefined || normalizedData === null) {
+      normalizedData = '';
+    }
+
+    return {
+      event,
+      data: normalizedData,
+      ports,
+    };
+  };

package/src/middlewares/prepareRequestData.ts

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

package/src/middlewares/sendRequest.ts

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

package/src/middlewares/updateSeqInfo.ts

@@ -0,0 +1,34 @@
+import { createDeferred } from '@x-oasis/deferred';
+import { isEventMethod } from '../common';
+import { SenderMiddlewareOutput, SendMiddlewareLifecycle } from '../types';
+import AbstractChannelProtocol from '../protocol/AbstractChannelProtocol';
+
+/**
+ *
+ * @param channelProtocol
+ * @returns
+ *
+ * Add how to handle the request and response
+ */
+export const updateSeqInfo = (channelProtocol: AbstractChannelProtocol) => {
+  const fn = (value: SenderMiddlewareOutput) => {
+    const { data, seqId } = value;
+    const header = data[0];
+    const body = data[1];
+    const methodName = header[3];
+
+    // 如果说是event method的话，需要将body重制一下
+    if (methodName && isEventMethod(methodName)) {
+      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.Transform;
+  return fn;
+};

package/src/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.methodName) {
+      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);
+};