dt-common-device 13.0.3 → 13.0.8

package/dist/device/cloud/services/Hub.service.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HubService = void 0;
+class HubService {
+    constructor(hub) {
+        Object.assign(this, hub);
+    }
+}
+exports.HubService = HubService;

package/dist/device/cloud/services/SmartThingsDeviceService.d.ts

@@ -0,0 +1,38 @@
+import { ISmartthingsDeviceCommandManager } from "../interface";
+import { IDeviceCommand, ISmartthingsDeviceCommand, ICommandResponse } from "../types";
+/**
+ * SmartThings Device Service Class
+ * Implements ISmartthingsDeviceCommandManager interface with empty implementations
+ * Implementation will be provided by the consuming project
+ */
+export declare class SmartThingsDeviceService implements ISmartthingsDeviceCommandManager {
+    /**
+     * Invokes a command on a device
+     * @param command - Device command to execute
+     * @param deviceId - Device identifier
+     * @returns Promise with command response
+     */
+    invokeCommand(command: IDeviceCommand, deviceId: string): Promise<ICommandResponse>;
+    /**
+     * Performs device action for SmartThings
+     * @param commands - Array of SmartThings device commands
+     * @param deviceId - Device identifier
+     * @param accessToken - Access token for authentication
+     * @returns Promise with action result
+     */
+    performDeviceAction(commands: ISmartthingsDeviceCommand[], deviceId: string, accessToken: string): Promise<any>;
+    /**
+     * Gets device status for SmartThings
+     * @param deviceId - Device identifier
+     * @param accessToken - Access token for authentication
+     * @returns Promise with device status
+     */
+    getDeviceStatus(deviceId: string, accessToken: string): Promise<any>;
+    /**
+     * Gets device lock status for SmartThings
+     * @param deviceId - Device identifier
+     * @param accessToken - Access token for authentication
+     * @returns Promise with lock status
+     */
+    getDeviceLockStatus(deviceId: string, accessToken: string): Promise<any>;
+}

package/dist/device/cloud/services/SmartThingsDeviceService.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmartThingsDeviceService = void 0;
+/**
+ * SmartThings Device Service Class
+ * Implements ISmartthingsDeviceCommandManager interface with empty implementations
+ * Implementation will be provided by the consuming project
+ */
+class SmartThingsDeviceService {
+    /**
+     * Invokes a command on a device
+     * @param command - Device command to execute
+     * @param deviceId - Device identifier
+     * @returns Promise with command response
+     */
+    async invokeCommand(command, deviceId) {
+        // Implementation will be provided by the consuming project
+        throw new Error("invokeCommand method not implemented");
+    }
+    /**
+     * Performs device action for SmartThings
+     * @param commands - Array of SmartThings device commands
+     * @param deviceId - Device identifier
+     * @param accessToken - Access token for authentication
+     * @returns Promise with action result
+     */
+    async performDeviceAction(commands, deviceId, accessToken) {
+        // Implementation will be provided by the consuming project
+        throw new Error("performDeviceAction method not implemented");
+    }
+    /**
+     * Gets device status for SmartThings
+     * @param deviceId - Device identifier
+     * @param accessToken - Access token for authentication
+     * @returns Promise with device status
+     */
+    async getDeviceStatus(deviceId, accessToken) {
+        // Implementation will be provided by the consuming project
+        throw new Error("getDeviceStatus method not implemented");
+    }
+    /**
+     * Gets device lock status for SmartThings
+     * @param deviceId - Device identifier
+     * @param accessToken - Access token for authentication
+     * @returns Promise with lock status
+     */
+    async getDeviceLockStatus(deviceId, accessToken) {
+        // Implementation will be provided by the consuming project
+        throw new Error("getDeviceLockStatus method not implemented");
+    }
+}
+exports.SmartThingsDeviceService = SmartThingsDeviceService;

package/dist/device/cloud/services/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./CloudDevice.service";
+export * from "./Connection.service";

package/dist/device/cloud/services/index.js

@@ -0,0 +1,18 @@
+"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("./CloudDevice.service"), exports);
+__exportStar(require("./Connection.service"), exports);

package/dist/device/cloud/types.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Represents a connection to a device provider.
+ * WARNING: Do not log or expose sensitive fields (accessToken, clientSecret).
+ */
+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 interface IConnectionPagination {
+    page: number;
+    limit: number;
+}
+/**
+ * Device account response from provider.
+ * WARNING: Do not log or expose connection_access_token.
+ */
+export interface IDeviceAccountResponse {
+    id: string;
+    connection_name: string;
+    connection_access_token: string;
+    connection_provider: string;
+    totalDevices: number;
+    connection_ref_id: string;
+    isActive: boolean;
+}
+export interface IConnectionConnectParams {
+    code?: string;
+    propertyId?: string;
+    [key: string]: unknown;
+}
+export declare enum ConnectionProvider {
+    Smartthings = "Smartthings",
+    SaltoKS = "SaltoKS",
+    TTLock = "TTLock",
+    Tuya = "Tuya",
+    Schlage = "Schlage",
+    YaleWifi = "YaleWifi",
+    Sensibo = "Sensibo",
+    Devicethread = "Devicethread"
+}

package/dist/device/cloud/types.js

@@ -0,0 +1,15 @@
+"use strict";
+// Device Cloud Type Interfaces for DeviceThread Common Library
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionProvider = void 0;
+var ConnectionProvider;
+(function (ConnectionProvider) {
+    ConnectionProvider["Smartthings"] = "Smartthings";
+    ConnectionProvider["SaltoKS"] = "SaltoKS";
+    ConnectionProvider["TTLock"] = "TTLock";
+    ConnectionProvider["Tuya"] = "Tuya";
+    ConnectionProvider["Schlage"] = "Schlage";
+    ConnectionProvider["YaleWifi"] = "YaleWifi";
+    ConnectionProvider["Sensibo"] = "Sensibo";
+    ConnectionProvider["Devicethread"] = "Devicethread";
+})(ConnectionProvider || (exports.ConnectionProvider = ConnectionProvider = {}));

package/dist/device/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./cloud/interface";
+export * from "./cloud/types";
+export type { IConnection, IConnectionConnectParams, IDevice, IDeviceAccountResponse, } from "./cloud/types";
+export type { IDeviceCloudService } from "./cloud/interface";

package/dist/device/index.js

@@ -0,0 +1,20 @@
+"use strict";
+// DeviceThread Common Library - Device Module
+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 });
+// Export cloud device interfaces
+__exportStar(require("./cloud/interface"), exports);
+__exportStar(require("./cloud/types"), exports);

package/dist/device/local/entities/AlertBuilder.d.ts

@@ -0,0 +1,87 @@
+import { CreateAlertData, AlertCategory, AlertSeverity, EntityType } from "../../../types/alert.types";
+/**
+ * AlertBuilder - A builder pattern implementation for constructing CreateAlertData objects
+ *
+ * This builder provides a fluent interface for creating alert data with proper validation
+ * and default values. It follows the Builder pattern which is a standard design pattern
+ * in TypeScript for constructing complex objects.
+ *
+ * Usage example:
+ * const alertData = new AlertBuilder()
+ *   .setCategory(AlertCategory.OPERATIONS)
+ *   .setPropertyId("prop123")
+ *   .setTitle("Device Offline")
+ *   .setDescription("Device has been offline for more than 5 minutes")
+ *   .setEntityId("device456")
+ *   .setEntityType(EntityType.DEVICE)
+ *   .setSeverity(AlertSeverity.HIGH)
+ *   .setCreatedBy("user789")
+ *   .build();
+ */
+export declare class AlertBuilder {
+    private data;
+    /**
+     * Sets the alert category
+     */
+    setCategory(category: AlertCategory): AlertBuilder;
+    /**
+     * Sets the property ID
+     */
+    setPropertyId(propertyId: string): AlertBuilder;
+    /**
+     * Sets the alert title
+     */
+    setTitle(title: string): AlertBuilder;
+    /**
+     * Sets the alert description
+     */
+    setDescription(description: string): AlertBuilder;
+    /**
+     * Sets the entity ID (optional)
+     */
+    setEntityId(entityId?: string): AlertBuilder;
+    /**
+     * Sets the entity type
+     */
+    setEntityType(entityType: EntityType): AlertBuilder;
+    /**
+     * Sets the alert severity (optional, defaults to MEDIUM)
+     */
+    setSeverity(severity?: AlertSeverity): AlertBuilder;
+    /**
+     * Sets the user who created the alert (optional)
+     */
+    setCreatedBy(createdBy?: string): AlertBuilder;
+    /**
+     * Sets the snooze until date (optional)
+     */
+    setSnoozeUntil(snoozeUntil?: Date): AlertBuilder;
+    /**
+     * Validates that all required fields are present
+     */
+    private validate;
+    /**
+     * Builds and returns the CreateAlertData object
+     * @throws Error if required fields are missing
+     */
+    build(): CreateAlertData;
+    /**
+     * Resets the builder to its initial state
+     */
+    reset(): AlertBuilder;
+    /**
+     * Creates a new builder instance with predefined values for common alert types
+     */
+    static createReadinessAlert(): AlertBuilder;
+    static createOperationsAlert(): AlertBuilder;
+    static createSecurityAlert(): AlertBuilder;
+    static createEnergyAlert(): AlertBuilder;
+    /**
+     * Creates a device-specific alert builder
+     */
+    static createDeviceAlert(deviceId: string, propertyId: string): AlertBuilder;
+    /**
+     * Creates a hub-specific alert builder
+     */
+    static createHubAlert(hubId: string, propertyId: string): AlertBuilder;
+}

package/dist/device/local/entities/AlertBuilder.example.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Example usage of AlertBuilder
+ * This file demonstrates various ways to use the AlertBuilder pattern
+ */
+export declare function createBasicAlert(): import("../../../types/alert.types").CreateAlertData;
+export declare function createDeviceAlert(): import("../../../types/alert.types").CreateAlertData;
+export declare function createSecurityAlert(): import("../../../types/alert.types").CreateAlertData;
+export declare function createEnergyAlert(): import("../../../types/alert.types").CreateAlertData;
+export declare function createHubAlert(): import("../../../types/alert.types").CreateAlertData;
+export declare function createSnoozedAlert(): import("../../../types/alert.types").CreateAlertData;
+export declare function createMultipleAlerts(): import("../../../types/alert.types").CreateAlertData[];

package/dist/device/local/entities/AlertBuilder.example.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBasicAlert = createBasicAlert;
+exports.createDeviceAlert = createDeviceAlert;
+exports.createSecurityAlert = createSecurityAlert;
+exports.createEnergyAlert = createEnergyAlert;
+exports.createHubAlert = createHubAlert;
+exports.createSnoozedAlert = createSnoozedAlert;
+exports.createMultipleAlerts = createMultipleAlerts;
+const AlertBuilder_1 = require("./AlertBuilder");
+const alert_types_1 = require("../../../types/alert.types");
+/**
+ * Example usage of AlertBuilder
+ * This file demonstrates various ways to use the AlertBuilder pattern
+ */
+// Example 1: Basic alert creation
+function createBasicAlert() {
+    const alertData = new AlertBuilder_1.AlertBuilder()
+        .setCategory(alert_types_1.AlertCategory.OPERATIONS)
+        .setPropertyId("prop123")
+        .setTitle("Device Offline")
+        .setDescription("Device has been offline for more than 5 minutes")
+        .setEntityId("device456")
+        .setEntityType(alert_types_1.EntityType.DEVICE)
+        .setSeverity(alert_types_1.AlertSeverity.HIGH)
+        .setCreatedBy("user789")
+        .build();
+    return alertData;
+}
+// Example 2: Using static factory methods
+function createDeviceAlert() {
+    const alertData = AlertBuilder_1.AlertBuilder.createDeviceAlert("device123", "prop456")
+        .setCategory(alert_types_1.AlertCategory.READINESS)
+        .setTitle("Device Maintenance Required")
+        .setDescription("Device firmware update is available")
+        .setSeverity(alert_types_1.AlertSeverity.MEDIUM)
+        .setCreatedBy("system")
+        .build();
+    return alertData;
+}
+// Example 3: Using predefined alert types
+function createSecurityAlert() {
+    const alertData = AlertBuilder_1.AlertBuilder.createSecurityAlert()
+        .setPropertyId("prop789")
+        .setTitle("Unauthorized Access Attempt")
+        .setDescription("Multiple failed login attempts detected")
+        .setEntityId("user123")
+        .setEntityType(alert_types_1.EntityType.USER)
+        .setCreatedBy("security-system")
+        .build();
+    return alertData;
+}
+// Example 4: Creating energy alert
+function createEnergyAlert() {
+    const alertData = AlertBuilder_1.AlertBuilder.createEnergyAlert()
+        .setPropertyId("prop101")
+        .setTitle("High Energy Consumption")
+        .setDescription("Energy usage is 20% above normal levels")
+        .setEntityId("zone456")
+        .setEntityType(alert_types_1.EntityType.COLLECTION)
+        .setCreatedBy("energy-monitor")
+        .build();
+    return alertData;
+}
+// Example 5: Creating hub alert
+function createHubAlert() {
+    const alertData = AlertBuilder_1.AlertBuilder.createHubAlert("hub789", "prop202")
+        .setCategory(alert_types_1.AlertCategory.OPERATIONS)
+        .setTitle("Hub Connection Lost")
+        .setDescription("Hub has lost connection to the network")
+        .setSeverity(alert_types_1.AlertSeverity.CRITICAL)
+        .setCreatedBy("network-monitor")
+        .build();
+    return alertData;
+}
+// Example 6: Alert with snooze
+function createSnoozedAlert() {
+    const snoozeUntil = new Date();
+    snoozeUntil.setHours(snoozeUntil.getHours() + 2); // Snooze for 2 hours
+    const alertData = new AlertBuilder_1.AlertBuilder()
+        .setCategory(alert_types_1.AlertCategory.OTHER)
+        .setPropertyId("prop303")
+        .setTitle("Scheduled Maintenance")
+        .setDescription("System maintenance scheduled for tonight")
+        .setEntityType(alert_types_1.EntityType.PROPERTY)
+        .setSeverity(alert_types_1.AlertSeverity.INFO)
+        .setCreatedBy("admin")
+        .setSnoozeUntil(snoozeUntil)
+        .build();
+    return alertData;
+}
+// Example 7: Reusing builder instance
+function createMultipleAlerts() {
+    const builder = new AlertBuilder_1.AlertBuilder()
+        .setPropertyId("prop404")
+        .setCreatedBy("system");
+    const alert1 = builder
+        .setCategory(alert_types_1.AlertCategory.OPERATIONS)
+        .setTitle("Device Temperature High")
+        .setDescription("Device temperature exceeds normal operating range")
+        .setEntityId("device789")
+        .setEntityType(alert_types_1.EntityType.DEVICE)
+        .setSeverity(alert_types_1.AlertSeverity.HIGH)
+        .build();
+    const alert2 = builder
+        .reset()
+        .setPropertyId("prop404")
+        .setCategory(alert_types_1.AlertCategory.ENERGY)
+        .setTitle("Low Battery Warning")
+        .setDescription("Device battery level is below 20%")
+        .setEntityId("device789")
+        .setEntityType(alert_types_1.EntityType.DEVICE)
+        .setSeverity(alert_types_1.AlertSeverity.MEDIUM)
+        .setCreatedBy("system")
+        .build();
+    return [alert1, alert2];
+}

package/dist/device/local/entities/AlertBuilder.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlertBuilder = void 0;
+const alert_types_1 = require("../../../types/alert.types");
+/**
+ * AlertBuilder - A builder pattern implementation for constructing CreateAlertData objects
+ *
+ * This builder provides a fluent interface for creating alert data with proper validation
+ * and default values. It follows the Builder pattern which is a standard design pattern
+ * in TypeScript for constructing complex objects.
+ *
+ * Usage example:
+ * const alertData = new AlertBuilder()
+ *   .setCategory(AlertCategory.OPERATIONS)
+ *   .setPropertyId("prop123")
+ *   .setTitle("Device Offline")
+ *   .setDescription("Device has been offline for more than 5 minutes")
+ *   .setEntityId("device456")
+ *   .setEntityType(EntityType.DEVICE)
+ *   .setSeverity(AlertSeverity.HIGH)
+ *   .setCreatedBy("user789")
+ *   .build();
+ */
+class AlertBuilder {
+    constructor() {
+        this.data = {};
+    }
+    /**
+     * Sets the alert category
+     */
+    setCategory(category) {
+        this.data.category = category;
+        return this;
+    }
+    /**
+     * Sets the property ID
+     */
+    setPropertyId(propertyId) {
+        if (!propertyId || propertyId.trim() === "") {
+            throw new Error("Property ID is required and cannot be empty");
+        }
+        this.data.propertyId = propertyId;
+        return this;
+    }
+    /**
+     * Sets the alert title
+     */
+    setTitle(title) {
+        if (!title || title.trim() === "") {
+            throw new Error("Title is required and cannot be empty");
+        }
+        this.data.title = title.trim();
+        return this;
+    }
+    /**
+     * Sets the alert description
+     */
+    setDescription(description) {
+        if (!description || description.trim() === "") {
+            throw new Error("Description is required and cannot be empty");
+        }
+        this.data.description = description.trim();
+        return this;
+    }
+    /**
+     * Sets the entity ID (optional)
+     */
+    setEntityId(entityId) {
+        if (entityId !== undefined) {
+            this.data.entityId = entityId.trim() || undefined;
+        }
+        return this;
+    }
+    /**
+     * Sets the entity type
+     */
+    setEntityType(entityType) {
+        this.data.entityType = entityType;
+        return this;
+    }
+    /**
+     * Sets the alert severity (optional, defaults to MEDIUM)
+     */
+    setSeverity(severity) {
+        if (severity !== undefined) {
+            this.data.severity = severity;
+        }
+        return this;
+    }
+    /**
+     * Sets the user who created the alert (optional)
+     */
+    setCreatedBy(createdBy) {
+        if (createdBy !== undefined) {
+            this.data.createdBy = createdBy.trim() || undefined;
+        }
+        return this;
+    }
+    /**
+     * Sets the snooze until date (optional)
+     */
+    setSnoozeUntil(snoozeUntil) {
+        if (snoozeUntil !== undefined) {
+            this.data.snoozeUntil = snoozeUntil;
+        }
+        return this;
+    }
+    /**
+     * Validates that all required fields are present
+     */
+    validate() {
+        const requiredFields = ["category", "propertyId", "title", "description", "entityType"];
+        const missingFields = requiredFields.filter(field => !this.data[field]);
+        if (missingFields.length > 0) {
+            throw new Error(`Missing required fields: ${missingFields.join(", ")}`);
+        }
+    }
+    /**
+     * Builds and returns the CreateAlertData object
+     * @throws Error if required fields are missing
+     */
+    build() {
+        this.validate();
+        // Set default severity if not provided
+        if (!this.data.severity) {
+            this.data.severity = alert_types_1.AlertSeverity.MEDIUM;
+        }
+        return this.data;
+    }
+    /**
+     * Resets the builder to its initial state
+     */
+    reset() {
+        this.data = {};
+        return this;
+    }
+    /**
+     * Creates a new builder instance with predefined values for common alert types
+     */
+    static createReadinessAlert() {
+        return new AlertBuilder()
+            .setCategory(alert_types_1.AlertCategory.READINESS)
+            .setSeverity(alert_types_1.AlertSeverity.MEDIUM);
+    }
+    static createOperationsAlert() {
+        return new AlertBuilder()
+            .setCategory(alert_types_1.AlertCategory.OPERATIONS)
+            .setSeverity(alert_types_1.AlertSeverity.HIGH);
+    }
+    static createSecurityAlert() {
+        return new AlertBuilder()
+            .setCategory(alert_types_1.AlertCategory.SECURITY)
+            .setSeverity(alert_types_1.AlertSeverity.CRITICAL);
+    }
+    static createEnergyAlert() {
+        return new AlertBuilder()
+            .setCategory(alert_types_1.AlertCategory.ENERGY)
+            .setSeverity(alert_types_1.AlertSeverity.LOW);
+    }
+    /**
+     * Creates a device-specific alert builder
+     */
+    static createDeviceAlert(deviceId, propertyId) {
+        return new AlertBuilder()
+            .setEntityType(alert_types_1.EntityType.DEVICE)
+            .setEntityId(deviceId)
+            .setPropertyId(propertyId);
+    }
+    /**
+     * Creates a hub-specific alert builder
+     */
+    static createHubAlert(hubId, propertyId) {
+        return new AlertBuilder()
+            .setEntityType(alert_types_1.EntityType.HUB)
+            .setEntityId(hubId)
+            .setPropertyId(propertyId);
+    }
+}
+exports.AlertBuilder = AlertBuilder;