@fluojs/microservices 1.0.4 → 2.0.0

package/dist/transports/grpc-transport.js

@@ -16,8 +16,10 @@ const grpcKinds = {
  * and exposes matching unary/server-stream/client-stream/bidi-stream client calls through one transport surface.
  */
 export class GrpcMicroserviceTransport {
-  /** Indicates whether gRPC owns server shutdown in addition to cached client cleanup. */
-  ownsResources;
+  /** Indicates that gRPC closes the cached outbound clients it creates. */
+  ownsResources = true;
+  /** Reports server and cached outbound client ownership independently. */
+  resourceOwnership;
   bidiStreamHandler;
   clientStreamHandler;
   closePromise;
@@ -46,7 +48,10 @@ export class GrpcMicroserviceTransport {
     this.requestTimeoutMs = options.requestTimeoutMs ?? 3_000;
     this.server = options.server;
     this.ownsServer = !options.server;
-    this.ownsResources = this.ownsServer;
+    this.resourceOwnership = {
+      outboundClients: 'framework',
+      server: this.ownsServer ? 'framework' : 'caller'
+    };
   }
   setLogger(logger) {
     this.logger = logger;
@@ -536,124 +541,11 @@ export class GrpcMicroserviceTransport {
       throw new Error(`GrpcMicroserviceTransport could not resolve server-streaming method "${parsedPattern.serviceName}.${parsedPattern.methodName}".`);
     }
     const metadata = this.createMetadata(grpcKinds.message);
-    const transport = this;
-    return {
-      [Symbol.asyncIterator]() {
-        const buffer = [];
-        let done = false;
-        let error;
-        let waiting;
-        let stream;
-        let removeAbortListener;
-        const cleanupAbortListener = () => {
-          removeAbortListener?.();
-          removeAbortListener = undefined;
-        };
-        const finish = () => {
-          done = true;
-          cleanupAbortListener();
-        };
-        const startStream = () => {
-          if (stream) {
-            return;
-          }
-          stream = method.call(runtime.client, payload, metadata);
-          stream.on('data', data => {
-            if (waiting) {
-              const w = waiting;
-              waiting = undefined;
-              w.resolve({
-                value: data,
-                done: false
-              });
-            } else {
-              buffer.push(data);
-            }
-          });
-          stream.on('end', () => {
-            finish();
-            if (waiting) {
-              const w = waiting;
-              waiting = undefined;
-              w.resolve({
-                value: undefined,
-                done: true
-              });
-            }
-          });
-          stream.on('error', err => {
-            finish();
-            if (signal?.aborted) {
-              error = new Error('gRPC server stream aborted.');
-            } else {
-              error = err instanceof Error ? err : new Error('gRPC server stream error.');
-            }
-            if (waiting) {
-              const w = waiting;
-              waiting = undefined;
-              w.reject(error);
-            }
-          });
-          if (signal) {
-            if (signal.aborted) {
-              finish();
-              error = new Error('gRPC server stream aborted.');
-              stream.cancel?.();
-              return;
-            }
-            const onAbort = () => {
-              finish();
-              error = new Error('gRPC server stream aborted.');
-              stream?.cancel?.();
-              if (waiting) {
-                const w = waiting;
-                waiting = undefined;
-                w.reject(error);
-              }
-            };
-            signal.addEventListener('abort', onAbort, {
-              once: true
-            });
-            removeAbortListener = () => signal.removeEventListener('abort', onAbort);
-          }
-        };
-        void transport;
-        return {
-          next() {
-            startStream();
-            if (buffer.length > 0) {
-              return Promise.resolve({
-                value: buffer.shift(),
-                done: false
-              });
-            }
-            if (error) {
-              return Promise.reject(error);
-            }
-            if (done) {
-              return Promise.resolve({
-                value: undefined,
-                done: true
-              });
-            }
-            return new Promise((resolve, reject) => {
-              waiting = {
-                resolve,
-                reject
-              };
-            });
-          },
-          return() {
-            finish();
-            stream?.cancel?.();
-            return Promise.resolve({
-              value: undefined,
-              done: true
-            });
-          }
-        };
-      }
-    };
+    const stream = method.call(runtime.client, payload, metadata);
+    return grpcReadableToAsyncIterable(stream, {
+      abortErrorMessage: 'gRPC server stream aborted.',
+      signal
+    });
   }
   callClientStream(parsedPattern, signal) {
     const runtime = this.getServiceRuntime(parsedPattern.serviceName);
@@ -665,40 +557,63 @@ export class GrpcMicroserviceTransport {
     let callStream;
     let ended = false;
     let cleanupAbortListener;
+    let settled = false;
+    let writerError;
+    let rejectResult;
     const cleanup = () => {
       cleanupAbortListener?.();
       cleanupAbortListener = undefined;
     };
     const result = new Promise((resolve, reject) => {
       if (signal?.aborted) {
+        settled = true;
         reject(new Error('gRPC client stream aborted before dispatch.'));
         return;
       }
-      callStream = method.call(runtime.client, metadata, (error, response) => {
+      rejectResult = reject;
+      const settle = complete => {
+        if (settled) {
+          return;
+        }
+        settled = true;
         cleanup();
+        complete();
+      };
+      callStream = method.call(runtime.client, metadata, (error, response) => {
+        // A local writer.error() failure is the authoritative cause: the transport-level
+        // status that follows an aborted call would otherwise mask it.
+        if (writerError) {
+          settle(() => reject(writerError));
+          return;
+        }
         if (error) {
           if (signal?.aborted) {
-            reject(new Error('gRPC client stream aborted.'));
+            settle(() => reject(new Error('gRPC client stream aborted.')));
             return;
           }
           const message = typeof error.message === 'string' && error.message.length > 0 ? error.message : 'Unhandled gRPC client stream error';
-          reject(new Error(message));
+          settle(() => reject(new Error(message)));
           return;
         }
-        resolve(response);
+        settle(() => resolve(response));
       });
-      if (signal) {
+      if (signal && !settled) {
         const onAbort = () => {
-          if (!ended) {
-            ended = true;
-            callStream?.end();
-          }
-          reject(new Error('gRPC client stream aborted.'));
+          settle(() => {
+            if (!ended) {
+              ended = true;
+              callStream?.end();
+            }
+            reject(new Error('gRPC client stream aborted.'));
+          });
         };
         signal.addEventListener('abort', onAbort, {
           once: true
         });
         cleanupAbortListener = () => signal.removeEventListener('abort', onAbort);
+        if (signal.aborted) {
+          onAbort();
+        }
       }
     });
     const writer = {
@@ -714,10 +629,19 @@ export class GrpcMicroserviceTransport {
         }
       },
       error(err) {
-        void err;
-        if (!ended) {
-          ended = true;
-          callStream?.end();
+        if (ended) {
+          return;
+        }
+        ended = true;
+        writerError = err;
+        abortClientStreamCall(callStream, err);
+
+        // Runtimes without cancel()/destroy() cannot abort the call, so settle locally
+        // instead of leaving the caller with a silently successful stream.
+        if (!settled) {
+          settled = true;
+          cleanup();
+          rejectResult?.(err);
         }
       }
     };
@@ -736,6 +660,9 @@ export class GrpcMicroserviceTransport {
     const duplexStream = method.call(runtime.client, metadata);
     let writerEnded = false;
     let cleanupAbortListener;
+    const localFailure = {
+      error: undefined
+    };
     if (signal) {
       if (signal.aborted) {
         duplexStream.cancel?.();
@@ -753,7 +680,11 @@ export class GrpcMicroserviceTransport {
         cleanupAbortListener = () => signal.removeEventListener('abort', onAbort);
       }
     }
-    const reader = grpcReadableToAsyncIterable(duplexStream, signal, cleanupAbortListener);
+    const reader = grpcReadableToAsyncIterable(duplexStream, {
+      externalAbortCleanup: cleanupAbortListener,
+      localFailure,
+      signal
+    });
     const writer = {
       write(data) {
         if (!writerEnded) {
@@ -767,11 +698,14 @@ export class GrpcMicroserviceTransport {
         }
       },
       error(err) {
-        void err;
-        if (!writerEnded) {
-          writerEnded = true;
-          duplexStream.end();
+        if (writerEnded) {
+          return;
         }
+        writerEnded = true;
+        // Recorded before cancelation so the reader reports the caller's cause rather than
+        // the CANCELLED status the aborted call raises.
+        localFailure.error = err;
+        abortDuplexStreamCall(duplexStream, err);
       }
     };
     return {
@@ -963,117 +897,183 @@ export class GrpcMicroserviceTransport {
     logTransportEventHandlerFailure(this.logger, 'GrpcMicroserviceTransport', error);
   }
 }
-function grpcReadableToAsyncIterable(stream, signal, externalAbortCleanup) {
-  return {
-    [Symbol.asyncIterator]() {
-      const buffer = [];
-      let done = false;
-      let error;
-      let waiting;
-      let removeAbortListener;
-      const cleanupAbortListeners = () => {
-        removeAbortListener?.();
-        removeAbortListener = undefined;
-        externalAbortCleanup?.();
-      };
-      const finish = () => {
-        done = true;
-        cleanupAbortListeners();
-      };
-      stream.on('data', data => {
-        if (waiting) {
-          const w = waiting;
-          waiting = undefined;
-          w.resolve({
-            value: data,
-            done: false
-          });
-        } else {
-          buffer.push(data);
+function grpcReadableToAsyncIterable(stream, options = {}) {
+  const {
+    signal
+  } = options;
+  const abortErrorMessage = options.abortErrorMessage ?? 'gRPC stream aborted.';
+  const buffer = [];
+  let cleanupExternalAbortListener = options.externalAbortCleanup;
+  let done = false;
+  let error;
+  let waiting;
+  let removeAbortListener;
+  const cleanupAbortListeners = () => {
+    const cleanupLocal = removeAbortListener;
+    const cleanupExternal = cleanupExternalAbortListener;
+    removeAbortListener = undefined;
+    cleanupExternalAbortListener = undefined;
+    cleanupLocal?.();
+    cleanupExternal?.();
+  };
+  const finish = () => {
+    if (done) {
+      return false;
+    }
+    done = true;
+    cleanupAbortListeners();
+    return true;
+  };
+  if (signal) {
+    if (signal.aborted) {
+      error = new Error(abortErrorMessage);
+      finish();
+      stream.cancel?.();
+    } else {
+      const onAbort = () => {
+        const abortError = new Error(abortErrorMessage);
+        if (!finish()) {
+          return;
         }
-      });
-      stream.on('end', () => {
-        finish();
+        error = abortError;
+        stream.cancel?.();
         if (waiting) {
-          const w = waiting;
+          const current = waiting;
           waiting = undefined;
-          w.resolve({
-            value: undefined,
-            done: true
-          });
+          current.reject(abortError);
         }
+      };
+      signal.addEventListener('abort', onAbort, {
+        once: true
       });
-      stream.on('error', err => {
-        finish();
-        if (signal?.aborted) {
-          error = new Error('gRPC stream aborted.');
-        } else {
-          error = err instanceof Error ? err : new Error('gRPC stream error.');
-        }
-        if (waiting) {
-          const w = waiting;
-          waiting = undefined;
-          w.reject(error);
-        }
+      removeAbortListener = () => signal.removeEventListener('abort', onAbort);
+    }
+  }
+  stream.on('data', data => {
+    if (done) {
+      return;
+    }
+    if (waiting) {
+      const current = waiting;
+      waiting = undefined;
+      current.resolve({
+        value: data,
+        done: false
       });
-      if (signal) {
-        if (signal.aborted) {
-          finish();
-          error = new Error('gRPC stream aborted.');
-          stream.cancel?.();
-        } else {
-          const onAbort = () => {
-            finish();
-            error = new Error('gRPC stream aborted.');
-            stream.cancel?.();
-            if (waiting) {
-              const w = waiting;
-              waiting = undefined;
-              w.reject(error);
-            }
-          };
-          signal.addEventListener('abort', onAbort, {
-            once: true
-          });
-          removeAbortListener = () => signal.removeEventListener('abort', onAbort);
-        }
+    } else {
+      buffer.push(data);
+    }
+  });
+  stream.on('end', () => {
+    if (!finish()) {
+      return;
+    }
+    if (waiting) {
+      const current = waiting;
+      waiting = undefined;
+      current.resolve({
+        value: undefined,
+        done: true
+      });
+    }
+  });
+  stream.on('error', err => {
+    const streamError = options.localFailure?.error ?? (signal?.aborted ? new Error(abortErrorMessage) : err);
+    if (!finish()) {
+      return;
+    }
+    error = streamError;
+    if (waiting) {
+      const current = waiting;
+      waiting = undefined;
+      current.reject(streamError);
+    }
+  });
+  const iterator = {
+    next() {
+      if (buffer.length > 0) {
+        return Promise.resolve({
+          value: buffer.shift(),
+          done: false
+        });
       }
-      return {
-        next() {
-          if (buffer.length > 0) {
-            return Promise.resolve({
-              value: buffer.shift(),
-              done: false
-            });
-          }
-          if (error) {
-            return Promise.reject(error);
-          }
-          if (done) {
-            return Promise.resolve({
-              value: undefined,
-              done: true
-            });
-          }
-          return new Promise((resolve, reject) => {
-            waiting = {
-              resolve,
-              reject
-            };
-          });
-        },
-        return() {
-          finish();
-          stream.cancel?.();
-          return Promise.resolve({
-            value: undefined,
-            done: true
-          });
-        }
-      };
+      if (error) {
+        return Promise.reject(error);
+      }
+      if (done) {
+        return Promise.resolve({
+          value: undefined,
+          done: true
+        });
+      }
+      return new Promise((resolve, reject) => {
+        waiting = {
+          resolve,
+          reject
+        };
+      });
+    },
+    return() {
+      const shouldCancel = finish();
+      buffer.length = 0;
+      if (waiting) {
+        const current = waiting;
+        waiting = undefined;
+        current.resolve({
+          value: undefined,
+          done: true
+        });
+      }
+      if (shouldCancel) {
+        stream.cancel?.();
+      }
+      return Promise.resolve({
+        value: undefined,
+        done: true
+      });
+    }
+  };
+  return {
+    [Symbol.asyncIterator]() {
+      return iterator;
     }
   };
 }
+
+/**
+ * Aborts an outbound client-streaming call so the peer observes a failure instead of a clean EOF.
+ *
+ * `destroy(err)` is preferred because it carries the cause; `cancel()` is the grpc-js fallback.
+ */
+function abortClientStreamCall(stream, err) {
+  if (!stream) {
+    return;
+  }
+  if (stream.destroy) {
+    stream.destroy(err);
+    return;
+  }
+  if (stream.cancel) {
+    stream.cancel();
+    return;
+  }
+  stream.end();
+}
+
+/**
+ * Aborts an outbound bidirectional-streaming call so the peer observes a failure instead of a clean EOF.
+ */
+function abortDuplexStreamCall(stream, err) {
+  if (stream.destroy) {
+    stream.destroy(err);
+    return;
+  }
+  if (stream.cancel) {
+    stream.cancel();
+    return;
+  }
+  stream.end();
+}
 function parseGrpcPattern(pattern) {
   const segments = pattern.split('.');
   if (segments.length !== 2 || segments[0]?.length === 0 || segments[1]?.length === 0) {

package/dist/transports/kafka-transport.d.ts

@@ -1,4 +1,4 @@
-import type { MicroserviceTransport, TransportHandler } from '../types.js';
+import type { MicroserviceTransport, MicroserviceTransportLogger, TransportHandler } from '../types.js';
 interface KafkaConsumerLike {
     subscribe(topic: string, handler: (message: string) => Promise<void> | void): Promise<void>;
     unsubscribe(topic: string): Promise<void>;
@@ -28,11 +28,19 @@ export declare class KafkaMicroserviceTransport implements MicroserviceTransport
     private handler;
     private listening;
     private listenPromise;
+    private logger;
     private readonly eventTopic;
     private readonly messageTopic;
     private readonly pending;
     private readonly requestTimeoutMs;
     private readonly responseTopic;
+    private logEventHandlerFailure;
+    /**
+     * Registers the runtime logger that receives inbound event handler failures.
+     *
+     * @param logger Logger used to report event handler failures.
+     */
+    setLogger(logger: MicroserviceTransportLogger): void;
     /**
      * Creates a Kafka transport with explicit producer and consumer collaborators.
      *

package/dist/transports/kafka-transport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"kafka-transport.d.ts","sourceRoot":"","sources":["../../src/transports/kafka-transport.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE3E,UAAU,iBAAiB;IACzB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5F,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3C;AAED,UAAU,iBAAiB;IACzB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACxD;AAgBD,gEAAgE;AAChE,MAAM,WAAW,iCAAiC;IAChD,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;GAKG;AACH,qBAAa,0BAA2B,YAAW,qBAAqB;IAiB1D,OAAO,CAAC,QAAQ,CAAC,OAAO;IAhBpC,OAAO,CAAC,YAAY,CAA4B;IAChD,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,OAAO,CAA+B;IAC9C,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,aAAa,CAA4B;IACjD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqC;IAC7D,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;IAC1C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IAEvC;;;;OAIG;gBAC0B,OAAO,EAAE,iCAAiC;IAOvE;;;;;OAKG;IACG,MAAM,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IAwDtD;;;;;;;OAOG;IACG,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;IAsFrF;;;;;;OAMG;IACG,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAc5D;;;;OAIG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YA6Cd,kBAAkB;YAkBlB,oBAAoB;YAwCpB,qBAAqB;IAqBnC,OAAO,CAAC,YAAY;CAqCrB"}
+{"version":3,"file":"kafka-transport.d.ts","sourceRoot":"","sources":["../../src/transports/kafka-transport.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,2BAA2B,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAGxG,UAAU,iBAAiB;IACzB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5F,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3C;AAED,UAAU,iBAAiB;IACzB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACxD;AAgBD,gEAAgE;AAChE,MAAM,WAAW,iCAAiC;IAChD,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;GAKG;AACH,qBAAa,0BAA2B,YAAW,qBAAqB;IAmC1D,OAAO,CAAC,QAAQ,CAAC,OAAO;IAlCpC,OAAO,CAAC,YAAY,CAA4B;IAChD,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,OAAO,CAA+B;IAC9C,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,aAAa,CAA4B;IACjD,OAAO,CAAC,MAAM,CAA0C;IACxD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqC;IAC7D,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;IAC1C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IAEvC,OAAO,CAAC,sBAAsB;IAQ9B;;;;OAIG;IACH,SAAS,CAAC,MAAM,EAAE,2BAA2B,GAAG,IAAI;IAIpD;;;;OAIG;gBAC0B,OAAO,EAAE,iCAAiC;IAOvE;;;;;OAKG;IACG,MAAM,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IAkDtD;;;;;;;OAOG;IACG,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;IAsFrF;;;;;;OAMG;IACG,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAc5D;;;;OAIG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YA6Cd,kBAAkB;YAuBlB,oBAAoB;YA2CpB,qBAAqB;IAqBnC,OAAO,CAAC,YAAY;CAqCrB"}