@fluojs/microservices 1.0.0-beta.1

package/dist/transports/redis-streams-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis-streams-transport.d.ts","sourceRoot":"","sources":["../../src/transports/redis-streams-transport.ts"],"names":[],"mappings":"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"}

package/dist/transports/redis-streams-transport.js

@@ -0,0 +1,482 @@
+import { logTransportEventHandlerFailure } from './event-handler-logger.js';
+
+/** Optional Redis Streams write controls used for bounded retention. */
+
+/** Minimal Redis Streams client contract required by {@link RedisStreamsMicroserviceTransport}. */
+
+/** Options for configuring the Redis Streams microservice transport. */
+
+function delay(ms) {
+  return new Promise(resolve => {
+    setTimeout(resolve, ms);
+  });
+}
+
+/**
+ * Redis Streams transport for durable request-response messages and event fan-out.
+ *
+ * The adapter uses consumer groups and a per-consumer response stream so callers can combine
+ * at-least-once delivery with request timeouts while preserving Fluo's transport abstraction.
+ */
+export class RedisStreamsMicroserviceTransport {
+  closing = false;
+  consumerId;
+  handler;
+  logger;
+  listening = false;
+  listenPromise;
+  messageGroupLeaseRegistered = false;
+  ownsMessageGroup = false;
+  pending = new Map();
+  pollPromises = [];
+  namespace;
+  consumerGroup;
+  requestTimeoutMs;
+  pollBlockMs;
+  messageRetentionMaxLen;
+  eventRetentionMaxLen;
+  responseRetentionMaxLen;
+
+  /**
+   * Creates a Redis Streams transport with dedicated reader and writer clients.
+   *
+   * @param options Namespace, consumer-group, polling, and timeout settings.
+   */
+  constructor(options) {
+    this.options = options;
+    this.consumerId = crypto.randomUUID();
+    this.namespace = options.namespace ?? 'fluo:streams';
+    this.consumerGroup = options.consumerGroup ?? 'fluo-handlers';
+    this.requestTimeoutMs = options.requestTimeoutMs ?? 3_000;
+    this.pollBlockMs = options.pollBlockMs ?? 500;
+    this.messageRetentionMaxLen = options.messageRetentionMaxLen;
+    this.eventRetentionMaxLen = options.eventRetentionMaxLen;
+    this.responseRetentionMaxLen = options.responseRetentionMaxLen ?? 1_000;
+  }
+  setLogger(logger) {
+    this.logger = logger;
+  }
+
+  /**
+   * Creates consumer groups and starts polling the request, event, and response streams.
+   *
+   * @param handler Runtime callback invoked for inbound event and message packets.
+   * @returns A promise that resolves once all stream consumers are initialized.
+   */
+  async listen(handler) {
+    this.closing = false;
+    this.handler = handler;
+    if (this.listening) {
+      return;
+    }
+    if (this.listenPromise) {
+      await this.listenPromise;
+      return;
+    }
+    this.listenPromise = (async () => {
+      this.ownsMessageGroup = await this.ensureConsumerGroup(this.messageStream, this.messageGroup);
+      await this.registerMessageGroupLease(this.ownsMessageGroup);
+      await this.options.readerClient.xgroupCreate(this.eventStream, this.eventGroup, '$', true);
+      await this.options.readerClient.xgroupCreate(this.responseStream, this.responseGroup, '$', true);
+      this.pollPromises = [this.pollStream(this.messageStream, this.messageGroup), this.pollStream(this.eventStream, this.eventGroup), this.pollStream(this.responseStream, this.responseGroup)];
+      this.listening = true;
+    })();
+    try {
+      await this.listenPromise;
+    } finally {
+      this.listenPromise = undefined;
+    }
+  }
+
+  /**
+   * Sends one request-response message through Redis Streams.
+   *
+   * @param pattern Pattern identifying the remote message handler.
+   * @param payload Serializable request payload.
+   * @param signal Optional abort signal used to cancel the request.
+   * @returns The remote handler response payload.
+   */
+  async send(pattern, payload, signal) {
+    if (this.closing) {
+      throw new Error('RedisStreamsMicroserviceTransport is closing. Wait for close() to complete before send().');
+    }
+    if (!this.listening) {
+      throw new Error('RedisStreamsMicroserviceTransport is not listening. Call listen() before send().');
+    }
+    const requestId = crypto.randomUUID();
+    return await new Promise((resolve, reject) => {
+      let abortHandler;
+      let timeout;
+      const cleanup = () => {
+        if (timeout) {
+          clearTimeout(timeout);
+        }
+        if (signal && abortHandler) {
+          signal.removeEventListener('abort', abortHandler);
+        }
+        this.pending.delete(requestId);
+      };
+      const entry = {
+        resolve: value => {
+          cleanup();
+          resolve(value);
+        },
+        reject: error => {
+          cleanup();
+          reject(error);
+        }
+      };
+      this.pending.set(requestId, entry);
+      timeout = setTimeout(() => {
+        entry.reject(new Error(`Redis Streams request timed out after ${String(this.requestTimeoutMs)}ms waiting for pattern "${pattern}".`));
+      }, this.requestTimeoutMs);
+      if (signal) {
+        if (signal.aborted) {
+          entry.reject(new Error('Redis Streams request aborted before publish.'));
+          return;
+        }
+        abortHandler = () => {
+          entry.reject(new Error('Redis Streams request aborted.'));
+        };
+        signal.addEventListener('abort', abortHandler, {
+          once: true
+        });
+      }
+      void Promise.resolve().then(async () => {
+        if (this.closing) {
+          entry.reject(new Error('Redis Streams microservice transport closed before request dispatch.'));
+          return;
+        }
+        const frame = {
+          kind: 'message',
+          pattern,
+          payload,
+          replyStream: this.responseStream,
+          requestId
+        };
+        await this.publishFrame(this.messageStream, {
+          kind: frame.kind,
+          pattern: frame.pattern,
+          payload: JSON.stringify(frame.payload),
+          replyStream: frame.replyStream,
+          requestId: frame.requestId
+        }, this.messageRetentionMaxLen);
+      }).catch(error => {
+        entry.reject(error instanceof Error ? error : new Error('Failed to publish Redis Streams request.'));
+      });
+    });
+  }
+
+  /**
+   * Emits one fire-and-forget event through Redis Streams.
+   *
+   * @param pattern Pattern identifying the remote event handlers.
+   * @param payload Serializable event payload.
+   * @returns A promise that resolves once the event frame is appended to the stream.
+   */
+  async emit(pattern, payload) {
+    const frame = {
+      kind: 'event',
+      pattern,
+      payload
+    };
+    await this.publishFrame(this.eventStream, {
+      kind: frame.kind,
+      pattern: frame.pattern,
+      payload: JSON.stringify(frame.payload)
+    }, this.eventRetentionMaxLen);
+  }
+
+  /**
+   * Stops polling and tears down the owned request, event, and response consumer resources.
+   *
+   * @returns A promise that resolves once shutdown cleanup finishes.
+   */
+  async close() {
+    this.closing = true;
+    let closeError;
+    if (this.listenPromise) {
+      await this.listenPromise;
+    }
+    try {
+      const settled = await Promise.allSettled(this.pollPromises);
+      const shouldDestroyMessageGroup = await this.releaseMessageGroupLease();
+      for (const result of settled) {
+        if (result.status === 'rejected') {
+          closeError ??= result.reason;
+        }
+      }
+      if (shouldDestroyMessageGroup) {
+        try {
+          await this.options.readerClient.xgroupDestroy(this.messageStream, this.messageGroup);
+        } catch (error) {
+          closeError ??= error;
+        }
+      }
+      try {
+        await this.options.readerClient.xgroupDestroy(this.eventStream, this.eventGroup);
+      } catch (error) {
+        closeError ??= error;
+      }
+      try {
+        await this.options.readerClient.xgroupDestroy(this.responseStream, this.responseGroup);
+      } catch (error) {
+        closeError ??= error;
+      }
+      try {
+        await this.options.readerClient.del?.(this.responseStream);
+      } catch (error) {
+        closeError ??= error;
+      }
+    } finally {
+      this.listening = false;
+      this.handler = undefined;
+      this.messageGroupLeaseRegistered = false;
+      this.ownsMessageGroup = false;
+      this.pollPromises = [];
+      for (const pending of [...this.pending.values()]) {
+        pending.reject(new Error('Redis Streams microservice transport closed before response.'));
+      }
+    }
+    if (closeError) {
+      throw closeError;
+    }
+  }
+  async ensureConsumerGroup(stream, group) {
+    try {
+      await this.options.readerClient.xgroupCreate(stream, group, '$', true);
+      return true;
+    } catch (error) {
+      if (this.isBusyGroupError(error)) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  async registerMessageGroupLease(createdGroup) {
+    const {
+      readerClient
+    } = this.options;
+    if (!readerClient.incr || !readerClient.decr || !readerClient.get || !readerClient.set || !readerClient.del) {
+      // Without the optional KV helpers we cannot coordinate shared-group ownership safely
+      // across listeners, so the fallback path keeps the request consumer group alive.
+      this.messageGroupLeaseRegistered = false;
+      return;
+    }
+    if (!createdGroup) {
+      // Joining an existing request group cannot prove that every active listener participates
+      // in the same lease protocol, so shared groups must be retained conservatively.
+      this.messageGroupLeaseRegistered = false;
+      return;
+    }
+    if (createdGroup) {
+      await readerClient.set(this.messageGroupOwnerKey, this.consumerId);
+    }
+    await readerClient.incr(this.messageGroupRefCountKey);
+    this.messageGroupLeaseRegistered = true;
+  }
+  async releaseMessageGroupLease() {
+    const {
+      readerClient
+    } = this.options;
+    if (!this.messageGroupLeaseRegistered || !readerClient.decr || !readerClient.get || !readerClient.del) {
+      // Fallback/no-lease clients intentionally retain the shared request group because
+      // destroying it here could break another active listener that joined via BUSYGROUP.
+      return false;
+    }
+    const remainingListeners = await readerClient.decr(this.messageGroupRefCountKey);
+    if (remainingListeners > 0) {
+      return false;
+    }
+    await readerClient.del(this.messageGroupRefCountKey);
+    const owner = await readerClient.get(this.messageGroupOwnerKey);
+    await readerClient.del(this.messageGroupOwnerKey);
+    if (!owner) {
+      return false;
+    }
+
+    // Even the original creator cannot prove that no fallback listener is still attached to
+    // the shared request group, so the conservative mixed-fleet policy retains the group.
+    return false;
+  }
+  async pollStream(stream, group) {
+    while (!this.closing) {
+      try {
+        const entries = await this.options.readerClient.xreadgroup(group, this.consumerId, [stream], {
+          blockMs: this.pollBlockMs,
+          count: 10
+        });
+        if (!entries || entries.length === 0) {
+          await delay(this.pollBlockMs);
+          continue;
+        }
+        for (const entry of entries) {
+          const parsed = this.parseFields(entry.fields);
+          if (!parsed) {
+            await this.options.readerClient.xack(stream, group, entry.id);
+            continue;
+          }
+          const shouldAcknowledge = await this.handleStreamEntry(stream, parsed);
+          if (shouldAcknowledge) {
+            await this.options.readerClient.xack(stream, group, entry.id);
+            await this.cleanupAcknowledgedEntry(stream, entry.id);
+          }
+        }
+      } catch {
+        if (!this.closing) {
+          await delay(this.pollBlockMs);
+        }
+      }
+    }
+  }
+  async handleStreamEntry(stream, message) {
+    if (stream === this.messageStream) {
+      await this.handleInboundRequest(message);
+      return true;
+    }
+    if (stream === this.eventStream) {
+      return await this.handleInboundEvent(message);
+    }
+    this.handleInboundResponse(message);
+    return true;
+  }
+  async handleInboundRequest(message) {
+    if (!this.handler) {
+      return;
+    }
+    if (message.kind !== 'message' || !message.requestId) {
+      return;
+    }
+    const requestId = message.requestId;
+    const replyStream = message.replyStream && message.replyStream.length > 0 ? message.replyStream : this.responseStream;
+    if (!this.handler) {
+      return;
+    }
+    try {
+      const payload = await this.handler({
+        kind: 'message',
+        pattern: message.pattern,
+        payload: message.payload,
+        requestId: message.requestId
+      });
+      await this.publishFrame(replyStream, {
+        kind: 'response',
+        pattern: message.pattern,
+        payload: JSON.stringify(payload),
+        requestId
+      }, this.responseRetentionMaxLen);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unhandled microservice error';
+      await this.publishFrame(replyStream, {
+        error: errorMessage,
+        kind: 'response',
+        pattern: message.pattern,
+        requestId
+      }, this.responseRetentionMaxLen);
+    }
+  }
+  async publishFrame(stream, fields, maxLenApproximate) {
+    if (typeof maxLenApproximate === 'number' && maxLenApproximate > 0) {
+      await this.options.writerClient.xadd(stream, fields, {
+        maxLenApproximate
+      });
+      return;
+    }
+    await this.options.writerClient.xadd(stream, fields);
+  }
+  async cleanupAcknowledgedEntry(stream, id) {
+    if (stream !== this.messageStream && stream !== this.responseStream) {
+      return;
+    }
+    await this.options.readerClient.xdel?.(stream, id);
+  }
+  async handleInboundEvent(message) {
+    if (!this.handler) {
+      return true;
+    }
+    if (message.kind !== 'event') {
+      return true;
+    }
+    try {
+      await this.handler({
+        kind: 'event',
+        pattern: message.pattern,
+        payload: message.payload
+      });
+      return true;
+    } catch (error) {
+      this.logEventHandlerFailure(error);
+      return false;
+    }
+  }
+  handleInboundResponse(message) {
+    if (message.kind !== 'response' || !message.requestId) {
+      return;
+    }
+    const pending = this.pending.get(message.requestId);
+    if (!pending) {
+      return;
+    }
+    if (message.error) {
+      pending.reject(new Error(message.error));
+      return;
+    }
+    pending.resolve(message.payload);
+  }
+  parseFields(fields) {
+    const kind = fields.kind;
+    const pattern = fields.pattern;
+    if (kind !== 'event' && kind !== 'message' && kind !== 'response') {
+      return undefined;
+    }
+    if (!pattern) {
+      return undefined;
+    }
+    let payload;
+    if (fields.payload !== undefined) {
+      try {
+        payload = JSON.parse(fields.payload);
+      } catch {
+        return undefined;
+      }
+    }
+    return {
+      error: fields.error,
+      kind,
+      pattern,
+      payload,
+      replyStream: fields.replyStream,
+      requestId: fields.requestId
+    };
+  }
+  logEventHandlerFailure(error) {
+    logTransportEventHandlerFailure(this.logger, 'RedisStreamsMicroserviceTransport', error);
+  }
+  isBusyGroupError(error) {
+    return error instanceof Error && error.message.includes('BUSYGROUP');
+  }
+  get messageStream() {
+    return `${this.namespace}:messages`;
+  }
+  get eventStream() {
+    return `${this.namespace}:events`;
+  }
+  get responseStream() {
+    return `${this.namespace}:responses:${this.consumerId}`;
+  }
+  get messageGroup() {
+    return this.consumerGroup;
+  }
+  get messageGroupOwnerKey() {
+    return `${this.namespace}:groups:${this.consumerGroup}:owner`;
+  }
+  get messageGroupRefCountKey() {
+    return `${this.namespace}:groups:${this.consumerGroup}:listeners`;
+  }
+  get eventGroup() {
+    return `${this.consumerGroup}:events:${this.consumerId}`;
+  }
+  get responseGroup() {
+    return `${this.consumerGroup}:responses:${this.consumerId}`;
+  }
+}

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

@@ -0,0 +1,73 @@
+import type { MicroserviceTransport, MicroserviceTransportLogger, TransportHandler } from '../types.js';
+interface RedisLike {
+    off?(event: 'message', listener: (channel: string, message: string) => void): unknown;
+    on(event: 'message', listener: (channel: string, message: string) => void): unknown;
+    publish(channel: string, message: string): Promise<unknown>;
+    subscribe(...channels: string[]): Promise<unknown>;
+    unsubscribe(...channels: string[]): Promise<unknown>;
+}
+/** Options for configuring the Redis Pub/Sub microservice transport. */
+export interface RedisPubSubMicroserviceTransportOptions {
+    namespace?: string;
+    publishClient: RedisLike;
+    requestTimeoutMs?: number;
+    subscribeClient: RedisLike;
+}
+/**
+ * Redis Pub/Sub transport for fire-and-forget microservice events.
+ *
+ * This adapter intentionally supports `emit()` only. Request-response flows must use
+ * a transport with durable reply semantics such as TCP, Kafka, or Redis Streams.
+ */
+export declare class RedisPubSubMicroserviceTransport implements MicroserviceTransport {
+    private readonly options;
+    private handler;
+    private logger;
+    private listening;
+    private listenPromise;
+    private readonly messageListener;
+    private readonly namespace;
+    private logEventHandlerFailure;
+    /**
+     * Creates a Redis Pub/Sub transport using dedicated publish and subscribe clients.
+     *
+     * @param options Namespace and Redis client settings for the transport.
+     */
+    constructor(options: RedisPubSubMicroserviceTransportOptions);
+    setLogger(logger: MicroserviceTransportLogger): void;
+    /**
+     * Subscribes to the namespaced event channel and registers the runtime handler.
+     *
+     * @param handler Runtime callback invoked for inbound event packets.
+     * @returns A promise that resolves once the Redis subscription is active.
+     */
+    listen(handler: TransportHandler): Promise<void>;
+    /**
+     * Publishes one fire-and-forget event through Redis Pub/Sub.
+     *
+     * @param pattern Pattern identifying the remote event handler.
+     * @param payload Serializable payload to publish.
+     * @returns A promise that resolves once Redis accepts the publication.
+     */
+    emit(pattern: string, payload: unknown): Promise<void>;
+    /**
+     * Rejects request-response usage for the Pub/Sub transport.
+     *
+     * @param pattern Unused request pattern.
+     * @param payload Unused request payload.
+     * @param signal Unused abort signal.
+     * @returns Never resolves successfully.
+     * @throws {Error} Always, because Pub/Sub has no reply channel contract.
+     */
+    send(pattern: string, payload: unknown, signal?: AbortSignal): Promise<unknown>;
+    /**
+     * Unsubscribes from the event channel and detaches the Redis message listener.
+     *
+     * @returns A promise that resolves once shutdown cleanup completes.
+     */
+    close(): Promise<void>;
+    private handleIncoming;
+    private get eventChannel();
+}
+export {};
+//# sourceMappingURL=redis-transport.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"redis-transport.d.ts","sourceRoot":"","sources":["../../src/transports/redis-transport.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,2BAA2B,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AASxG,UAAU,SAAS;IACjB,GAAG,CAAC,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC;IACtF,EAAE,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC;IACpF,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC5D,SAAS,CAAC,GAAG,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACnD,WAAW,CAAC,GAAG,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACtD;AAED,wEAAwE;AACxE,MAAM,WAAW,uCAAuC;IACtD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,SAAS,CAAC;IACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,eAAe,EAAE,SAAS,CAAC;CAC5B;AAED;;;;;GAKG;AACH,qBAAa,gCAAiC,YAAW,qBAAqB;IAmBhE,OAAO,CAAC,QAAQ,CAAC,OAAO;IAlBpC,OAAO,CAAC,OAAO,CAA+B;IAC9C,OAAO,CAAC,MAAM,CAA0C;IACxD,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,aAAa,CAA4B;IACjD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAE9B;IACF,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IAEnC,OAAO,CAAC,sBAAsB;IAI9B;;;;OAIG;gBAC0B,OAAO,EAAE,uCAAuC;IAI7E,SAAS,CAAC,MAAM,EAAE,2BAA2B,GAAG,IAAI;IAIpD;;;;;OAKG;IACG,MAAM,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IA+BtD;;;;;;OAMG;IACG,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAU5D;;;;;;;;OAQG;IACG,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;IAOrF;;;;OAIG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YAwBd,cAAc;IA4B5B,OAAO,KAAK,YAAY,GAEvB;CACF"}