@hile/message-modem 1.0.7 → 2.0.0

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+import { Readable } from 'node:stream';
 export * from './exception.js';
 export declare enum MESSAGE_MODEM_TYPE {
     REQUEST = 0,
@@ -8,6 +9,7 @@ export interface MessageTransferFormat<T = any> {
     id: number;
     mode: MESSAGE_MODEM_TYPE;
     twoway: boolean;
+    stream?: boolean;
     data?: T;
 }
 export interface MessageReturnFormat<T = any> {
@@ -15,10 +17,17 @@ export interface MessageReturnFormat<T = any> {
     data: T;
     message: string;
 }
+export interface MessageStreamChunk<T = any> {
+    status: string | number;
+    seq: number;
+    payload: T;
+    final: boolean;
+}
 export declare abstract class MessageModem {
     private id;
     private readonly aborts;
     private readonly stacks;
+    private readonly streams;
     protected _dispose(): void;
     /**
      * 创建自增 ID
@@ -36,7 +45,7 @@ export declare abstract class MessageModem {
      * @param data - 消息数据
      * @returns
      */
-    protected abstract exec(data: any): Promise<any>;
+    protected abstract exec(data: any, signal?: AbortSignal): Promise<any>;
     /**
      * 创建发送消息数据
      * @param mode - 消息类型
@@ -48,19 +57,27 @@ export declare abstract class MessageModem {
      * 发送消息
      * @param data - 消息数据
      * @param timeout - 超时时间
+     * @param signal - 中止信号
      * @returns 消息响应
      */
-    protected _send<T = any>(data: T, timeout?: number): {
-        abort: () => void;
-        response: <U = any>() => Promise<U>;
-    };
+    protected _send<T = any>(data: any, options?: {
+        timeout?: number;
+        signal?: AbortSignal;
+    }): Promise<T>;
     /**
      * 推送消息
      * @param data - 消息数据
      * @param timeout - 超时时间
+     * @param signal - 中止信号
      * @returns 消息响应
      */
-    protected _push<T = any>(data: T, timeout?: number): void;
+    protected _push<T = any>(data: T, options?: {
+        timeout?: number;
+        signal?: AbortSignal;
+    }): void;
+    protected _stream(data: any, options?: {
+        signal?: AbortSignal;
+    }): Readable;
     /**
      * 写入消息
      * @param data - 消息数据
@@ -78,6 +95,8 @@ export declare abstract class MessageModem {
      * @param msg - 消息数据
      */
     private onResponse;
+    private onStreamRequest;
+    private onStreamResponse;
     /**
      * 接收消息
      * @param msg - 消息数据

package/dist/index.js

@@ -1,4 +1,5 @@
 import { AbortException, Exception, TimeoutException } from "./exception.js";
+import { Readable } from 'node:stream';
 export * from './exception.js';
 export var MESSAGE_MODEM_TYPE;
 (function (MESSAGE_MODEM_TYPE) {
@@ -10,15 +11,20 @@ export class MessageModem {
     id = 0;
     aborts = new Map();
     stacks = new Map();
+    streams = new Map();
     _dispose() {
         for (const { reject } of this.stacks.values()) {
             reject(new AbortException());
         }
-        for (const reject of this.aborts.values()) {
-            reject(new AbortException());
+        for (const controller of this.aborts.values()) {
+            controller.abort();
+        }
+        for (const stream of this.streams.values()) {
+            stream.destroy(new AbortException());
         }
         this.aborts.clear();
         this.stacks.clear();
+        this.streams.clear();
     }
     /**
      * 创建自增 ID
@@ -38,13 +44,14 @@ export class MessageModem {
      * @param data - 消息数据
      * @returns 消息数据
      */
-    createPostData(mode, data, twoway = true) {
+    createPostData(mode, data, twoway = true, stream = false) {
         const id = this.createIncrementId();
         const state = {
-            id, twoway, data, mode,
+            id, twoway, data, mode, stream,
         };
         if (mode === MESSAGE_MODEM_TYPE.ABORT) {
             state.twoway = false;
+            state.stream = false;
         }
         return state;
     }
@@ -52,19 +59,50 @@ export class MessageModem {
      * 发送消息
      * @param data - 消息数据
      * @param timeout - 超时时间
+     * @param signal - 中止信号
      * @returns 消息响应
      */
-    _send(data, timeout = 30000) {
-        return this._write(data, timeout, true);
+    _send(data, options) {
+        return this._write(data, {
+            timeout: options?.timeout ?? 30000,
+            twoway: true,
+            signal: options?.signal,
+        });
     }
     /**
      * 推送消息
      * @param data - 消息数据
      * @param timeout - 超时时间
+     * @param signal - 中止信号
      * @returns 消息响应
      */
-    _push(data, timeout = 30000) {
-        this._write(data, timeout, false);
+    _push(data, options) {
+        this._write(data, {
+            timeout: options?.timeout ?? 30000,
+            twoway: false,
+            signal: options?.signal,
+        });
+    }
+    _stream(data, options) {
+        const state = this.createPostData(MESSAGE_MODEM_TYPE.REQUEST, data, true, true);
+        const stream = new Readable({ objectMode: true, read() { } });
+        this.streams.set(state.id, stream);
+        this.post(state);
+        const onAbort = () => {
+            this.post(this.createPostData(MESSAGE_MODEM_TYPE.ABORT, state.id));
+            stream.destroy(new AbortException());
+            this.streams.delete(state.id);
+        };
+        if (options?.signal) {
+            options.signal.addEventListener('abort', onAbort);
+        }
+        stream.on('close', () => {
+            if (this.streams.has(state.id)) {
+                this.streams.delete(state.id);
+            }
+            options?.signal?.removeEventListener('abort', onAbort);
+        });
+        return stream;
     }
     /**
      * 写入消息
@@ -72,7 +110,10 @@ export class MessageModem {
      * @param timeout - 超时时间
      * @returns 消息响应
      */
-    _write(data, timeout = 30000, twoway = false) {
+    _write(data, options) {
+        const timeout = options?.timeout ?? 30000;
+        const twoway = !!options?.twoway;
+        const signal = options?.signal;
         // 创建请求消息数据
         const state = this.createPostData(MESSAGE_MODEM_TYPE.REQUEST, data, twoway);
         // 发送消息
@@ -80,135 +121,101 @@ export class MessageModem {
         // 如果消息是单向的，则直接返回
         if (!twoway)
             return;
-        const controller = new AbortController();
-        return {
-            // 终止请求
-            abort: () => controller.abort(),
-            // 等待响应
-            response: () => new Promise((resolve, reject) => {
-                // 清理 stacks
-                const clear = () => {
-                    if (this.stacks.has(state.id)) {
-                        this.stacks.delete(state.id);
-                    }
-                };
-                const clean = () => {
-                    clearTimeout(timer);
-                    controller.signal.removeEventListener('abort', aborthandler);
+        return new Promise((resolve, reject) => {
+            const clear = () => {
+                if (this.stacks.has(state.id)) {
+                    this.stacks.delete(state.id);
+                }
+            };
+            const clean = () => {
+                clearTimeout(timer);
+                signal?.removeEventListener('abort', onAbort);
+                clear();
+            };
+            const onAbort = () => {
+                clearTimeout(timer);
+                try {
+                    this.post(this.createPostData(MESSAGE_MODEM_TYPE.ABORT, state.id));
+                }
+                catch {
+                    /* 例如 WebSocket 已关闭时 send 可能抛错 */
+                }
+                finally {
+                    signal?.removeEventListener('abort', onAbort);
                     clear();
-                };
-                // Abort 处理函数（post 失败时仍须 reject，否则调用方会一直挂起）
-                const aborthandler = () => {
-                    clearTimeout(timer);
-                    try {
-                        this.post(this.createPostData(MESSAGE_MODEM_TYPE.ABORT, state.id));
-                    }
-                    catch {
-                        /* 例如 WebSocket 已关闭时 send 可能抛错 */
-                    }
-                    finally {
-                        controller.signal.removeEventListener('abort', aborthandler);
-                        clear();
-                        reject(new AbortException());
-                    }
-                };
-                // 成功处理
-                const _resolve = (data) => {
-                    clean();
-                    resolve(data);
-                };
-                // 失败处理
-                const _reject = (e) => {
-                    clean();
-                    reject(e);
-                };
-                // 超时处理
-                const timer = setTimeout(() => {
-                    if (!controller.signal.aborted) {
-                        controller.abort();
-                    }
-                    else {
-                        _reject(new TimeoutException());
-                    }
-                }, timeout).unref();
-                // 添加 Abort 处理函数
-                controller.signal.addEventListener('abort', aborthandler);
-                // 添加栈
-                this.stacks.set(state.id, {
-                    resolve: _resolve,
-                    reject: _reject,
-                });
-            })
-        };
+                    reject(new AbortException());
+                }
+            };
+            // 成功处理
+            const _resolve = (data) => {
+                clean();
+                resolve(data);
+            };
+            // 失败处理
+            const _reject = (e) => {
+                clean();
+                reject(e);
+            };
+            const timer = setTimeout(() => _reject(new TimeoutException()), timeout).unref();
+            signal?.addEventListener('abort', onAbort);
+            this.stacks.set(state.id, {
+                resolve: _resolve,
+                reject: _reject,
+            });
+        });
     }
     /**
      * 处理请求消息
      * @param msg - 消息数据
      */
     onRequest(msg) {
-        // 执行消息
-        // 使用 Promise.race 处理消息执行和 Abort 处理
-        Promise.race([
-            this.exec(msg.data).catch(e => ({ e })),
-            new Promise((_, reject) => this.aborts.set(msg.id, reject)),
-        ]).then(value => {
-            // 如果消息执行失败
-            if (value?.e) {
-                // 如果消息是双向的，则发送响应消息
-                if (msg.twoway) {
-                    this.post({
-                        id: msg.id,
-                        mode: MESSAGE_MODEM_TYPE.RESPONSE,
-                        twoway: false,
-                        data: {
-                            status: value.e instanceof Exception ? value.e.status : 500,
-                            data: null,
-                            message: value.e.message,
-                        }
-                    });
-                }
+        const controller = new AbortController();
+        this.aborts.set(msg.id, controller);
+        controller.signal.addEventListener('abort', () => {
+            if (this.aborts.has(msg.id)) {
+                this.aborts.delete(msg.id);
             }
-            else {
-                // 如果消息是双向的，则发送响应消息
-                if (msg.twoway) {
-                    this.post({
-                        id: msg.id,
-                        mode: MESSAGE_MODEM_TYPE.RESPONSE,
-                        twoway: false,
-                        data: {
-                            status: 200,
-                            data: value,
-                        }
-                    });
-                }
+        });
+        this.exec(msg.data, controller.signal)
+            .then(value => {
+            if (controller.signal.aborted)
+                return;
+            if (isAsyncIterable(value)) {
+                throw new Exception(500, 'Async iterable is not supported');
+            }
+            if (msg.twoway) {
+                this.post({
+                    id: msg.id,
+                    mode: MESSAGE_MODEM_TYPE.RESPONSE,
+                    twoway: false,
+                    data: {
+                        status: 200,
+                        data: value,
+                    }
+                });
             }
-        }).catch(e => {
-            if (e instanceof AbortException)
+        })
+            .catch(e => {
+            if (controller.signal.aborted)
                 return;
-            // 如果消息是双向的，则发送响应消息
             if (msg.twoway) {
-                // 发送响应消息
-                const code = e instanceof Exception ? e.status : 500;
                 this.post({
                     id: msg.id,
                     mode: MESSAGE_MODEM_TYPE.RESPONSE,
                     twoway: false,
                     data: {
-                        status: code,
+                        status: e instanceof Exception ? e.status : 500,
                         data: null,
                         message: e.message,
                     }
                 });
             }
-        }).finally(() => {
+        })
+            .finally(() => {
             // 删除 Abort 处理函数
             if (this.aborts.has(msg.id)) {
                 this.aborts.delete(msg.id);
             }
-            // 清理栈
-            if (this.stacks.has(msg.id)) {
-                this.stacks.delete(msg.id);
-            }
         });
     }
     /**
@@ -230,6 +237,99 @@ export class MessageModem {
             }
         }
     }
+    onStreamRequest(msg) {
+        const controller = new AbortController();
+        this.aborts.set(msg.id, controller);
+        controller.signal.addEventListener('abort', () => {
+            if (this.aborts.has(msg.id)) {
+                this.aborts.delete(msg.id);
+            }
+        });
+        this.exec(msg.data, controller.signal)
+            .then(async (value) => {
+            if (!isAsyncIterable(value)) {
+                throw new Exception(500, 'Invalid async iterable');
+            }
+            let i = 0;
+            for await (const chunk of value) {
+                if (controller.signal.aborted)
+                    return;
+                this.post({
+                    id: msg.id,
+                    mode: MESSAGE_MODEM_TYPE.RESPONSE,
+                    stream: true,
+                    data: {
+                        status: 200,
+                        seq: i++,
+                        payload: chunk,
+                        final: false,
+                    },
+                    twoway: false,
+                });
+            }
+            if (controller.signal.aborted)
+                return;
+            this.post({
+                id: msg.id,
+                mode: MESSAGE_MODEM_TYPE.RESPONSE,
+                stream: true,
+                data: {
+                    status: 200,
+                    seq: i++,
+                    payload: undefined,
+                    final: true,
+                },
+                twoway: false,
+            });
+        })
+            .catch(e => {
+            if (controller.signal.aborted)
+                return;
+            this.post({
+                id: msg.id,
+                mode: MESSAGE_MODEM_TYPE.RESPONSE,
+                stream: true,
+                data: {
+                    status: e instanceof Exception ? e.status : 500,
+                    seq: 0,
+                    payload: e instanceof Exception ? e.message : 'Unknown error',
+                    final: true,
+                },
+                twoway: false,
+            });
+        })
+            .finally(() => {
+            if (this.aborts.has(msg.id)) {
+                this.aborts.delete(msg.id);
+            }
+        });
+    }
+    onStreamResponse(msg) {
+        const id = msg.id;
+        const res = msg.data;
+        // 如果栈中存在该消息，则处理响应消息
+        if (this.streams.has(id)) {
+            const stream = this.streams.get(id);
+            if (res) {
+                if (res.status === 200) {
+                    if (res.final) {
+                        stream.push(null);
+                    }
+                    else {
+                        stream.push(res.payload);
+                    }
+                }
+                else {
+                    const err = new Exception(res.status, res.payload);
+                    setImmediate(() => stream.destroy(err));
+                }
+            }
+            else {
+                const err = new Exception(404, 'Empty chunk data');
+                setImmediate(() => stream.destroy(err));
+            }
+        }
+    }
     /**
      * 接收消息
      * @param msg - 消息数据
@@ -239,20 +339,35 @@ export class MessageModem {
         switch (msg.mode) {
             // 处理请求消息
             case MESSAGE_MODEM_TYPE.REQUEST:
-                this.onRequest(msg);
+                if (msg.stream) {
+                    this.onStreamRequest(msg);
+                }
+                else {
+                    this.onRequest(msg);
+                }
                 break;
             // 处理响应消息
             case MESSAGE_MODEM_TYPE.RESPONSE:
-                this.onResponse(msg);
+                if (msg.stream) {
+                    this.onStreamResponse(msg);
+                }
+                else {
+                    this.onResponse(msg);
+                }
                 break;
             // 处理终止消息
             case MESSAGE_MODEM_TYPE.ABORT:
                 const id = msg.data;
                 if (this.aborts.has(id)) {
-                    const reject = this.aborts.get(id);
-                    reject(new AbortException());
-                    break;
+                    const controller = this.aborts.get(id);
+                    if (!controller.signal.aborted) {
+                        controller.abort();
+                    }
                 }
+                break;
         }
     }
 }
+function isAsyncIterable(value) {
+    return value != null && typeof value[Symbol.asyncIterator] === 'function';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hile/message-modem",
-  "version": "1.0.7",
+  "version": "2.0.0",
   "type": "module",
   "main": "./dist/index.js",
   "scripts": {
@@ -21,5 +21,5 @@
     "fix-esm-import-path": "^1.10.3",
     "vitest": "^4.0.18"
   },
-  "gitHead": "4549afb84d25e8dffdfab2e27ed05e52828c368d"
+  "gitHead": "d28b20bc22ee08c45cbf4596672705cb96e8e461"
 }