@horizon-republic/nestjs-jetstream 1.0.4

package/dist/server/jetstream-server.module.js

@@ -0,0 +1,375 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var JetstreamServerModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JetstreamServerModule = void 0;
+const common_1 = require("@nestjs/common");
+const connection_provider_1 = require("../common/connection.provider");
+const service_type_enum_1 = require("../common/enum/service-type.enum");
+const helpers_1 = require("../common/helpers");
+const pattern_registry_1 = require("../common/pattern-registry");
+const jetstream_strategy_1 = require("./jetstream.strategy");
+const jetstream_transport_1 = require("./jetstream.transport");
+const consumer_provider_1 = require("./providers/consumer.provider");
+const message_routing_provider_1 = require("./providers/message-routing.provider");
+const message_provider_1 = require("./providers/message.provider");
+const stream_provider_1 = require("./providers/stream.provider");
+/**
+ * Dynamic module for configuring NATS JetStream server transport in NestJS microservices.
+ *
+ * @description
+ * This module provides a complete NATS JetStream consumer implementation that enables
+ * NestJS applications to receive and process messages from JetStream streams. It handles
+ * the entire lifecycle of JetStream consumers, including connection management, stream
+ * creation, message consumption, and routing to appropriate handlers.
+ *
+ * @example
+ * ```typescript
+ * // Single service configuration
+ * @Module({
+ *   imports: [
+ *     JetstreamServerModule.forRoot({
+ *       servers: ['nats://localhost:4222'],
+ *       name: 'orders-service',
+ *     }),
+ *   ],
+ * })
+ * export class AppModule {}
+ *
+ * // Multiple services in one application
+ * @Module({
+ *   imports: [
+ *     JetstreamServerModule.forRoot({
+ *       servers: ['nats://localhost:4222'],
+ *       name: 'orders-service',
+ *     }),
+ *     JetstreamServerModule.forRoot({
+ *       servers: ['nats://localhost:4222'],
+ *       name: 'notifications-service',
+ *     }),
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ *
+ * @see {@link https://docs.nestjs.com/microservices/nats | NestJS NATS Microservices}
+ * @see {@link https://docs.nats.io/nats-concepts/jetstream | NATS JetStream Documentation}
+ */
+let JetstreamServerModule = JetstreamServerModule_1 = class JetstreamServerModule {
+    /**
+     * Configures the JetStream server module with the provided options.
+     *
+     * @description
+     * Creates a dynamic module with all necessary providers for JetStream message consumption.
+     * The module automatically:
+     * - Establishes a NATS connection
+     * - Creates or updates JetStream streams for events and commands
+     * - Creates durable consumers for reliable message delivery
+     * - Routes incoming messages to registered handlers
+     * - Handles reconnections and failures gracefully.
+     *
+     * Each provider is registered with a unique token based on the service name, ensuring
+     * that multiple server instances can coexist without conflicts.
+     *
+     * @param options Configuration options for the JetStream server (without serviceType).
+     * @returns A dynamic module configuration ready to be imported.
+     *
+     * @example
+     * ```typescript
+     * JetstreamServerModule.forRoot({
+     *   servers: ['nats://localhost:4222'],
+     *   name: 'orders-service',
+     * })
+     * ```
+     */
+    static forRoot(options) {
+        const providers = this.createProviders(options);
+        return {
+            module: JetstreamServerModule_1,
+            providers: [
+                {
+                    provide: (0, helpers_1.getJetStreamServerOptionsToken)(options.name),
+                    useValue: {
+                        ...options,
+                        name: `${options.name}__microservice`,
+                        serviceType: service_type_enum_1.ServiceType.Consumer,
+                    },
+                },
+                ...providers,
+            ],
+            exports: [(0, helpers_1.getJetStreamTransportToken)(options.name)],
+        };
+    }
+    /**
+     * Asynchronously configures the JetStream server module.
+     *
+     * @description
+     * Allows configuration to be loaded asynchronously, useful for scenarios where
+     * options need to be retrieved from configuration services, databases, or
+     * environment variables at runtime.
+     *
+     * Supports three configuration patterns:
+     * - **useFactory**: Most flexible, allows async operations and dependency injection
+     * - **useExisting**: References an existing provider in the module
+     * - **useClass**: Instantiates a class that provides the configuration.
+     *
+     * @param asyncOptions Async configuration options.
+     * @returns A dynamic module configuration with async providers.
+     *
+     * @example
+     * ```typescript
+     * // Using factory with ConfigService
+     * JetstreamServerModule.forRootAsync({
+     *   name: 'orders-service',
+     *   imports: [ConfigModule],
+     *   useFactory: (configService: ConfigService) => ({
+     *     servers: configService.get<string[]>('NATS_SERVERS'),
+     *     name: configService.get<string>('SERVICE_NAME'),
+     *   }),
+     *   inject: [ConfigService],
+     * })
+     *
+     * // Using existing provider
+     * const JETSTREAM_CONFIG = 'JETSTREAM_CONFIG';
+     *
+     * @Module({
+     *   providers: [{
+     *     provide: JETSTREAM_CONFIG,
+     *     useValue: { servers: ['nats://localhost:4222'], name: 'my-service' },
+     *   }],
+     *   exports: [JETSTREAM_CONFIG],
+     * })
+     * class ConfigModule {}
+     *
+     * JetstreamServerModule.forRootAsync({
+     *   name: 'orders-service',
+     *   imports: [ConfigModule],
+     *   useExisting: JETSTREAM_CONFIG,
+     * })
+     *
+     * // Using class
+     * @Injectable()
+     * class JetstreamConfig {
+     *   servers = ['nats://localhost:4222'];
+     *   name = 'my-service';
+     * }
+     *
+     * JetstreamServerModule.forRootAsync({
+     *   name: 'orders-service',
+     *   useClass: JetstreamConfig,
+     * })
+     * ```
+     */
+    static forRootAsync(asyncOptions) {
+        const asyncProviders = this.createAsyncProviders(asyncOptions);
+        const providers = this.createProviders({ name: asyncOptions.name });
+        return {
+            module: JetstreamServerModule_1,
+            imports: asyncOptions.imports ?? [],
+            providers: [...asyncProviders, ...providers],
+            exports: [(0, helpers_1.getJetStreamTransportToken)(asyncOptions.name)],
+        };
+    }
+    /**
+     * Creates async configuration providers based on the provided options.
+     *
+     * @description
+     * Generates the appropriate provider configuration for async module setup.
+     * Handles all three async patterns: useFactory, useExisting, and useClass.
+     *
+     * @param options Async configuration options.
+     * @returns Array of providers for async configuration.
+     */
+    static createAsyncProviders(options) {
+        if (options.useFactory) {
+            return [
+                {
+                    provide: (0, helpers_1.getJetStreamServerOptionsToken)(options.name),
+                    useFactory: (...args) => {
+                        const result = options.useFactory(...args);
+                        if (result instanceof Promise) {
+                            return result.then((config) => ({
+                                ...config,
+                                name: `${options.name}__microservice`,
+                                serviceType: service_type_enum_1.ServiceType.Consumer,
+                            }));
+                        }
+                        return {
+                            ...result,
+                            name: `${options.name}__microservice`,
+                            serviceType: service_type_enum_1.ServiceType.Consumer,
+                        };
+                    },
+                    inject: options.inject ?? [],
+                },
+            ];
+        }
+        if (options.useExisting) {
+            return [
+                {
+                    provide: (0, helpers_1.getJetStreamServerOptionsToken)(options.name),
+                    useFactory: (config) => ({
+                        ...config,
+                        name: `${options.name}__microservice`,
+                        serviceType: service_type_enum_1.ServiceType.Consumer,
+                    }),
+                    inject: [options.useExisting],
+                },
+            ];
+        }
+        return [
+            {
+                provide: options.useClass,
+                useClass: options.useClass,
+            },
+            {
+                provide: (0, helpers_1.getJetStreamServerOptionsToken)(options.name),
+                useFactory: (config) => ({
+                    ...config,
+                    name: `${options.name}__microservice`,
+                    serviceType: service_type_enum_1.ServiceType.Consumer,
+                }),
+                inject: [options.useClass],
+            },
+        ];
+    }
+    /**
+     * Creates all required providers for the JetStream server.
+     *
+     * @description
+     * Generates the complete provider tree for a JetStream server instance.
+     * This method is shared between forRoot and forRootAsync to ensure
+     * consistent provider configuration.
+     *
+     * @param options JetStream transport options (partial for async case).
+     * @returns Array of all required providers.
+     */
+    static createProviders(options) {
+        return [
+            // ============================================================
+            // Infrastructure Layer
+            // ============================================================
+            /**
+             * NATS connection provider.
+             * Manages the underlying NATS connection lifecycle, including
+             * connect/disconnect/reconnect events and graceful shutdown.
+             */
+            {
+                provide: helpers_1.getToken.connection(options.name),
+                inject: [(0, helpers_1.getJetStreamServerOptionsToken)(options.name)],
+                useFactory: (options) => new connection_provider_1.ConnectionProvider(options),
+            },
+            /**
+             * JetStream stream provider.
+             * Ensures that required JetStream streams exist and are properly
+             * configured for both event and command message types.
+             */
+            {
+                provide: helpers_1.getToken.stream(options.name),
+                inject: [(0, helpers_1.getJetStreamServerOptionsToken)(options.name), helpers_1.getToken.connection(options.name)],
+                useFactory: (options, connection) => {
+                    return new stream_provider_1.StreamProvider(options, connection);
+                },
+            },
+            // ============================================================
+            // Consumer Layer
+            // ============================================================
+            /**
+             * JetStream consumer provider.
+             * Creates and manages durable consumers for pulling messages
+             * from JetStream streams with acknowledgment support.
+             */
+            {
+                provide: helpers_1.getToken.consumer(options.name),
+                inject: [
+                    (0, helpers_1.getJetStreamServerOptionsToken)(options.name),
+                    helpers_1.getToken.connection(options.name),
+                    helpers_1.getToken.stream(options.name),
+                ],
+                useFactory: (options, connection, stream) => new consumer_provider_1.ConsumerProvider(options, connection, stream),
+            },
+            // ============================================================
+            // Message Layer
+            // ============================================================
+            /**
+             * Message provider.
+             * Handles low-level message consumption from JetStream consumers,
+             * including message acknowledgment and error handling.
+             */
+            {
+                provide: helpers_1.getToken.message(options.name),
+                inject: [helpers_1.getToken.connection(options.name), helpers_1.getToken.consumer(options.name)],
+                useFactory: (connection, consumer) => {
+                    return new message_provider_1.MessageProvider(connection, consumer);
+                },
+            },
+            // ============================================================
+            // Application Layer
+            // ============================================================
+            /**
+             * Pattern registry.
+             * Maps NATS subjects to NestJS message handlers registered via.
+             */
+            {
+                provide: helpers_1.getToken.patternRegistry(options.name),
+                inject: [(0, helpers_1.getJetStreamServerOptionsToken)(options.name), helpers_1.getToken.strategy(options.name)],
+                useFactory: (options, strategy) => {
+                    return new pattern_registry_1.PatternRegistry(options, strategy);
+                },
+            },
+            /**
+             * Message routing provider.
+             * Routes incoming messages to appropriate handlers based on
+             * subject patterns and handles response serialization.
+             */
+            {
+                provide: helpers_1.getToken.messageRouting(options.name),
+                inject: [
+                    helpers_1.getToken.connection(options.name),
+                    helpers_1.getToken.message(options.name),
+                    helpers_1.getToken.patternRegistry(options.name),
+                ],
+                useFactory: (connection, message, patternRegistry) => new message_routing_provider_1.MessageRoutingProvider(connection, message, patternRegistry),
+            },
+            // ============================================================
+            // Transport Layer
+            // ============================================================
+            /**
+             * JetStream transport strategy.
+             * Coordinates all providers to implement the NestJS CustomTransportStrategy
+             * interface and manage the complete message processing lifecycle.
+             */
+            {
+                provide: helpers_1.getToken.strategy(options.name),
+                inject: [
+                    helpers_1.getToken.connection(options.name),
+                    helpers_1.getToken.stream(options.name),
+                    helpers_1.getToken.consumer(options.name),
+                ],
+                useFactory: (connection, stream, consumer) => new jetstream_strategy_1.JetstreamStrategy(connection, stream, consumer),
+            },
+            /**
+             * JetStream transport wrapper.
+             * Main entry point that combines options and strategy into
+             * a CustomStrategy implementation for NestJS microservices.
+             */
+            {
+                provide: (0, helpers_1.getJetStreamTransportToken)(options.name),
+                inject: [(0, helpers_1.getJetStreamServerOptionsToken)(options.name), helpers_1.getToken.strategy(options.name)],
+                useFactory: (options, strategy) => {
+                    return new jetstream_transport_1.JetstreamTransport(options, strategy);
+                },
+            },
+        ];
+    }
+};
+exports.JetstreamServerModule = JetstreamServerModule;
+exports.JetstreamServerModule = JetstreamServerModule = JetstreamServerModule_1 = __decorate([
+    (0, common_1.Module)({})
+], JetstreamServerModule);
+//# sourceMappingURL=jetstream-server.module.js.map

package/dist/server/jetstream-server.module.js.map

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

package/dist/server/jetstream.strategy.d.ts

@@ -0,0 +1,150 @@
+import { OnModuleInit } from '@nestjs/common';
+import { CustomTransportStrategy, Server, TransportId } from '@nestjs/microservices';
+import { NatsConnection } from 'nats';
+import { ConnectionProvider } from '../common/connection.provider';
+import { ConsumerProvider } from './providers/consumer.provider';
+import { StreamProvider } from './providers/stream.provider';
+import { INatsEventsMap } from './types/nats.events-map';
+/**
+ * Custom transport strategy for NATS JetStream integration with NestJS microservices.
+ *
+ * @description
+ * This class implements a custom transport strategy that enables NestJS microservices
+ * to communicate via NATS JetStream. It handles the complete lifecycle of the transport,
+ * including connection management, stream creation, consumer setup, and automatic reconnection.
+ *
+ * The strategy extends the NestJS `Server` class and implements both `CustomTransportStrategy`
+ * and `OnModuleInit` interfaces to integrate seamlessly with the NestJS lifecycle.
+ *
+ * @remarks
+ * Key features:
+ * - Automatic reconnection handling on connection loss
+ * - Stream and consumer lifecycle management
+ * - Event-driven architecture using RxJS
+ * - Graceful shutdown support
+ * - Type-safe event handling via NATS events map
+ *
+ *
+ * @see {@link https://docs.nestjs.com/microservices/custom-transport | NestJS Custom Transport}
+ * @see {@link https://docs.nats.io/nats-concepts/jetstream | NATS JetStream Documentation}
+ */
+export declare class JetstreamStrategy extends Server<INatsEventsMap> implements CustomTransportStrategy, OnModuleInit {
+    private readonly connectionProvider;
+    private readonly streamProvider;
+    private readonly consumerProvider;
+    /**
+     * Unique identifier for this transport strategy.
+     *
+     * @description
+     * A symbol that uniquely identifies this transport within the NestJS microservices ecosystem.
+     * This ensures that the transport can be distinguished from other custom transports.
+     */
+    readonly transportId: TransportId;
+    /**
+     * Subject for managing component lifecycle and cleanup.
+     *
+     * @description
+     * Emits when the transport is being destroyed, signaling all active subscriptions
+     * to complete and clean up their resources.
+     */
+    private readonly destroy$;
+    /**
+     * Subject for triggering reconnection logic.
+     *
+     * @description
+     * Emits when the NATS connection is re-established, triggering the recreation
+     * of streams and consumers to resume normal operation.
+     */
+    private readonly reconnect$;
+    /**
+     * Creates an instance of JetstreamStrategy.
+     *
+     * @param connectionProvider Provider that manages the NATS connection lifecycle and status.
+     * @param streamProvider Provider responsible for creating and managing JetStream streams.
+     * @param consumerProvider Provider responsible for creating and managing JetStream consumers.
+     */
+    constructor(connectionProvider: ConnectionProvider, streamProvider: StreamProvider, consumerProvider: ConsumerProvider);
+    /**
+     * Lifecycle hook that runs after module initialization.
+     *
+     * @description
+     * Sets up automatic reconnection handling by listening to NATS reconnect events.
+     * When a reconnection occurs, it triggers the `reconnect$` subject to reinitialize
+     * streams and consumers.
+     *
+     * This ensures that the transport can automatically recover from connection failures
+     * without manual intervention.
+     */
+    onModuleInit(): void;
+    /**
+     * Starts listening for messages on the JetStream transport.
+     *
+     * @description
+     * Initializes the transport by:
+     * 1. Setting up a reactive pipeline that responds to reconnection events
+     * 2. Creating necessary JetStream streams via `StreamProvider`
+     * 3. Creating JetStream consumers via `ConsumerProvider`
+     * 4. Invoking the callback when setup is complete.
+     *
+     * The pipeline automatically handles reconnections by recreating streams and consumers
+     * when the `reconnect$` subject emits. The `startWith` operator ensures the pipeline
+     * runs immediately on first subscription.
+     *
+     * @param done Callback function invoked after successful initialization or reconnection.
+     */
+    listen(done: () => void): void;
+    /**
+     * Closes the transport and cleans up all resources.
+     *
+     * @description
+     * Performs graceful shutdown by:
+     * 1. Emitting to `destroy$` to complete all active subscriptions
+     * 2. Completing the destroy subject itself
+     * 3. Initiating graceful shutdown of the NATS connection.
+     *
+     * This ensures that all messages are processed and acknowledged before
+     * the connection is terminated.
+     */
+    close(): void;
+    /**
+     * Registers an event listener for NATS connection events.
+     *
+     * @description
+     * Sets up a type-safe event listener that subscribes to connection status changes
+     * from the `ConnectionProvider`. When an event matching the specified type occurs,
+     * the callback is invoked with the event data.
+     *
+     * The subscription is automatically cleaned up when the transport is destroyed.
+     *
+     * @template EventKey - Type of event key from the NATS events map.
+     * @param event The NATS event to listen for (e.g., `Events.Reconnect`, `Events.Disconnect`).
+     * @param callback Callback function invoked when the event occurs, receives event data as argument.
+     *
+     * @example
+     * ```typescript
+     * strategy.on(Events.Disconnect, () => {
+     *   console.log('Connection lost');
+     * });
+     * ```
+     */
+    on<EventKey extends keyof INatsEventsMap>(event: EventKey, callback: INatsEventsMap[EventKey]): void;
+    /**
+     * Retrieves the underlying NATS connection instance.
+     *
+     * @description
+     * Provides direct access to the raw NATS connection for advanced use cases
+     * where low-level NATS API access is required. This is useful for custom
+     * operations not covered by the transport abstraction.
+     *
+     * @template T - Type to cast the connection to, defaults to `NatsConnection`.
+     * @returns The unwrapped NATS connection instance.
+     *
+     * @example
+     * ```typescript
+     * const connection = strategy.unwrap<NatsConnection>();
+     * const jsm = await connection.jetstreamManager();
+     * ```
+     */
+    unwrap<T = NatsConnection>(): T;
+}
+//# sourceMappingURL=jetstream.strategy.d.ts.map

package/dist/server/jetstream.strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jetstream.strategy.d.ts","sourceRoot":"","sources":["../../src/server/jetstream.strategy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC1D,OAAO,EAAE,uBAAuB,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACrF,OAAO,EAAU,cAAc,EAAE,MAAM,MAAM,CAAC;AAG9C,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAEnE,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBACa,iBACX,SAAQ,MAAM,CAAC,cAAc,CAC7B,YAAW,uBAAuB,EAAE,YAAY;IAqC9C,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IACnC,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IArCnC;;;;;;OAMG;IACH,SAAyB,WAAW,EAAE,WAAW,CAAiC;IAElF;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAuB;IAEhD;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAuB;IAElD;;;;;;OAMG;gBAEgB,kBAAkB,EAAE,kBAAkB,EACtC,cAAc,EAAE,cAAc,EAC9B,gBAAgB,EAAE,gBAAgB;IAKrD;;;;;;;;;;OAUG;IACI,YAAY,IAAI,IAAI;IAM3B;;;;;;;;;;;;;;;OAeG;IACI,MAAM,CAAC,IAAI,EAAE,MAAM,IAAI,GAAG,IAAI;IAYrC;;;;;;;;;;;OAWG;IACI,KAAK,IAAI,IAAI;IAMpB;;;;;;;;;;;;;;;;;;;;OAoBG;IACI,EAAE,CAAC,QAAQ,SAAS,MAAM,cAAc,EAC7C,KAAK,EAAE,QAAQ,EACf,QAAQ,EAAE,cAAc,CAAC,QAAQ,CAAC,GACjC,IAAI;IAcP;;;;;;;;;;;;;;;;OAgBG;IACa,MAAM,CAAC,CAAC,GAAG,cAAc,KAAK,CAAC;CAGhD"}