dt-common-device 1.3.0 → 2.0.0

package/dist/index.js

@@ -15,7 +15,7 @@ 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.LocalScheduleService = exports.LocalPropertyService = exports.LocalConnectionService = exports.LocalHubService = exports.LocalDeviceService = exports.DeviceFactory = exports.CloudDeviceService = exports.CloudDevice = void 0;
+exports.shutdown = 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; } });
@@ -27,11 +27,18 @@ Object.defineProperty(exports, "LocalHubService", { enumerable: true, get: funct
 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; } });
+// Events exports
+__exportStar(require("./events"), exports);
+__exportStar(require("./events/interfaces"), exports);
 __exportStar(require("./device/cloud/interfaces"), exports);
 // Local exports
 __exportStar(require("./device/local/interfaces"), exports);
-__exportStar(require("./device/local/events"), exports);
+__exportStar(require("./events"), exports);
+__exportStar(require("./events/interfaces"), exports);
+// Types exports
+__exportStar(require("./types"), exports);
 //initialize export
 var config_1 = require("./config/config");
 Object.defineProperty(exports, "initialize", { enumerable: true, get: function () { return config_1.initialize; } });
 Object.defineProperty(exports, "getConfig", { enumerable: true, get: function () { return config_1.getConfig; } });
+Object.defineProperty(exports, "shutdown", { enumerable: true, get: function () { return config_1.shutdown; } });

package/dist/types/alert.types.d.ts

@@ -0,0 +1,57 @@
+import { EntityType } from "./issue.types";
+export declare enum AlertCategory {
+    READINESS = "READINESS",
+    OPERATIONS = "OPERATIONS",
+    SECURITY = "SECURITY",
+    ENERGY = "ENERGY",
+    OTHER = "OTHER"
+}
+export declare enum AlertSeverity {
+    INFO = "INFO",
+    LOW = "LOW",
+    MEDIUM = "MEDIUM",
+    HIGH = "HIGH",
+    CRITICAL = "CRITICAL"
+}
+export interface AlertDocument {
+    _id: string;
+    category: AlertCategory;
+    propertyId: string;
+    title: string;
+    description: string;
+    entityId?: string;
+    entityType: EntityType;
+    severity: AlertSeverity;
+    isRead: boolean;
+    isActive: boolean;
+    isDeleted: boolean;
+    snoozeUntil?: Date;
+    createdBy?: string;
+    updatedBy?: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface CreateAlertData {
+    category: AlertCategory;
+    propertyId: string;
+    title: string;
+    description: string;
+    entityId?: string;
+    entityType: EntityType;
+    severity?: AlertSeverity;
+    createdBy?: string;
+    snoozeUntil?: Date;
+}
+export interface UpdateAlertData {
+    category?: AlertCategory;
+    title?: string;
+    description?: string;
+    entityId?: string;
+    entityType?: EntityType;
+    severity?: AlertSeverity;
+    isRead?: boolean;
+    isActive?: boolean;
+    snoozeUntil?: Date;
+    updatedBy?: string;
+}
+export { EntityType } from "./issue.types";

package/dist/types/alert.types.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityType = exports.AlertSeverity = exports.AlertCategory = void 0;
+var AlertCategory;
+(function (AlertCategory) {
+    AlertCategory["READINESS"] = "READINESS";
+    AlertCategory["OPERATIONS"] = "OPERATIONS";
+    AlertCategory["SECURITY"] = "SECURITY";
+    AlertCategory["ENERGY"] = "ENERGY";
+    AlertCategory["OTHER"] = "OTHER";
+})(AlertCategory || (exports.AlertCategory = AlertCategory = {}));
+var AlertSeverity;
+(function (AlertSeverity) {
+    AlertSeverity["INFO"] = "INFO";
+    AlertSeverity["LOW"] = "LOW";
+    AlertSeverity["MEDIUM"] = "MEDIUM";
+    AlertSeverity["HIGH"] = "HIGH";
+    AlertSeverity["CRITICAL"] = "CRITICAL";
+})(AlertSeverity || (exports.AlertSeverity = AlertSeverity = {}));
+// Re-export EntityType from issue.types.ts to avoid duplication
+var issue_types_1 = require("./issue.types");
+Object.defineProperty(exports, "EntityType", { enumerable: true, get: function () { return issue_types_1.EntityType; } });

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

@@ -1,8 +1,19 @@
+import { IInternalEvent } from "../events/interfaces/IInternalEvent";
+export interface ILogger {
+    info(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+}
+type AllowedSource = "ACCESS_SERVICE" | "ADMIN_SERVICE" | "ENERGY_SERVICE";
 export type DeviceConfig = {
-    ADMIN_SERVICE?: string;
-    OPERATIONAL_SERVICE?: string;
+    SOURCE: AllowedSource;
+    SQS_QUEUE_URL: string;
     DEVICE_SERVICE?: string;
-    MONITORING_SERVICE?: string;
+    ADMIN_SERVICE?: string;
+    ACCESS_SERVICE?: string;
     ENERGY_SERVICE?: string;
-    [key: string]: string | undefined;
+    INTERNAL_EVENT_HANDLER: IInternalEvent;
+    LOGGER: ILogger;
+    [key: string]: any;
 };
+export {};

package/dist/types/index.d.ts

@@ -1 +1,3 @@
 export * from "./config.types";
+export * from "./issue.types";
+export * from "./alert.types";

package/dist/types/index.js

@@ -15,3 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./config.types"), exports);
+__exportStar(require("./issue.types"), exports);
+__exportStar(require("./alert.types"), exports);

package/dist/types/issue.types.d.ts

@@ -0,0 +1,90 @@
+export declare enum IssuesCategory {
+    READINESS = "READINESS",
+    OPERATIONS = "OPERATIONS",
+    SECURITY = "SECURITY",
+    ENERGY = "ENERGY",
+    OTHER = "OTHER"
+}
+export declare enum EntityType {
+    DEVICE = "DEVICE",
+    COLLECTION = "COLLECTION",
+    USER = "USER",
+    INTEGRATION = "INTEGRATION",
+    PROPERTY = "PROPERTY",
+    HUB = "HUB",
+    SCHEDULE = "SCHEDULE",
+    ALERT = "ALERT",
+    OTHER = "OTHER"
+}
+export declare enum IssueStatus {
+    PENDING = "PENDING",
+    IN_PROGRESS = "IN_PROGRESS",
+    RESOLVED = "RESOLVED",
+    CLOSED = "CLOSED",
+    CANCELLED = "CANCELLED",
+    ON_HOLD = "ON_HOLD"
+}
+export declare enum IssuePriority {
+    LOW = "LOW",
+    MEDIUM = "MEDIUM",
+    HIGH = "HIGH",
+    CRITICAL = "CRITICAL",
+    URGENT = "URGENT"
+}
+export interface IssueComment {
+    id: string;
+    userId: string;
+    content: string;
+    createdAt: Date;
+    updatedAt?: Date;
+}
+export interface IssueDocument {
+    _id: string;
+    category: IssuesCategory;
+    propertyId: string;
+    title: string;
+    description: string;
+    entityId?: string;
+    entityType: EntityType;
+    status: IssueStatus;
+    priority: IssuePriority;
+    assignedTo?: string;
+    createdBy: string;
+    updatedBy?: string;
+    isDeleted: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+    resolvedAt?: Date;
+    dueDate?: Date;
+    comments?: IssueComment[];
+}
+export interface CreateIssueData {
+    category: IssuesCategory;
+    propertyId: string;
+    title: string;
+    description: string;
+    entityId?: string;
+    entityType: EntityType;
+    priority?: IssuePriority;
+    assignedTo?: string;
+    createdBy: string;
+    dueDate?: Date;
+}
+export interface UpdateIssueData {
+    category?: IssuesCategory;
+    title?: string;
+    description?: string;
+    entityId?: string;
+    entityType?: EntityType;
+    status?: IssueStatus;
+    priority?: IssuePriority;
+    assignedTo?: string;
+    updatedBy: string;
+    resolvedAt?: Date;
+    dueDate?: Date;
+    isDeleted?: boolean;
+}
+export interface AddCommentData {
+    userId: string;
+    content: string;
+}

package/dist/types/issue.types.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IssuePriority = exports.IssueStatus = exports.EntityType = exports.IssuesCategory = void 0;
+var IssuesCategory;
+(function (IssuesCategory) {
+    IssuesCategory["READINESS"] = "READINESS";
+    IssuesCategory["OPERATIONS"] = "OPERATIONS";
+    IssuesCategory["SECURITY"] = "SECURITY";
+    IssuesCategory["ENERGY"] = "ENERGY";
+    IssuesCategory["OTHER"] = "OTHER";
+})(IssuesCategory || (exports.IssuesCategory = IssuesCategory = {}));
+var EntityType;
+(function (EntityType) {
+    EntityType["DEVICE"] = "DEVICE";
+    EntityType["COLLECTION"] = "COLLECTION";
+    EntityType["USER"] = "USER";
+    EntityType["INTEGRATION"] = "INTEGRATION";
+    EntityType["PROPERTY"] = "PROPERTY";
+    EntityType["HUB"] = "HUB";
+    EntityType["SCHEDULE"] = "SCHEDULE";
+    EntityType["ALERT"] = "ALERT";
+    EntityType["OTHER"] = "OTHER";
+})(EntityType || (exports.EntityType = EntityType = {}));
+var IssueStatus;
+(function (IssueStatus) {
+    IssueStatus["PENDING"] = "PENDING";
+    IssueStatus["IN_PROGRESS"] = "IN_PROGRESS";
+    IssueStatus["RESOLVED"] = "RESOLVED";
+    IssueStatus["CLOSED"] = "CLOSED";
+    IssueStatus["CANCELLED"] = "CANCELLED";
+    IssueStatus["ON_HOLD"] = "ON_HOLD";
+})(IssueStatus || (exports.IssueStatus = IssueStatus = {}));
+var IssuePriority;
+(function (IssuePriority) {
+    IssuePriority["LOW"] = "LOW";
+    IssuePriority["MEDIUM"] = "MEDIUM";
+    IssuePriority["HIGH"] = "HIGH";
+    IssuePriority["CRITICAL"] = "CRITICAL";
+    IssuePriority["URGENT"] = "URGENT";
+})(IssuePriority || (exports.IssuePriority = IssuePriority = {}));

package/dist/utils/http-utils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Validates if a URL is properly formatted and accessible
+ */
+export declare function validateServiceUrl(url: string): boolean;
+/**
+ * Creates a properly configured axios instance with error handling
+ */
+export declare function createAxiosInstance(baseURL?: string): import("axios").AxiosInstance;
+export declare function getDeviceServiceAxiosInstance(): any;
+/**
+ * Retry function for failed HTTP requests
+ */
+export declare function retryRequest<T>(requestFn: () => Promise<T>, maxRetries?: number, delay?: number): Promise<T>;

package/dist/utils/http-utils.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateServiceUrl = validateServiceUrl;
+exports.createAxiosInstance = createAxiosInstance;
+exports.getDeviceServiceAxiosInstance = getDeviceServiceAxiosInstance;
+exports.retryRequest = retryRequest;
+const config_1 = require("../config/config");
+const axios_1 = __importDefault(require("axios"));
+/**
+ * Validates if a URL is properly formatted and accessible
+ */
+function validateServiceUrl(url) {
+    try {
+        const parsedUrl = new URL(url);
+        return parsedUrl.protocol === "http:" || parsedUrl.protocol === "https:";
+    }
+    catch (error) {
+        (0, config_1.getConfig)().LOGGER.error(`Invalid service URL: ${url}`, error);
+        return false;
+    }
+}
+/**
+ * Creates a properly configured axios instance with error handling
+ */
+function createAxiosInstance(baseURL) {
+    const instance = axios_1.default.create({
+        baseURL,
+        timeout: 30000, // 30 seconds timeout
+        maxRedirects: 5,
+        validateStatus: (status) => status < 500, // Don't throw on 4xx errors
+        headers: {
+            "Content-Type": "application/json",
+            "User-Agent": "dt-common-device/1.3.0",
+        },
+    });
+    // Add request interceptor for logging
+    instance.interceptors.request.use((config) => {
+        const logger = (0, config_1.getConfig)().LOGGER;
+        logger.info(`Making request to: ${config.method?.toUpperCase()} ${config.url}`, {
+            baseURL: config.baseURL,
+            timeout: config.timeout,
+        });
+        return config;
+    }, (error) => {
+        (0, config_1.getConfig)().LOGGER.error("Request interceptor error:", error);
+        return Promise.reject(error);
+    });
+    // Add response interceptor for error handling
+    instance.interceptors.response.use((response) => {
+        return response;
+    }, (error) => {
+        const logger = (0, config_1.getConfig)().LOGGER;
+        const errorInfo = {
+            url: error.config?.url,
+            method: error.config?.method,
+            status: error.response?.status,
+            statusText: error.response?.statusText,
+            message: error.message,
+            code: error.code,
+            baseURL: error.config?.baseURL,
+        };
+        logger.error("HTTP request failed:", errorInfo);
+        // Log additional details for network errors
+        if (error.code === "ECONNREFUSED" || error.code === "ENOTFOUND") {
+            logger.error("Network connectivity issue detected. Please check:", {
+                serviceUrl: error.config?.baseURL,
+                errorCode: error.code,
+                errorMessage: error.message,
+            });
+        }
+        return Promise.reject(error);
+    });
+    return instance;
+}
+/**
+ * Centralized axios instance for device service
+ */
+let deviceServiceAxiosInstance = null;
+function getDeviceServiceAxiosInstance() {
+    if (!deviceServiceAxiosInstance) {
+        const { DEVICE_SERVICE } = (0, config_1.getConfig)();
+        if (!DEVICE_SERVICE) {
+            throw new Error("DEVICE_SERVICE is not configured. Call initialize() first with DEVICE_SERVICE.");
+        }
+        deviceServiceAxiosInstance = createAxiosInstance(DEVICE_SERVICE);
+    }
+    return deviceServiceAxiosInstance;
+}
+/**
+ * Retry function for failed HTTP requests
+ */
+async function retryRequest(requestFn, maxRetries = 3, delay = 1000) {
+    let lastError;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+            return await requestFn();
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt === maxRetries) {
+                (0, config_1.getConfig)().LOGGER.error(`Request failed after ${maxRetries} attempts:`, error);
+                throw error;
+            }
+            (0, config_1.getConfig)().LOGGER.warn(`Request attempt ${attempt} failed, retrying in ${delay}ms:`, {
+                error: error.message,
+                attempt,
+                maxRetries,
+            });
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            delay *= 2; // Exponential backoff
+        }
+    }
+    throw lastError;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dt-common-device",
-  "version": "1.3.0",
+  "version": "2.0.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
@@ -43,6 +43,7 @@
     "dt-pub-sub": "^1.0.0",
     "ioredis": "5.6.1",
     "lodash": "^4.17.21",
+    "mongoose": "8.16.1",
     "pg": "8.16.3",
     "typedi": "0.10.0"
   }

package/src/config/config.ts

@@ -1,25 +1,80 @@
 import { DeviceConfig } from "../types";
 import { initializeAudit } from "dt-audit-library";
+import { connectDatabase } from "../db/db";
 import dotenv from "dotenv";
+import { InternalEventSubscription } from "../events";
+import { validateServiceUrl } from "../utils/http-utils";
+
 dotenv.config();
 
 let config: DeviceConfig | null = null;
 let auditInitialized = false;
+let eventSubscription: InternalEventSubscription | null = null;
 
-export function initialize(cfg: DeviceConfig) {
-  // Check if at least one service is provided
-  const hasAtLeastOneService = [
-    "ADMIN_SERVICE",
-    "OPERATIONAL_SERVICE",
-    "DEVICE_SERVICE",
-    "MONITORING_SERVICE",
-    "ENERGY_SERVICE",
-  ].some((key) => Boolean(cfg[key]));
-
-  if (!hasAtLeastOneService) {
-    throw new Error("At least one http service must be initialized");
-  }
+export async function initialize(cfg: DeviceConfig): Promise<void> {
+  // Initialize config
   config = { ...cfg };
+
+  // Validate service URLs if provided
+  if (cfg.DEVICE_SERVICE && !validateServiceUrl(cfg.DEVICE_SERVICE)) {
+    throw new Error(`Invalid DEVICE_SERVICE URL: ${cfg.DEVICE_SERVICE}`);
+  }
+  if (cfg.ADMIN_SERVICE && !validateServiceUrl(cfg.ADMIN_SERVICE)) {
+    throw new Error(`Invalid ADMIN_SERVICE URL: ${cfg.ADMIN_SERVICE}`);
+  }
+  if (cfg.ACCESS_SERVICE && !validateServiceUrl(cfg.ACCESS_SERVICE)) {
+    throw new Error(`Invalid ACCESS_SERVICE URL: ${cfg.ACCESS_SERVICE}`);
+  }
+  if (cfg.ENERGY_SERVICE && !validateServiceUrl(cfg.ENERGY_SERVICE)) {
+    throw new Error(`Invalid ENERGY_SERVICE URL: ${cfg.ENERGY_SERVICE}`);
+  }
+
+  // Initialize internal event subscription if handler is provided
+  if (cfg.INTERNAL_EVENT_HANDLER) {
+    try {
+      eventSubscription = new InternalEventSubscription(
+        cfg.INTERNAL_EVENT_HANDLER
+      );
+      cfg.LOGGER.info("InternalEventSubscription initialized successfully");
+    } catch (error) {
+      cfg.LOGGER.error("Failed to initialize InternalEventSubscription", {
+        error,
+      });
+      throw error;
+    }
+  }
+
+  // Connect to databases
+  try {
+    await connectDatabase();
+    cfg.LOGGER.info("Database connections established successfully");
+  } catch (error) {
+    cfg.LOGGER.error("Failed to connect to databases", { error });
+    throw error;
+  }
+
+  // Subscribe to events if event subscription is available
+  if (eventSubscription) {
+    try {
+      await eventSubscription.subscribe();
+      cfg.LOGGER.info("Event subscription started successfully");
+    } catch (error: any) {
+      cfg.LOGGER.error(
+        `Failed to start event subscription: ${
+          error.message || error.toString()
+        }`
+      );
+      // Don't throw here as the main setup should continue
+    }
+  }
+
+  // Check if required env variables are set
+  checkRequiredEnv();
+
+  // Initialize audit
+  ensureAuditInitialized();
+
+  console.log("dt-common-device: Initialization completed successfully");
 }
 
 export function getConfig(): DeviceConfig {
@@ -31,12 +86,22 @@ export function getConfig(): DeviceConfig {
   return config;
 }
 
-export function checkAwsEnv() {
+export function getEventSubscription(): InternalEventSubscription | null {
+  return eventSubscription;
+}
+
+export function checkRequiredEnv() {
   const requiredEnv = [
     "AWS_SECRET_ACCESS_KEY",
     "AWS_REGION",
     "AWS_ACCESS_KEY_ID",
     "EVENT_BUS_NAME",
+    "ADMIN_DB_URI",
+    "MONGODB_URI",
+    "REDIS_HOST",
+    "REDIS_PORT",
+    "POSTHOG_API_KEY",
+    "POSTHOG_HOST",
   ];
   const missing = requiredEnv.filter((key) => !process.env[key]);
   if (missing.length > 0) {
@@ -55,6 +120,9 @@ export function ensureAuditInitialized() {
   const host = process.env.POSTHOG_HOST;
 
   if (!apiKey || !host) {
+    getConfig().LOGGER.error(
+      "POSTHOG_API_KEY and POSTHOG_HOST must be set in environment variables"
+    );
     throw new Error(
       "dt-common-device: POSTHOG_API_KEY and POSTHOG_HOST must be set in environment variables"
     );
@@ -71,6 +139,9 @@ export function ensureAuditInitialized() {
 export function getPostgresDbUri(): string {
   const fullUri = process.env.ADMIN_DB_URI;
   if (!fullUri) {
+    getConfig().LOGGER.error(
+      "ADMIN_DB_URI must be set in environment variables or .env file"
+    );
     throw new Error(
       "dt-common-device: ADMIN_DB_URI must be set in environment variables or .env file"
     );
@@ -78,6 +149,19 @@ export function getPostgresDbUri(): string {
   return fullUri;
 }
 
+export function getMongoUri(): string {
+  const fullUri = process.env.MONGODB_URI;
+  if (!fullUri) {
+    getConfig().LOGGER.error(
+      "MONGODB_URI must be set in environment variables or .env file"
+    );
+    throw new Error(
+      "dt-common-device: MONGODB_URI must be set in environment variables or .env file"
+    );
+  }
+  return fullUri;
+}
+
 /**
  * Returns the Redis DB Host and port from environment variables.
  * Throws an error if not set.
@@ -86,9 +170,28 @@ export function getRedisDbHostAndPort(): { host: string; port: number } {
   const host = process.env.REDIS_HOST;
   const port = process.env.REDIS_PORT;
   if (!host || !port) {
+    getConfig().LOGGER.error(
+      "REDIS_HOST and REDIS_PORT must be set in environment variables"
+    );
     throw new Error(
       "dt-common-device: REDIS_HOST and REDIS_PORT must be set in environment variables"
     );
   }
   return { host, port: Number(port) };
 }
+
+/**
+ * Graceful shutdown function
+ */
+export async function shutdown(): Promise<void> {
+  if (eventSubscription) {
+    try {
+      await eventSubscription.unsubscribe();
+      getConfig().LOGGER.info("Event subscription stopped successfully");
+    } catch (error) {
+      getConfig().LOGGER.error("Failed to stop event subscription", { error });
+    }
+  }
+
+  getConfig().LOGGER.info("dt-common-device: Shutdown completed");
+}

package/src/{device/local/events/Events.ts → constants/Event.ts}

@@ -1,9 +1,16 @@
 export const DT_EVENT_TYPES = {
   DEVICE: {
-    DEVICE: {
-      CREATED: "device.device.created",
-      UPDATED: "device.device.updated",
-      DELETED: "device.device.deleted",
+    CREATE: {
+      SUCCESS: "device.create.success",
+      FAILED: "device.create.failed",
+    },
+    UPDATE: {
+      SUCCESS: "device.update.success",
+      FAILED: "device.update.failed",
+    },
+    DELETE: {
+      SUCCESS: "device.delete.success",
+      FAILED: "device.delete.failed",
     },
     STATE: {
       SET: "device.state.set",
@@ -34,21 +41,35 @@ export const DT_EVENT_TYPES = {
     },
   },
   CONNECTION: {
-    CONNECTION: {
-      CREATED: "connection.connection.created",
-      UPDATED: "connection.connection.updated",
-      DELETED: "connection.connection.deleted",
+    CREATE: {
+      SUCCESS: "connection.create.success",
+      FAILED: "connection.create.failed",
+    },
+    UPDATE: {
+      SUCCESS: "connection.update.success",
+      FAILED: "connection.update.failed",
+    },
+    DELETE: {
+      SUCCESS: "connection.delete.success",
+      FAILED: "connection.delete.failed",
     },
   },
   PROPERTY: {
-    PROPERTY: {
-      CREATED: "property.property.created",
-      UPDATED: "property.property.updated",
-      DELETED: "property.property.deleted",
+    CREATE: {
+      SUCCESS: "property.create.success",
+      FAILED: "property.create.failed",
+    },
+    UPDATE: {
+      SUCCESS: "property.update.success",
+      FAILED: "property.update.failed",
+    },
+    DELETE: {
+      SUCCESS: "property.delete.success",
+      FAILED: "property.delete.failed",
     },
     PREFERENCES: {
       UPDATED: "property.preferences.updated",
       CREATED: "property.preferences.created",
     },
   },
-};
+};