@hile/message-modem 4.0.0 → 4.0.1

package/dist/index.d.ts

@@ -12,8 +12,18 @@ export interface MessageTransferFormat<T = any> {
     twoway: boolean;
     stream?: boolean;
     streamVersion?: 1;
+    streamWindow?: number;
     data?: T;
 }
+export interface MessageStreamOptions {
+    signal?: AbortSignal;
+    /** Maximum total stream lifetime in milliseconds. */
+    timeout?: number;
+    /** Maximum time between valid stream responses in milliseconds. */
+    idleTimeout?: number;
+    /** Maximum number of produced but not yet consumed chunks. */
+    window?: number;
+}
 export interface MessageReturnFormat<T = any> {
     status: string | number;
     data: T;
@@ -78,9 +88,7 @@ export declare abstract class MessageModem {
         timeout?: number;
         signal?: AbortSignal;
     }): void;
-    protected _stream(data: any, options?: {
-        signal?: AbortSignal;
-    }): Readable;
+    protected _stream(data: any, options?: MessageStreamOptions): Readable;
     /**
      * 写入消息
      * @param data - 消息数据

package/dist/index.js

@@ -8,6 +8,30 @@ export var MESSAGE_MODEM_TYPE;
     MESSAGE_MODEM_TYPE[MESSAGE_MODEM_TYPE["ABORT"] = 2] = "ABORT";
     MESSAGE_MODEM_TYPE[MESSAGE_MODEM_TYPE["STREAM_CREDIT"] = 3] = "STREAM_CREDIT";
 })(MESSAGE_MODEM_TYPE || (MESSAGE_MODEM_TYPE = {}));
+const MAX_STREAM_WINDOW = 64;
+const MAX_TIMER_DELAY = 2_147_483_647;
+function streamLimit(value, name) {
+    if (value === undefined)
+        return undefined;
+    if (!Number.isSafeInteger(value) || value < 1) {
+        throw new TypeError(`${name} must be a positive safe integer`);
+    }
+    return value;
+}
+function streamWindow(value) {
+    const normalized = streamLimit(value, 'Stream window') ?? 1;
+    if (normalized > MAX_STREAM_WINDOW) {
+        throw new TypeError(`Stream window must not exceed ${MAX_STREAM_WINDOW}`);
+    }
+    return normalized;
+}
+function streamTimeout(value, name) {
+    const normalized = streamLimit(value, name);
+    if (normalized !== undefined && normalized > MAX_TIMER_DELAY) {
+        throw new TypeError(`${name} must not exceed ${MAX_TIMER_DELAY}`);
+    }
+    return normalized;
+}
 class CreditReadable extends Readable {
     onConsumed;
     constructor(onConsumed) {
@@ -105,28 +129,61 @@ export class MessageModem {
             signal: options?.signal,
         });
     }
-    _stream(data, options) {
+    _stream(data, options = {}) {
+        const window = streamWindow(options.window);
+        const timeout = streamTimeout(options.timeout, 'Stream timeout');
+        const idleTimeout = streamTimeout(options.idleTimeout, 'Stream idle timeout');
         const state = this.createPostData(MESSAGE_MODEM_TYPE.REQUEST, data, true, true);
         state.streamVersion = 1;
+        if (window > 1)
+            state.streamWindow = window;
         let consumer;
         const stream = new CreditReadable(() => {
-            if (!consumer.creditOwed || consumer.completed || consumer.cancelled)
+            if (consumer.creditsOwed === 0 || consumer.completed || consumer.cancelled)
                 return;
-            consumer.creditOwed = false;
+            consumer.creditsOwed--;
             try {
-                this.post(this.createPostData(MESSAGE_MODEM_TYPE.STREAM_CREDIT, { id: state.id, seq: consumer.nextSeq - 1 }, false));
+                this.post(this.createPostData(MESSAGE_MODEM_TYPE.STREAM_CREDIT, { id: state.id, seq: consumer.nextCreditSeq++ }, false));
             }
             catch (error) {
                 consumer.cancelled = true;
                 stream.destroy(error);
             }
         });
+        let totalTimer;
+        let idleTimer;
+        const clearTimers = () => {
+            if (totalTimer)
+                clearTimeout(totalTimer);
+            if (idleTimer)
+                clearTimeout(idleTimer);
+            totalTimer = undefined;
+            idleTimer = undefined;
+        };
+        const expire = (message) => {
+            if (consumer.completed || consumer.cancelled)
+                return;
+            sendAbort();
+            stream.destroy(new TimeoutException(message));
+        };
+        const touch = () => {
+            if (!idleTimeout || consumer.completed || consumer.cancelled)
+                return;
+            if (idleTimer)
+                clearTimeout(idleTimer);
+            idleTimer = setTimeout(() => expire('Stream idle timeout'), idleTimeout);
+            idleTimer.unref?.();
+        };
         consumer = {
             stream,
             completed: false,
             cancelled: false,
-            creditOwed: false,
+            creditsOwed: 0,
+            maxCredits: window,
             nextSeq: 0,
+            nextCreditSeq: 0,
+            touch,
+            clearTimers,
         };
         const sendAbort = () => {
             if (consumer.completed || consumer.cancelled)
@@ -150,8 +207,14 @@ export class MessageModem {
         }
         this.streams.set(state.id, consumer);
         options?.signal?.addEventListener('abort', onAbort, { once: true });
+        if (timeout) {
+            totalTimer = setTimeout(() => expire('Stream timeout'), timeout);
+            totalTimer.unref?.();
+        }
+        touch();
         stream.on('close', () => {
             sendAbort();
+            clearTimers();
             if (this.streams.has(state.id)) {
                 this.streams.delete(state.id);
             }
@@ -329,6 +392,26 @@ export class MessageModem {
             });
             return;
         }
+        let window;
+        try {
+            window = streamWindow(msg.streamWindow);
+        }
+        catch (error) {
+            this.post({
+                id: msg.id,
+                mode: MESSAGE_MODEM_TYPE.RESPONSE,
+                stream: true,
+                streamVersion: 1,
+                data: {
+                    status: 400,
+                    seq: 0,
+                    payload: error instanceof Error ? error.message : 'Invalid stream window',
+                    final: true,
+                },
+                twoway: false,
+            });
+            return;
+        }
         if (this.streamProducers.has(msg.id) || this.streamProducers.size >= 128) {
             this.post({
                 id: msg.id,
@@ -342,7 +425,8 @@ export class MessageModem {
         }
         const controller = new AbortController();
         const producer = {
-            credits: 1,
+            credits: window,
+            maxCredits: window,
             nextCreditSeq: 0,
         };
         let sequence = 0;
@@ -445,6 +529,7 @@ export class MessageModem {
             const consumer = this.streams.get(id);
             const stream = consumer.stream;
             if (res) {
+                consumer.touch();
                 if (!Number.isSafeInteger(res.seq) || res.seq !== consumer.nextSeq) {
                     stream.destroy(new Exception(409, `Invalid stream sequence: expected ${consumer.nextSeq}, received ${String(res.seq)}`));
                     return;
@@ -453,21 +538,28 @@ export class MessageModem {
                 if (res.status === 200) {
                     if (res.final) {
                         consumer.completed = true;
+                        consumer.clearTimers();
                         stream.push(null);
                     }
                     else {
-                        consumer.creditOwed = true;
+                        if (consumer.creditsOwed >= consumer.maxCredits) {
+                            stream.destroy(new Exception(429, 'Stream window exceeded'));
+                            return;
+                        }
+                        consumer.creditsOwed++;
                         stream.push(res.payload);
                     }
                 }
                 else {
                     consumer.completed = true;
+                    consumer.clearTimers();
                     const err = new Exception(res.status, res.payload);
                     setImmediate(() => stream.destroy(err));
                 }
             }
             else {
                 consumer.completed = true;
+                consumer.clearTimers();
                 const err = new Exception(404, 'Empty chunk data');
                 setImmediate(() => stream.destroy(err));
             }
@@ -517,8 +609,10 @@ export class MessageModem {
                     || credit.seq < 0)
                     break;
                 const producer = this.streamProducers.get(credit.id);
-                if (producer && producer.credits === 0 && credit.seq === producer.nextCreditSeq) {
-                    producer.credits = 1;
+                if (producer
+                    && producer.credits < producer.maxCredits
+                    && credit.seq === producer.nextCreditSeq) {
+                    producer.credits++;
                     producer.nextCreditSeq++;
                     producer.wake?.();
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hile/message-modem",
-  "version": "4.0.0",
+  "version": "4.0.1",
   "type": "module",
   "main": "./dist/index.js",
   "scripts": {
@@ -22,5 +22,5 @@
     "fix-esm-import-path": "^1.10.3",
     "vitest": "^4.0.18"
   },
-  "gitHead": "b46cb7f3705a226f58e4d65a2ff985ea54b9a159"
+  "gitHead": "fe98c6f8cca2860ccbb213c575cfda44588cbd06"
 }