@midwayjs/mqtt 3.14.12 → 3.15.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2013 - Now midwayjs
+
+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/dist/configuration.d.ts

@@ -1,7 +1,10 @@
 import { IMidwayContainer } from '@midwayjs/core';
 import { MidwayMQTTFramework } from './framework';
+import { MqttProducerFactory } from './service';
 export declare class MQTTConfiguration {
     framework: MidwayMQTTFramework;
+    factory: MqttProducerFactory;
     onReady(container: IMidwayContainer): Promise<void>;
+    onStop(): Promise<void>;
 }
 //# sourceMappingURL=configuration.d.ts.map

package/dist/configuration.js

@@ -15,7 +15,10 @@ const framework_1 = require("./framework");
 const service_1 = require("./service");
 let MQTTConfiguration = class MQTTConfiguration {
     async onReady(container) {
-        await container.getAsync(service_1.MqttProducerFactory);
+        this.factory = await container.getAsync(service_1.MqttProducerFactory);
+    }
+    async onStop() {
+        await this.factory.stop();
     }
 };
 __decorate([

package/dist/framework.d.ts

@@ -10,6 +10,8 @@ export declare class MidwayMQTTFramework extends BaseFramework<IMidwayMQTTApplic
     run(): Promise<void>;
     protected beforeStop(): Promise<void>;
     createSubscriber(connectionOptions: IClientOptions, clientName?: string): Promise<MqttClient>;
+    getSubscriber(name: string): MqttClient;
+    getSubscribers(): MqttClient[];
     getFrameworkName(): string;
 }
 //# sourceMappingURL=framework.d.ts.map

package/dist/framework.js

@@ -22,6 +22,9 @@ let MidwayMQTTFramework = class MidwayMQTTFramework extends core_1.BaseFramework
         return this.configService.getConfiguration('mqtt');
     }
     async applicationInitialize(options) {
+        this.app = {};
+    }
+    async run() {
         const { sub } = this.configurationOptions;
         if (Object.keys(sub || {}).length === 0) {
             this.mqttLogger.info('[midway-mqtt] Not found consumer config, skip init consumer');
@@ -34,29 +37,22 @@ let MidwayMQTTFramework = class MidwayMQTTFramework extends core_1.BaseFramework
             mqttSubscriberMap[subscriberName] = subscriberModule;
         }
         for (const customKey in sub) {
-            const consumer = await this.createSubscriber(sub[customKey].connectOptions);
-            consumer.subscribe(sub[customKey].subscribeOptions.topicObject, sub[customKey].subscribeOptions.opts, async (err, granted) => {
+            const consumer = await this.createSubscriber(sub[customKey].connectOptions, customKey);
+            await consumer.subscribeAsync(sub[customKey].subscribeOptions.topicObject, sub[customKey].subscribeOptions.opts);
+            consumer.on('message', async (topic, message, packet) => {
                 const ctx = this.app.createAnonymousContext();
-                ctx.packet = granted;
-                if (err) {
-                    const result = await this.filterManager.runErrorFilter(err, ctx);
-                    if (result.error) {
-                        this.mqttLogger.error(err);
-                    }
-                }
-                else {
-                    const fn = await this.applyMiddleware(async (ctx) => {
-                        const instance = await ctx.requestContext.getAsync(mqttSubscriberMap[customKey]);
-                        // eslint-disable-next-line prefer-spread
-                        return await instance['subscribe'].call(instance, ctx);
-                    });
-                    return await fn(ctx);
-                }
+                ctx.topic = topic;
+                ctx.packet = packet;
+                ctx.message = message;
+                const fn = await this.applyMiddleware(async (ctx) => {
+                    const instance = await ctx.requestContext.getAsync(mqttSubscriberMap[customKey]);
+                    // eslint-disable-next-line prefer-spread
+                    return await instance['subscribe'].call(instance, ctx);
+                });
+                return await fn(ctx);
             });
         }
-        this.app = {};
     }
-    async run() { }
     async beforeStop() {
         for (const [name, consumer] of this.subscriberMap) {
             await consumer.endAsync();
@@ -64,14 +60,25 @@ let MidwayMQTTFramework = class MidwayMQTTFramework extends core_1.BaseFramework
         }
     }
     async createSubscriber(connectionOptions, clientName) {
-        const client = await (0, mqtt_1.connectAsync)(connectionOptions);
-        client.on('error', err => {
-            this.mqttLogger.error(err);
+        return new Promise(resolve => {
+            const client = (0, mqtt_1.connect)(connectionOptions);
+            client.on('connect', () => {
+                if (clientName) {
+                    this.logger.info('[midway-mqtt] subscriber: %s is connect', clientName);
+                    this.subscriberMap.set(clientName, client);
+                }
+                resolve(client);
+            });
+            client.on('error', err => {
+                this.mqttLogger.error(err);
+            });
         });
-        if (clientName) {
-            this.subscriberMap.set(clientName, client);
-        }
-        return client;
+    }
+    getSubscriber(name) {
+        return this.subscriberMap.get(name);
+    }
+    getSubscribers() {
+        return Object.values(this.subscriberMap);
     }
     getFrameworkName() {
         return 'midway:mqtt';

package/dist/interface.d.ts

@@ -1,5 +1,6 @@
+/// <reference types="node" />
 import { IConfigurationOptions, IMidwayApplication, IMidwayContext, NextFunction as BaseNextFunction, ServiceFactoryConfigOption } from '@midwayjs/core';
-import type { IClientOptions, IClientSubscribeOptions, IClientSubscribeProperties, ISubscriptionMap, ISubscriptionGrant } from 'mqtt';
+import type { IClientOptions, IClientSubscribeOptions, IClientSubscribeProperties, ISubscriptionMap, IPublishPacket } from 'mqtt';
 export interface MqttSubscriberOptions {
     topicObject: string | string[] | ISubscriptionMap;
     opts?: IClientSubscribeOptions | IClientSubscribeProperties;
@@ -15,10 +16,15 @@ export interface IMidwayMQTTConfigurationOptions extends IConfigurationOptions {
     pub: ServiceFactoryConfigOption<IClientOptions>;
 }
 export type IMidwayMQTTContext = IMidwayContext<{
-    packet: ISubscriptionGrant[];
+    topic: string;
+    message: Buffer;
+    packet: IPublishPacket;
 }>;
 export type Application = IMidwayMQTTApplication;
 export interface Context extends IMidwayMQTTContext {
 }
 export type NextFunction = BaseNextFunction;
+export interface IMqttSubscriber {
+    subscribe(ctx: IMidwayMQTTContext): Promise<void>;
+}
 //# sourceMappingURL=interface.d.ts.map

package/dist/service.d.ts

@@ -1,12 +1,12 @@
-import { ServiceFactory } from '@midwayjs/core';
-import { MqttClient } from 'mqtt';
+import { ILogger, ServiceFactory, ServiceFactoryConfigOption } from '@midwayjs/core';
+import { type IClientOptions, MqttClient } from 'mqtt';
 export declare class MqttProducerFactory extends ServiceFactory<MqttClient> {
-    logger: any;
-    pubConfig: any;
+    logger: ILogger;
+    pubConfig: ServiceFactoryConfigOption<IClientOptions>;
     getName(): string;
     init(): Promise<void>;
     protected createClient(config: any, clientName: any): Promise<MqttClient>;
-    destroyClient(producer: any): Promise<void>;
+    destroyClient(producer: MqttClient, name: string): Promise<void>;
 }
 export declare class DefaultMqttProducer implements MqttClient {
     private mqttProducerFactory;

package/dist/service.js

@@ -11,9 +11,8 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultMqttProducer = exports.MqttProducerFactory = void 0;
 const core_1 = require("@midwayjs/core");
-const core_2 = require("@midwayjs/core");
 const mqtt_1 = require("mqtt");
-let MqttProducerFactory = class MqttProducerFactory extends core_2.ServiceFactory {
+let MqttProducerFactory = class MqttProducerFactory extends core_1.ServiceFactory {
     getName() {
         return 'mqtt';
     }
@@ -21,23 +20,20 @@ let MqttProducerFactory = class MqttProducerFactory extends core_2.ServiceFactor
         await this.initClients(this.pubConfig);
     }
     async createClient(config, clientName) {
-        const producer = await new Promise((resolve, reject) => {
-            (0, mqtt_1.connectAsync)(config)
-                .then(client => {
-                client.on('error', err => {
-                    this.logger.error(err);
-                });
-                client.on('connect', () => {
-                    resolve(client);
-                });
-            })
-                .catch(reject);
+        return new Promise(resolve => {
+            const client = (0, mqtt_1.connect)(config);
+            client.on('connect', () => {
+                this.logger.info('[midway-mqtt] producer: %s is connect', clientName);
+                resolve(client);
+            });
+            client.on('error', err => {
+                this.logger.error(err);
+            });
         });
-        this.logger.info('[midway-mqtt] producer: %s is ready', clientName);
-        return producer;
     }
-    async destroyClient(producer) {
+    async destroyClient(producer, name) {
         await producer.endAsync();
+        this.logger.info('[midway-mqtt] producer: %s is close', name);
     }
 };
 __decorate([
@@ -63,7 +59,7 @@ let DefaultMqttProducer = class DefaultMqttProducer {
     async init() {
         this.instance = this.mqttProducerFactory.get(this.mqttProducerFactory.getDefaultClientName() || 'default');
         if (!this.instance) {
-            throw new core_2.MidwayCommonError('mqtt default producer instance not found.');
+            throw new core_1.MidwayCommonError('mqtt default producer instance not found.');
         }
     }
 };
@@ -82,5 +78,5 @@ DefaultMqttProducer = __decorate([
     (0, core_1.Scope)(core_1.ScopeEnum.Singleton)
 ], DefaultMqttProducer);
 exports.DefaultMqttProducer = DefaultMqttProducer;
-(0, core_2.delegateTargetAllPrototypeMethod)(DefaultMqttProducer, mqtt_1.MqttClient);
+(0, core_1.delegateTargetAllPrototypeMethod)(DefaultMqttProducer, mqtt_1.MqttClient);
 //# sourceMappingURL=service.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midwayjs/mqtt",
-  "version": "3.14.12",
+  "version": "3.15.2",
   "description": "Midway Framework for mqtt",
   "main": "dist/index.js",
   "typings": "index.d.ts",
@@ -23,8 +23,8 @@
   ],
   "license": "MIT",
   "devDependencies": {
-    "@midwayjs/mock": "^3.14.12",
-    "@midwayjs/core": "^3.14.12"
+    "@midwayjs/core": "^3.15.0",
+    "@midwayjs/mock": "^3.15.2"
   },
   "dependencies": {
     "mqtt": "5.3.5"
@@ -37,5 +37,5 @@
   "engines": {
     "node": ">=16"
   },
-  "gitHead": "a603d2348d6141f8f723901498f03a162a037708"
+  "gitHead": "e8b53689c50aa8c9a691de7d985cafd62f5f70e7"
 }

package/dist/mq.d.ts

@@ -1,24 +0,0 @@
-/**
- * This RabbitMQ Server changed from https://github.com/JeniTurtle/egg-rabbitmq-plus/blob/master/rabbitmq.ts
- */
-/// <reference types="node" />
-import * as amqp from 'amqp-connection-manager';
-import { IRabbitMQApplication } from './interface';
-import { ConsumeMessage } from 'amqplib/properties';
-import { RabbitMQListenerOptions, ILogger } from '@midwayjs/core';
-import type { Channel } from 'amqplib';
-import { EventEmitter } from 'events';
-export declare class RabbitMQServer extends EventEmitter implements IRabbitMQApplication {
-    protected channelManagerSet: Set<Channel>;
-    protected connection: amqp.AmqpConnectionManager;
-    protected logger: ILogger;
-    protected reconnectTime: any;
-    constructor(options?: any);
-    bindError(): void;
-    createChannel(isConfirmChannel?: boolean): Promise<any>;
-    connect(url: any, socketOptions: any): Promise<void>;
-    createConsumer(listenerOptions: RabbitMQListenerOptions, listenerCallback: (msg: ConsumeMessage | null, channel: Channel, channelWrapper: any) => Promise<void>): Promise<void>;
-    protected closeConnection(): Promise<void>;
-    close(): Promise<void>;
-}
-//# sourceMappingURL=mq.d.ts.map

package/dist/mq.js

@@ -1,112 +0,0 @@
-"use strict";
-/**
- * This RabbitMQ Server changed from https://github.com/JeniTurtle/egg-rabbitmq-plus/blob/master/rabbitmq.ts
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RabbitMQServer = void 0;
-const amqp = require("amqp-connection-manager");
-const events_1 = require("events");
-class RabbitMQServer extends events_1.EventEmitter {
-    constructor(options = {}) {
-        var _a;
-        super();
-        this.channelManagerSet = new Set();
-        this.connection = null;
-        this.logger = options.logger;
-        this.reconnectTime = (_a = options.reconnectTime) !== null && _a !== void 0 ? _a : 10 * 1000;
-        this.bindError();
-    }
-    bindError() {
-        this.on('error', err => {
-            this.logger.error(err);
-        });
-    }
-    createChannel(isConfirmChannel = false) {
-        if (!isConfirmChannel) {
-            return this.connection.connection.createChannel();
-        }
-        else {
-            return this.connection.connection.createConfirmChannel();
-        }
-    }
-    async connect(url, socketOptions) {
-        this.connection = await amqp.connect(url, socketOptions);
-        // 监听在设置创建 channel 的错误
-        this.connection.on('error', err => {
-            if (err) {
-                if (err.err) {
-                    err = err.err;
-                }
-                this.logger.error('Message Queue error', err);
-            }
-            else {
-                this.logger.info('Message Queue disconnected!');
-            }
-        });
-        await new Promise((resolve, reject) => {
-            // 监听 成功连接 的通知
-            this.connection.on('connect', () => {
-                this.logger.info('Message Queue connected!');
-                resolve();
-            });
-            // 监听 连接失败的错误 通知
-            this.connection.on('connectFailed', err => {
-                if (err) {
-                    if (err.err) {
-                        err = err.err;
-                    }
-                    this.logger.error('Message Queue disconnected', err);
-                }
-                else {
-                    this.logger.info('Message Queue disconnected!');
-                }
-                reject(err);
-            });
-        });
-    }
-    async createConsumer(listenerOptions, listenerCallback) {
-        const channelWrapper = this.connection.createChannel({
-            setup: (channel) => {
-                var _a, _b, _c;
-                // `channel` here is a regular amqplib `ConfirmChannel`.
-                const channelHandlers = [];
-                // create queue
-                channelHandlers.push(channel.assertQueue(listenerOptions.queueName, Object.assign({ durable: true }, listenerOptions)));
-                if (listenerOptions.exchange) {
-                    // create exchange
-                    channelHandlers.push(channel.assertExchange(listenerOptions.exchange, (_b = (_a = listenerOptions.exchangeOptions) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : 'topic', listenerOptions.exchangeOptions));
-                    // bind exchange and queue
-                    channelHandlers.push(channel.bindQueue(listenerOptions.queueName, listenerOptions.exchange, listenerOptions.routingKey || listenerOptions.pattern, listenerOptions.exchangeOptions));
-                }
-                channelHandlers.push(channel.prefetch((_c = listenerOptions.prefetch) !== null && _c !== void 0 ? _c : 1));
-                // listen queue
-                channelHandlers.push(channel.consume(listenerOptions.queueName, async (msg) => {
-                    await listenerCallback(msg, channel, channelWrapper);
-                }, listenerOptions.consumeOptions));
-                return Promise.all(channelHandlers);
-            },
-            json: true,
-        });
-        return channelWrapper.waitForConnect();
-    }
-    async closeConnection() {
-        try {
-            if (this.connection) {
-                await this.connection.close();
-            }
-            this.logger.debug('Message Queue connection close success');
-        }
-        catch (err) {
-            this.logger.error('Message Queue connection close error', err);
-        }
-        finally {
-            this.connection = null;
-        }
-    }
-    async close() {
-        this.logger.debug('Message Queue will be close');
-        await this.closeConnection();
-    }
-}
-exports.RabbitMQServer = RabbitMQServer;
-//# sourceMappingURL=mq.js.map