@xnestjs/rabbitmq 1.5.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Panates
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,71 @@
+# @xnestjs/rabbitmq
+
+NestJS extension library for RabbitMQ
+
+## Install
+
+```sh
+npm install @xnestjs/rabbitmq
+# or using yarn
+yarn add @xnestjs/rabbitmq
+```
+
+## Usage
+
+### Register sync
+
+An example of nestjs module that import the @xnestjs/rabbitmq
+
+```ts
+// module.ts
+import { Module } from '@nestjs/common';
+import { RabbitmqModule } from '@xnestjs/rabbitmq';
+
+@Module({
+    imports: [
+        RabbitmqModule.forRoot({
+            useValue: {
+                urls: ['amqp://localhost:5672'],
+            },
+        }),
+    ],
+})
+export class MyModule {
+}
+```
+
+### Register async
+
+An example of nestjs module that import the @xnestjs/rabbitmq async
+
+```ts
+// module.ts
+import { Module } from '@nestjs/common';
+import { RabbitmqModule } from '@xnestjs/rabbitmq';
+
+@Module({
+    imports: [
+        RabbitmqModule.forRootAsync({
+            inject: [ConfigModule],
+            useFactory: (config: ConfigService) => ({
+                urls: config.get('RMQ_URLS'),
+            }),
+        }),
+    ]
+})
+export class MyModule {
+}
+```
+
+## Environment Variables
+
+The library supports configuration through environment variables. Environment variables below is accepted.
+All environment variables starts with prefix (RMQ_). This can be configured while registering the module.
+
+| Environment Variable        | Type      | Default | Description |
+|-----------------------------|-----------|---------|-------------|
+| RMQ_URLS                    | String[]! |         |             |
+| RMQ_PREFETCH_COUNT          | Number    |         |             |
+| RMQ_MAX_CONNECTION_ATTEMPTS | Number    |         |             |
+| RMQ_RECONNECT_TIME          | Number    |         |             |
+| RMQ_HEARTBEAT_INTERVAL      | Number    |         |             |

package/cjs/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RMQ_MODULE_ID = exports.RMQ_CONNECTION_OPTIONS = void 0;
+exports.RMQ_CONNECTION_OPTIONS = Symbol('RMQ_CONNECTION_OPTIONS');
+exports.RMQ_MODULE_ID = Symbol('RMQ_MODULE_ID');

package/cjs/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientRMQ = void 0;
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./constants.js"), exports);
+tslib_1.__exportStar(require("./rabbitmq.module.js"), exports);
+tslib_1.__exportStar(require("./types.js"), exports);
+var microservices_1 = require("@nestjs/microservices");
+Object.defineProperty(exports, "ClientRMQ", { enumerable: true, get: function () { return microservices_1.ClientRMQ; } });

package/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/cjs/rabbitmq-core.module.js

@@ -0,0 +1,144 @@
+"use strict";
+var RabbitmqCoreModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RabbitmqCoreModule = void 0;
+const tslib_1 = require("tslib");
+const node_assert_1 = tslib_1.__importDefault(require("node:assert"));
+const crypto = tslib_1.__importStar(require("node:crypto"));
+const node_process_1 = tslib_1.__importDefault(require("node:process"));
+const objects_1 = require("@jsopen/objects");
+const common_1 = require("@nestjs/common");
+const microservices_1 = require("@nestjs/microservices");
+const colors = tslib_1.__importStar(require("ansi-colors"));
+const putil_varhelpers_1 = require("putil-varhelpers");
+const constants_js_1 = require("./constants.js");
+const CLIENT_TOKEN = Symbol('CLIENT_TOKEN');
+let RabbitmqCoreModule = RabbitmqCoreModule_1 = class RabbitmqCoreModule {
+    /**
+     *
+     */
+    static forRoot(moduleOptions) {
+        const connectionOptions = this._readConnectionOptions(moduleOptions.useValue || {}, moduleOptions.envPrefix);
+        return this._createDynamicModule(moduleOptions, {
+            global: moduleOptions.global,
+            providers: [
+                {
+                    provide: constants_js_1.RMQ_CONNECTION_OPTIONS,
+                    useValue: connectionOptions,
+                },
+            ],
+        });
+    }
+    /**
+     *
+     */
+    static forRootAsync(asyncOptions) {
+        node_assert_1.default.ok(asyncOptions.useFactory, 'useFactory is required');
+        return this._createDynamicModule(asyncOptions, {
+            global: asyncOptions.global,
+            providers: [
+                {
+                    provide: constants_js_1.RMQ_CONNECTION_OPTIONS,
+                    inject: asyncOptions.inject,
+                    useFactory: async (...args) => {
+                        const opts = await asyncOptions.useFactory(...args);
+                        return this._readConnectionOptions(opts, asyncOptions.envPrefix);
+                    },
+                },
+            ],
+        });
+    }
+    static _createDynamicModule(opts, metadata) {
+        const token = opts.token ?? microservices_1.ClientRMQ;
+        const name = typeof token === 'string' ? token : 'RabbitMQ';
+        const logger = typeof opts.logger === 'string' ? new common_1.Logger(opts.logger) : opts.logger;
+        const exports = [constants_js_1.RMQ_CONNECTION_OPTIONS, ...(metadata.exports ?? [])];
+        const providers = [
+            ...(metadata.providers ?? []),
+            {
+                provide: common_1.Logger,
+                useValue: logger,
+            },
+            {
+                provide: CLIENT_TOKEN,
+                useExisting: token,
+            },
+            {
+                provide: constants_js_1.RMQ_MODULE_ID,
+                useValue: crypto.randomUUID(),
+            },
+        ];
+        if (name !== token) {
+            exports.push(token);
+            providers.push({
+                provide: token,
+                useExisting: name,
+            });
+        }
+        return {
+            module: RabbitmqCoreModule_1,
+            providers,
+            imports: [
+                /** Import ClientsModule */
+                microservices_1.ClientsModule.registerAsync({
+                    clients: [
+                        {
+                            name,
+                            extraProviders: metadata.providers,
+                            inject: [constants_js_1.RMQ_CONNECTION_OPTIONS],
+                            useFactory: (connectionOptions) => {
+                                return {
+                                    transport: microservices_1.Transport.RMQ,
+                                    options: connectionOptions,
+                                };
+                            },
+                        },
+                    ],
+                }),
+            ],
+            exports,
+        };
+    }
+    static _readConnectionOptions(moduleOptions, prefix = 'RMQ_') {
+        const options = (0, objects_1.clone)(moduleOptions);
+        const env = node_process_1.default.env;
+        options.urls = options.urls || (env[prefix + 'URLS'] ?? 'amqp://localhost:5672').split(/\s*,\s*/);
+        options.prefetchCount = options.prefetchCount ?? (0, putil_varhelpers_1.toInt)(env[prefix + 'PREFETCH_COUNT']);
+        options.maxConnectionAttempts = options.maxConnectionAttempts ?? (0, putil_varhelpers_1.toInt)(env[prefix + 'MAX_CONNECTION_ATTEMPTS']);
+        options.socketOptions = options.socketOptions ?? {};
+        options.socketOptions.reconnectTimeInSeconds =
+            options.socketOptions.reconnectTimeInSeconds ?? (0, putil_varhelpers_1.toInt)(env[prefix + 'RECONNECT_TIME']);
+        options.socketOptions.heartbeatIntervalInSeconds =
+            options.socketOptions.heartbeatIntervalInSeconds ?? (0, putil_varhelpers_1.toInt)(env[prefix + 'HEARTBEAT_INTERVAL']);
+        return options;
+    }
+    /**
+     *
+     * @constructor
+     */
+    constructor(client, connectionOptions, logger) {
+        this.client = client;
+        this.connectionOptions = connectionOptions;
+        this.logger = logger;
+    }
+    async onApplicationBootstrap() {
+        const options = this.connectionOptions;
+        if (!options.lazyConnect && options.urls?.length) {
+            this.logger?.log('Connecting to RabbitMQ at ' + colors.blue(options.urls.join(',')));
+            common_1.Logger.flush();
+            await this.client.connect().catch(e => {
+                this.logger?.error('RabbitMQ connection failed: ' + e.message);
+                throw e;
+            });
+        }
+    }
+    onApplicationShutdown() {
+        return this.client.close();
+    }
+};
+exports.RabbitmqCoreModule = RabbitmqCoreModule;
+exports.RabbitmqCoreModule = RabbitmqCoreModule = RabbitmqCoreModule_1 = tslib_1.__decorate([
+    tslib_1.__param(0, (0, common_1.Inject)(CLIENT_TOKEN)),
+    tslib_1.__param(1, (0, common_1.Inject)(constants_js_1.RMQ_CONNECTION_OPTIONS)),
+    tslib_1.__metadata("design:paramtypes", [microservices_1.ClientRMQ, Object, common_1.Logger])
+], RabbitmqCoreModule);

package/cjs/rabbitmq.module.js

@@ -0,0 +1,25 @@
+"use strict";
+var RabbitmqModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RabbitmqModule = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const rabbitmq_core_module_js_1 = require("./rabbitmq-core.module.js");
+let RabbitmqModule = RabbitmqModule_1 = class RabbitmqModule {
+    static forRoot(options) {
+        return {
+            module: RabbitmqModule_1,
+            imports: [rabbitmq_core_module_js_1.RabbitmqCoreModule.forRoot(options)],
+        };
+    }
+    static forRootAsync(options) {
+        return {
+            module: RabbitmqModule_1,
+            imports: [rabbitmq_core_module_js_1.RabbitmqCoreModule.forRootAsync(options)],
+        };
+    }
+};
+exports.RabbitmqModule = RabbitmqModule;
+exports.RabbitmqModule = RabbitmqModule = RabbitmqModule_1 = tslib_1.__decorate([
+    (0, common_1.Module)({})
+], RabbitmqModule);

package/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/esm/constants.js

@@ -0,0 +1,2 @@
+export const RMQ_CONNECTION_OPTIONS = Symbol('RMQ_CONNECTION_OPTIONS');
+export const RMQ_MODULE_ID = Symbol('RMQ_MODULE_ID');

package/esm/index.js

@@ -0,0 +1,4 @@
+export * from './constants.js';
+export * from './rabbitmq.module.js';
+export * from './types.js';
+export { ClientRMQ } from '@nestjs/microservices';

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/rabbitmq-core.module.js

@@ -0,0 +1,141 @@
+var RabbitmqCoreModule_1;
+import { __decorate, __metadata, __param } from "tslib";
+import assert from 'node:assert';
+import * as crypto from 'node:crypto';
+import process from 'node:process';
+import { clone } from '@jsopen/objects';
+import { Inject, Logger } from '@nestjs/common';
+import { ClientRMQ, ClientsModule, Transport } from '@nestjs/microservices';
+import * as colors from 'ansi-colors';
+import { toInt } from 'putil-varhelpers';
+import { RMQ_CONNECTION_OPTIONS, RMQ_MODULE_ID } from './constants.js';
+const CLIENT_TOKEN = Symbol('CLIENT_TOKEN');
+let RabbitmqCoreModule = RabbitmqCoreModule_1 = class RabbitmqCoreModule {
+    /**
+     *
+     */
+    static forRoot(moduleOptions) {
+        const connectionOptions = this._readConnectionOptions(moduleOptions.useValue || {}, moduleOptions.envPrefix);
+        return this._createDynamicModule(moduleOptions, {
+            global: moduleOptions.global,
+            providers: [
+                {
+                    provide: RMQ_CONNECTION_OPTIONS,
+                    useValue: connectionOptions,
+                },
+            ],
+        });
+    }
+    /**
+     *
+     */
+    static forRootAsync(asyncOptions) {
+        assert.ok(asyncOptions.useFactory, 'useFactory is required');
+        return this._createDynamicModule(asyncOptions, {
+            global: asyncOptions.global,
+            providers: [
+                {
+                    provide: RMQ_CONNECTION_OPTIONS,
+                    inject: asyncOptions.inject,
+                    useFactory: async (...args) => {
+                        const opts = await asyncOptions.useFactory(...args);
+                        return this._readConnectionOptions(opts, asyncOptions.envPrefix);
+                    },
+                },
+            ],
+        });
+    }
+    static _createDynamicModule(opts, metadata) {
+        const token = opts.token ?? ClientRMQ;
+        const name = typeof token === 'string' ? token : 'RabbitMQ';
+        const logger = typeof opts.logger === 'string' ? new Logger(opts.logger) : opts.logger;
+        const exports = [RMQ_CONNECTION_OPTIONS, ...(metadata.exports ?? [])];
+        const providers = [
+            ...(metadata.providers ?? []),
+            {
+                provide: Logger,
+                useValue: logger,
+            },
+            {
+                provide: CLIENT_TOKEN,
+                useExisting: token,
+            },
+            {
+                provide: RMQ_MODULE_ID,
+                useValue: crypto.randomUUID(),
+            },
+        ];
+        if (name !== token) {
+            exports.push(token);
+            providers.push({
+                provide: token,
+                useExisting: name,
+            });
+        }
+        return {
+            module: RabbitmqCoreModule_1,
+            providers,
+            imports: [
+                /** Import ClientsModule */
+                ClientsModule.registerAsync({
+                    clients: [
+                        {
+                            name,
+                            extraProviders: metadata.providers,
+                            inject: [RMQ_CONNECTION_OPTIONS],
+                            useFactory: (connectionOptions) => {
+                                return {
+                                    transport: Transport.RMQ,
+                                    options: connectionOptions,
+                                };
+                            },
+                        },
+                    ],
+                }),
+            ],
+            exports,
+        };
+    }
+    static _readConnectionOptions(moduleOptions, prefix = 'RMQ_') {
+        const options = clone(moduleOptions);
+        const env = process.env;
+        options.urls = options.urls || (env[prefix + 'URLS'] ?? 'amqp://localhost:5672').split(/\s*,\s*/);
+        options.prefetchCount = options.prefetchCount ?? toInt(env[prefix + 'PREFETCH_COUNT']);
+        options.maxConnectionAttempts = options.maxConnectionAttempts ?? toInt(env[prefix + 'MAX_CONNECTION_ATTEMPTS']);
+        options.socketOptions = options.socketOptions ?? {};
+        options.socketOptions.reconnectTimeInSeconds =
+            options.socketOptions.reconnectTimeInSeconds ?? toInt(env[prefix + 'RECONNECT_TIME']);
+        options.socketOptions.heartbeatIntervalInSeconds =
+            options.socketOptions.heartbeatIntervalInSeconds ?? toInt(env[prefix + 'HEARTBEAT_INTERVAL']);
+        return options;
+    }
+    /**
+     *
+     * @constructor
+     */
+    constructor(client, connectionOptions, logger) {
+        this.client = client;
+        this.connectionOptions = connectionOptions;
+        this.logger = logger;
+    }
+    async onApplicationBootstrap() {
+        const options = this.connectionOptions;
+        if (!options.lazyConnect && options.urls?.length) {
+            this.logger?.log('Connecting to RabbitMQ at ' + colors.blue(options.urls.join(',')));
+            Logger.flush();
+            await this.client.connect().catch(e => {
+                this.logger?.error('RabbitMQ connection failed: ' + e.message);
+                throw e;
+            });
+        }
+    }
+    onApplicationShutdown() {
+        return this.client.close();
+    }
+};
+RabbitmqCoreModule = RabbitmqCoreModule_1 = __decorate([
+    __param(0, Inject(CLIENT_TOKEN)),
+    __param(1, Inject(RMQ_CONNECTION_OPTIONS)),
+    __metadata("design:paramtypes", [ClientRMQ, Object, Logger])
+], RabbitmqCoreModule);
+export { RabbitmqCoreModule };

package/esm/rabbitmq.module.js

@@ -0,0 +1,22 @@
+var RabbitmqModule_1;
+import { __decorate } from "tslib";
+import { Module } from '@nestjs/common';
+import { RabbitmqCoreModule } from './rabbitmq-core.module.js';
+let RabbitmqModule = RabbitmqModule_1 = class RabbitmqModule {
+    static forRoot(options) {
+        return {
+            module: RabbitmqModule_1,
+            imports: [RabbitmqCoreModule.forRoot(options)],
+        };
+    }
+    static forRootAsync(options) {
+        return {
+            module: RabbitmqModule_1,
+            imports: [RabbitmqCoreModule.forRootAsync(options)],
+        };
+    }
+};
+RabbitmqModule = RabbitmqModule_1 = __decorate([
+    Module({})
+], RabbitmqModule);
+export { RabbitmqModule };

package/esm/types.js

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

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@xnestjs/rabbitmq",
+  "version": "1.5.1",
+  "description": "NestJS extension library for RabbitMQ",
+  "author": "Panates",
+  "license": "MIT",
+  "dependencies": {
+    "@jsopen/objects": "^1.5.2",
+    "ansi-colors": "^4.1.3",
+    "putil-varhelpers": "^1.6.5",
+    "tslib": "^2.8.1"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^10.0.0 || ^11.0.0",
+    "@nestjs/core": "^10.0.0 || ^11.0.0",
+    "@nestjs/microservices": "^10.0.0 || ^11.0.0",
+    "amqp-connection-manager": "*",
+    "amqplib": "*"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./types/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "require": {
+        "types": "./types/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "default": "./esm/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./cjs/index.js",
+  "module": "./esm/index.js",
+  "types": "./types/index.d.ts",
+  "repository": {
+    "registry": "https://github.com/panates/xnestjs.git",
+    "directory": "packages/rabitmq"
+  },
+  "engines": {
+    "node": ">=16.0",
+    "npm": ">=7.0.0"
+  },
+  "files": [
+    "cjs/",
+    "esm/",
+    "types/",
+    "LICENSE",
+    "README.md"
+  ],
+  "keywords": [
+    "nestjs",
+    "rabitmq"
+  ]
+}

package/types/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const RMQ_CONNECTION_OPTIONS: unique symbol;
+export declare const RMQ_MODULE_ID: unique symbol;

package/types/index.d.cts

@@ -0,0 +1,4 @@
+export * from './constants.js';
+export * from './rabbitmq.module.js';
+export * from './types.js';
+export { ClientRMQ } from '@nestjs/microservices';

package/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from './constants.js';
+export * from './rabbitmq.module.js';
+export * from './types.js';
+export { ClientRMQ } from '@nestjs/microservices';

package/types/rabbitmq-core.module.d.ts

@@ -0,0 +1,25 @@
+import { DynamicModule, Logger, OnApplicationBootstrap, OnApplicationShutdown } from '@nestjs/common';
+import { ClientRMQ } from '@nestjs/microservices';
+import type { RabbitmqConnectionOptions, RabbitmqModuleAsyncOptions, RabbitmqModuleOptions } from './types.js';
+export declare class RabbitmqCoreModule implements OnApplicationShutdown, OnApplicationBootstrap {
+    protected client: ClientRMQ;
+    private connectionOptions;
+    private logger?;
+    /**
+     *
+     */
+    static forRoot(moduleOptions: RabbitmqModuleOptions): DynamicModule;
+    /**
+     *
+     */
+    static forRootAsync(asyncOptions: RabbitmqModuleAsyncOptions): DynamicModule;
+    private static _createDynamicModule;
+    private static _readConnectionOptions;
+    /**
+     *
+     * @constructor
+     */
+    constructor(client: ClientRMQ, connectionOptions: RabbitmqConnectionOptions, logger?: Logger | undefined);
+    onApplicationBootstrap(): Promise<void>;
+    onApplicationShutdown(): void;
+}

package/types/rabbitmq.module.d.ts

@@ -0,0 +1,6 @@
+import { type DynamicModule } from '@nestjs/common';
+import type { RabbitmqModuleAsyncOptions, RabbitmqModuleOptions } from './types.js';
+export declare class RabbitmqModule {
+    static forRoot(options: RabbitmqModuleOptions): DynamicModule;
+    static forRootAsync(options: RabbitmqModuleAsyncOptions): DynamicModule;
+}

package/types/types.d.ts

@@ -0,0 +1,22 @@
+import type { Logger } from '@nestjs/common';
+import type { ModuleMetadata } from '@nestjs/common/interfaces';
+import type { InjectionToken } from '@nestjs/common/interfaces/modules/injection-token.interface';
+import type { RmqOptions } from '@nestjs/microservices';
+type ExtractRmqOptions = Required<RmqOptions>['options'];
+export interface RabbitmqConnectionOptions extends ExtractRmqOptions {
+    lazyConnect?: boolean;
+}
+export interface RabbitmqModuleOptions extends BaseModuleOptions {
+    useValue?: Partial<RabbitmqConnectionOptions>;
+}
+export interface RabbitmqModuleAsyncOptions extends BaseModuleOptions, Pick<ModuleMetadata, 'imports'> {
+    inject?: any[];
+    useFactory: (...args: any[]) => Promise<Partial<RabbitmqConnectionOptions>> | Partial<RabbitmqConnectionOptions>;
+}
+interface BaseModuleOptions {
+    token?: InjectionToken;
+    envPrefix?: string;
+    logger?: Logger | string;
+    global?: boolean;
+}
+export {};