@fluojs/microservices 1.0.0-beta.1

package/dist/transports/redis-transport.js

@@ -0,0 +1,152 @@
+import { logTransportEventHandlerFailure } from './event-handler-logger.js';
+
+/** Options for configuring the Redis Pub/Sub microservice transport. */
+
+/**
+ * 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 class RedisPubSubMicroserviceTransport {
+  handler;
+  logger;
+  listening = false;
+  listenPromise;
+  messageListener = (channel, message) => {
+    void this.handleIncoming(channel, message);
+  };
+  namespace;
+  logEventHandlerFailure(error) {
+    logTransportEventHandlerFailure(this.logger, 'RedisPubSubMicroserviceTransport', error);
+  }
+
+  /**
+   * Creates a Redis Pub/Sub transport using dedicated publish and subscribe clients.
+   *
+   * @param options Namespace and Redis client settings for the transport.
+   */
+  constructor(options) {
+    this.options = options;
+    this.namespace = options.namespace ?? 'fluo:microservices';
+  }
+  setLogger(logger) {
+    this.logger = logger;
+  }
+
+  /**
+   * 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.
+   */
+  async listen(handler) {
+    this.handler = handler;
+    if (this.listening) {
+      return;
+    }
+    if (this.listenPromise) {
+      await this.listenPromise;
+      return;
+    }
+    this.listenPromise = (async () => {
+      this.options.subscribeClient.on('message', this.messageListener);
+      try {
+        await this.options.subscribeClient.subscribe(this.eventChannel);
+        this.listening = true;
+      } catch (error) {
+        this.options.subscribeClient.off?.('message', this.messageListener);
+        throw error;
+      }
+    })();
+    try {
+      await this.listenPromise;
+    } finally {
+      this.listenPromise = undefined;
+    }
+  }
+
+  /**
+   * 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.
+   */
+  async emit(pattern, payload) {
+    const message = {
+      kind: 'event',
+      pattern,
+      payload
+    };
+    await this.options.publishClient.publish(this.eventChannel, JSON.stringify(message));
+  }
+
+  /**
+   * 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.
+   */
+  async send(pattern, payload, signal) {
+    void pattern;
+    void payload;
+    void signal;
+    throw new Error('RedisPubSubMicroserviceTransport does not support request/reply send(). Use emit() or a transport with durable request/reply semantics.');
+  }
+
+  /**
+   * Unsubscribes from the event channel and detaches the Redis message listener.
+   *
+   * @returns A promise that resolves once shutdown cleanup completes.
+   */
+  async close() {
+    let closeError;
+    if (this.listenPromise) {
+      await this.listenPromise;
+    }
+    try {
+      if (this.listening) {
+        await this.options.subscribeClient.unsubscribe(this.eventChannel);
+      }
+    } catch (error) {
+      closeError = error;
+    } finally {
+      this.options.subscribeClient.off?.('message', this.messageListener);
+      this.listening = false;
+      this.handler = undefined;
+    }
+    if (closeError) {
+      throw closeError;
+    }
+  }
+  async handleIncoming(channel, rawMessage) {
+    let message;
+    try {
+      message = JSON.parse(rawMessage);
+    } catch {
+      return;
+    }
+    if (!this.handler) {
+      return;
+    }
+    if (channel === this.eventChannel && message.kind === 'event') {
+      try {
+        await this.handler({
+          kind: 'event',
+          pattern: message.pattern,
+          payload: message.payload
+        });
+      } catch (error) {
+        this.logEventHandlerFailure(error);
+      }
+      return;
+    }
+  }
+  get eventChannel() {
+    return `${this.namespace}:events`;
+  }
+}

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

@@ -0,0 +1,66 @@
+import type { MicroserviceTransport, TransportHandler } from '../types.js';
+interface TcpMicroserviceTransportOptions {
+    host?: string;
+    maxFrameBytes?: number;
+    port: number;
+    requestTimeoutMs?: number;
+}
+/**
+ * Lightweight TCP transport for request-response messages and fire-and-forget events.
+ *
+ * This adapter uses newline-delimited JSON frames over raw sockets and is intended for
+ * simple first-party microservice setups where both sides can share the same framing contract.
+ */
+export declare class TcpMicroserviceTransport implements MicroserviceTransport {
+    private readonly options;
+    private handler;
+    private listenPromise;
+    private readonly sockets;
+    private readonly host;
+    private readonly maxFrameBytes;
+    private readonly requestTimeoutMs;
+    private readonly server;
+    /**
+     * Creates a TCP transport bound to one host/port pair.
+     *
+     * @param options TCP host, port, and request-timeout settings.
+     */
+    constructor(options: TcpMicroserviceTransportOptions);
+    /**
+     * Starts the TCP server and registers the runtime packet handler.
+     *
+     * @param handler Runtime callback invoked for inbound event and message packets.
+     * @returns A promise that resolves once the TCP server is listening.
+     */
+    listen(handler: TransportHandler): Promise<void>;
+    /**
+     * Emits one fire-and-forget event over the TCP transport.
+     *
+     * @param pattern Pattern identifying the remote event handler.
+     * @param payload Serializable payload sent to the remote runtime.
+     * @returns A promise that resolves after the event frame is written.
+     */
+    emit(pattern: string, payload: unknown): Promise<void>;
+    /**
+     * Sends one request-response message over the TCP transport.
+     *
+     * @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.
+     */
+    send(pattern: string, payload: unknown, signal?: AbortSignal): Promise<unknown>;
+    /**
+     * Closes the TCP server and destroys any active sockets.
+     *
+     * @returns A promise that resolves once the server is fully closed.
+     */
+    close(): Promise<void>;
+    private handleInboundPacket;
+    private sendWirePacket;
+    private bindSocketParser;
+    private writeLine;
+    private serializeFrame;
+}
+export {};
+//# sourceMappingURL=tcp-transport.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tcp-transport.d.ts","sourceRoot":"","sources":["../../src/transports/tcp-transport.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,gBAAgB,EAAmB,MAAM,aAAa,CAAC;AAQ5F,UAAU,+BAA+B;IACvC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAID;;;;;GAKG;AACH,qBAAa,wBAAyB,YAAW,qBAAqB;IAkBxD,OAAO,CAAC,QAAQ,CAAC,OAAO;IAjBpC,OAAO,CAAC,OAAO,CAA+B;IAC9C,OAAO,CAAC,aAAa,CAA4B;IACjD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;IAC7C,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;IAC9B,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;IAC1C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAIpB;IAEH;;;;OAIG;gBAC0B,OAAO,EAAE,+BAA+B;IAMrE;;;;;OAKG;IACG,MAAM,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IA2BtD;;;;;;OAMG;IACG,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAI5D;;;;;;;OAOG;IACG,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;IAKrF;;;;OAIG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YA2Bd,mBAAmB;YA8BnB,cAAc;IAmG5B,OAAO,CAAC,gBAAgB;IAyCxB,OAAO,CAAC,SAAS;IAIjB,OAAO,CAAC,cAAc;CASvB"}

package/dist/transports/tcp-transport.js

@@ -0,0 +1,283 @@
+import { createServer, Socket } from 'node:net';
+const DEFAULT_MAX_FRAME_BYTES = 1_048_576;
+
+/**
+ * Lightweight TCP transport for request-response messages and fire-and-forget events.
+ *
+ * This adapter uses newline-delimited JSON frames over raw sockets and is intended for
+ * simple first-party microservice setups where both sides can share the same framing contract.
+ */
+export class TcpMicroserviceTransport {
+  handler;
+  listenPromise;
+  sockets = new Set();
+  host;
+  maxFrameBytes;
+  requestTimeoutMs;
+  server = createServer(socket => {
+    this.sockets.add(socket);
+    this.bindSocketParser(socket, async packet => this.handleInboundPacket(socket, packet));
+    socket.once('close', () => this.sockets.delete(socket));
+  });
+
+  /**
+   * Creates a TCP transport bound to one host/port pair.
+   *
+   * @param options TCP host, port, and request-timeout settings.
+   */
+  constructor(options) {
+    this.options = options;
+    this.host = options.host ?? '127.0.0.1';
+    this.maxFrameBytes = options.maxFrameBytes ?? DEFAULT_MAX_FRAME_BYTES;
+    this.requestTimeoutMs = options.requestTimeoutMs ?? 3_000;
+  }
+
+  /**
+   * Starts the TCP server and registers the runtime packet handler.
+   *
+   * @param handler Runtime callback invoked for inbound event and message packets.
+   * @returns A promise that resolves once the TCP server is listening.
+   */
+  async listen(handler) {
+    this.handler = handler;
+    if (this.server.listening) {
+      return;
+    }
+    if (this.listenPromise) {
+      await this.listenPromise;
+      return;
+    }
+    this.listenPromise = new Promise((resolve, reject) => {
+      this.server.once('error', reject);
+      this.server.listen(this.options.port, this.host, () => {
+        this.server.off('error', reject);
+        resolve();
+      });
+    });
+    try {
+      await this.listenPromise;
+    } finally {
+      this.listenPromise = undefined;
+    }
+  }
+
+  /**
+   * Emits one fire-and-forget event over the TCP transport.
+   *
+   * @param pattern Pattern identifying the remote event handler.
+   * @param payload Serializable payload sent to the remote runtime.
+   * @returns A promise that resolves after the event frame is written.
+   */
+  async emit(pattern, payload) {
+    await this.sendWirePacket({
+      kind: 'event',
+      pattern,
+      payload
+    });
+  }
+
+  /**
+   * Sends one request-response message over the TCP transport.
+   *
+   * @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) {
+    const requestId = randomRequestId();
+    return await this.sendWirePacket({
+      kind: 'message',
+      pattern,
+      payload,
+      requestId
+    }, signal);
+  }
+
+  /**
+   * Closes the TCP server and destroys any active sockets.
+   *
+   * @returns A promise that resolves once the server is fully closed.
+   */
+  async close() {
+    if (this.listenPromise) {
+      await this.listenPromise;
+    }
+    for (const socket of this.sockets) {
+      socket.destroy();
+    }
+    this.sockets.clear();
+    if (!this.server.listening) {
+      return;
+    }
+    await new Promise((resolve, reject) => {
+      this.server.close(error => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve();
+      });
+    });
+  }
+  async handleInboundPacket(socket, packet) {
+    if (!this.handler) {
+      return;
+    }
+    if (packet.kind === 'event') {
+      await this.handler(packet);
+      return;
+    }
+    const requestId = packet.requestId;
+    if (!requestId) {
+      return;
+    }
+    try {
+      const payload = await this.handler(packet);
+      this.writeLine(socket, this.serializeFrame({
+        payload,
+        requestId
+      }));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unhandled microservice error';
+      try {
+        this.writeLine(socket, this.serializeFrame({
+          error: message,
+          requestId
+        }));
+      } catch {
+        socket.destroy();
+      }
+    }
+  }
+  async sendWirePacket(packet, signal) {
+    const serializedPacket = this.serializeFrame(packet);
+    return await new Promise((resolve, reject) => {
+      const socket = new Socket();
+      let settled = false;
+      let timeoutId;
+      let onAbort;
+      const cleanup = () => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        if (signal && onAbort) {
+          signal.removeEventListener('abort', onAbort);
+        }
+        socket.removeAllListeners();
+      };
+      const settle = callback => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        cleanup();
+        callback();
+      };
+      const fail = error => {
+        settle(() => {
+          socket.destroy();
+          reject(error);
+        });
+      };
+      if (signal) {
+        if (signal.aborted) {
+          fail(new Error('Microservice send aborted before dispatch.'));
+          return;
+        }
+        onAbort = () => {
+          fail(new Error('Microservice send aborted.'));
+        };
+        signal.addEventListener('abort', onAbort, {
+          once: true
+        });
+      }
+      timeoutId = setTimeout(() => {
+        fail(new Error(`Microservice TCP request timed out after ${String(this.requestTimeoutMs)}ms.`));
+      }, this.requestTimeoutMs);
+      if (packet.kind === 'event') {
+        socket.once('connect', () => {
+          try {
+            this.writeLine(socket, serializedPacket);
+            settle(() => {
+              socket.end();
+              resolve(undefined);
+            });
+          } catch (error) {
+            fail(error);
+          }
+        });
+      } else {
+        this.bindSocketParser(socket, value => {
+          const response = value;
+          if (response.requestId !== packet.requestId) {
+            return;
+          }
+          if (response.error) {
+            fail(new Error(response.error));
+            return;
+          }
+          settle(() => {
+            socket.end();
+            resolve(response.payload);
+          });
+        });
+        socket.once('connect', () => {
+          try {
+            this.writeLine(socket, serializedPacket);
+          } catch (error) {
+            fail(error);
+          }
+        });
+      }
+      socket.once('error', fail);
+      socket.connect(this.options.port, this.host);
+    });
+  }
+  bindSocketParser(socket, onPacket) {
+    let buffer = '';
+    let bufferBytes = 0;
+    socket.on('data', chunk => {
+      const chunkString = typeof chunk === 'string' ? chunk : chunk.toString('utf8');
+      buffer += chunkString;
+      bufferBytes += Buffer.byteLength(chunkString, 'utf8');
+      if (bufferBytes > this.maxFrameBytes) {
+        socket.destroy();
+        return;
+      }
+      let newLineIndex = buffer.indexOf('\n');
+      while (newLineIndex >= 0) {
+        const rawLine = buffer.slice(0, newLineIndex);
+        const line = rawLine.trim();
+        buffer = buffer.slice(newLineIndex + 1);
+        bufferBytes = Buffer.byteLength(buffer, 'utf8');
+        if (Buffer.byteLength(rawLine, 'utf8') > this.maxFrameBytes) {
+          socket.destroy();
+          return;
+        }
+        if (line.length > 0) {
+          try {
+            void Promise.resolve(onPacket(JSON.parse(line))).catch(() => undefined);
+          } catch {
+            socket.destroy();
+            return;
+          }
+        }
+        newLineIndex = buffer.indexOf('\n');
+      }
+    });
+  }
+  writeLine(socket, line) {
+    socket.write(`${line}\n`);
+  }
+  serializeFrame(value) {
+    const line = JSON.stringify(value);
+    if (Buffer.byteLength(line, 'utf8') > this.maxFrameBytes) {
+      throw new Error(`Microservice TCP frame exceeded ${String(this.maxFrameBytes)} bytes.`);
+    }
+    return line;
+  }
+}
+function randomRequestId() {
+  return crypto.randomUUID();
+}

package/dist/types.d.ts

@@ -0,0 +1,105 @@
+import type { MetadataPropertyKey, Token } from '@fluojs/core';
+import type { Provider, Scope } from '@fluojs/di';
+import type { ApplicationLogger } from '@fluojs/runtime';
+/** Pattern matcher used to route messages and events to handler methods. */
+export type Pattern = RegExp | string;
+/** Supported microservice handler kinds discovered from decorators. */
+export type HandlerKind = 'bidi-stream' | 'client-stream' | 'event' | 'message' | 'server-stream';
+/** Metadata stored by one pattern decorator on a handler method. */
+export interface HandlerMetadata {
+    kind: HandlerKind;
+    pattern: Pattern;
+}
+/** Runtime descriptor for one discovered microservice handler method. */
+export interface HandlerDescriptor {
+    kind: HandlerKind;
+    methodKey: MetadataPropertyKey;
+    methodName: string;
+    moduleName: string;
+    pattern: Pattern;
+    scope: Scope;
+    targetName: string;
+    token: Token;
+}
+/** Transport payload delivered to the runtime dispatch layer. */
+export interface TransportPacket {
+    kind: HandlerKind;
+    pattern: string;
+    payload: unknown;
+    requestId?: string;
+}
+/** Async entrypoint used by transports to hand packets to the runtime. */
+export type TransportHandler = (packet: TransportPacket) => Promise<unknown>;
+/** Narrow logger seam transports use for non-fatal handler failure reporting. */
+export interface MicroserviceTransportLogger extends Pick<ApplicationLogger, 'error'> {
+}
+/** Writer contract used for server-side and bidirectional streaming responses. */
+export interface ServerStreamWriter {
+    write(data: unknown): void;
+    end(): void;
+    error(err: Error): void;
+}
+/** Handler signature for server-streaming routes. */
+export type ServerStreamHandler = (payload: unknown, writer: ServerStreamWriter) => void | Promise<void>;
+/** Transport callback signature for server-streaming listeners. */
+export type TransportServerStreamHandler = (pattern: string, payload: unknown, writer: ServerStreamWriter) => void | Promise<void>;
+/** Handler signature for client-streaming routes. */
+export type ClientStreamHandler = (reader: AsyncIterable<unknown>) => Promise<unknown>;
+/** Transport callback signature for client-streaming listeners. */
+export type TransportClientStreamHandler = (pattern: string, reader: AsyncIterable<unknown>) => Promise<unknown>;
+/** Handler signature for bidirectional streaming routes. */
+export type BidiStreamHandler = (reader: AsyncIterable<unknown>, writer: ServerStreamWriter) => void | Promise<void>;
+/** Transport callback signature for bidirectional streaming listeners. */
+export type TransportBidiStreamHandler = (pattern: string, reader: AsyncIterable<unknown>, writer: ServerStreamWriter) => void | Promise<void>;
+/** Transport adapter contract implemented by TCP, Redis, Kafka, gRPC, and other protocols. */
+export interface MicroserviceTransport {
+    bidiStream?(pattern: string, signal?: AbortSignal): {
+        reader: AsyncIterable<unknown>;
+        writer: ServerStreamWriter;
+    };
+    clientStream?(pattern: string, signal?: AbortSignal): {
+        writer: ServerStreamWriter;
+        result: Promise<unknown>;
+    };
+    close(): Promise<void>;
+    emit(pattern: string, payload: unknown): Promise<void>;
+    listen(handler: TransportHandler): Promise<void>;
+    listenBidiStreaming?(handler: TransportBidiStreamHandler): void;
+    listenClientStreaming?(handler: TransportClientStreamHandler): void;
+    listenServerStreaming?(handler: TransportServerStreamHandler): void;
+    setLogger?(logger: MicroserviceTransportLogger): void;
+    send(pattern: string, payload: unknown, signal?: AbortSignal): Promise<unknown>;
+    serverStream?(pattern: string, payload: unknown, signal?: AbortSignal): AsyncIterable<unknown>;
+}
+/** Optional module-definition overrides for callers that want module-first custom registration. */
+export interface MicroserviceModuleRegistrationOptions {
+    /** Extra tokens exported in addition to `MicroserviceLifecycleService` and `MICROSERVICE`. */
+    additionalExports?: Token[];
+    /** Whether the configured microservice module should register globally. Defaults to `true`. */
+    global?: boolean;
+    /** Additional providers appended after the built-in microservice runtime wiring. */
+    providers?: Provider[];
+}
+/** Module options accepted by {@link MicroservicesModule.forRoot}. */
+export interface MicroserviceModuleOptions {
+    /** Optional module-definition overrides that provide a module-first alternative to raw provider-array composition. */
+    module?: MicroserviceModuleRegistrationOptions;
+    transport: MicroserviceTransport;
+}
+/** Programmatic microservice facade exposed through DI and compatibility tokens. */
+export interface Microservice {
+    bidiStream?(pattern: string, signal?: AbortSignal): {
+        reader: AsyncIterable<unknown>;
+        writer: ServerStreamWriter;
+    };
+    clientStream?(pattern: string, signal?: AbortSignal): {
+        writer: ServerStreamWriter;
+        result: Promise<unknown>;
+    };
+    close(signal?: string): Promise<void>;
+    emit(pattern: string, payload: unknown): Promise<void>;
+    listen(): Promise<void>;
+    send(pattern: string, payload: unknown, signal?: AbortSignal): Promise<unknown>;
+    serverStream?(pattern: string, payload: unknown, signal?: AbortSignal): AsyncIterable<unknown>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

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

package/dist/types.js

@@ -0,0 +1 @@
+export {};