@kohost/api-client 1.0.0-beta.2 → 1.0.0-beta.4

package/dist/defs.js

@@ -0,0 +1,196 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/defs/deviceTypes.js
+var require_deviceTypes = __commonJS({
+  "src/defs/deviceTypes.js"(exports2, module2) {
+    var types = [
+      "dimmer",
+      "switch",
+      "thermostat",
+      "lock",
+      "windowCovering",
+      "sceneController",
+      "courtesy",
+      "alarm",
+      "camera",
+      "source",
+      "motionSensor"
+    ];
+    module2.exports = types;
+  }
+});
+
+// src/defs/formalDeviceTypes.js
+var require_formalDeviceTypes = __commonJS({
+  "src/defs/formalDeviceTypes.js"(exports2, module2) {
+    var deviceTypes2 = require_deviceTypes();
+    var formalDeviceTypes2 = deviceTypes2.map(
+      (type) => type.charAt(0).toUpperCase() + type.slice(1)
+    );
+    module2.exports = formalDeviceTypes2;
+  }
+});
+
+// src/http/index.js
+var require_http = __commonJS({
+  "src/http/index.js"(exports2, module2) {
+    var { EventEmitter } = require("events");
+    var KohostApiClient = class extends EventEmitter {
+      /* 
+        @param {Object} options - The options to create the client
+        @param {String} options.propertyId - The property ID
+        @param {String} options.url - The base URL for the API endpint
+        @param {Object} options.headers - Additional headers to send with each request
+      
+        */
+      constructor(options = {
+        url: "",
+        propertyId: "",
+        headers: {}
+      }) {
+        super();
+        if (!options.url)
+          throw new Error("options.url is required");
+        if (!options.propertyId)
+          throw new Error("options.property is required");
+        this.options = options;
+        this.isBrowser = typeof window !== "undefined";
+        this._init = false;
+        import("axios").then((axiosModule) => {
+          const axios = axiosModule.default;
+          this._http = axios.create({
+            baseURL: options.url,
+            responseType: "json",
+            withCredentials: true,
+            headers: {
+              "Content-Type": "application/json",
+              Accept: "application/json",
+              [KohostApiClient.defs.propertyHeader]: options.propertyId,
+              ...options.headers
+            }
+          });
+          this._http.interceptors.response.use(
+            this._handleResponse,
+            this._handleResponseError
+          );
+          this._http.interceptors.request.use((config) => {
+            if (!this.isBrowser) {
+              config.headers[KohostApiClient.defs.authTokenHeader] = this.authToken;
+            }
+            return config;
+          });
+          this._init = true;
+        });
+      }
+      static get defs() {
+        return {
+          authTokenHeader: "X-Auth-Token",
+          refreshTokenHeader: "X-Refresh-Token",
+          propertyHeader: "X-Property-Id"
+        };
+      }
+      _handleResponse(response) {
+        var _a;
+        if ((_a = response == null ? void 0 : response.data) == null ? void 0 : _a.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;
+      }
+      _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;
+        try {
+          const expectedError = status >= 400 && status < 500;
+          const newTokensNeeded = expectedError && errorType === "TokenExpiredError";
+          if (expectedError && errorMessage === "Login Required") {
+            this._onLoginRequired();
+            return Promise.reject(error);
+          }
+          if (expectedError && errorMessage === "No token provided") {
+            this._onLoginRequired();
+            return Promise.reject(error);
+          }
+          if (expectedError && newTokensNeeded) {
+            return this.RefreshToken().then(() => {
+              return this.http(originalReq);
+            });
+          }
+        } 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");
+      }
+    };
+    module2.exports = KohostApiClient;
+  }
+});
+
+// src/defs/index.js
+var deviceTypes = require_deviceTypes();
+var formalDeviceTypes = require_formalDeviceTypes();
+var { defs: httpDefs } = require_http();
+var defs = {
+  http: httpDefs,
+  deviceTypes,
+  formalDeviceTypes
+};
+module.exports = defs;

package/dist/errors.js

@@ -0,0 +1,174 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// src/errors/AppError.js
+var require_AppError = __commonJS({
+  "src/errors/AppError.js"(exports2, module2) {
+    module2.exports = 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);
+      }
+    };
+  }
+});
+
+// src/errors/AuthenticationError.js
+var require_AuthenticationError = __commonJS({
+  "src/errors/AuthenticationError.js"(exports2, module2) {
+    var AppError = require_AppError();
+    module2.exports = class AuthenticationError extends AppError {
+      constructor(message = "Authentication Error", options = {}) {
+        super(message, options);
+        this.statusCode = 401;
+        Object.setPrototypeOf(this, AuthenticationError.prototype);
+      }
+    };
+  }
+});
+
+// src/errors/AuthorizationError.js
+var require_AuthorizationError = __commonJS({
+  "src/errors/AuthorizationError.js"(exports2, module2) {
+    var AppError = require_AppError();
+    module2.exports = class AuthorizationError extends AppError {
+      constructor(message = "Authorization Error", options = {}) {
+        super(message, options);
+        this.statusCode = 403;
+        Object.setPrototypeOf(this, AuthorizationError.prototype);
+      }
+    };
+  }
+});
+
+// src/errors/DeviceCommError.js
+var require_DeviceCommError = __commonJS({
+  "src/errors/DeviceCommError.js"(exports2, module2) {
+    var AppError = require_AppError();
+    module2.exports = class DeviceCommError extends AppError {
+      constructor(message = "Device Communication Error", options = {}) {
+        super(message, options);
+        this.statusCode = 503;
+        Object.setPrototypeOf(this, DeviceCommError.prototype);
+      }
+    };
+  }
+});
+
+// src/errors/LoginError.js
+var require_LoginError = __commonJS({
+  "src/errors/LoginError.js"(exports2, module2) {
+    var AppError = require_AppError();
+    module2.exports = class LoginError extends AppError {
+      constructor(message = "Invalid Login information provided", options = {}) {
+        super(message, options);
+        this.statusCode = 401;
+        Object.setPrototypeOf(this, LoginError.prototype);
+      }
+    };
+  }
+});
+
+// src/errors/NotFoundError.js
+var require_NotFoundError = __commonJS({
+  "src/errors/NotFoundError.js"(exports2, module2) {
+    var AppError = require_AppError();
+    module2.exports = class NotFoundError extends AppError {
+      constructor(message = "Resource Not Found", options = {}) {
+        super(message, options);
+        this.statusCode = 404;
+        Object.setPrototypeOf(this, NotFoundError.prototype);
+      }
+    };
+  }
+});
+
+// src/errors/RequestError.js
+var require_RequestError = __commonJS({
+  "src/errors/RequestError.js"(exports2, module2) {
+    var AppError = require_AppError();
+    module2.exports = class RequestError extends AppError {
+      constructor(message = "Bad Request", options = {}) {
+        super(message, options);
+        this.statusCode = 400;
+        Object.setPrototypeOf(this, RequestError.prototype);
+      }
+    };
+  }
+});
+
+// src/errors/SystemCommError.js
+var require_SystemCommError = __commonJS({
+  "src/errors/SystemCommError.js"(exports2, module2) {
+    var AppError = require_AppError();
+    module2.exports = class SystemCommError extends AppError {
+      constructor(message = "System Communication Error", options = {}) {
+        super(message, options);
+        this.statusCode = 503;
+        Object.setPrototypeOf(this, SystemCommError.prototype);
+      }
+    };
+  }
+});
+
+// src/errors/TokenExpiredError.js
+var require_TokenExpiredError = __commonJS({
+  "src/errors/TokenExpiredError.js"(exports2, module2) {
+    var AppError = require_AppError();
+    module2.exports = class TokenExpiredError extends AppError {
+      constructor(message = "Token Expired", options = {}) {
+        super(message, options);
+        this.statusCode = 401;
+        Object.setPrototypeOf(this, TokenExpiredError.prototype);
+      }
+    };
+  }
+});
+
+// src/errors/UnprocessableRequestError.js
+var require_UnprocessableRequestError = __commonJS({
+  "src/errors/UnprocessableRequestError.js"(exports2, module2) {
+    var AppError = require_AppError();
+    module2.exports = class UnprocessableRequestError extends AppError {
+      constructor(message = "Unprocessable Request Error", options = {}) {
+        super(message, options);
+        this.statusCode = 422;
+        Object.setPrototypeOf(this, UnprocessableRequestError.prototype);
+      }
+    };
+  }
+});
+
+// src/errors/ValidationError.js
+var require_ValidationError = __commonJS({
+  "src/errors/ValidationError.js"(exports2, module2) {
+    var AppError = require_AppError();
+    module2.exports = class ValidationError extends AppError {
+      constructor(message = "Validation Error", options = {}) {
+        super(message, options);
+        this.statusCode = 400;
+        Object.setPrototypeOf(this, ValidationError.prototype);
+      }
+    };
+  }
+});
+
+// src/errors/index.js
+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()
+};
+module.exports = Errors;