@modernlock/common 1.0.63 → 1.0.65

package/build/events/base-consumer.d.ts

@@ -8,8 +8,11 @@ export declare abstract class Consumer {
     abstract exchangeType: ExchangeTypes;
     abstract routingKey: RoutingKeys;
     abstract queue: Queues;
-    abstract onMessage(msg: amqp.Message, data: any, channel: amqp.Channel): void;
+    abstract onMessage(msg: amqp.Message, data: any, channel?: amqp.Channel): Promise<void>;
     private channel;
+    private dlx;
+    private dlxType;
+    private dlRoutingKey;
     constructor(channel: amqp.Channel);
     listen(): Promise<void>;
     parseMessage(msg: amqp.Message): any;

package/build/events/base-consumer.js

@@ -12,21 +12,51 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Consumer = void 0;
 class Consumer {
     constructor(channel) {
+        // We define standard names for our Dead letter queu
+        this.dlx = 'dead_letter_exchange';
+        this.dlxType = 'direct';
+        this.dlRoutingKey = 'dead_letter';
         this.channel = channel;
     }
     ;
     listen() {
         return __awaiter(this, void 0, void 0, function* () {
             try {
+                // Assert the Dead Letter Exchange
+                yield this.channel.assertExchange(this.dlx, this.dlxType);
+                // Assert the Dead Letter Queue
+                const dlQueueName = `${this.queue}.dlq`; // e.g., "update-calendar.dlq"
+                yield this.channel.assertQueue(dlQueueName, { durable: true });
+                // Bind them so failed messages go into the DLQ
+                yield this.channel.bindQueue(dlQueueName, this.dlx, this.dlRoutingKey);
                 yield this.channel.assertExchange(this.exchange, this.exchangeType);
-                const q = yield this.channel.assertQueue(this.queue, { durable: true });
+                // Assert the Main Queue with special arguments linking to DLQ
+                const q = yield this.channel.assertQueue(this.queue, {
+                    durable: true,
+                    arguments: {
+                        // If message is Nack'ed (rejected), send to this exchange:
+                        'x-dead-letter-exchange': this.dlx,
+                        // With this routing key:
+                        'x-dead-letter-routing-key': this.dlRoutingKey
+                        // Optional: Time to Live (TTL) before moving to DLQ
+                        // 'x-message-ttl': 60000 
+                    }
+                });
                 yield this.channel.bindQueue(q.queue, this.exchange, this.routingKey);
-                this.channel.consume(q.queue, (msg) => {
+                yield this.channel.prefetch(1);
+                this.channel.consume(q.queue, (msg) => __awaiter(this, void 0, void 0, function* () {
                     if (!msg)
-                        throw new Error('Message is required');
-                    const data = this.parseMessage(msg);
-                    this.onMessage(msg, data, this.channel);
-                });
+                        return;
+                    try {
+                        const data = this.parseMessage(msg);
+                        yield this.onMessage(data, msg);
+                        this.channel.ack(msg);
+                    }
+                    catch (error) {
+                        console.error(`Error processing message in ${this.queue}:`, error);
+                        this.channel.nack(msg, false, false);
+                    }
+                }));
             }
             catch (error) {
                 console.error('Failed to publish message:', error);

package/build/events/rabbitmq-wrapper.d.ts

@@ -10,5 +10,6 @@ export declare class RabbitmqWrapper {
     connect(url: string): Promise<void>;
     connectWithRetries(url: string): Promise<void>;
     private reconnect;
+    close(): Promise<void>;
 }
 export declare const rabbitmqWrapper: RabbitmqWrapper;

package/build/events/rabbitmq-wrapper.js

@@ -115,6 +115,19 @@ class RabbitmqWrapper {
             }
         });
     }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (this.channel)
+                    yield this.channel.close();
+                if (this.connection)
+                    yield this.connection.close();
+            }
+            catch (err) {
+                console.error("Error closing RabbitMQ connection", err);
+            }
+        });
+    }
 }
 exports.RabbitmqWrapper = RabbitmqWrapper;
 ;

package/build/index.d.ts

@@ -38,6 +38,7 @@ export * from "./config/elasticsearchConnection";
 export * from "./interfaces/reservation";
 export * from "./things/events";
 export * from "./mqtt/topics";
+export * from "./mqtt/mqtt-wrapper";
 export * from "./things/commands";
 export * from "./@types/notification";
 export * from "./@types/express";

package/build/index.js

@@ -54,6 +54,7 @@ __exportStar(require("./config/elasticsearchConnection"), exports);
 __exportStar(require("./interfaces/reservation"), exports);
 __exportStar(require("./things/events"), exports);
 __exportStar(require("./mqtt/topics"), exports);
+__exportStar(require("./mqtt/mqtt-wrapper"), exports);
 __exportStar(require("./things/commands"), exports);
 __exportStar(require("./@types/notification"), exports);
 __exportStar(require("./@types/express"), exports);

package/build/mqtt/mqtt-wrapper.d.ts

@@ -0,0 +1,15 @@
+import * as mqtt from 'mqtt';
+type MqttMessageHandler = (message: string, topic: string) => void;
+declare class MqttWrapper {
+    private client?;
+    private handlers;
+    constructor();
+    connect(options: mqtt.IClientOptions): Promise<void>;
+    private routeMessage;
+    private topicMatches;
+    publish(topic: string, message: string, options?: mqtt.IClientPublishOptions): Promise<void>;
+    subscribe(topic: string, callback: MqttMessageHandler): Promise<void>;
+    disconnect(): Promise<void>;
+}
+export declare const mqttWrapper: MqttWrapper;
+export {};

package/build/mqtt/mqtt-wrapper.js

@@ -0,0 +1,140 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mqttWrapper = void 0;
+const mqtt = __importStar(require("mqtt"));
+class MqttWrapper {
+    constructor() {
+        this.handlers = new Map();
+    }
+    // 1. Connect Method (Async & Explicit)
+    connect(options) {
+        return new Promise((resolve, reject) => {
+            this.client = mqtt.connect(options);
+            this.client.on('connect', () => {
+                console.log('✅ Connected to MQTT broker');
+                resolve();
+            });
+            this.client.on('error', (err) => {
+                console.error('❌ MQTT error:', err);
+                // Only reject if we are still trying to connect initially
+                // If already connected, this is just a runtime error log
+            });
+            this.client.on('message', (topic, message) => {
+                this.routeMessage(topic, message.toString('utf8'));
+            });
+        });
+    }
+    routeMessage(topic, message) {
+        // Optimization: If no handlers, don't loop
+        if (this.handlers.size === 0)
+            return;
+        for (const [filter, handler] of this.handlers.entries()) {
+            if (this.topicMatches(filter, topic)) {
+                handler(message, topic);
+            }
+        }
+    }
+    topicMatches(filter, topic) {
+        const filterParts = filter.split('/');
+        const topicParts = topic.split('/');
+        for (let i = 0; i < filterParts.length; i++) {
+            const filterPart = filterParts[i];
+            const topicPart = topicParts[i];
+            if (filterPart === '#')
+                return true;
+            if (filterPart === '+') {
+                if (!topicPart)
+                    return false;
+                continue;
+            }
+            if (filterPart !== topicPart)
+                return false;
+        }
+        return filterParts.length === topicParts.length;
+    }
+    publish(topic, message, options = { qos: 0 }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.client)
+                throw new Error("Cannot publish before connecting");
+            return new Promise((resolve, reject) => {
+                this.client.publish(topic, message, options, (err) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve();
+                });
+            });
+        });
+    }
+    subscribe(topic, callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.client)
+                throw new Error("Cannot subscribe before connecting");
+            return new Promise((resolve, reject) => {
+                if (this.handlers.has(topic)) {
+                    this.handlers.set(topic, callback);
+                    return resolve();
+                }
+                this.client.subscribe(topic, { qos: 1 }, (err) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        console.log(`Subscribed to MQTT topic: ${topic}`);
+                        this.handlers.set(topic, callback);
+                        resolve();
+                    }
+                });
+            });
+        });
+    }
+    // 2. Graceful Shutdown
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => {
+                if (this.client) {
+                    this.client.end(false, () => {
+                        console.log("MQTT Disconnected");
+                        resolve();
+                    });
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+}
+exports.mqttWrapper = new MqttWrapper();

package/build/mqtt/topics.d.ts

@@ -3,7 +3,9 @@ export declare enum MqttTopics {
     connectionJoiningReply = "m@dernl0ck/connection-joining-reply/#",
     database = "m@dernl0ck/database/#",
     databaseInquiry = "m@dernl0ck/database-inquiry/#",
-    thingsNotification = "m@dernl0ck/devices/#"
+    thingsNotification = "m@dernl0ck/devices/#",
+    factoryDevicesDetected = "factory/devices/detected",
+    factoryDevicesRegistered = "factory/devices/registered"
 }
 export declare const mqttCallTopics: {
     getConnectionJoiningTopic: (coordinatorId: string) => string;

package/build/mqtt/topics.js

@@ -8,6 +8,8 @@ var MqttTopics;
     MqttTopics["database"] = "m@dernl0ck/database/#";
     MqttTopics["databaseInquiry"] = "m@dernl0ck/database-inquiry/#";
     MqttTopics["thingsNotification"] = "m@dernl0ck/devices/#";
+    MqttTopics["factoryDevicesDetected"] = "factory/devices/detected";
+    MqttTopics["factoryDevicesRegistered"] = "factory/devices/registered";
 })(MqttTopics = exports.MqttTopics || (exports.MqttTopics = {}));
 exports.mqttCallTopics = {
     getConnectionJoiningTopic: (coordinatorId) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modernlock/common",
-  "version": "1.0.63",
+  "version": "1.0.65",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
   "files": [
@@ -27,6 +27,7 @@
     "cookie-session": "^2.0.0",
     "express": "4.18.2",
     "jsonwebtoken": "9.0.0",
+    "mqtt": "^5.14.1",
     "winston": "^3.12.0",
     "winston-elasticsearch": "^0.18.0"
   },