@xnestjs/kafka 0.10.0

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,3 @@
+# @xnestjs/kafka
+
+NestJS extension library for kafka

package/cjs/constants.js

@@ -0,0 +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 = Symbol('KAFKA_MODULE_ID');

package/cjs/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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);

package/cjs/interfaces/module-options.interface.js

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

package/cjs/kafka-core.module.js

@@ -0,0 +1,109 @@
+"use strict";
+var KafkaCoreModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaCoreModule = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const crypto = tslib_1.__importStar(require("crypto"));
+const kafkajs_1 = require("kafkajs");
+const constants_js_1 = require("./constants.js");
+const create_log_creator_js_1 = require("./utils/create-log-creator.js");
+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,
+            providers: [
+                ...asyncProviders,
+                loggerProvider,
+                kafkaProvider,
+                {
+                    provide: constants_js_1.KAFKA_MODULE_ID,
+                    useValue: crypto.randomUUID(),
+                },
+            ],
+            exports: [kafkaProvider],
+        };
+    }
+    static createAsyncProviders(asyncOptions) {
+        if (asyncOptions.useExisting || asyncOptions.useFactory)
+            return [this.createAsyncOptionsProvider(asyncOptions)];
+        if (asyncOptions.useClass) {
+            return [
+                this.createAsyncOptionsProvider(asyncOptions),
+                {
+                    provide: asyncOptions.useClass,
+                    useClass: asyncOptions.useClass,
+                },
+            ];
+        }
+        throw new Error('Invalid configuration. Must provide useFactory, useClass or useExisting');
+    }
+    static createAsyncOptionsProvider(asyncOptions) {
+        if (asyncOptions.useFactory) {
+            return {
+                provide: constants_js_1.KAFKA_MODULE_OPTIONS,
+                useFactory: asyncOptions.useFactory,
+                inject: asyncOptions.inject || [],
+            };
+        }
+        const useClass = asyncOptions.useClass || asyncOptions.useExisting;
+        if (useClass) {
+            return {
+                provide: constants_js_1.KAFKA_MODULE_OPTIONS,
+                useFactory: (optionsFactory) => optionsFactory.createOptions(),
+                inject: [useClass],
+            };
+        }
+        throw new Error('Invalid configuration. Must provide useFactory, useClass or useExisting');
+    }
+    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),
+        });
+    }
+};
+exports.KafkaCoreModule = KafkaCoreModule;
+exports.KafkaCoreModule = KafkaCoreModule = KafkaCoreModule_1 = tslib_1.__decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({})
+], KafkaCoreModule);

package/cjs/kafka.module.js

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

package/cjs/package.json

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

package/cjs/utils/create-log-creator.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogCreator = createLogCreator;
+const kafkajs_1 = require("kafkajs");
+function createLogCreator(logger) {
+    return ({ namespace, level, log }) => {
+        const { message, ...extra } = log;
+        switch (level) {
+            case kafkajs_1.logLevel.ERROR:
+                return logger.error(message, new Error(message), {
+                    ...extra,
+                    namespace,
+                });
+            case kafkajs_1.logLevel.WARN:
+                return logger.warn(message, {
+                    ...extra,
+                    namespace,
+                });
+            case kafkajs_1.logLevel.INFO:
+                return logger.log(message, {
+                    ...extra,
+                    namespace,
+                });
+            case kafkajs_1.logLevel.DEBUG:
+                return logger.debug(message, {
+                    ...extra,
+                    namespace,
+                });
+            default:
+                return logger.verbose(message, {
+                    ...extra,
+                    namespace,
+                });
+        }
+    };
+}

package/esm/constants.js

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

package/esm/index.js

@@ -0,0 +1,4 @@
+export * from './constants.js';
+export * from './interfaces/module-options.interface.js';
+export * from './kafka.module.js';
+export * from 'kafkajs';

package/esm/interfaces/module-options.interface.js

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

package/esm/kafka-core.module.js

@@ -0,0 +1,106 @@
+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';
+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,
+            providers: [
+                ...asyncProviders,
+                loggerProvider,
+                kafkaProvider,
+                {
+                    provide: KAFKA_MODULE_ID,
+                    useValue: crypto.randomUUID(),
+                },
+            ],
+            exports: [kafkaProvider],
+        };
+    }
+    static createAsyncProviders(asyncOptions) {
+        if (asyncOptions.useExisting || asyncOptions.useFactory)
+            return [this.createAsyncOptionsProvider(asyncOptions)];
+        if (asyncOptions.useClass) {
+            return [
+                this.createAsyncOptionsProvider(asyncOptions),
+                {
+                    provide: asyncOptions.useClass,
+                    useClass: asyncOptions.useClass,
+                },
+            ];
+        }
+        throw new Error('Invalid configuration. Must provide useFactory, useClass or useExisting');
+    }
+    static createAsyncOptionsProvider(asyncOptions) {
+        if (asyncOptions.useFactory) {
+            return {
+                provide: KAFKA_MODULE_OPTIONS,
+                useFactory: asyncOptions.useFactory,
+                inject: asyncOptions.inject || [],
+            };
+        }
+        const useClass = asyncOptions.useClass || asyncOptions.useExisting;
+        if (useClass) {
+            return {
+                provide: KAFKA_MODULE_OPTIONS,
+                useFactory: (optionsFactory) => optionsFactory.createOptions(),
+                inject: [useClass],
+            };
+        }
+        throw new Error('Invalid configuration. Must provide useFactory, useClass or useExisting');
+    }
+    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),
+        });
+    }
+};
+KafkaCoreModule = KafkaCoreModule_1 = __decorate([
+    Global(),
+    Module({})
+], KafkaCoreModule);
+export { KafkaCoreModule };

package/esm/kafka.module.js

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

package/esm/package.json

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

package/esm/utils/create-log-creator.js

@@ -0,0 +1,33 @@
+import { logLevel } from 'kafkajs';
+export function createLogCreator(logger) {
+    return ({ namespace, level, log }) => {
+        const { message, ...extra } = log;
+        switch (level) {
+            case logLevel.ERROR:
+                return logger.error(message, new Error(message), {
+                    ...extra,
+                    namespace,
+                });
+            case logLevel.WARN:
+                return logger.warn(message, {
+                    ...extra,
+                    namespace,
+                });
+            case logLevel.INFO:
+                return logger.log(message, {
+                    ...extra,
+                    namespace,
+                });
+            case logLevel.DEBUG:
+                return logger.debug(message, {
+                    ...extra,
+                    namespace,
+                });
+            default:
+                return logger.verbose(message, {
+                    ...extra,
+                    namespace,
+                });
+        }
+    };
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@xnestjs/kafka",
+  "version": "0.10.0",
+  "description": "NestJS extension library for Kafka",
+  "author": "Panates",
+  "license": "MIT",
+  "peerDependencies": {
+    "@nestjs/common": "^10.4.1",
+    "@nestjs/core": "^10.4.1",
+    "kafkajs": "^2.2.4"
+  },
+  "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/kafka"
+  },
+  "engines": {
+    "node": ">=16.0",
+    "npm": ">=7.0.0"
+  },
+  "files": [
+    "cjs/",
+    "esm/",
+    "types/",
+    "LICENSE",
+    "README.md"
+  ],
+  "keywords": [
+    "nestjs",
+    "kafka"
+  ]
+}

package/types/constants.d.ts

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

package/types/index.d.cts

@@ -0,0 +1,4 @@
+export * from './constants.js';
+export * from './interfaces/module-options.interface.js';
+export * from './kafka.module.js';
+export * from 'kafkajs';

package/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from './constants.js';
+export * from './interfaces/module-options.interface.js';
+export * from './kafka.module.js';
+export * from 'kafkajs';

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

@@ -0,0 +1,19 @@
+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[];
+}

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

@@ -0,0 +1,9 @@
+import { DynamicModule } from '@nestjs/common';
+import { KafkaModuleAsyncOptions, KafkaModuleOptions } from './interfaces/module-options.interface.js';
+export declare class KafkaCoreModule {
+    static forRoot(options: KafkaModuleOptions): DynamicModule;
+    static forRootAsync(asyncOptions: KafkaModuleAsyncOptions): DynamicModule;
+    private static createAsyncProviders;
+    private static createAsyncOptionsProvider;
+    private static createKafka;
+}

package/types/kafka.module.d.ts

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

package/types/utils/create-log-creator.d.ts

@@ -0,0 +1,6 @@
+import { Logger } from '@nestjs/common';
+export declare function createLogCreator(logger: Logger): ({ namespace, level, log }: {
+    namespace: any;
+    level: any;
+    log: any;
+}) => void;