@xnestjs/kafka 1.2.6 → 1.5.0

package/README.md

@@ -1,3 +1,102 @@
 # @xnestjs/kafka
 
-NestJS extension library for kafka
+NestJS extension library for Apache Kafka
+
+## Install
+
+```sh
+npm install @xnestjs/kafka
+# or using yarn
+yarn add @xnestjs/kafka
+```
+
+## Usage
+
+### Register sync
+
+An example of nestjs module that import the @xnestjs/kafka
+
+```ts
+// module.ts
+import { Module } from '@nestjs/common';
+import { KafkaModule } from '@xnestjs/kafka';
+
+@Module({
+    imports: [
+        KafkaModule.forRoot({
+            useValue: {
+                brokers: ['localhost'],
+            },
+        }),
+    ],
+})
+export class MyModule {
+}
+```
+
+### Register async
+
+An example of nestjs module that import the @xnestjs/kafka async
+
+```ts
+// module.ts
+import { Module } from '@nestjs/common';
+import { KafkaModule } from '@xnestjs/kafka';
+
+@Module({
+    imports: [
+        KafkaModule.forRootAsync({
+            inject: [ConfigModule],
+            useFactory: (config: ConfigService) => ({
+                brokers: config.get('KAFKA_BROKERS'),
+            }),
+        }),
+    ]
+})
+export class MyModule {
+}
+```
+
+## Environment Variables
+
+The library supports configuration through environment variables. Environment variables below is accepted.
+All environment variables starts with prefix (KAFKA_). This can be configured while registering the module.
+
+| Environment Variable          | Type      | Default             | Description                                                                                                                                                                                            |
+|-------------------------------|-----------|---------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| KAFKA_URL                     | String[]! |                     |                                                                                                                                                                                                        |
+| KAFKA_CONSUMER_GROUP_ID       | String    | kafka_default_group |                                                                                                                                                                                                        |
+| KAFKA_CLIENT_ID               | String    |                     |                                                                                                                                                                                                        |
+| KAFKA_SASL                    | Enum      |                     | Defines the SASL Mechanism. Accepted values are (`plain`, `scram-sha-256`, `scram-sha-512`, `aws`)                                                                                                     |
+| KAFKA_SSL                     | Boolean   | False               | Enabled the SSL connection                                                                                                                                                                             |
+| KAFKA_SSL_CA_CERT             | String    |                     | Optionally override the trusted CA certificates. Default is to trust the well-known CAs curated by Mozilla. Mozilla's CAs are completely replaced when CAs are explicitly specified using this option. |
+| KAFKA_SSL_CERT_FILE           | String    |                     | The File that contains Cert chains in PEM format.                                                                                                                                                      |
+| KAFKA_SSL_KEY_FILE            | String    |                     | The File that contains private keys in PEM format.                                                                                                                                                     |
+| KAFKA_SSL_KEY_PASSPHRASE      | String    |                     | PFX or PKCS12 encoded private key and certificate chain.                                                                                                                                               |
+| KAFKA_SSL_REJECT_UNAUTHORIZED | Boolean   |                     | If true the server will reject any connection which is notauthorized with the list of supplied CAs. This option only has an effect if requestCert is true.                                             |
+| KAFKA_CONNECT_TIMEOUT         | Number    |                     |                                                                                                                                                                                                        |
+| KAFKA_AUTH_TIMEOUT            | Number    |                     |                                                                                                                                                                                                        |
+| KAFKA_REAUTH_THRESHOLD        | Number    |                     |                                                                                                                                                                                                        |
+| KAFKA_REQUEST_TIMEOUT         | Number    |                     |                                                                                                                                                                                                        |
+| KAFKA_ENFORCE_REQUEST_TIMEOUT | Number    |                     |                                                                                                                                                                                                        |
+| KAFKA_RETRIES                 | Number    |                     |                                                                                                                                                                                                        |
+| KAFKA_RETRY_MAX_TIME          | Number    |                     |                                                                                                                                                                                                        |
+| KAFKA_RETRY_INITIAL_TIME      | Number    |                     |                                                                                                                                                                                                        |
+
+### SASL Environment Variables
+
+The environment variables are available when KAFKA_SASL is one of `plain`, `scram-sha-256` or `scram-sha-512`
+
+| Environment Variable | Type    | Default | Description |
+|----------------------|---------|---------|-------------|
+| KAFKA_SASL_USERNAME  | String! |         | Username    |
+| KAFKA_SASL_PASSWORD  | String! |         | Password    |
+
+The environment variables are available when KAFKA_SASL is `aws`
+
+| Environment Variable  | Type    | Default | Description |
+|-----------------------|---------|---------|-------------|
+| AWS_AUTH_IDENTITY     | String! |         |             |
+| AWS_ACCESS_KEY_ID     | String! |         |             |
+| AWS_SECRET_ACCESS_KEY | String! |         |             |
+| AWS_SESSION_TOKEN     | String  |         |             |

package/cjs/constants.js

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

package/cjs/{utils/create-log-creator.js → create-log-creator.js}

@@ -4,6 +4,8 @@ exports.createLogCreator = createLogCreator;
 const kafkajs_1 = require("kafkajs");
 function createLogCreator(logger) {
     return ({ namespace, level, log }) => {
+        if (!logger)
+            return;
         const { message, ...extra } = log;
         switch (level) {
             case kafkajs_1.logLevel.ERROR:

package/cjs/index.js

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

package/cjs/kafka-core.module.js

@@ -3,107 +3,192 @@ var KafkaCoreModule_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KafkaCoreModule = 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 crypto = tslib_1.__importStar(require("crypto"));
-const kafkajs_1 = require("kafkajs");
+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 create_log_creator_js_1 = require("./utils/create-log-creator.js");
+const create_log_creator_js_1 = require("./create-log-creator.js");
+const CLIENT_TOKEN = Symbol('CLIENT_TOKEN');
 let KafkaCoreModule = KafkaCoreModule_1 = class KafkaCoreModule {
-    static forRoot(options) {
-        const logger = options.logger || new common_1.Logger();
-        const loggerProvider = {
-            provide: common_1.Logger,
-            useValue: logger,
-        };
-        const optionsProvider = {
-            provide: constants_js_1.KAFKA_MODULE_OPTIONS,
-            useValue: options,
-        };
-        const kafkaProvider = {
-            provide: options.id || kafkajs_1.Kafka,
-            useFactory: () => this.createKafka({ ...options, logger }),
-        };
-        return {
-            module: KafkaCoreModule_1,
-            providers: [loggerProvider, kafkaProvider, optionsProvider],
-            exports: [kafkaProvider],
-        };
-    }
-    static forRootAsync(asyncOptions) {
-        const loggerProvider = {
-            provide: common_1.Logger,
-            inject: [constants_js_1.KAFKA_MODULE_OPTIONS],
-            useFactory: (options) => options.logger || new common_1.Logger(),
-        };
-        const kafkaProvider = {
-            provide: asyncOptions.id || kafkajs_1.Kafka,
-            inject: [constants_js_1.KAFKA_MODULE_OPTIONS, common_1.Logger],
-            useFactory: async (options, logger) => this.createKafka({ ...options, logger }),
-        };
-        const asyncProviders = this.createAsyncProviders(asyncOptions);
-        return {
-            module: KafkaCoreModule_1,
-            imports: asyncOptions.imports,
+    /**
+     *
+     */
+    static forRoot(moduleOptions) {
+        const connectionOptions = this._readConnectionOptions(moduleOptions.useValue || {}, moduleOptions.envPrefix);
+        return this._createDynamicModule(moduleOptions, {
+            global: moduleOptions.global,
             providers: [
-                ...asyncProviders,
-                loggerProvider,
-                kafkaProvider,
                 {
-                    provide: constants_js_1.KAFKA_MODULE_ID,
-                    useValue: crypto.randomUUID(),
+                    provide: constants_js_1.KAFKA_CONNECTION_OPTIONS,
+                    useValue: connectionOptions,
                 },
             ],
-            exports: [kafkaProvider],
-        };
+        });
     }
-    static createAsyncProviders(asyncOptions) {
-        if (asyncOptions.useExisting || asyncOptions.useFactory)
-            return [this.createAsyncOptionsProvider(asyncOptions)];
-        if (asyncOptions.useClass) {
-            return [
-                this.createAsyncOptionsProvider(asyncOptions),
+    /**
+     *
+     */
+    static forRootAsync(asyncOptions) {
+        node_assert_1.default.ok(asyncOptions.useFactory, 'useFactory is required');
+        return this._createDynamicModule(asyncOptions, {
+            global: asyncOptions.global,
+            providers: [
                 {
-                    provide: asyncOptions.useClass,
-                    useClass: asyncOptions.useClass,
+                    provide: constants_js_1.KAFKA_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.ClientKafka;
+        const name = typeof token === 'string' ? token : 'Kafka';
+        const logger = typeof opts.logger === 'string' ? new common_1.Logger(opts.logger) : opts.logger;
+        const exports = [constants_js_1.KAFKA_CONNECTION_OPTIONS, ...(metadata.exports ?? [])];
+        const providers = [
+            ...(metadata.providers ?? []),
+            {
+                provide: common_1.Logger,
+                useValue: logger,
+            },
+            {
+                provide: CLIENT_TOKEN,
+                useExisting: token,
+            },
+            {
+                provide: constants_js_1.KAFKA_MODULE_ID,
+                useValue: crypto.randomUUID(),
+            },
+        ];
+        if (name !== token) {
+            exports.push(token);
+            providers.push({
+                provide: token,
+                useExisting: name,
+            });
         }
-        throw new Error('Invalid configuration. Must provide useFactory, useClass or useExisting');
+        return {
+            module: KafkaCoreModule_1,
+            providers,
+            imports: [
+                /** Import ClientsModule */
+                microservices_1.ClientsModule.registerAsync({
+                    clients: [
+                        {
+                            name,
+                            extraProviders: metadata.providers,
+                            inject: [constants_js_1.KAFKA_CONNECTION_OPTIONS],
+                            useFactory: (connectionOptions) => {
+                                return {
+                                    transport: microservices_1.Transport.KAFKA,
+                                    options: {
+                                        client: {
+                                            ...connectionOptions,
+                                            logCreator: () => (0, create_log_creator_js_1.createLogCreator)(logger),
+                                        },
+                                        consumer: connectionOptions.consumer,
+                                    },
+                                };
+                            },
+                        },
+                    ],
+                }),
+            ],
+            exports,
+        };
     }
-    static createAsyncOptionsProvider(asyncOptions) {
-        if (asyncOptions.useFactory) {
-            return {
-                provide: constants_js_1.KAFKA_MODULE_OPTIONS,
-                useFactory: asyncOptions.useFactory,
-                inject: asyncOptions.inject || [],
+    static _readConnectionOptions(moduleOptions, prefix = 'KAFKA_') {
+        const options = (0, objects_1.clone)(moduleOptions);
+        const env = node_process_1.default.env;
+        options.brokers = options.brokers || (env[prefix + 'URL'] ?? 'localhost').split(/\s*,\s*/);
+        if (options.ssl == null && (0, putil_varhelpers_1.toBoolean)(env[prefix + 'SSL'])) {
+            options.ssl = {
+                ca: [env[prefix + 'SSL_CA_CERT'] || ''],
+                cert: env[prefix + 'SSL_CERT_FILE'],
+                key: env[prefix + 'SSL_KEY_FILE'],
+                passphrase: env[prefix + 'SSL_KEY_PASSPHRASE'],
+                rejectUnauthorized: (0, putil_varhelpers_1.toBoolean)(env[prefix + 'SSL_REJECT_UNAUTHORIZED']),
+                checkServerIdentity: (host, cert) => {
+                    if (cert.subject.CN !== host) {
+                        return new Error(`Certificate CN (${cert.subject.CN}) does not match host (${host})`);
+                    }
+                },
             };
         }
-        const useClass = asyncOptions.useClass || asyncOptions.useExisting;
-        if (useClass) {
-            return {
-                provide: constants_js_1.KAFKA_MODULE_OPTIONS,
-                useFactory: (optionsFactory) => optionsFactory.createOptions(),
-                inject: [useClass],
+        const sasl = env[prefix + 'SASL'];
+        if (options.sasl == null && sasl) {
+            if (sasl === 'plain' || sasl === 'scram-sha-256' || sasl === 'scram-sha-512') {
+                options.sasl = {
+                    mechanism: sasl,
+                    username: env[prefix + 'SASL_USERNAME'] || '',
+                    password: env[prefix + 'SASL_PASSWORD'] || '',
+                };
+            }
+            else if (sasl === 'aws') {
+                options.sasl = {
+                    mechanism: sasl,
+                    authorizationIdentity: env[prefix + 'AWS_AUTH_IDENTITY'] || '',
+                    accessKeyId: env[prefix + 'AWS_ACCESS_KEY_ID'] || '',
+                    secretAccessKey: env[prefix + 'AWS_SECRET_ACCESS_KEY'] || '',
+                    sessionToken: env[prefix + 'AWS_SESSION_TOKEN'],
+                };
+            }
+        }
+        options.clientId = options.clientId ?? env[prefix + 'CLIENT_ID'];
+        options.connectionTimeout = options.connectionTimeout ?? (0, putil_varhelpers_1.toInt)(env[prefix + 'CONNECT_TIMEOUT']);
+        options.authenticationTimeout = options.authenticationTimeout ?? (0, putil_varhelpers_1.toInt)(env[prefix + 'AUTH_TIMEOUT']);
+        options.reauthenticationThreshold = options.reauthenticationThreshold ?? (0, putil_varhelpers_1.toInt)(env[prefix + 'REAUTH_THRESHOLD']);
+        options.requestTimeout = options.requestTimeout ?? (0, putil_varhelpers_1.toInt)(env[prefix + 'REQUEST_TIMEOUT']);
+        options.enforceRequestTimeout = options.enforceRequestTimeout ?? (0, putil_varhelpers_1.toBoolean)(env[prefix + 'ENFORCE_REQUEST_TIMEOUT']);
+        const retries = (0, putil_varhelpers_1.toInt)(env[prefix + 'RETRIES']);
+        if (options.retry == null && retries) {
+            options.retry = {
+                maxRetryTime: (0, putil_varhelpers_1.toInt)(env[prefix + 'RETRY_MAX_TIME']),
+                initialRetryTime: (0, putil_varhelpers_1.toInt)(env[prefix + 'RETRY_INITIAL_TIME']),
+                retries,
             };
         }
-        throw new Error('Invalid configuration. Must provide useFactory, useClass or useExisting');
+        options.consumer = options.consumer || {};
+        options.consumer.groupId =
+            options.consumer.groupId ?? (env[prefix + 'CONSUMER_GROUP_ID'] || 'kafka_default_group');
+        return options;
     }
-    static async createKafka(options) {
-        const logger = typeof options.logger === 'string'
-            ? new common_1.Logger(options.logger)
-            : typeof options.logger === 'object'
-                ? options.logger
-                : new common_1.Logger();
-        return new kafkajs_1.Kafka({
-            ...options,
-            // @ts-ignore
-            id: undefined,
-            logCreator: () => (0, create_log_creator_js_1.createLogCreator)(logger),
-        });
+    /**
+     *
+     * @constructor
+     */
+    constructor(client, connectionOptions, logger) {
+        this.client = client;
+        this.connectionOptions = connectionOptions;
+        this.logger = logger;
+    }
+    async onApplicationBootstrap() {
+        const options = this.connectionOptions;
+        if (!options.lazyConnect) {
+            this.logger?.log('Connecting to Kafka brokers' + (Array.isArray(options.brokers) ? colors.blue(options.brokers.join(',')) : ''));
+            common_1.Logger.flush();
+            await this.client.connect().catch(e => {
+                this.logger?.error('Kafka connection failed: ' + e.message);
+                throw e;
+            });
+        }
+    }
+    onApplicationShutdown() {
+        return this.client.close();
     }
 };
 exports.KafkaCoreModule = KafkaCoreModule;
 exports.KafkaCoreModule = KafkaCoreModule = KafkaCoreModule_1 = tslib_1.__decorate([
-    (0, common_1.Global)(),
-    (0, common_1.Module)({})
+    tslib_1.__param(0, (0, common_1.Inject)(CLIENT_TOKEN)),
+    tslib_1.__param(1, (0, common_1.Inject)(constants_js_1.KAFKA_CONNECTION_OPTIONS)),
+    tslib_1.__metadata("design:paramtypes", [microservices_1.ClientKafka, Object, common_1.Logger])
 ], KafkaCoreModule);

package/esm/constants.js

@@ -1,2 +1,2 @@
-export const KAFKA_MODULE_OPTIONS = Symbol('KAFKA_MODULE_OPTIONS');
+export const KAFKA_CONNECTION_OPTIONS = Symbol('KAFKA_CONNECTION_OPTIONS');
 export const KAFKA_MODULE_ID = Symbol('KAFKA_MODULE_ID');

package/esm/{utils/create-log-creator.js → create-log-creator.js}

@@ -1,6 +1,8 @@
 import { logLevel } from 'kafkajs';
 export function createLogCreator(logger) {
     return ({ namespace, level, log }) => {
+        if (!logger)
+            return;
         const { message, ...extra } = log;
         switch (level) {
             case logLevel.ERROR:

package/esm/index.js

@@ -1,4 +1,4 @@
 export * from './constants.js';
-export * from './interfaces/module-options.interface.js';
 export * from './kafka.module.js';
-export * from 'kafkajs';
+export * from './types.js';
+export { ClientKafka } from '@nestjs/microservices';

package/esm/kafka-core.module.js

@@ -1,106 +1,191 @@
 var KafkaCoreModule_1;
-import { __decorate } from "tslib";
-import { Global, Logger, Module } from '@nestjs/common';
-import * as crypto from 'crypto';
-import { Kafka } from 'kafkajs';
-import { KAFKA_MODULE_ID, KAFKA_MODULE_OPTIONS } from './constants.js';
-import { createLogCreator } from './utils/create-log-creator.js';
+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 { ClientKafka, ClientsModule, Transport } from '@nestjs/microservices';
+import * as colors from 'ansi-colors';
+import { toBoolean, toInt } from 'putil-varhelpers';
+import { KAFKA_CONNECTION_OPTIONS, KAFKA_MODULE_ID } from './constants.js';
+import { createLogCreator } from './create-log-creator.js';
+const CLIENT_TOKEN = Symbol('CLIENT_TOKEN');
 let KafkaCoreModule = KafkaCoreModule_1 = class KafkaCoreModule {
-    static forRoot(options) {
-        const logger = options.logger || new Logger();
-        const loggerProvider = {
-            provide: Logger,
-            useValue: logger,
-        };
-        const optionsProvider = {
-            provide: KAFKA_MODULE_OPTIONS,
-            useValue: options,
-        };
-        const kafkaProvider = {
-            provide: options.id || Kafka,
-            useFactory: () => this.createKafka({ ...options, logger }),
-        };
-        return {
-            module: KafkaCoreModule_1,
-            providers: [loggerProvider, kafkaProvider, optionsProvider],
-            exports: [kafkaProvider],
-        };
-    }
-    static forRootAsync(asyncOptions) {
-        const loggerProvider = {
-            provide: Logger,
-            inject: [KAFKA_MODULE_OPTIONS],
-            useFactory: (options) => options.logger || new Logger(),
-        };
-        const kafkaProvider = {
-            provide: asyncOptions.id || Kafka,
-            inject: [KAFKA_MODULE_OPTIONS, Logger],
-            useFactory: async (options, logger) => this.createKafka({ ...options, logger }),
-        };
-        const asyncProviders = this.createAsyncProviders(asyncOptions);
-        return {
-            module: KafkaCoreModule_1,
-            imports: asyncOptions.imports,
+    /**
+     *
+     */
+    static forRoot(moduleOptions) {
+        const connectionOptions = this._readConnectionOptions(moduleOptions.useValue || {}, moduleOptions.envPrefix);
+        return this._createDynamicModule(moduleOptions, {
+            global: moduleOptions.global,
             providers: [
-                ...asyncProviders,
-                loggerProvider,
-                kafkaProvider,
                 {
-                    provide: KAFKA_MODULE_ID,
-                    useValue: crypto.randomUUID(),
+                    provide: KAFKA_CONNECTION_OPTIONS,
+                    useValue: connectionOptions,
                 },
             ],
-            exports: [kafkaProvider],
-        };
+        });
     }
-    static createAsyncProviders(asyncOptions) {
-        if (asyncOptions.useExisting || asyncOptions.useFactory)
-            return [this.createAsyncOptionsProvider(asyncOptions)];
-        if (asyncOptions.useClass) {
-            return [
-                this.createAsyncOptionsProvider(asyncOptions),
+    /**
+     *
+     */
+    static forRootAsync(asyncOptions) {
+        assert.ok(asyncOptions.useFactory, 'useFactory is required');
+        return this._createDynamicModule(asyncOptions, {
+            global: asyncOptions.global,
+            providers: [
                 {
-                    provide: asyncOptions.useClass,
-                    useClass: asyncOptions.useClass,
+                    provide: KAFKA_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 ?? ClientKafka;
+        const name = typeof token === 'string' ? token : 'Kafka';
+        const logger = typeof opts.logger === 'string' ? new Logger(opts.logger) : opts.logger;
+        const exports = [KAFKA_CONNECTION_OPTIONS, ...(metadata.exports ?? [])];
+        const providers = [
+            ...(metadata.providers ?? []),
+            {
+                provide: Logger,
+                useValue: logger,
+            },
+            {
+                provide: CLIENT_TOKEN,
+                useExisting: token,
+            },
+            {
+                provide: KAFKA_MODULE_ID,
+                useValue: crypto.randomUUID(),
+            },
+        ];
+        if (name !== token) {
+            exports.push(token);
+            providers.push({
+                provide: token,
+                useExisting: name,
+            });
         }
-        throw new Error('Invalid configuration. Must provide useFactory, useClass or useExisting');
+        return {
+            module: KafkaCoreModule_1,
+            providers,
+            imports: [
+                /** Import ClientsModule */
+                ClientsModule.registerAsync({
+                    clients: [
+                        {
+                            name,
+                            extraProviders: metadata.providers,
+                            inject: [KAFKA_CONNECTION_OPTIONS],
+                            useFactory: (connectionOptions) => {
+                                return {
+                                    transport: Transport.KAFKA,
+                                    options: {
+                                        client: {
+                                            ...connectionOptions,
+                                            logCreator: () => createLogCreator(logger),
+                                        },
+                                        consumer: connectionOptions.consumer,
+                                    },
+                                };
+                            },
+                        },
+                    ],
+                }),
+            ],
+            exports,
+        };
     }
-    static createAsyncOptionsProvider(asyncOptions) {
-        if (asyncOptions.useFactory) {
-            return {
-                provide: KAFKA_MODULE_OPTIONS,
-                useFactory: asyncOptions.useFactory,
-                inject: asyncOptions.inject || [],
+    static _readConnectionOptions(moduleOptions, prefix = 'KAFKA_') {
+        const options = clone(moduleOptions);
+        const env = process.env;
+        options.brokers = options.brokers || (env[prefix + 'URL'] ?? 'localhost').split(/\s*,\s*/);
+        if (options.ssl == null && toBoolean(env[prefix + 'SSL'])) {
+            options.ssl = {
+                ca: [env[prefix + 'SSL_CA_CERT'] || ''],
+                cert: env[prefix + 'SSL_CERT_FILE'],
+                key: env[prefix + 'SSL_KEY_FILE'],
+                passphrase: env[prefix + 'SSL_KEY_PASSPHRASE'],
+                rejectUnauthorized: toBoolean(env[prefix + 'SSL_REJECT_UNAUTHORIZED']),
+                checkServerIdentity: (host, cert) => {
+                    if (cert.subject.CN !== host) {
+                        return new Error(`Certificate CN (${cert.subject.CN}) does not match host (${host})`);
+                    }
+                },
             };
         }
-        const useClass = asyncOptions.useClass || asyncOptions.useExisting;
-        if (useClass) {
-            return {
-                provide: KAFKA_MODULE_OPTIONS,
-                useFactory: (optionsFactory) => optionsFactory.createOptions(),
-                inject: [useClass],
+        const sasl = env[prefix + 'SASL'];
+        if (options.sasl == null && sasl) {
+            if (sasl === 'plain' || sasl === 'scram-sha-256' || sasl === 'scram-sha-512') {
+                options.sasl = {
+                    mechanism: sasl,
+                    username: env[prefix + 'SASL_USERNAME'] || '',
+                    password: env[prefix + 'SASL_PASSWORD'] || '',
+                };
+            }
+            else if (sasl === 'aws') {
+                options.sasl = {
+                    mechanism: sasl,
+                    authorizationIdentity: env[prefix + 'AWS_AUTH_IDENTITY'] || '',
+                    accessKeyId: env[prefix + 'AWS_ACCESS_KEY_ID'] || '',
+                    secretAccessKey: env[prefix + 'AWS_SECRET_ACCESS_KEY'] || '',
+                    sessionToken: env[prefix + 'AWS_SESSION_TOKEN'],
+                };
+            }
+        }
+        options.clientId = options.clientId ?? env[prefix + 'CLIENT_ID'];
+        options.connectionTimeout = options.connectionTimeout ?? toInt(env[prefix + 'CONNECT_TIMEOUT']);
+        options.authenticationTimeout = options.authenticationTimeout ?? toInt(env[prefix + 'AUTH_TIMEOUT']);
+        options.reauthenticationThreshold = options.reauthenticationThreshold ?? toInt(env[prefix + 'REAUTH_THRESHOLD']);
+        options.requestTimeout = options.requestTimeout ?? toInt(env[prefix + 'REQUEST_TIMEOUT']);
+        options.enforceRequestTimeout = options.enforceRequestTimeout ?? toBoolean(env[prefix + 'ENFORCE_REQUEST_TIMEOUT']);
+        const retries = toInt(env[prefix + 'RETRIES']);
+        if (options.retry == null && retries) {
+            options.retry = {
+                maxRetryTime: toInt(env[prefix + 'RETRY_MAX_TIME']),
+                initialRetryTime: toInt(env[prefix + 'RETRY_INITIAL_TIME']),
+                retries,
             };
         }
-        throw new Error('Invalid configuration. Must provide useFactory, useClass or useExisting');
+        options.consumer = options.consumer || {};
+        options.consumer.groupId =
+            options.consumer.groupId ?? (env[prefix + 'CONSUMER_GROUP_ID'] || 'kafka_default_group');
+        return options;
     }
-    static async createKafka(options) {
-        const logger = typeof options.logger === 'string'
-            ? new Logger(options.logger)
-            : typeof options.logger === 'object'
-                ? options.logger
-                : new Logger();
-        return new Kafka({
-            ...options,
-            // @ts-ignore
-            id: undefined,
-            logCreator: () => createLogCreator(logger),
-        });
+    /**
+     *
+     * @constructor
+     */
+    constructor(client, connectionOptions, logger) {
+        this.client = client;
+        this.connectionOptions = connectionOptions;
+        this.logger = logger;
+    }
+    async onApplicationBootstrap() {
+        const options = this.connectionOptions;
+        if (!options.lazyConnect) {
+            this.logger?.log('Connecting to Kafka brokers' + (Array.isArray(options.brokers) ? colors.blue(options.brokers.join(',')) : ''));
+            Logger.flush();
+            await this.client.connect().catch(e => {
+                this.logger?.error('Kafka connection failed: ' + e.message);
+                throw e;
+            });
+        }
+    }
+    onApplicationShutdown() {
+        return this.client.close();
     }
 };
 KafkaCoreModule = KafkaCoreModule_1 = __decorate([
-    Global(),
-    Module({})
+    __param(0, Inject(CLIENT_TOKEN)),
+    __param(1, Inject(KAFKA_CONNECTION_OPTIONS)),
+    __metadata("design:paramtypes", [ClientKafka, Object, Logger])
 ], KafkaCoreModule);
 export { KafkaCoreModule };

package/package.json

@@ -1,15 +1,19 @@
 {
   "name": "@xnestjs/kafka",
-  "version": "1.2.6",
+  "version": "1.5.0",
   "description": "NestJS extension library for Kafka",
   "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",
     "kafkajs": "^2.0.0"
   },
   "type": "module",

package/types/constants.d.ts

@@ -1,2 +1,2 @@
-export declare const KAFKA_MODULE_OPTIONS: unique symbol;
+export declare const KAFKA_CONNECTION_OPTIONS: unique symbol;
 export declare const KAFKA_MODULE_ID: unique symbol;

package/types/{utils/create-log-creator.d.ts → create-log-creator.d.ts}

@@ -1,5 +1,5 @@
 import { Logger } from '@nestjs/common';
-export declare function createLogCreator(logger: Logger): ({ namespace, level, log }: {
+export declare function createLogCreator(logger?: Logger): ({ namespace, level, log }: {
     namespace: any;
     level: any;
     log: any;

package/types/index.d.cts

@@ -1,4 +1,4 @@
 export * from './constants.js';
-export * from './interfaces/module-options.interface.js';
 export * from './kafka.module.js';
-export * from 'kafkajs';
+export * from './types.js';
+export { ClientKafka } from '@nestjs/microservices';

package/types/index.d.ts

@@ -1,4 +1,4 @@
 export * from './constants.js';
-export * from './interfaces/module-options.interface.js';
 export * from './kafka.module.js';
-export * from 'kafkajs';
+export * from './types.js';
+export { ClientKafka } from '@nestjs/microservices';

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

@@ -1,9 +1,25 @@
-import { DynamicModule } from '@nestjs/common';
-import { KafkaModuleAsyncOptions, KafkaModuleOptions } from './interfaces/module-options.interface.js';
-export declare class KafkaCoreModule {
-    static forRoot(options: KafkaModuleOptions): DynamicModule;
+import { DynamicModule, Logger, OnApplicationBootstrap, OnApplicationShutdown } from '@nestjs/common';
+import { ClientKafka } from '@nestjs/microservices';
+import type { KafkaConnectionOptions, KafkaModuleAsyncOptions, KafkaModuleOptions } from './types';
+export declare class KafkaCoreModule implements OnApplicationShutdown, OnApplicationBootstrap {
+    protected client: ClientKafka;
+    private connectionOptions;
+    private logger?;
+    /**
+     *
+     */
+    static forRoot(moduleOptions: KafkaModuleOptions): DynamicModule;
+    /**
+     *
+     */
     static forRootAsync(asyncOptions: KafkaModuleAsyncOptions): DynamicModule;
-    private static createAsyncProviders;
-    private static createAsyncOptionsProvider;
-    private static createKafka;
+    private static _createDynamicModule;
+    private static _readConnectionOptions;
+    /**
+     *
+     * @constructor
+     */
+    constructor(client: ClientKafka, connectionOptions: KafkaConnectionOptions, logger?: Logger | undefined);
+    onApplicationBootstrap(): Promise<void>;
+    onApplicationShutdown(): Promise<void>;
 }

package/types/kafka.module.d.ts

@@ -1,5 +1,5 @@
 import { DynamicModule } from '@nestjs/common';
-import type { KafkaModuleAsyncOptions, KafkaModuleOptions } from './interfaces/module-options.interface.js';
+import type { KafkaModuleAsyncOptions, KafkaModuleOptions } from './types';
 export declare class KafkaModule {
     static forRoot(options: KafkaModuleOptions): DynamicModule;
     static forRootAsync(options: KafkaModuleAsyncOptions): DynamicModule;

package/types/types.d.ts

@@ -0,0 +1,24 @@
+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 { ConsumerConfig } from '@nestjs/microservices/external/kafka.interface';
+import type { KafkaConfig } from 'kafkajs';
+import type { StrictOmit } from 'ts-gems';
+export interface KafkaConnectionOptions extends StrictOmit<KafkaConfig, 'logLevel' | 'logCreator'> {
+    consumer?: ConsumerConfig;
+    lazyConnect?: boolean;
+}
+interface BaseModuleOptions {
+    token?: InjectionToken;
+    envPrefix?: string;
+    logger?: Logger | string;
+    global?: boolean;
+}
+export interface KafkaModuleOptions extends BaseModuleOptions {
+    useValue?: Partial<KafkaConnectionOptions>;
+}
+export interface KafkaModuleAsyncOptions extends BaseModuleOptions, Pick<ModuleMetadata, 'imports'> {
+    inject?: any[];
+    useFactory: (...args: any[]) => Promise<Partial<KafkaConnectionOptions>> | Partial<KafkaConnectionOptions>;
+}
+export {};

package/types/interfaces/module-options.interface.d.ts

@@ -1,19 +0,0 @@
-import { Logger, Type } from '@nestjs/common';
-import type { ModuleMetadata } from '@nestjs/common/interfaces';
-import type { InjectionToken } from '@nestjs/common/interfaces/modules/injection-token.interface';
-import { KafkaConfig } from 'kafkajs';
-import { StrictOmit } from 'ts-gems';
-export interface KafkaModuleOptions extends StrictOmit<KafkaConfig, 'logLevel' | 'logCreator'> {
-    id?: InjectionToken;
-    logger?: Logger | string;
-}
-export interface KafkaModuleOptionsFactory {
-    createOptions(): Promise<KafkaModuleOptions> | KafkaModuleOptions;
-}
-export interface KafkaModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
-    id?: InjectionToken;
-    useExisting?: Type<KafkaModuleOptionsFactory>;
-    useClass?: Type<KafkaModuleOptionsFactory>;
-    useFactory?: (...args: any[]) => Promise<StrictOmit<KafkaModuleOptions, 'id'>> | StrictOmit<KafkaModuleOptions, 'id'>;
-    inject?: any[];
-}