@midwayjs/kafka 3.18.0 → 3.19.0

package/dist/configuration.d.ts

@@ -1,4 +1,3 @@
 export declare class KafkaConfiguration {
-    onReady(): Promise<void>;
 }
 //# sourceMappingURL=configuration.d.ts.map

package/dist/configuration.js

@@ -9,7 +9,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.KafkaConfiguration = void 0;
 const core_1 = require("@midwayjs/core");
 let KafkaConfiguration = class KafkaConfiguration {
-    async onReady() { }
 };
 KafkaConfiguration = __decorate([
     (0, core_1.Configuration)({
@@ -17,7 +16,16 @@ KafkaConfiguration = __decorate([
         importConfigs: [
             {
                 default: {
-                    kafka: {},
+                    kafka: {
+                        contextLoggerApplyLogger: 'kafkaLogger',
+                    },
+                    midwayLogger: {
+                        clients: {
+                            kafkaLogger: {
+                                fileLogName: 'midway-kafka.log',
+                            },
+                        },
+                    },
                 },
             },
         ],

package/dist/decorator.d.ts

@@ -0,0 +1,3 @@
+export declare const KAFKA_DECORATOR_KEY = "rpc:kafka";
+export declare function KafkaConsumer(consumerName: string): ClassDecorator;
+//# sourceMappingURL=decorator.d.ts.map

package/dist/decorator.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaConsumer = exports.KAFKA_DECORATOR_KEY = void 0;
+const core_1 = require("@midwayjs/core");
+exports.KAFKA_DECORATOR_KEY = 'rpc:kafka';
+function KafkaConsumer(consumerName) {
+    return target => {
+        (0, core_1.saveModule)(exports.KAFKA_DECORATOR_KEY, target);
+        (0, core_1.saveClassMetadata)(exports.KAFKA_DECORATOR_KEY, consumerName, target);
+        (0, core_1.Scope)(core_1.ScopeEnum.Request)(target);
+        (0, core_1.Provide)()(target);
+    };
+}
+exports.KafkaConsumer = KafkaConsumer;
+//# sourceMappingURL=decorator.js.map

package/dist/framework.d.ts

@@ -1,10 +1,16 @@
-import { BaseFramework, MidwayFrameworkType } from '@midwayjs/core';
-import { IMidwayKafkaContext } from './interface';
+import { BaseFramework, MidwayFrameworkType, ILogger, TypedResourceManager } from '@midwayjs/core';
+import { IKafkaConsumerInitOptions, IKafkaConsumer, IMidwayKafkaContext } from './interface';
+import { Kafka, Consumer } from 'kafkajs';
 export declare class MidwayKafkaFramework extends BaseFramework<any, IMidwayKafkaContext, any> {
+    protected LogCreator: any;
+    protected typedResourceManager: TypedResourceManager<Consumer, IKafkaConsumerInitOptions, IKafkaConsumer>;
     configure(): any;
+    kafKaLogger: ILogger;
     applicationInitialize(): Promise<void>;
     run(): Promise<void>;
-    private loadSubscriber;
+    private loadLegacySubscriber;
+    getConsumer(subscriberNameOrInstanceName: string): any;
+    getKafka(instanceName: string): Kafka;
     getFrameworkName(): string;
     protected beforeStop(): Promise<void>;
     getFrameworkType(): MidwayFrameworkType;

package/dist/framework.js

@@ -5,33 +5,131 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MidwayKafkaFramework = void 0;
 const core_1 = require("@midwayjs/core");
 const kafka_1 = require("./kafka");
+const decorator_1 = require("./decorator");
+const kafkajs_1 = require("kafkajs");
+const manager_1 = require("./manager");
+const toMidwayLogLevel = level => {
+    switch (level) {
+        case kafkajs_1.logLevel.NOTHING:
+            return 'none';
+        case kafkajs_1.logLevel.ERROR:
+            return 'error';
+        case kafkajs_1.logLevel.WARN:
+            return 'warn';
+        case kafkajs_1.logLevel.INFO:
+            return 'info';
+        case kafkajs_1.logLevel.DEBUG:
+            return 'debug';
+    }
+};
 let MidwayKafkaFramework = class MidwayKafkaFramework extends core_1.BaseFramework {
     configure() {
         return this.configService.getConfiguration('kafka');
     }
     async applicationInitialize() {
+        this.LogCreator = logLevel => {
+            const logger = this.kafKaLogger;
+            return ({ level, log }) => {
+                const lvl = toMidwayLogLevel(level);
+                const { message, ...extra } = log;
+                logger === null || logger === void 0 ? void 0 : logger[lvl](message, extra);
+            };
+        };
         // Create a connection manager
-        this.app = new kafka_1.KafkaConsumerServer({
-            logger: this.logger,
-            ...this.configurationOptions,
-        });
+        if (this.configurationOptions['kafkaConfig']) {
+            this.app = new kafka_1.KafkaConsumerServer({
+                logger: this.kafKaLogger,
+                ...this.configurationOptions,
+            });
+        }
+        else {
+            this.app = {};
+        }
     }
     async run() {
-        try {
-            await this.app.connect(this.configurationOptions.kafkaConfig, this.configurationOptions.consumerConfig);
-            await this.loadSubscriber();
-            this.logger.info('Kafka consumer server start success');
+        if (this.configurationOptions['kafkaConfig']) {
+            try {
+                await this.app.connect(this.configurationOptions.kafkaConfig, this.configurationOptions.consumerConfig);
+                await this.loadLegacySubscriber();
+                this.kafKaLogger.info('Kafka consumer server start success');
+            }
+            catch (error) {
+                this.kafKaLogger.error('Kafka consumer connect fail', error);
+                await this.app.closeConnection();
+            }
         }
-        catch (error) {
-            this.logger.error('Kafka consumer connect fail', error);
-            await this.app.closeConnection();
+        else {
+            const { consumer } = this.configurationOptions;
+            if (!consumer)
+                return;
+            const subscriberMap = {};
+            // find subscriber
+            const subscriberModules = (0, core_1.listModule)(decorator_1.KAFKA_DECORATOR_KEY);
+            for (const subscriberModule of subscriberModules) {
+                const subscriberName = (0, core_1.getClassMetadata)(decorator_1.KAFKA_DECORATOR_KEY, subscriberModule);
+                subscriberMap[subscriberName] = subscriberModule;
+            }
+            this.typedResourceManager = new core_1.TypedResourceManager({
+                initializeValue: consumer,
+                initializeClzProvider: subscriberMap,
+                resourceInitialize: async (resourceInitializeConfig, resourceName) => {
+                    let client;
+                    if (resourceInitializeConfig.kafkaInstanceRef) {
+                        client = manager_1.KafkaManager.getInstance().getKafkaInstance(resourceInitializeConfig.kafkaInstanceRef);
+                        if (!client) {
+                            throw new core_1.MidwayCommonError(`kafka instance ${resourceInitializeConfig.kafkaInstanceRef} not found`);
+                        }
+                    }
+                    else {
+                        client = new kafkajs_1.Kafka({
+                            logCreator: this.LogCreator,
+                            ...resourceInitializeConfig.connectionOptions,
+                        });
+                        manager_1.KafkaManager.getInstance().addKafkaInstance(resourceName, client);
+                    }
+                    const consumer = client.consumer(resourceInitializeConfig.consumerOptions);
+                    await consumer.connect();
+                    await consumer.subscribe(resourceInitializeConfig.subscribeOptions);
+                    return consumer;
+                },
+                resourceBinding: async (ClzProvider, resourceInitializeConfig, consumer) => {
+                    const runMethod = ClzProvider.prototype['eachBatch']
+                        ? 'eachBatch'
+                        : 'eachMessage';
+                    const runConfig = {
+                        ...resourceInitializeConfig.consumerRunConfig,
+                    };
+                    runConfig[runMethod] = async (payload) => {
+                        const ctx = this.app.createAnonymousContext();
+                        const fn = await this.applyMiddleware(async (ctx) => {
+                            ctx.payload = payload;
+                            ctx.consumer = consumer;
+                            const instance = await ctx.requestContext.getAsync(ClzProvider);
+                            return await instance[runMethod].call(instance, payload, ctx);
+                        });
+                        return await fn(ctx);
+                    };
+                    return runConfig;
+                },
+                resourceStart: async (resource, resourceInitializeConfig, resourceBindingResult) => {
+                    await resource.run(resourceBindingResult);
+                },
+                resourceDestroy: async (resource) => {
+                    await resource.disconnect();
+                },
+            });
+            await this.typedResourceManager.init();
+            await this.typedResourceManager.start();
         }
     }
-    async loadSubscriber() {
+    async loadLegacySubscriber() {
         const subscriberModules = (0, core_1.listModule)(core_1.MS_CONSUMER_KEY, module => {
             const metadata = (0, core_1.getClassMetadata)(core_1.MS_CONSUMER_KEY, module);
             return metadata.type === core_1.MSListenerType.KAFKA;
@@ -62,7 +160,8 @@ let MidwayKafkaFramework = class MidwayKafkaFramework extends core_1.BaseFramewo
                     topics: topicTitles,
                 }, e.subscription));
                 await this.app.connection.run(Object.assign(e.runConfig, {
-                    eachMessage: async ({ topic, partition, message }) => {
+                    eachMessage: async (payload) => {
+                        const { topic, partition, message } = payload;
                         let propertyKey;
                         for (const methodBindListeners of data) {
                             for (const listenerOptions of methodBindListeners) {
@@ -81,6 +180,8 @@ let MidwayKafkaFramework = class MidwayKafkaFramework extends core_1.BaseFramewo
                                                 },
                                             ]);
                                         },
+                                        payload,
+                                        consumer: this.app.connection,
                                     };
                                     this.app.createAnonymousContext(ctx);
                                     if (typeof propertyKey === 'string') {
@@ -121,16 +222,30 @@ let MidwayKafkaFramework = class MidwayKafkaFramework extends core_1.BaseFramewo
             });
         }
     }
+    getConsumer(subscriberNameOrInstanceName) {
+        if (this.typedResourceManager) {
+            return this.typedResourceManager.getResource(subscriberNameOrInstanceName);
+        }
+    }
+    getKafka(instanceName) {
+        return manager_1.KafkaManager.getInstance().getKafkaInstance(instanceName);
+    }
     getFrameworkName() {
         return 'midway:kafka';
     }
     async beforeStop() {
-        await this.app.close();
+        if (this.typedResourceManager) {
+            await this.typedResourceManager.destroy();
+        }
     }
     getFrameworkType() {
         return core_1.MidwayFrameworkType.MS_KAFKA;
     }
 };
+__decorate([
+    (0, core_1.Logger)('kafkaLogger'),
+    __metadata("design:type", Object)
+], MidwayKafkaFramework.prototype, "kafKaLogger", void 0);
 MidwayKafkaFramework = __decorate([
     (0, core_1.Framework)()
 ], MidwayKafkaFramework);

package/dist/index.d.ts

@@ -1,6 +1,8 @@
-import * as Kafkajs from 'kafkajs';
+import * as KafkaJS from 'kafkajs';
 export { MidwayKafkaFramework as Framework } from './framework';
-export * from './interface';
 export { KafkaConfiguration as Configuration } from './configuration';
-export { Kafkajs };
+export * from './interface';
+export * from './decorator';
+export * from './service';
+export { KafkaJS };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -14,12 +14,14 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Kafkajs = exports.Configuration = exports.Framework = void 0;
-const Kafkajs = require("kafkajs");
-exports.Kafkajs = Kafkajs;
+exports.KafkaJS = exports.Configuration = exports.Framework = void 0;
+const KafkaJS = require("kafkajs");
+exports.KafkaJS = KafkaJS;
 var framework_1 = require("./framework");
 Object.defineProperty(exports, "Framework", { enumerable: true, get: function () { return framework_1.MidwayKafkaFramework; } });
-__exportStar(require("./interface"), exports);
 var configuration_1 = require("./configuration");
 Object.defineProperty(exports, "Configuration", { enumerable: true, get: function () { return configuration_1.KafkaConfiguration; } });
+__exportStar(require("./interface"), exports);
+__exportStar(require("./decorator"), exports);
+__exportStar(require("./service"), exports);
 //# sourceMappingURL=index.js.map

package/dist/interface.d.ts

@@ -1,15 +1,27 @@
-import { IConfigurationOptions, IMidwayApplication, IMidwayContext, NextFunction as BaseNextFunction } from '@midwayjs/core';
-import { Kafka, KafkaConfig } from 'kafkajs';
+import { IConfigurationOptions, IMidwayApplication, IMidwayContext, NextFunction as BaseNextFunction, ServiceFactoryConfigOption } from "@midwayjs/core";
+import { AdminConfig, Consumer, ConsumerConfig, ConsumerRunConfig, ConsumerSubscribeTopic, ConsumerSubscribeTopics, EachBatchHandler, EachBatchPayload, EachMessageHandler, EachMessagePayload, Kafka, KafkaConfig, ProducerConfig } from 'kafkajs';
 export interface IKafkaApplication {
 }
 export type IMidwayKafkaApplication = IMidwayApplication<IMidwayKafkaContext> & IKafkaApplication;
-export interface IMidwayKafkaConfigurationOptions extends IConfigurationOptions, KafkaConfig {
-}
 export type IMidwayKafkaContext = IMidwayContext<{
-    topic: any;
-    partition: any;
-    message: any;
-    commitOffsets(data: any): void;
+    /**
+     * @deprecated please use `ctx.payload` instead
+     */
+    topic?: any;
+    /**
+     * @deprecated please use `ctx.payload` instead
+     */
+    partition?: any;
+    /**
+     * @deprecated please use `ctx.payload` instead
+     */
+    message?: any;
+    /**
+     * @deprecated please use `ctx.consumer.commitOffsets` instead
+     */
+    commitOffsets?(data: any): void;
+    payload: EachMessagePayload | EachBatchPayload;
+    consumer: Consumer;
 }>;
 export type Application = IMidwayKafkaApplication;
 export interface Context extends IMidwayKafkaContext {
@@ -18,10 +30,57 @@ export type NextFunction = BaseNextFunction;
 export type DefaultConfig = string | Kafka;
 /**
  * 客户端的相关配置，在midwayjs的自定义配置项
+ * @deprecated
  */
 export interface IMidwayConsumerConfig {
     topic: string;
     subscription: any;
     runConfig: any;
 }
+/**
+ * The options for the kafka consumer initialization in midway
+ */
+export interface IKafkaConsumerInitOptions {
+    /**
+     * The connection options for the kafka instance
+     */
+    connectionOptions: KafkaConfig;
+    /**
+     * The consumer options for the kafka consumer
+     */
+    consumerOptions: ConsumerConfig;
+    subscribeOptions: ConsumerSubscribeTopics | ConsumerSubscribeTopic;
+    consumerRunConfig: ConsumerRunConfig;
+    kafkaInstanceRef?: string;
+}
+/**
+ * The options for the kafka producer initialization in midway
+ */
+export interface IMidwayKafkaProducerInitOptions {
+    connectionOptions: KafkaConfig;
+    producerOptions: ProducerConfig;
+    kafkaInstanceRef?: string;
+}
+/**
+ * The options for the kafka admin initialization in midway
+ */
+export interface IMidwayKafkaAdminInitOptions {
+    kafkaInstanceRef?: string;
+    connectionOptions: KafkaConfig;
+    /**
+     * The options for the kafka admin initialization
+     */
+    adminOptions: AdminConfig;
+}
+export interface IMidwayKafkaConfigurationOptions extends IConfigurationOptions {
+    consumer: {
+        [name: string]: Partial<IKafkaConsumerInitOptions>;
+    };
+    producer: ServiceFactoryConfigOption<Partial<IMidwayKafkaProducerInitOptions>>;
+    admin: ServiceFactoryConfigOption<Partial<IMidwayKafkaAdminInitOptions>>;
+}
+export interface IKafkaConsumer {
+    eachBatch?: EachBatchHandler;
+    eachMessage?: EachMessageHandler;
+}
 //# sourceMappingURL=interface.d.ts.map

package/dist/manager.d.ts

@@ -0,0 +1,10 @@
+import { Kafka } from 'kafkajs';
+export declare class KafkaManager {
+    private kafkaInstanceMap;
+    private static instance;
+    private constructor();
+    getKafkaInstance(name: string): Kafka;
+    addKafkaInstance(name: string, kafka: Kafka): void;
+    static getInstance(): KafkaManager;
+}
+//# sourceMappingURL=manager.d.ts.map

package/dist/manager.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaManager = void 0;
+class KafkaManager {
+    constructor() {
+        this.kafkaInstanceMap = new Map();
+    }
+    getKafkaInstance(name) {
+        return this.kafkaInstanceMap.get(name);
+    }
+    addKafkaInstance(name, kafka) {
+        this.kafkaInstanceMap.set(name, kafka);
+    }
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new KafkaManager();
+        }
+        return this.instance;
+    }
+}
+exports.KafkaManager = KafkaManager;
+//# sourceMappingURL=manager.js.map

package/dist/service.d.ts

@@ -0,0 +1,22 @@
+import { ILogger, ServiceFactory, ServiceFactoryConfigOption } from '@midwayjs/core';
+import { Producer, Admin } from 'kafkajs';
+import { IMidwayKafkaAdminInitOptions, IMidwayKafkaProducerInitOptions } from './interface';
+export declare class KafkaProducerFactory extends ServiceFactory<Producer> {
+    logger: ILogger;
+    pubConfig: ServiceFactoryConfigOption<IMidwayKafkaProducerInitOptions>;
+    getName(): string;
+    init(): Promise<void>;
+    protected createClient(config: IMidwayKafkaProducerInitOptions, clientName: any): Promise<Producer>;
+    destroyClient(producer: Producer, name: string): Promise<void>;
+    destroy(): Promise<void>;
+}
+export declare class KafkaAdminFactory extends ServiceFactory<Admin> {
+    logger: ILogger;
+    adminConfig: ServiceFactoryConfigOption<IMidwayKafkaProducerInitOptions>;
+    getName(): string;
+    init(): Promise<void>;
+    protected createClient(config: IMidwayKafkaAdminInitOptions, clientName: any): Promise<Admin>;
+    destroyClient(admin: Admin, name: string): Promise<void>;
+    destroy(): Promise<void>;
+}
+//# sourceMappingURL=service.d.ts.map

package/dist/service.js

@@ -0,0 +1,131 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaAdminFactory = exports.KafkaProducerFactory = void 0;
+const core_1 = require("@midwayjs/core");
+const kafkajs_1 = require("kafkajs");
+const manager_1 = require("./manager");
+let KafkaProducerFactory = class KafkaProducerFactory extends core_1.ServiceFactory {
+    getName() {
+        return 'kafka:producer';
+    }
+    async init() {
+        await this.initClients(this.pubConfig);
+    }
+    async createClient(config, clientName) {
+        const { connectionOptions, producerOptions, kafkaInstanceRef } = config;
+        let client;
+        if (kafkaInstanceRef) {
+            client = manager_1.KafkaManager.getInstance().getKafkaInstance(kafkaInstanceRef);
+            if (!client) {
+                throw new core_1.MidwayCommonError(`[midway:kafka] kafka instance ${kafkaInstanceRef} not found`);
+            }
+        }
+        else {
+            client = new kafkajs_1.Kafka(connectionOptions);
+            manager_1.KafkaManager.getInstance().addKafkaInstance(kafkaInstanceRef, client);
+        }
+        const producer = client.producer(producerOptions);
+        producer.on('producer.connect', () => {
+            this.logger.info('[midway:kafka] producer: %s is connect', clientName);
+        });
+        await producer.connect();
+        return producer;
+    }
+    async destroyClient(producer, name) {
+        await producer.disconnect();
+        this.logger.info('[midway:kafka] producer: %s is close', name);
+    }
+    async destroy() {
+        await super.stop();
+    }
+};
+__decorate([
+    (0, core_1.Logger)('kafkaLogger'),
+    __metadata("design:type", Object)
+], KafkaProducerFactory.prototype, "logger", void 0);
+__decorate([
+    (0, core_1.Config)('kafka.producer'),
+    __metadata("design:type", Object)
+], KafkaProducerFactory.prototype, "pubConfig", void 0);
+__decorate([
+    (0, core_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], KafkaProducerFactory.prototype, "init", null);
+__decorate([
+    (0, core_1.Destroy)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], KafkaProducerFactory.prototype, "destroy", null);
+KafkaProducerFactory = __decorate([
+    (0, core_1.Singleton)()
+], KafkaProducerFactory);
+exports.KafkaProducerFactory = KafkaProducerFactory;
+let KafkaAdminFactory = class KafkaAdminFactory extends core_1.ServiceFactory {
+    getName() {
+        return 'kafka:admin';
+    }
+    async init() {
+        await this.initClients(this.adminConfig);
+    }
+    async createClient(config, clientName) {
+        const { connectionOptions, adminOptions, kafkaInstanceRef } = config;
+        let client;
+        if (kafkaInstanceRef) {
+            client = manager_1.KafkaManager.getInstance().getKafkaInstance(kafkaInstanceRef);
+            if (!client) {
+                throw new core_1.MidwayCommonError(`[midway:kafka] kafka instance ${kafkaInstanceRef} not found`);
+            }
+        }
+        else {
+            client = new kafkajs_1.Kafka(connectionOptions);
+            manager_1.KafkaManager.getInstance().addKafkaInstance(kafkaInstanceRef, client);
+        }
+        const admin = client.admin(adminOptions);
+        await admin.connect();
+        return admin;
+    }
+    async destroyClient(admin, name) {
+        await admin.disconnect();
+        this.logger.info('[midway:kafka] admin: %s is close', name);
+    }
+    async destroy() {
+        await super.stop();
+    }
+};
+__decorate([
+    (0, core_1.Logger)('kafkaLogger'),
+    __metadata("design:type", Object)
+], KafkaAdminFactory.prototype, "logger", void 0);
+__decorate([
+    (0, core_1.Config)('kafka.admin'),
+    __metadata("design:type", Object)
+], KafkaAdminFactory.prototype, "adminConfig", void 0);
+__decorate([
+    (0, core_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], KafkaAdminFactory.prototype, "init", null);
+__decorate([
+    (0, core_1.Destroy)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], KafkaAdminFactory.prototype, "destroy", null);
+KafkaAdminFactory = __decorate([
+    (0, core_1.Singleton)()
+], KafkaAdminFactory);
+exports.KafkaAdminFactory = KafkaAdminFactory;
+//# sourceMappingURL=service.js.map

package/index.d.ts

@@ -1,5 +1,13 @@
 import { IMidwayKafkaConfigurationOptions } from './dist';
 export * from './dist/index';
+export {
+  EachMessagePayload,
+  EachBatchPayload,
+  Consumer,
+  Kafka,
+  Producer,
+  Admin,
+} from 'kafkajs';
 
 declare module '@midwayjs/core/dist/interface' {
   interface MidwayConfig {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midwayjs/kafka",
-  "version": "3.18.0",
+  "version": "3.19.0",
   "description": "Midway Framework for kafka",
   "main": "dist/index.js",
   "typings": "index.d.ts",
@@ -33,8 +33,8 @@
   },
   "homepage": "https://github.com/midwayjs/midway#readme",
   "devDependencies": {
-    "@midwayjs/core": "^3.18.0",
-    "@midwayjs/mock": "^3.18.0"
+    "@midwayjs/core": "^3.19.0",
+    "@midwayjs/mock": "^3.19.0"
   },
   "dependencies": {
     "kafkajs": "2.2.4"
@@ -42,5 +42,5 @@
   "engines": {
     "node": ">=12"
   },
-  "gitHead": "5e6180ba0fabe1acc6df112c68855129a534e941"
+  "gitHead": "437e92d9375b0e375f83aa363f3e6a60187c7109"
 }