@kohost/api-client 3.0.0-beta.4 → 3.0.0-beta.41

package/dist/cjs/SocketIoClient.js

@@ -0,0 +1,66 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/SocketIoClient/index.js
+var io = require("socket.io-client");
+var { EventEmitter } = require("events");
+module.exports = /* @__PURE__ */ __name(class SocketIoClient extends EventEmitter {
+  constructor(config = { url: null, propertyId: null, options: {} }) {
+    super();
+    if (!config.url)
+      throw new Error("Websocket URL / endpoint not provided");
+    if (!config.propertyId)
+      throw new Error("Property ID not provided");
+    this.url = config.url;
+    this.propertyId = config.propertyId;
+    this.options = {
+      autoConnect: false,
+      forceNew: false,
+      reconnection: true,
+      reconnectionAttempts: Infinity,
+      reconnectionDelay: 1e3,
+      withCredentials: true,
+      transports: ["websocket", "polling"],
+      upgrade: true,
+      ...config.options
+    };
+    this.socket = io(this.url, this.options);
+    this.socket.on("connect", () => {
+      this.emit("connect", this.socket);
+    });
+    this.socket.on("disconnect", (reason) => {
+      this.emit("disconnect", reason);
+    });
+    this.socket.on("reconnect_attempt", (data) => {
+      this.emit("reconnect_attempt", data);
+    });
+    this.socket.on("connect_error", (error) => {
+      this.emit("connect_error", error);
+    });
+  }
+  get connected() {
+    return this.socket?.connected || false;
+  }
+  get disconnected() {
+    return this.socket?.disconnected || false;
+  }
+  connect() {
+    this.socket.connect();
+  }
+  disconnect() {
+    this.socket.disconnect();
+  }
+  reconnect() {
+    this.disconnect();
+    this.connect();
+  }
+  subscribe(event, callback) {
+    this.socket.on(event, callback);
+  }
+  unsubscribe(event, callback) {
+    this.socket.off(event, callback);
+  }
+  send(event, { data = {}, query = {}, ...rest }) {
+    this.socket.emit(event, { data, query, ...rest });
+  }
+}, "SocketIoClient");

package/dist/cjs/defs.js

@@ -1,4 +1,6 @@
+var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
@@ -12,12 +14,12 @@ var require_deviceTypes = __commonJS({
       "thermostat",
       "lock",
       "windowCovering",
-      "sceneController",
       "courtesy",
       "alarm",
       "camera",
-      "source",
-      "motionSensor"
+      "mediaSource",
+      "motionSensor",
+      "gateway"
     ];
     module2.exports = types;
   }
@@ -50,6 +52,8 @@ var require_Client = __commonJS({
       constructor(options = {
         url: "",
         propertyId: "",
+        organizationId: "",
+        apiKey: "",
         headers: {}
       }) {
         super();
@@ -59,7 +63,8 @@ var require_Client = __commonJS({
           throw new Error("options.property is required");
         this.options = options;
         this.isBrowser = typeof window !== "undefined";
-        this._http = axios.create({
+        this.isRefreshingToken = false;
+        const config = {
           baseURL: options.url,
           responseType: "json",
           withCredentials: true,
@@ -69,96 +74,81 @@ var require_Client = __commonJS({
             [KohostApiClient.defs.propertyHeader]: options.propertyId,
             ...options.headers
           }
-        });
+        };
+        if (options.apiKey) {
+          config.headers[KohostApiClient.defs.apiKeyHeader] = options.apiKey;
+        }
+        this._http = axios.create(config);
         this._http.interceptors.response.use(
           this._handleResponse.bind(this),
           this._handleResponseError.bind(this)
         );
-        this._http.interceptors.request.use((config) => {
-          if (!this.isBrowser) {
-            config.headers[KohostApiClient.defs.authTokenHeader] = this.authToken;
-          }
-          return config;
-        });
       }
       static get defs() {
         return {
-          authTokenHeader: "X-Auth-Token",
-          refreshTokenHeader: "X-Refresh-Token",
+          apiKeyHeader: "X-Api-Key",
           propertyHeader: "X-Property-Id"
         };
       }
       _handleResponse(response) {
-        var _a;
         try {
-          if ((_a = response == null ? void 0 : response.data) == null ? void 0 : _a.data) {
+          if (response?.data?.data) {
             response.query = response.data.query;
             response.pagination = response.data.pagination;
             response.data = response.data.data;
           }
-          if (!this.isBrowser && response.headers[this.authTokenHeaderKey]) {
-            this.authToken = response.headers[this.authTokenHeaderKey];
-          }
-          if (!this.isBrowser && response.headers[this.refreshTokenHeaderKey]) {
-            this.refreshToken = response.headers[this.refreshTokenHeaderKey];
-          }
           return response;
         } catch (error) {
           return Promise.reject(error);
         }
       }
       _handleResponseError(error) {
-        var _a, _b;
         const { config: originalReq } = error;
         if (!error.response)
           return Promise.reject(error);
         const { status, data } = error.response;
-        const errorType = (_a = data == null ? void 0 : data.error) == null ? void 0 : _a.type;
-        const errorMessage = (_b = data == null ? void 0 : data.error) == null ? void 0 : _b.message;
+        const errorType = data?.error?.type;
+        const errorMessage = data?.error?.message;
         try {
           const expectedError = status >= 400 && status < 500;
           const newTokensNeeded = expectedError && errorType === "TokenExpiredError";
+          if (expectedError && errorMessage === "Phone Verification is required") {
+            this._onPhoneVerificationRequired();
+            return Promise.reject(error);
+          }
           if (expectedError && errorMessage === "Login Required") {
             this._onLoginRequired();
             return Promise.reject(error);
           }
-          if (expectedError && errorMessage === "No token provided") {
+          if (expectedError && errorMessage === "No auth header or cookie provided") {
             this._onLoginRequired();
             return Promise.reject(error);
           }
           if (expectedError && newTokensNeeded) {
-            return this.RefreshToken().then(() => {
-              return this.http(originalReq);
-            });
+            while (!this.isRefreshingToken) {
+              this.isRefreshingToken = true;
+              return this.RefreshToken().then(() => {
+                this.isRefreshingToken = false;
+                return this._http(originalReq);
+              }).catch((err) => {
+                this.isRefreshingToken = false;
+                return Promise.reject(err);
+              });
+            }
           }
         } catch (error2) {
           console.log(error2);
         }
         return Promise.reject(error);
       }
-      get authTokenHeaderKey() {
-        return KohostApiClient.defs.authTokenHeader.toLowerCase();
-      }
-      get refreshTokenHeaderKey() {
-        return KohostApiClient.defs.refreshTokenHeader.toLowerCase();
-      }
-      get lsTokenKey() {
-        return `${this.options.propertyId}_${KohostApiClient.defs.authTokenHeader}`;
-      }
-      get authToken() {
-        return this._authToken;
-      }
-      /* 
-      @param {String} token - The token to set
-      @returns undefined
-      */
-      set authToken(token) {
-        this._authToken = token;
-      }
       _onLoginRequired() {
         this.emit("LoginRequired");
       }
+      _onPhoneVerificationRequired() {
+        this.emit("PhoneVerificationRequired");
+      }
     };
+    __name(KohostApiClient, "KohostApiClient");
     module2.exports = KohostApiClient;
   }
 });

package/dist/cjs/index.cjs.js

@@ -5,12 +5,16 @@ const Events = require("./Events");
 const defs = require("./defs");
 const utils = require("./utils");
 const Client = require("./Client");
+const SocketIoClient = require("./SocketIoClient");
+const AMQPClient = require("./AMQPClient");
 const Kohost = {
   Models,
   Errors,
   Commands,
   Events,
   Client,
+  SocketIoClient,
+  AMQPClient,
   defs,
   utils
 };

package/dist/cjs/utils.js

@@ -1,4 +1,6 @@
+var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
@@ -9,6 +11,7 @@ var require_getFormalDeviceType = __commonJS({
     function getFormalDeviceType2(deviceType) {
       return deviceType.charAt(0).toUpperCase() + deviceType.slice(1);
     }
+    __name(getFormalDeviceType2, "getFormalDeviceType");
     module2.exports = getFormalDeviceType2;
   }
 });
@@ -22,12 +25,12 @@ var require_deviceTypes = __commonJS({
       "thermostat",
       "lock",
       "windowCovering",
-      "sceneController",
       "courtesy",
       "alarm",
       "camera",
-      "source",
-      "motionSensor"
+      "mediaSource",
+      "motionSensor",
+      "gateway"
     ];
     module2.exports = types;
   }
@@ -40,6 +43,7 @@ var require_getDeviceTypes = __commonJS({
     function getDeviceTypes2() {
       return deviceTypes;
     }
+    __name(getDeviceTypes2, "getDeviceTypes");
     module2.exports = getDeviceTypes2;
   }
 });
@@ -49,10 +53,13 @@ var require_common = __commonJS({
   "src/schemas/definitions/common.json"(exports2, module2) {
     module2.exports = {
       $schema: "http://json-schema.org/draft-07/schema",
-      $id: "https://api.kohost.app/schemas/v3/definitions/common.json",
+      $id: "https://api.kohost.io/schemas/v3/definitions/common.json",
       definitions: {
         id: {
-          type: "string"
+          type: "string",
+          not: {
+            enum: ["global", "system"]
+          }
         },
         systemData: {
           type: "object",
@@ -62,6 +69,10 @@ var require_common = __commonJS({
           type: "object",
           default: {}
         },
+        date: {
+          type: ["string", "object"],
+          format: "date-time"
+        },
         createdAt: {
           type: ["string", "object"],
           format: "date-time"
@@ -118,6 +129,30 @@ var require_common = __commonJS({
               maxLength: 2
             }
           }
+        },
+        driver: {
+          type: "string",
+          enum: [
+            "aws-kinesis",
+            "butler",
+            "crestron",
+            "ecobee",
+            "igor",
+            "inncom",
+            "kohost-k7",
+            "kohost-pms",
+            "lg",
+            "lirc",
+            "mews",
+            "pelican-wireless",
+            "rebrandly",
+            "salto",
+            "salto-irn",
+            "se",
+            "sendgrid",
+            "stay-n-touch",
+            "twilio"
+          ]
         }
       }
     };
@@ -129,17 +164,18 @@ var require_device = __commonJS({
   "src/schemas/definitions/device.json"(exports2, module2) {
     module2.exports = {
       $schema: "http://json-schema.org/draft-07/schema",
-      $id: "https://api.kohost.app/schemas/v3/definitions/device.json",
+      $id: "https://api.kohost.io/schemas/v3/definitions/device.json",
       definitions: {
         id: {
-          $ref: "https://api.kohost.app/schemas/v3/definitions/common.json#/definitions/id"
+          $ref: "https://api.kohost.io/schemas/v3/definitions/common.json#/definitions/id"
         },
         systemData: {
-          $ref: "https://api.kohost.app/schemas/v3/definitions/common.json#/definitions/systemData"
+          $ref: "https://api.kohost.io/schemas/v3/definitions/common.json#/definitions/systemData"
         },
         type: {
           type: "string",
           enum: [
+            "alarm",
             "dimmer",
             "switch",
             "motionSensor",
@@ -149,8 +185,13 @@ var require_device = __commonJS({
             "thermostat",
             "lock",
             "courtesy",
-            "sceneController",
-            "gateway"
+            "gateway",
+            "tv",
+            "dvr",
+            "appleTv",
+            "discPlayer",
+            "mediaPlayer",
+            "uncontrolledDevice"
           ]
         },
         name: {
@@ -179,7 +220,11 @@ var require_device = __commonJS({
               "softwareFailure",
               "hardwareFailureWithCode",
               "softwareFailureWithCode",
-              "motionDetection"
+              "motionDetection",
+              "airFilterNeedsCleaned",
+              "smokeDetected",
+              "outsideSafeTemperatureRange",
+              "outsideSafeHumidityRange"
             ]
           }
         },
@@ -193,6 +238,9 @@ var require_device = __commonJS({
             timestamp: {
               type: "number",
               minimum: 1655907956593
+            },
+            description: {
+              type: "string"
             }
           }
         },
@@ -200,6 +248,10 @@ var require_device = __commonJS({
           type: "number",
           minimum: 0,
           maximum: 100
+        },
+        watts: {
+          type: "number",
+          minimum: 0
         }
       }
     };
@@ -225,13 +277,201 @@ var require_schema = __commonJS({
     ajv.addSchema(commonDefs);
     ajv.addSchema(deviceDefs);
     module2.exports = {
-      add: function add(schema2) {
+      add: /* @__PURE__ */ __name(function add(schema2) {
         ajv.addSchema(schema2);
-      },
-      compile: function compile(schema2) {
+      }, "add"),
+      compile: /* @__PURE__ */ __name(function compile(schema2) {
         return ajv.compile(schema2);
+      }, "compile")
+    };
+  }
+});
+
+// src/Errors/AppError.js
+var require_AppError = __commonJS({
+  "src/Errors/AppError.js"(exports2, module2) {
+    module2.exports = /* @__PURE__ */ __name(class AppError extends Error {
+      constructor(message = "Internal Server Error", options) {
+        super(message, options);
+        this.type = this.constructor.name;
+        this.statusCode = 500;
+        Object.setPrototypeOf(this, AppError.prototype);
+      }
+    }, "AppError");
+  }
+});
+
+// src/Errors/AuthenticationError.js
+var require_AuthenticationError = __commonJS({
+  "src/Errors/AuthenticationError.js"(exports2, module2) {
+    var AppError = require_AppError();
+    module2.exports = /* @__PURE__ */ __name(class AuthenticationError extends AppError {
+      constructor(message = "Authentication Error", options = {}) {
+        super(message, options);
+        this.statusCode = 401;
+        Object.setPrototypeOf(this, AuthenticationError.prototype);
+      }
+    }, "AuthenticationError");
+  }
+});
+
+// src/Errors/AuthorizationError.js
+var require_AuthorizationError = __commonJS({
+  "src/Errors/AuthorizationError.js"(exports2, module2) {
+    var AppError = require_AppError();
+    module2.exports = /* @__PURE__ */ __name(class AuthorizationError extends AppError {
+      constructor(message = "Authorization Error", options = {}) {
+        super(message, options);
+        this.statusCode = 403;
+        Object.setPrototypeOf(this, AuthorizationError.prototype);
+      }
+    }, "AuthorizationError");
+  }
+});
+
+// src/Errors/DeviceCommError.js
+var require_DeviceCommError = __commonJS({
+  "src/Errors/DeviceCommError.js"(exports2, module2) {
+    var AppError = require_AppError();
+    module2.exports = /* @__PURE__ */ __name(class DeviceCommError extends AppError {
+      constructor(message = "Device Communication Error", options = {}) {
+        super(message, options);
+        this.statusCode = 503;
+        Object.setPrototypeOf(this, DeviceCommError.prototype);
+      }
+    }, "DeviceCommError");
+  }
+});
+
+// src/Errors/LoginError.js
+var require_LoginError = __commonJS({
+  "src/Errors/LoginError.js"(exports2, module2) {
+    var AppError = require_AppError();
+    module2.exports = /* @__PURE__ */ __name(class LoginError extends AppError {
+      constructor(message = "Invalid Login information provided", options = {}) {
+        super(message, options);
+        this.statusCode = 401;
+        Object.setPrototypeOf(this, LoginError.prototype);
+      }
+    }, "LoginError");
+  }
+});
+
+// src/Errors/NotFoundError.js
+var require_NotFoundError = __commonJS({
+  "src/Errors/NotFoundError.js"(exports2, module2) {
+    var AppError = require_AppError();
+    module2.exports = /* @__PURE__ */ __name(class NotFoundError extends AppError {
+      constructor(message = "Resource Not Found", options = {}) {
+        super(message, options);
+        this.statusCode = 404;
+        Object.setPrototypeOf(this, NotFoundError.prototype);
+      }
+    }, "NotFoundError");
+  }
+});
+
+// src/Errors/RequestError.js
+var require_RequestError = __commonJS({
+  "src/Errors/RequestError.js"(exports2, module2) {
+    var AppError = require_AppError();
+    module2.exports = /* @__PURE__ */ __name(class RequestError extends AppError {
+      constructor(message = "Bad Request", options = {}) {
+        super(message, options);
+        this.statusCode = 400;
+        Object.setPrototypeOf(this, RequestError.prototype);
+      }
+    }, "RequestError");
+  }
+});
+
+// src/Errors/SystemCommError.js
+var require_SystemCommError = __commonJS({
+  "src/Errors/SystemCommError.js"(exports2, module2) {
+    var AppError = require_AppError();
+    module2.exports = /* @__PURE__ */ __name(class SystemCommError extends AppError {
+      constructor(message = "System Communication Error", options = {}) {
+        super(message, options);
+        this.statusCode = 503;
+        Object.setPrototypeOf(this, SystemCommError.prototype);
+      }
+    }, "SystemCommError");
+  }
+});
+
+// src/Errors/TokenExpiredError.js
+var require_TokenExpiredError = __commonJS({
+  "src/Errors/TokenExpiredError.js"(exports2, module2) {
+    var AppError = require_AppError();
+    module2.exports = /* @__PURE__ */ __name(class TokenExpiredError extends AppError {
+      constructor(message = "Token Expired", options = {}) {
+        super(message, options);
+        this.statusCode = 401;
+        Object.setPrototypeOf(this, TokenExpiredError.prototype);
+      }
+    }, "TokenExpiredError");
+  }
+});
+
+// src/Errors/UnprocessableRequestError.js
+var require_UnprocessableRequestError = __commonJS({
+  "src/Errors/UnprocessableRequestError.js"(exports2, module2) {
+    var AppError = require_AppError();
+    module2.exports = /* @__PURE__ */ __name(class UnprocessableRequestError extends AppError {
+      constructor(message = "Unprocessable Request Error", options = {}) {
+        super(message, options);
+        this.statusCode = 422;
+        Object.setPrototypeOf(this, UnprocessableRequestError.prototype);
+      }
+    }, "UnprocessableRequestError");
+  }
+});
+
+// src/Errors/ValidationError.js
+var require_ValidationError = __commonJS({
+  "src/Errors/ValidationError.js"(exports2, module2) {
+    var AppError = require_AppError();
+    module2.exports = /* @__PURE__ */ __name(class ValidationError extends AppError {
+      constructor(message = "Validation Error", options = {}) {
+        super(message, options);
+        this.statusCode = 400;
+        Object.setPrototypeOf(this, ValidationError.prototype);
       }
+    }, "ValidationError");
+  }
+});
+
+// src/Errors/index.js
+var require_Errors = __commonJS({
+  "src/Errors/index.js"(exports2, module2) {
+    var Errors = {
+      AppError: require_AppError(),
+      AuthenticationError: require_AuthenticationError(),
+      AuthorizationError: require_AuthorizationError(),
+      DeviceCommError: require_DeviceCommError(),
+      LoginError: require_LoginError(),
+      NotFoundError: require_NotFoundError(),
+      RequestError: require_RequestError(),
+      SystemCommError: require_SystemCommError(),
+      TokenExpiredError: require_TokenExpiredError(),
+      UnprocessableRequestError: require_UnprocessableRequestError(),
+      ValidationError: require_ValidationError()
     };
+    module2.exports = Errors;
+  }
+});
+
+// src/utils/errorFactory.js
+var require_errorFactory = __commonJS({
+  "src/utils/errorFactory.js"(exports2, module2) {
+    var Errors = require_Errors();
+    module2.exports = /* @__PURE__ */ __name(function errorFactory2(errName) {
+      const AllErrors = Object.values(Errors);
+      const TheError = AllErrors.find((E) => E.prototype.name === errName);
+      if (!TheError)
+        return new Error("Invalid error name: " + errName);
+      return TheError;
+    }, "errorFactory");
   }
 });
 
@@ -239,8 +479,10 @@ var require_schema = __commonJS({
 var getFormalDeviceType = require_getFormalDeviceType();
 var getDeviceTypes = require_getDeviceTypes();
 var schema = require_schema();
+var errorFactory = require_errorFactory();
 module.exports = {
   getFormalDeviceType,
   getDeviceTypes,
-  schema
+  schema,
+  errorFactory
 };