@opra/nestjs-kafka 1.22.0 → 1.22.1

package/constants.d.ts

@@ -0,0 +1 @@
+export declare const OPRA_KAFKA_MODULE_CONFIG = "OPRA_KAFKA_MODULE_CONFIG";

package/constants.js

@@ -0,0 +1 @@
+export const OPRA_KAFKA_MODULE_CONFIG = 'OPRA_KAFKA_MODULE_CONFIG';

package/index.d.ts

@@ -0,0 +1,5 @@
+import 'reflect-metadata';
+import { IS_PUBLIC_KEY, OpraNestUtils, Public } from '@opra/nestjs';
+export * from './constants.js';
+export * from './opra-kafka.module.js';
+export { IS_PUBLIC_KEY, OpraNestUtils, Public };

package/index.js

@@ -0,0 +1,5 @@
+import 'reflect-metadata';
+import { IS_PUBLIC_KEY, OpraNestUtils, Public } from '@opra/nestjs';
+export * from './constants.js';
+export * from './opra-kafka.module.js';
+export { IS_PUBLIC_KEY, OpraNestUtils, Public };

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

@@ -0,0 +1,16 @@
+import { type DynamicModule, OnApplicationBootstrap, OnApplicationShutdown, OnModuleInit } from '@nestjs/common';
+import { KafkaAdapter } from '@opra/kafka';
+import { MQControllerFactory } from '@opra/nestjs';
+import type { OpraKafkaModule } from './opra-kafka.module.js';
+export declare class OpraKafkaCoreModule implements OnModuleInit, OnApplicationBootstrap, OnApplicationShutdown {
+    private controllerFactory;
+    protected adapter: KafkaAdapter;
+    protected config: OpraKafkaModule.ApiConfig;
+    constructor(controllerFactory: MQControllerFactory, adapter: KafkaAdapter, config: OpraKafkaModule.ApiConfig);
+    static forRoot(moduleOptions: OpraKafkaModule.ModuleOptions): DynamicModule;
+    static forRootAsync(moduleOptions: OpraKafkaModule.AsyncModuleOptions): DynamicModule;
+    protected static _getDynamicModule(moduleOptions: OpraKafkaModule.ModuleOptions | OpraKafkaModule.AsyncModuleOptions): DynamicModule;
+    onModuleInit(): any;
+    onApplicationBootstrap(): Promise<void>;
+    onApplicationShutdown(): Promise<void>;
+}

package/opra-kafka-core.module.js

@@ -0,0 +1,137 @@
+var OpraKafkaCoreModule_1;
+import { __decorate, __metadata, __param } from "tslib";
+import { isConstructor } from '@jsopen/objects';
+import { Global, Inject, Logger, Module, } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+import { ApiDocumentFactory } from '@opra/common';
+import { KafkaAdapter } from '@opra/kafka';
+import { MQControllerFactory } from '@opra/nestjs';
+import { OPRA_KAFKA_MODULE_CONFIG } from './constants.js';
+const opraKafkaNestjsAdapterToken = Symbol('OpraKafkaNestjsAdapter');
+let OpraKafkaCoreModule = OpraKafkaCoreModule_1 = class OpraKafkaCoreModule {
+    controllerFactory;
+    adapter;
+    config;
+    constructor(controllerFactory, adapter, config) {
+        this.controllerFactory = controllerFactory;
+        this.adapter = adapter;
+        this.config = config;
+    }
+    static forRoot(moduleOptions) {
+        return this._getDynamicModule({
+            ...moduleOptions,
+            providers: [
+                ...(moduleOptions?.providers || []),
+                {
+                    provide: OPRA_KAFKA_MODULE_CONFIG,
+                    useValue: {
+                        ...moduleOptions,
+                        logger: moduleOptions.logger || new Logger(moduleOptions.name),
+                    },
+                },
+            ],
+        });
+    }
+    static forRootAsync(moduleOptions) {
+        if (!moduleOptions.useFactory)
+            throw new Error('Invalid configuration. Must provide "useFactory"');
+        return this._getDynamicModule({
+            ...moduleOptions,
+            providers: [
+                ...(moduleOptions?.providers || []),
+                {
+                    provide: OPRA_KAFKA_MODULE_CONFIG,
+                    inject: moduleOptions.inject,
+                    useFactory: async (...args) => {
+                        const result = await moduleOptions.useFactory(...args);
+                        result.logger = result.logger || new Logger(result.name);
+                        return result;
+                    },
+                },
+            ],
+        });
+    }
+    static _getDynamicModule(moduleOptions) {
+        const token = moduleOptions.id || KafkaAdapter;
+        const adapterProvider = {
+            provide: token,
+            inject: [MQControllerFactory, ModuleRef, OPRA_KAFKA_MODULE_CONFIG],
+            useFactory: async (controllerFactory, moduleRef, config) => {
+                const controllers = controllerFactory
+                    .exploreControllers()
+                    .map(x => x.wrapper.instance);
+                const document = await ApiDocumentFactory.createDocument({
+                    info: config.info,
+                    types: config.types,
+                    references: config.references,
+                    api: {
+                        name: config.name,
+                        description: config.description,
+                        transport: 'mq',
+                        platform: KafkaAdapter.PlatformName,
+                        controllers,
+                    },
+                });
+                const interceptors = moduleOptions.interceptors
+                    ? moduleOptions.interceptors.map(x => {
+                        if (isConstructor(x)) {
+                            return async (ctx, next) => {
+                                const interceptor = moduleRef.get(x);
+                                if (typeof interceptor.intercept === 'function')
+                                    return interceptor.intercept(ctx, next);
+                            };
+                        }
+                        return x;
+                    })
+                    : undefined;
+                return new KafkaAdapter(document, { ...config, interceptors });
+            },
+        };
+        return {
+            global: moduleOptions.global,
+            module: OpraKafkaCoreModule_1,
+            controllers: moduleOptions.controllers,
+            providers: [
+                ...(moduleOptions?.providers || []),
+                MQControllerFactory,
+                adapterProvider,
+                {
+                    provide: opraKafkaNestjsAdapterToken,
+                    useExisting: token,
+                },
+            ],
+            imports: [...(moduleOptions?.imports || [])],
+            exports: [...(moduleOptions?.exports || []), adapterProvider],
+        };
+    }
+    onModuleInit() {
+        /** NestJS initialize controller instances on init stage.
+         * So we should update instance properties */
+        const mqApi = this.adapter.document.getMqApi();
+        const controllers = Array.from(mqApi.controllers.values());
+        for (const { wrapper } of this.controllerFactory
+            .exploreControllers()
+            .values()) {
+            const ctor = wrapper.instance.constructor;
+            const controller = controllers.find(x => x.ctor === ctor);
+            if (controller) {
+                controller.instance = wrapper.instance;
+            }
+        }
+    }
+    async onApplicationBootstrap() {
+        await this.adapter.start();
+    }
+    async onApplicationShutdown() {
+        await this.adapter.close();
+    }
+};
+OpraKafkaCoreModule = OpraKafkaCoreModule_1 = __decorate([
+    Module({}),
+    Global(),
+    __param(1, Inject(opraKafkaNestjsAdapterToken)),
+    __param(2, Inject(OPRA_KAFKA_MODULE_CONFIG)),
+    __metadata("design:paramtypes", [MQControllerFactory,
+        KafkaAdapter, Object])
+], OpraKafkaCoreModule);
+export { OpraKafkaCoreModule };

package/opra-kafka.module.d.ts

@@ -0,0 +1,34 @@
+import { type DynamicModule, Logger, type Type } from '@nestjs/common';
+import { ApiDocumentFactory } from '@opra/common';
+import type { KafkaAdapter } from '@opra/kafka';
+export declare namespace OpraKafkaModule {
+    export interface ModuleOptions extends BaseModuleOptions, ApiConfig {
+    }
+    export interface AsyncModuleOptions extends BaseModuleOptions {
+        inject?: any[];
+        useFactory?: (...args: any[]) => Promise<ApiConfig> | ApiConfig;
+    }
+    interface BaseModuleOptions extends Pick<DynamicModule, 'imports' | 'providers' | 'exports' | 'controllers' | 'global'> {
+        id?: any;
+        interceptors?: (KafkaAdapter.InterceptorFunction | KafkaAdapter.IKafkaInterceptor | Type<KafkaAdapter.IKafkaInterceptor>)[];
+    }
+    export interface ApiConfig extends Pick<ApiDocumentFactory.InitArguments, 'types' | 'references' | 'info'>, Pick<KafkaAdapter.Config, 'client' | 'consumers' | 'logExtra' | 'defaults'> {
+        name: string;
+        description?: string;
+        scope?: string;
+        logger?: Logger;
+    }
+    export {};
+}
+export declare class OpraKafkaModule {
+    /**
+     *
+     * @param options
+     */
+    static forRoot(options: OpraKafkaModule.ModuleOptions): DynamicModule;
+    /**
+     *
+     * @param options
+     */
+    static forRootAsync(options: OpraKafkaModule.AsyncModuleOptions): DynamicModule;
+}

package/opra-kafka.module.js

@@ -0,0 +1,30 @@
+var OpraKafkaModule_1;
+import { __decorate } from "tslib";
+import { Module } from '@nestjs/common';
+import { OpraKafkaCoreModule } from './opra-kafka-core.module.js';
+let OpraKafkaModule = OpraKafkaModule_1 = class OpraKafkaModule {
+    /**
+     *
+     * @param options
+     */
+    static forRoot(options) {
+        return {
+            module: OpraKafkaModule_1,
+            imports: [OpraKafkaCoreModule.forRoot(options)],
+        };
+    }
+    /**
+     *
+     * @param options
+     */
+    static forRootAsync(options) {
+        return {
+            module: OpraKafkaModule_1,
+            imports: [OpraKafkaCoreModule.forRootAsync(options)],
+        };
+    }
+};
+OpraKafkaModule = OpraKafkaModule_1 = __decorate([
+    Module({})
+], OpraKafkaModule);
+export { OpraKafkaModule };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/nestjs-kafka",
-  "version": "1.22.0",
+  "version": "1.22.1",
   "description": "Opra NestJS Kafka Module",
   "author": "Panates",
   "license": "MIT",
@@ -12,10 +12,10 @@
     "tslib": "^2.8.1"
   },
   "peerDependencies": {
-    "@opra/common": "^1.22.0",
-    "@opra/core": "^1.22.0",
-    "@opra/nestjs": "^1.22.0",
-    "@opra/kafka": "^1.22.0",
+    "@opra/common": "^1.22.1",
+    "@opra/core": "^1.22.1",
+    "@opra/nestjs": "^1.22.1",
+    "@opra/kafka": "^1.22.1",
     "@nestjs/common": "^10.0.0 || ^11.0.0",
     "@nestjs/core": "^10.0.0 || ^11.0.0",
     "@nestjs/microservices": "^10.0.0 || ^11.0.0",
@@ -39,14 +39,6 @@
     "url": "git+https://github.com/panates/opra.git",
     "directory": "packages/nestjs-kafka"
   },
-  "files": [
-    "bin/",
-    "cjs/",
-    "esm/",
-    "types/",
-    "LICENSE",
-    "README.md"
-  ],
   "keywords": [
     "opra",
     "nestjs",