dt-common-device 1.2.3 → 1.2.4

package/dist/index.js

@@ -15,20 +15,19 @@ 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.getConfig = exports.initialize = exports.LocalPropertyService = exports.LocalConnectionService = exports.LocalHubService = exports.LocalDeviceService = exports.CloudDeviceService = exports.CloudConnection = exports.DeviceFactory = exports.CloudDevice = void 0;
+exports.getConfig = exports.initialize = exports.LocalScheduleService = exports.LocalPropertyService = exports.LocalConnectionService = exports.LocalHubService = exports.LocalDeviceService = exports.DeviceFactory = exports.CloudDeviceService = exports.CloudDevice = void 0;
 // Cloud exports
 var entities_1 = require("./device/cloud/entities");
 Object.defineProperty(exports, "CloudDevice", { enumerable: true, get: function () { return entities_1.CloudDevice; } });
-Object.defineProperty(exports, "DeviceFactory", { enumerable: true, get: function () { return entities_1.DeviceFactory; } });
-Object.defineProperty(exports, "CloudConnection", { enumerable: true, get: function () { return entities_1.CloudConnection; } });
 Object.defineProperty(exports, "CloudDeviceService", { enumerable: true, get: function () { return entities_1.CloudDeviceService; } });
+Object.defineProperty(exports, "DeviceFactory", { enumerable: true, get: function () { return entities_1.DeviceFactory; } });
 var services_1 = require("./device/local/services");
 Object.defineProperty(exports, "LocalDeviceService", { enumerable: true, get: function () { return services_1.LocalDeviceService; } });
 Object.defineProperty(exports, "LocalHubService", { enumerable: true, get: function () { return services_1.LocalHubService; } });
 Object.defineProperty(exports, "LocalConnectionService", { enumerable: true, get: function () { return services_1.LocalConnectionService; } });
 Object.defineProperty(exports, "LocalPropertyService", { enumerable: true, get: function () { return services_1.LocalPropertyService; } });
+Object.defineProperty(exports, "LocalScheduleService", { enumerable: true, get: function () { return services_1.LocalScheduleService; } });
 __exportStar(require("./device/cloud/interfaces"), exports);
-__exportStar(require("./device/cloud/types"), exports);
 // Local exports
 __exportStar(require("./device/local/interfaces"), exports);
 //initialize export

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "dt-common-device",
-  "version": "1.2.3",
+  "version": "1.2.4",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc",
-    "patch": "npm version patch && npm run build",
-    "minor": "npm version minor && npm run build",
-    "major": "npm version major && npm run build",
+    "patch": "npm version patch && npm run build && npm publish",
+    "minor": "npm version minor && npm run build && npm publish",
+    "major": "npm version major && npm run build && npm publish",
     "security:audit": "npm audit --audit-level=moderate",
     "security:fix": "npm audit fix",
     "security:check": "npm audit && npm outdated",

package/src/device/cloud/entities/CloudDevice.ts

@@ -1,7 +1,7 @@
 import { IDevice } from "../../local/interfaces";
 import { ICloudDevice } from "../interfaces/ICloudDevice";
 import { ICloudDeviceService } from "../interfaces/ICloudDeviceService";
-import { IConnection } from "../types";
+import { IConnection } from "../../local/interfaces/IConnection";
 
 export abstract class CloudDevice implements ICloudDevice {
   deviceId: string;

package/src/device/cloud/entities/CloudDeviceService.ts

@@ -1,5 +1,5 @@
 import { ICloudDeviceService } from "../interfaces/ICloudDeviceService";
-import { IConnection } from "../types";
+import { IConnection } from "../../local/interfaces/IConnection";
 
 export class CloudDeviceService implements ICloudDeviceService {
   async getConnection(deviceId: string): Promise<IConnection> {

package/src/device/cloud/entities/index.ts

@@ -1,4 +1,3 @@
 export * from "./CloudDevice";
 export * from "./DeviceFactory";
-export * from "./CloudConnection";
 export * from "./CloudDeviceService";

package/src/device/cloud/interfaces/ICloudDeviceService.ts

@@ -1,5 +1,5 @@
 // Interface for CloudDeviceService
-import { IConnection } from "../types";
+import { IConnection } from "../../local/interfaces/IConnection";
 
 export interface ICloudDeviceService {
   getConnection(deviceId: string): Promise<IConnection>;

package/src/device/cloud/interfaces/index.ts

@@ -1,3 +1,3 @@
-export * from "./ICloudConnection";
 export * from "./ICloudDevice";
 export * from "./ICloudDeviceService";
+export * from "./IDeviceFactory";

package/src/device/local/events/EventHandler.ts

@@ -98,4 +98,20 @@ export class EventHandler {
     };
     await publishAudit(payload);
   }
+
+  async onDeviceMetaChange(deviceId: string, metaData: Record<string, any>) {
+    await eventDispatcher.publishEvent(
+      DeviceEvents.DEVICE_META_DATA_SET,
+      { deviceId, metaData },
+      this.source
+    );
+    const payload = {
+      eventType: DeviceEvents.DEVICE_META_DATA_SET,
+      properties: {
+        deviceId,
+        metaData,
+      },
+    };
+    await publishAudit(payload);
+  }
 }

package/src/device/local/interfaces/IConnection.ts

@@ -0,0 +1,27 @@
+export interface IConnection {
+  id?: string;
+  createdAt?: Date;
+  updatedAt?: Date;
+  isDeleted?: boolean;
+  connectionName: string;
+  connectionRefId: string;
+  propertyId: string;
+  connectionProvider: ConnectionProvider;
+  accessToken?: string;
+  refreshToken?: string;
+  clientId?: string;
+  clientSecret: string;
+  isActive?: boolean;
+  metaData?: any;
+}
+
+export enum ConnectionProvider {
+  Smartthings = "Smartthings",
+  SaltoKS = "SaltoKS",
+  TTLock = "TTLock",
+  Tuya = "Tuya",
+  Schlage = "Schlage",
+  YaleWifi = "YaleWifi",
+  Sensibo = "Sensibo",
+  Devicethread = "Devicethread",
+}

package/src/device/local/interfaces/ISchedule.ts

@@ -0,0 +1,40 @@
+export interface ISchedule {
+  id?: string;
+  name: string;
+  deviceId: string;
+  scheduleId: string | null; // generated from cloud api, optional
+  state: {
+    targetTemperature?: number;
+    temperatureUnit?: "C" | "F";
+    mode?: "cool" | "heat" | "fan" | "dry" | "auto";
+    swing?:
+      | "stopped"
+      | "rangeFull"
+      | "fixedTop"
+      | "fixedMiddleTop"
+      | "fixedMiddle"
+      | "fixedMiddleBottom"
+      | "fixedBottom";
+    fanLevel?: "auto" | "low" | "medium" | "high";
+  };
+  startTime: string; // ISO date string
+  endTime: string; // ISO date string
+  recurringDays: (
+    | "Monday"
+    | "Tuesday"
+    | "Wednesday"
+    | "Thursday"
+    | "Friday"
+    | "Saturday"
+    | "Sunday"
+  )[];
+  createTime?: string; // ISO date string, optional
+  nextTime?: string; // ISO date string, optional
+  nextTimeSecondsFromNow?: number;
+  targetTimeLocal: string; // ISO date string
+  timezone: string;
+  scheduleInheritedFrom: "zone" | "device";
+  zoneId: string;
+  userId: string;
+  status?: "SET" | "UNSET";
+}

package/src/device/local/repository/Connection.repository.ts

@@ -1,5 +1,5 @@
 import { getPostgresClient } from "../../../db";
-import { IConnection } from "../../cloud/types";
+import { IConnection } from "../interfaces/IConnection";
 import { Service } from "typedi";
 
 @Service()
@@ -8,6 +8,26 @@ export class ConnectionRepository {
   constructor() {
     this.pool = getPostgresClient();
   }
+
+  async createConnection(data: Partial<IConnection>): Promise<IConnection> {
+    const result = await this.pool.query(
+      "INSERT INTO dt_connections (connectionName, connectionRefId, propertyId, connectionProvider, accessToken, refreshToken, clientId, clientSecret, isActive, metaData) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10) RETURNING *",
+      [
+        data.connectionName,
+        data.connectionRefId,
+        data.propertyId,
+        data.connectionProvider,
+        data.accessToken,
+        data.refreshToken,
+        data.clientId,
+        data.clientSecret,
+        data.isActive,
+        data.metaData,
+      ]
+    );
+    return result.rows[0];
+  }
+
   async getConnectionById(connectionId: string): Promise<IConnection> {
     const result = await this.pool.query(
       "SELECT * FROM dt_connections WHERE id = $1",

package/src/device/local/repository/Hub.repository.ts

@@ -19,7 +19,7 @@ export class HubRepository {
     this.postgres = getPostgresClient();
   }
 
-  async addHub(body: any): Promise<IDevice> {
+  async addHub(body: Partial<IDevice>): Promise<IDevice> {
     return await axios.post(`${this.baseUrl}/devices/hubs`, body);
   }
 

package/src/device/local/repository/Schedule.repository.ts

@@ -0,0 +1,56 @@
+import { Service } from "typedi";
+import { getConfig } from "../../../config/config";
+import axios from "axios";
+import { ISchedule } from "../interfaces/ISchedule";
+
+@Service()
+export class ScheduleRepository {
+  private readonly baseUrl: string;
+  constructor() {
+    const { DEVICE_SERVICE } = getConfig();
+    if (!DEVICE_SERVICE) {
+      throw new Error(
+        "DEVICE_SERVICE is not configured. Call initialize() first with DEVICE_SERVICE."
+      );
+    }
+    this.baseUrl = DEVICE_SERVICE;
+  }
+  async getSchedule(scheduleId: string) {
+    try {
+      const response = await axios.get(
+        `${this.baseUrl}/devices/schedule?id=${scheduleId}`
+      );
+      return response.data;
+    } catch (error: any) {
+      console.log(error);
+      throw new Error(`Failed to get schedule: ${error.response.data.message}`);
+    }
+  }
+
+  async getScheduleByZone(zoneId: string) {
+    try {
+      const response = await axios.get(
+        `${this.baseUrl}/devices/schedules?zoneId=${zoneId}`
+      );
+      return response.data;
+    } catch (error: any) {
+      console.log(error);
+      throw new Error(`Failed to get schedule: ${error.response.data.message}`);
+    }
+  }
+
+  async setSchedule(scheduleId: string, schedule: ISchedule) {
+    try {
+      const response = await axios.put(
+        `${this.baseUrl}/devices/schedules/${scheduleId}`,
+        schedule
+      );
+      return response.data;
+    } catch (error: any) {
+      console.log(error);
+      throw new Error(
+        `Failed to update schedule: ${error.response.data.message}`
+      );
+    }
+  }
+}

package/src/device/local/services/Connection.service.ts

@@ -1,6 +1,6 @@
 import { Container } from "typedi";
-import { IConnection } from "../../cloud/types";
 import { ConnectionRepository } from "../repository/Connection.repository";
+import { IConnection } from "../interfaces/IConnection";
 
 export class LocalConnectionService {
   private readonly connectionRepository: ConnectionRepository;
@@ -8,11 +8,32 @@ export class LocalConnectionService {
     this.connectionRepository = Container.get(ConnectionRepository);
   }
 
+  async createConnection(data: Partial<IConnection>): Promise<IConnection> {
+    if (
+      !data.connectionName ||
+      !data.connectionRefId ||
+      !data.propertyId ||
+      !data.connectionProvider
+    ) {
+      throw new Error("Missing required fields");
+    }
+    return await this.connectionRepository.createConnection(data);
+  }
+
   async getConnection(connectionId: string): Promise<IConnection> {
+    if (!connectionId) {
+      throw new Error("Connection ID is required");
+    }
     return await this.connectionRepository.getConnectionById(connectionId);
   }
 
-  async updateConnection(connectionId: string, data: any) {
+  async updateConnection(
+    connectionId: string,
+    data: Partial<IConnection>
+  ): Promise<IConnection> {
+    if (!connectionId) {
+      throw new Error("Connection ID is required");
+    }
     return await this.connectionRepository.updateConnection(connectionId, data);
   }
 }

package/src/device/local/services/Device.service.ts

@@ -1,27 +1,16 @@
-import axios from "axios";
-import {
-  getConfig,
-  checkAwsEnv,
-  ensureAuditInitialized,
-} from "../../../config/config";
+import { checkAwsEnv, ensureAuditInitialized } from "../../../config/config";
 import { IDevice } from "../interfaces";
-import { eventDispatcher } from "dt-pub-sub";
-import { publishAudit } from "dt-audit-library";
 import { EventHandler } from "../events/EventHandler";
 import { isEqual } from "lodash";
 import { AlertService } from "./Alert.service";
-import { getPostgresClient } from "../../../db";
 import { DeviceRepository } from "../repository/Device.repository";
 import Container from "typedi";
 
 export class LocalDeviceService {
-  private readonly source = "dt-common-device";
   private readonly eventHandler: EventHandler;
   private readonly alertService: AlertService;
-  //private readonly redis;
   private readonly deviceRepository: DeviceRepository;
   constructor() {
-    // this.redis = getRedisClient();
     checkAwsEnv();
     ensureAuditInitialized();
     this.eventHandler = new EventHandler();
@@ -37,6 +26,9 @@ export class LocalDeviceService {
     deviceId: string,
     withHubDetails: boolean = false
   ): Promise<IDevice> {
+    if (!deviceId) {
+      throw new Error("Device ID is required");
+    }
     return await this.deviceRepository.getDevice(deviceId, withHubDetails);
   }
 
@@ -44,6 +36,9 @@ export class LocalDeviceService {
     deviceIds: string[],
     withHubDetails: boolean = false
   ): Promise<IDevice[]> {
+    if (!deviceIds.length) {
+      throw new Error("At least one device ID is required");
+    }
     return await this.deviceRepository.getDevices(deviceIds, withHubDetails);
   }
 
@@ -51,6 +46,9 @@ export class LocalDeviceService {
     propertyId: string,
     withHubDetails: boolean = false
   ): Promise<IDevice[]> {
+    if (!propertyId) {
+      throw new Error("Property ID is required");
+    }
     return await this.deviceRepository.getPropertyDevices(
       propertyId,
       withHubDetails
@@ -58,18 +56,30 @@ export class LocalDeviceService {
   }
 
   async updateDevice(deviceId: string, body: any): Promise<any> {
+    if (!deviceId) {
+      throw new Error("Device ID is required");
+    }
     return await this.eventHandler.onDeviceUpdate(deviceId, body);
   }
 
   async deleteDevice(deviceId: string): Promise<any> {
+    if (!deviceId) {
+      throw new Error("Device ID is required");
+    }
     return await this.eventHandler.onDeviceDelete(deviceId);
   }
 
   async getState(deviceId: string) {
+    if (!deviceId) {
+      throw new Error("Device ID is required");
+    }
     return await this.deviceRepository.getState(deviceId);
   }
 
   async setState(deviceId: string, newState: any) {
+    if (!deviceId || !newState) {
+      throw new Error("Device ID and new state are required");
+    }
     // If old state and new state are different
     const oldState = (await this.getState(deviceId))?.data?.state || {};
     const changedKeys = Object.keys(newState).filter(
@@ -81,10 +91,16 @@ export class LocalDeviceService {
   }
 
   async getStatus(deviceId: string) {
+    if (!deviceId) {
+      throw new Error("Device ID is required");
+    }
     return await this.deviceRepository.getStatus(deviceId);
   }
 
   async setStatus(deviceId: string, newStatus: any) {
+    if (!deviceId || !newStatus) {
+      throw new Error("Device ID and new status are required");
+    }
     // If old status and new status are different
     const oldStatus = await this.getStatus(deviceId);
     const changedKeys = Object.keys(newStatus).filter(
@@ -110,9 +126,15 @@ export class LocalDeviceService {
   }
 
   async getBatteryLevel(deviceId: string) {
+    if (!deviceId) {
+      throw new Error("Device ID is required");
+    }
     return await this.deviceRepository.getBatteryLevel(deviceId);
   }
   async setBatteryLevel(deviceId: string, newBatteryLevel: any) {
+    if (!deviceId || !newBatteryLevel) {
+      throw new Error("Device ID and new battery level are required");
+    }
     // If old battery level and new battery level are different
     const oldBatteryLevel = await this.getBatteryLevel(deviceId);
     const changedKeys = Object.keys(newBatteryLevel).filter(
@@ -136,29 +158,29 @@ export class LocalDeviceService {
     }
   }
   async getMetaData(deviceId: string) {
+    if (!deviceId) {
+      throw new Error("Device ID is required");
+    }
     return await this.deviceRepository.getMetaData(deviceId);
   }
   async setMetaData(deviceId: string, metaData: Record<string, any>) {
-    await eventDispatcher.publishEvent(
-      "device.metaData.set",
-      { deviceId, metaData },
-      this.source
-    );
-    const payload = {
-      eventType: "device.metaData.set",
-      properties: {
-        deviceId,
-        metaData,
-      },
-    };
-    await publishAudit(payload);
+    if (!deviceId || !metaData) {
+      throw new Error("Device ID and meta data are required");
+    }
+    return await this.eventHandler.onDeviceMetaChange(deviceId, metaData);
   }
 
   async getDevicesByZone(zoneId: string) {
+    if (!zoneId) {
+      throw new Error("Zone ID is required");
+    }
     return await this.deviceRepository.getDevicesByZone(zoneId);
   }
 
   async getDevicesByAccessGroup(accessGroupId: string) {
+    if (!accessGroupId) {
+      throw new Error("Access Group ID is required");
+    }
     return await this.deviceRepository.getDevicesByAccessGroup(accessGroupId);
   }
 }

package/src/device/local/services/Hub.service.ts

@@ -8,31 +8,50 @@ export class LocalHubService {
     this.hubRepository = Container.get(HubRepository);
   }
 
-  async addHub(body: IDevice): Promise<IDevice> {
+  async addHub(body: Partial<IDevice>): Promise<IDevice> {
     return await this.hubRepository.addHub(body);
   }
 
   async getHubs(hubIds: string[]): Promise<IDevice[]> {
+    if (!hubIds.length) {
+      throw new Error("At least one hub ID is required");
+    }
     return await this.hubRepository.getHubs(hubIds);
   }
 
   async getHub(hubId: string): Promise<IDevice> {
+    if (!hubId) {
+      throw new Error("Hub ID is required");
+    }
     return await this.hubRepository.getHub(hubId);
   }
 
   async updateHub(hubId: string, body: Partial<IDevice>): Promise<IDevice> {
+    if (!hubId) {
+      throw new Error("Hub ID is required");
+    }
     return await this.hubRepository.updateHub(hubId, body);
   }
 
   async getStatus(hubId: string): Promise<any> {
+    if (!hubId) {
+      throw new Error("Hub ID is required");
+    }
     return await this.hubRepository.getStatus(hubId);
   }
 
   async deleteHub(hubId: string): Promise<any> {
+    if (!hubId) {
+      throw new Error("Hub ID is required");
+    }
     return await this.hubRepository.deleteHub(hubId);
   }
 
+
   async deleteAllHubs(hubIds: string[]): Promise<any> {
+    if (!hubIds.length) {
+      throw new Error("At least one hub ID is required");
+    }
     return await this.hubRepository.deleteAllHubs(hubIds);
   }
 }

package/src/device/local/services/Property.service.ts

@@ -7,14 +7,23 @@ export class LocalPropertyService {
   }
 
   async getPropertyPreferences(propertyId: string) {
+    if (!propertyId) {
+      throw new Error("Property ID is required");
+    }
     return await this.propertyRepository.getPropertyPreferences(propertyId);
   }
 
   async getProperty(propertyId: string) {
+    if (!propertyId) {
+      throw new Error("Property ID is required");
+    }
     return await this.propertyRepository.getProperty(propertyId);
   }
 
   async getPropertyTimeZone(propertyId: string) {
+    if (!propertyId) {
+      throw new Error("Property ID is required");
+    }
     const property = await this.propertyRepository.getProperty(propertyId);
     if (!property) {
       throw new Error("Property not found");

package/src/device/local/services/Schedule.service.ts

@@ -0,0 +1,22 @@
+import Container from "typedi";
+import { ScheduleRepository } from "../repository/Schedule.repository";
+import { ISchedule } from "../interfaces/ISchedule";
+
+export class LocalScheduleService {
+  private readonly scheduleRepository: ScheduleRepository;
+  constructor() {
+    this.scheduleRepository = Container.get(ScheduleRepository);
+  }
+
+  async getSchedule(scheduleId: string) {
+    return await this.scheduleRepository.getSchedule(scheduleId);
+  }
+
+  async setSchedule(scheduleId: string, schedule: ISchedule) {
+    return await this.scheduleRepository.setSchedule(scheduleId, schedule);
+  }
+
+  async getScheduleByZone(zoneId: string) {
+    return await this.scheduleRepository.getScheduleByZone(zoneId);
+  }
+}

package/src/device/local/services/index.ts

@@ -2,3 +2,4 @@ export { LocalDeviceService } from "./Device.service";
 export { LocalHubService } from "./Hub.service";
 export { LocalConnectionService } from "./Connection.service";
 export { LocalPropertyService } from "./Property.service";
+export { LocalScheduleService } from "./Schedule.service";

package/src/index.ts

@@ -3,19 +3,18 @@
 // Cloud exports
 export {
   CloudDevice,
-  DeviceFactory,
-  CloudConnection,
   CloudDeviceService,
+  DeviceFactory,
 } from "./device/cloud/entities";
 export {
   LocalDeviceService,
   LocalHubService,
   LocalConnectionService,
   LocalPropertyService,
+  LocalScheduleService,
 } from "./device/local/services";
 
 export * from "./device/cloud/interfaces";
-export * from "./device/cloud/types";
 
 // Local exports
 export * from "./device/local/interfaces";

package/src/device/cloud/entities/CloudConnection.ts

@@ -1,13 +0,0 @@
-// Device Cloud Service - Class Implementation
-import { ICloudConnection } from "../interfaces";
-import { IDeviceAccountResponse, IConnection } from "../types";
-
-export abstract class CloudConnection implements ICloudConnection {
-  abstract createConnection(
-    data: IConnection,
-    userId: string
-  ): Promise<IConnection>;
-  abstract getDeviceAccount(
-    connection: IConnection
-  ): Promise<IDeviceAccountResponse>;
-}

package/src/device/cloud/interfaces/ICloudConnection.ts

@@ -1,6 +0,0 @@
-import { IConnection, IDeviceAccountResponse } from "../types";
-
-export interface ICloudConnection {
-  createConnection(data: IConnection, userId: string): Promise<IConnection>;
-  getDeviceAccount(connection: IConnection): Promise<IDeviceAccountResponse>;
-}