@kohost/api-client 1.0.0-beta.3 → 1.0.0-beta.5

package/dist/cjs/defs.js

@@ -0,0 +1,175 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// 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/Client/index.js
+var require_Client = __commonJS({
+  "src/Client/index.js"(exports2, module2) {
+    var { EventEmitter } = require("events");
+    var axios = require("axios");
+    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._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.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",
+          propertyHeader: "X-Property-Id"
+        };
+      }
+      _handleResponse(response) {
+        var _a;
+        try {
+          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;
+        } 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;
+        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_Client();
+var defs = {
+  http: httpDefs,
+  deviceTypes,
+  formalDeviceTypes
+};
+module.exports = defs;

package/dist/cjs/index.cjs.js

@@ -0,0 +1,17 @@
+const Models = require("./Models");
+const Errors = require("./Errors");
+const Commands = require("./Commands");
+const Events = require("./Events");
+const defs = require("./defs");
+const utils = require("./utils");
+const Client = require("./Client");
+const Kohost = {
+  Models,
+  Errors,
+  Commands,
+  Events,
+  Client,
+  defs,
+  utils
+};
+module.exports = Kohost;

package/dist/cjs/utils.js

@@ -0,0 +1,246 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// src/utils/getFormalDeviceType.js
+var require_getFormalDeviceType = __commonJS({
+  "src/utils/getFormalDeviceType.js"(exports2, module2) {
+    function getFormalDeviceType2(deviceType) {
+      return deviceType.charAt(0).toUpperCase() + deviceType.slice(1);
+    }
+    module2.exports = getFormalDeviceType2;
+  }
+});
+
+// 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/utils/getDeviceTypes.js
+var require_getDeviceTypes = __commonJS({
+  "src/utils/getDeviceTypes.js"(exports2, module2) {
+    var deviceTypes = require_deviceTypes();
+    function getDeviceTypes2() {
+      return deviceTypes;
+    }
+    module2.exports = getDeviceTypes2;
+  }
+});
+
+// src/schemas/definitions/common.json
+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",
+      definitions: {
+        id: {
+          type: "string"
+        },
+        systemData: {
+          type: "object",
+          default: {}
+        },
+        metadata: {
+          type: "object",
+          default: {}
+        },
+        createdAt: {
+          type: ["string", "object"],
+          format: "date-time"
+        },
+        updatedAt: {
+          type: ["string", "object"],
+          format: "date-time"
+        },
+        file: {
+          type: "object",
+          required: ["name", "type", "data"],
+          properties: {
+            name: {
+              type: "string",
+              description: "Name of the file."
+            },
+            type: {
+              type: "string",
+              description: "MIME type of the file (e.g. application/pdf)."
+            },
+            data: {
+              type: "string",
+              description: "Base64-encoded data of the file."
+            }
+          }
+        },
+        address: {
+          type: "object",
+          properties: {
+            id: {
+              type: "string"
+            },
+            line1: {
+              type: "string"
+            },
+            line2: {
+              type: "string"
+            },
+            line3: {
+              type: "string"
+            },
+            city: {
+              type: "string"
+            },
+            state: {
+              type: "string"
+            },
+            postalCode: {
+              type: "string"
+            },
+            countryCode: {
+              type: "string",
+              minLength: 2,
+              maxLength: 2
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/schemas/definitions/device.json
+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",
+      definitions: {
+        id: {
+          $ref: "https://api.kohost.app/schemas/v3/definitions/common.json#/definitions/id"
+        },
+        systemData: {
+          $ref: "https://api.kohost.app/schemas/v3/definitions/common.json#/definitions/systemData"
+        },
+        type: {
+          type: "string",
+          enum: [
+            "dimmer",
+            "switch",
+            "motionSensor",
+            "windowCovering",
+            "camera",
+            "mediaSource",
+            "thermostat",
+            "lock",
+            "courtesy",
+            "sceneController",
+            "gateway"
+          ]
+        },
+        name: {
+          type: "string"
+        },
+        subType: {
+          type: ["string", "null"]
+        },
+        supportedNotifications: {
+          type: "array",
+          uniqueItems: true,
+          items: {
+            enum: [
+              "button 1",
+              "button 2",
+              "button 3",
+              "button 4",
+              "button 5",
+              "idle",
+              "powerHasBeedApplied",
+              "acMainsDisconnected",
+              "acMainsReconnected",
+              "replaceBatterySoon",
+              "replaceBatteryNow",
+              "hardwareFailure",
+              "softwareFailure",
+              "hardwareFailureWithCode",
+              "softwareFailureWithCode",
+              "motionDetection"
+            ]
+          }
+        },
+        notification: {
+          type: ["object", "null"],
+          properties: {
+            name: {
+              type: "string",
+              $ref: "#/definitions/supportedNotifications/items"
+            },
+            timestamp: {
+              type: "number",
+              minimum: 1655907956593
+            }
+          }
+        },
+        batteryLevel: {
+          type: "number",
+          minimum: 0,
+          maximum: 100
+        }
+      }
+    };
+  }
+});
+
+// src/utils/schema.js
+var require_schema = __commonJS({
+  "src/utils/schema.js"(exports2, module2) {
+    var Ajv = require("ajv");
+    var ajv = new Ajv({
+      allErrors: true,
+      useDefaults: true,
+      strict: false,
+      allowMatchingProperties: true,
+      allowUnionTypes: true,
+      strictRequired: false
+    });
+    var addFormats = require("ajv-formats");
+    var commonDefs = require_common();
+    var deviceDefs = require_device();
+    addFormats(ajv);
+    ajv.addSchema(commonDefs);
+    ajv.addSchema(deviceDefs);
+    module2.exports = {
+      add: function add(schema2) {
+        ajv.addSchema(schema2);
+      },
+      compile: function compile(schema2) {
+        return ajv.compile(schema2);
+      }
+    };
+  }
+});
+
+// src/utils/index.js
+var getFormalDeviceType = require_getFormalDeviceType();
+var getDeviceTypes = require_getDeviceTypes();
+var schema = require_schema();
+module.exports = {
+  getFormalDeviceType,
+  getDeviceTypes,
+  schema
+};