dt-common-device 13.0.9 → 13.0.13

package/dist/config/config.js

@@ -74,6 +74,11 @@ async function initialize(cfg) {
         db_keys = constants_1.CONFIG_KEYS.OPERATION_NODE.db_keys;
         await validateServiceConfig(cfg);
     }
+    if (cfg.SOURCE === "NOTIFICATION_SERVICE") {
+        sourceKey = "NOTIFICATION";
+        db_keys = constants_1.CONFIG_KEYS.NOTIFICATION.db_keys;
+        await validateServiceConfig(cfg);
+    }
     // Connect to databases
     try {
         await (0, db_1.connectDatabase)();

package/dist/config/config.types.d.ts

@@ -4,7 +4,7 @@ export interface ILogger {
     warn(message: string, ...args: any[]): void;
     error(message: string, ...args: any[]): void;
 }
-type AllowedSource = "ACCESS_SERVICE" | "ADMIN_SERVICE" | "ENERGY_SERVICE" | "REMOTE_SERVICE" | "SCHEDULE_SERVICE" | "MIGRATION" | "OPERATION_NODE_SERVICE";
+type AllowedSource = "ACCESS_SERVICE" | "ADMIN_SERVICE" | "ENERGY_SERVICE" | "REMOTE_SERVICE" | "SCHEDULE_SERVICE" | "MIGRATION" | "OPERATION_NODE_SERVICE" | "NOTIFICATION_SERVICE";
 export type IConfig = {
     SOURCE: AllowedSource;
     INTERNAL_EVENT_HANDLER?: IInternalEvent;

package/dist/config/constants.d.ts

@@ -63,4 +63,12 @@ export declare const CONFIG_KEYS: {
             pms: string;
         };
     };
+    NOTIFICATION: {
+        env: string[];
+        INTERNAL_EVENT_HANDLER: boolean;
+        db_keys: {
+            redis: string;
+            redis_port: string;
+        };
+    };
 };

package/dist/config/constants.js

@@ -106,4 +106,12 @@ exports.CONFIG_KEYS = {
             pms: "PMS_DB_URI",
         },
     },
+    NOTIFICATION: {
+        env: ["REDIS_HOST", "REDIS_PORT"],
+        INTERNAL_EVENT_HANDLER: false,
+        db_keys: {
+            redis: "REDIS_HOST",
+            redis_port: "REDIS_PORT",
+        },
+    },
 };

package/dist/entities/admin/Admin.repository.d.ts

@@ -9,12 +9,14 @@ export declare class AdminRepository {
     getZonesByAccessGroups(accessGroupIds: string[], type?: string[]): Promise<any[]>;
     getAccessGroup(accessGroupId: string, propertyId?: string): Promise<IAccessGroup | null>;
     getZoneAccessGroupByZoneId(zoneId: string): Promise<IZoneAccessGroup[] | null>;
+    getZoneIdsByAccessGroupIds(accessGroupIds: string[]): Promise<string[]>;
     getAllParentZones(zoneId: string): Promise<string[]>;
     getDirectChildZones(zoneId: string, propertyId?: string): Promise<string[]>;
     getAllChildZones(zoneId: string, propertyId?: string): Promise<string[]>;
     getAccessGroupsByZoneId(zoneId: string): Promise<IAccessGroup[]>;
     getAccessGroupsByZoneIds(zoneIds: string[]): Promise<IAccessGroup[]>;
     getZone(zoneId: string, propertyId?: string): Promise<IZone | null>;
+    getZonesByIds(zoneIds: string[]): Promise<IZone[]>;
     getUser(userId: string): Promise<IUser | null>;
     getZoneByDeviceId(deviceId: string): Promise<IZone | null>;
     getAccessGroups(propertyId: string, accessibleBy?: string): Promise<IAccessGroup[]>;

package/dist/entities/admin/Admin.repository.js

@@ -278,6 +278,18 @@ let AdminRepository = (() => {
             }
             return null;
         }
+        async getZoneIdsByAccessGroupIds(accessGroupIds) {
+            if (accessGroupIds.length === 0) {
+                return [];
+            }
+            const query = `
+      SELECT DISTINCT "zoneId"
+      FROM dt_zones_collection_map
+      WHERE "collectionId" = ANY($1)
+    `;
+            const result = await this.postgres.query(query, [accessGroupIds]);
+            return result.rows.map((row) => row.zoneId);
+        }
         async getAllParentZones(zoneId) {
             const allParentZoneIds = [];
             let currentZoneId = zoneId;
@@ -416,6 +428,40 @@ let AdminRepository = (() => {
                 throw new Error("Failed to get zone");
             }
         }
+        async getZonesByIds(zoneIds) {
+            if (zoneIds.length === 0) {
+                return [];
+            }
+            try {
+                // Batch query to get all zones at once
+                const query = `SELECT * FROM dt_zones WHERE "id" = ANY($1)`;
+                const result = await this.postgres.query(query, [zoneIds]);
+                // Get all unique zone type IDs
+                const zoneTypeIds = [
+                    ...new Set(result.rows.map((row) => row.zoneTypeId)),
+                ];
+                // Batch query for zone types
+                let zoneTypesMap = new Map();
+                if (zoneTypeIds.length > 0) {
+                    const zoneTypesQuery = `SELECT * FROM "dt_zoneTypes" WHERE "id" = ANY($1)`;
+                    const zoneTypesResult = await this.postgres.query(zoneTypesQuery, [
+                        zoneTypeIds,
+                    ]);
+                    zoneTypesResult.rows.forEach((zt) => {
+                        zoneTypesMap.set(zt.id, { id: zt.id, name: zt.name });
+                    });
+                }
+                // Map zone types to zones
+                return result.rows.map((zoneData) => {
+                    zoneData.zoneType = zoneTypesMap.get(zoneData.zoneTypeId) || {};
+                    return zoneData;
+                });
+            }
+            catch (error) {
+                console.error("Error in getZonesByIds:", error);
+                return [];
+            }
+        }
         async getUser(userId) {
             const user = await this.postgres.query(`SELECT * FROM dt_users WHERE "id" = $1`, [userId]);
             if (user.rows.length > 0) {

package/dist/entities/admin/Admin.service.d.ts

@@ -8,6 +8,7 @@ export declare class AdminService {
     getAccessGroup(accessGroupId: string, propertyId?: string): Promise<IAccessGroup | null>;
     getAccessGroupByZoneId(zoneId: string): Promise<IAccessGroup[] | []>;
     getAccessgroupBySubParentZoneId(zoneId: string): Promise<IAccessGroup[]>;
+    getAllParentSubZonesByAccessGroupIds(accessGroupIds: string[]): Promise<string[]>;
     getZone(zoneId: string, propertyId?: string): Promise<IZone | null>;
     getUser(userId: string): Promise<IUser | null>;
     getZoneByDeviceId(deviceId: string): Promise<IZone | null>;

package/dist/entities/admin/Admin.service.js

@@ -133,6 +133,7 @@ let AdminService = (() => {
             }
             return accessGroups;
         }
+        //--------------------------USED FOR QUERY RESERVATION-----------------------
         async getAccessgroupBySubParentZoneId(zoneId) {
             if (!zoneId) {
                 throw new Error("Zone ID is required");
@@ -211,6 +212,51 @@ let AdminService = (() => {
                 return [];
             }
         }
+        // used for query reservation to find all the zones mapped with the access groups
+        async getAllParentSubZonesByAccessGroupIds(accessGroupIds) {
+            if (!accessGroupIds || accessGroupIds.length === 0) {
+                throw new Error("Access Group IDs are required");
+            }
+            try {
+                // Step 1: Find all zones mapped with these access groups
+                const mappedZoneIds = await this.adminRepository.getZoneIdsByAccessGroupIds(accessGroupIds);
+                if (mappedZoneIds.length === 0) {
+                    return [];
+                }
+                // OPTIMIZATION 1: Batch get all zones at once (reduces DB calls from O(n) to O(1))
+                const zones = await this.adminRepository.getZonesByIds(mappedZoneIds);
+                const zoneMap = new Map();
+                zones.forEach((zone) => zoneMap.set(zone.id, zone));
+                // Use Set to collect unique zone IDs from the start
+                const allZoneIds = new Set(mappedZoneIds);
+                // OPTIMIZATION 2: Process all zones in parallel (reduces time from O(n) sequential to O(1) parallel)
+                const zoneProcessingPromises = mappedZoneIds.map(async (zoneId) => {
+                    const zone = zoneMap.get(zoneId);
+                    if (!zone) {
+                        return { parentIds: [], childIds: [] };
+                    }
+                    // OPTIMIZATION 3: Get parents and children in parallel for each zone
+                    const [parentZoneIds, childZoneIds] = await Promise.all([
+                        this.adminRepository.getAllParentZones(zoneId),
+                        this.adminRepository.getAllChildZones(zoneId, zone.propertyId),
+                    ]);
+                    return { parentIds: parentZoneIds, childIds: childZoneIds };
+                });
+                // Wait for all zone processing to complete
+                const results = await Promise.all(zoneProcessingPromises);
+                // OPTIMIZATION 4: Batch add all IDs to Set (O(n) operation)
+                results.forEach(({ parentIds, childIds }) => {
+                    parentIds.forEach((id) => allZoneIds.add(id));
+                    childIds.forEach((id) => allZoneIds.add(id));
+                });
+                return Array.from(allZoneIds);
+            }
+            catch (error) {
+                console.error("Error in getAllParentSubZonesByAccessGroupIds:", error);
+                return [];
+            }
+        }
+        //----------------------------------------------------------------------------------
         async getZone(zoneId, propertyId) {
             if (!zoneId) {
                 throw new Error("Zone ID is required");

package/dist/index.d.ts

@@ -20,3 +20,4 @@ export { initialize, getConfig, shutdown } from "./config/config";
 export * from "./webhookQueue";
 export * from "./copilotQueue";
 export * from "./serviceQueue";
+export * from "./notificationQueue";

package/dist/index.js

@@ -65,3 +65,5 @@ __exportStar(require("./webhookQueue"), exports);
 __exportStar(require("./copilotQueue"), exports);
 //Export Service Queue
 __exportStar(require("./serviceQueue"), exports);
+// Export Notification Queue (Redis pub/sub for notifications)
+__exportStar(require("./notificationQueue"), exports);

package/dist/notificationQueue/index.d.ts

@@ -0,0 +1 @@
+export * from "./queue.service";

package/dist/notificationQueue/index.js

@@ -0,0 +1,17 @@
+"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 __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 });
+__exportStar(require("./queue.service"), exports);

package/dist/notificationQueue/queue.service.d.ts

@@ -0,0 +1,21 @@
+export interface NotificationQueuePayload {
+    userId: string;
+    orgId?: string;
+    propertyId?: string;
+    data?: any;
+    title?: string;
+    message?: string;
+    url?: string;
+}
+export interface NotificationQueueOptions {
+    channel?: string;
+}
+/**
+ * Publish an event payload to Redis so any interested consumer can process it.
+ */
+export declare function enqueueEvent(event: NotificationQueuePayload, opts?: NotificationQueueOptions): Promise<void>;
+/**
+ * Start a single pub/sub consumer in this process.
+ * The `handler` is responsible for business logic (e.g. calling processEvent()).
+ */
+export declare function startConsumer(handler: (payload: NotificationQueuePayload) => Promise<void>, opts?: NotificationQueueOptions): Promise<void>;

package/dist/notificationQueue/queue.service.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enqueueEvent = enqueueEvent;
+exports.startConsumer = startConsumer;
+const redis_1 = require("../db/redis");
+const DEFAULT_CHANNEL = "notification:events";
+let consumerStarted = false;
+/**
+ * Publish an event payload to Redis so any interested consumer can process it.
+ */
+async function enqueueEvent(event, opts) {
+    const client = (0, redis_1.getRedisClient)();
+    const channel = opts?.channel ?? DEFAULT_CHANNEL;
+    try {
+        await client.publish(channel, JSON.stringify(event));
+    }
+    catch (error) {
+        // eslint-disable-next-line no-console
+        console.error("Failed to publish notification event", {
+            error,
+            channel,
+            event,
+        });
+    }
+}
+/**
+ * Start a single pub/sub consumer in this process.
+ * The `handler` is responsible for business logic (e.g. calling processEvent()).
+ */
+async function startConsumer(handler, opts) {
+    if (consumerStarted) {
+        // eslint-disable-next-line no-console
+        console.warn("NotificationQueue consumer already started; skipping");
+        return;
+    }
+    consumerStarted = true;
+    const baseClient = (0, redis_1.getRedisClient)();
+    const subscriber = baseClient.duplicate();
+    const channel = opts?.channel ?? DEFAULT_CHANNEL;
+    try {
+        await subscriber.connect();
+    }
+    catch (error) {
+        // eslint-disable-next-line no-console
+        console.error("Failed to connect Redis subscriber for notifications", {
+            error,
+        });
+        return;
+    }
+    subscriber.on("error", (error) => {
+        // eslint-disable-next-line no-console
+        console.error("Redis notification subscriber error", { error });
+    });
+    try {
+        // ioredis `subscribe` expects an (err, count) callback, not a message handler.
+        // We subscribe first, then attach a separate "message" listener.
+        await subscriber.subscribe(channel);
+        subscriber.on("message", async (subscribedChannel, message) => {
+            // Only process messages for the intended channel (defensive in case of multiple subscriptions)
+            if (subscribedChannel !== channel) {
+                return;
+            }
+            let payload;
+            try {
+                payload = JSON.parse(message);
+            }
+            catch (error) {
+                // eslint-disable-next-line no-console
+                console.error("Failed to parse pub/sub notification payload", {
+                    error,
+                    message,
+                    channel: subscribedChannel,
+                });
+                return;
+            }
+            try {
+                await handler(payload);
+            }
+            catch (error) {
+                // eslint-disable-next-line no-console
+                console.error("Failed to process pub/sub notification event", {
+                    error,
+                    payload,
+                    channel: subscribedChannel,
+                });
+            }
+        });
+    }
+    catch (error) {
+        // eslint-disable-next-line no-console
+        console.error("Error while subscribing to notification channel", {
+            error,
+            channel,
+        });
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dt-common-device",
-  "version": "13.0.9",
+  "version": "13.0.13",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [