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

package/events/SystemSourceUpdatedEvent.js

@@ -0,0 +1,17 @@
+const Event = require("./Event");
+
+class SystemSourceUpdatedEvent extends Event {
+  constructor(source) {
+    super(source);
+  }
+
+  get name() {
+    return "SystemSourceUpdated";
+  }
+
+  get routingKey() {
+    return `source.${this.data.id}.updated`;
+  }
+}
+
+module.exports = SystemSourceUpdatedEvent;

package/events/SystemSpaceUpdatedEvent.js

@@ -0,0 +1,17 @@
+const Event = require("./Event");
+
+class SystemSpaceUpdatedEvent extends Event {
+  constructor(space) {
+    super(space);
+  }
+
+  get name() {
+    return "SystemSpaceUpdated";
+  }
+
+  get routingKey() {
+    return `space.${this.data.id}.updated`;
+  }
+}
+
+module.exports = SystemSpaceUpdatedEvent;

package/events/SystemSwitchUpdatedEvent.js

@@ -0,0 +1,17 @@
+const Event = require("./Event");
+
+class SystemSwitchUpdatedEvent extends Event {
+  constructor(_switch) {
+    super(_switch);
+  }
+
+  get name() {
+    return "SystemSwitchUpdated";
+  }
+
+  get routingKey() {
+    return `switch.${this.data.id}.updated`;
+  }
+}
+
+module.exports = SystemSwitchUpdatedEvent;

package/events/SystemThermostatUpdatedEvent.js

@@ -0,0 +1,17 @@
+const Event = require("./Event");
+
+class SystemThermostatUpdatedEvent extends Event {
+  constructor(thermostat) {
+    super(thermostat);
+  }
+
+  get name() {
+    return "SystemThermostatUpdated";
+  }
+
+  get routingKey() {
+    return `thermostat.${this.data.id}.updated`;
+  }
+}
+
+module.exports = SystemThermostatUpdatedEvent;

package/events/SystemUserUpdatedEvent.js

@@ -0,0 +1,17 @@
+const Event = require("./Event");
+
+class SystemUserUpdatedEvent extends Event {
+  constructor(thermostat) {
+    super(thermostat);
+  }
+
+  get name() {
+    return "SystemUserUpdated";
+  }
+
+  get routingKey() {
+    return `user.${this.data.id}.updated`;
+  }
+}
+
+module.exports = SystemUserUpdatedEvent;

package/events/SystemWindowCoveringUpdatedEvent.js

@@ -0,0 +1,17 @@
+const Event = require("./Event");
+
+class SystemWindowCoveringUpdatedEvent extends Event {
+  constructor(wc) {
+    super(wc);
+  }
+
+  get name() {
+    return "SystemWindowCoveringUpdated";
+  }
+
+  get routingKey() {
+    return `windowCovering.${this.data.id}.updated`;
+  }
+}
+
+module.exports = SystemWindowCoveringUpdatedEvent;

package/events/index.js

@@ -0,0 +1,28 @@
+const SystemThermostatUpdatedEvent = require("./SystemThermostatUpdatedEvent");
+const SystemDimmerUpdatedEvent = require("./SystemDimmerUpdatedEvent");
+const SystemSwitchUpdatedEvent = require("./SystemSwitchUpdatedEvent");
+const SystemLockUpdatedEvent = require("./SystemLockUpdatedEvent");
+const SystemCameraUpdatedEvent = require("./SystemCameraUpdatedEvent");
+const SystemSceneControllerUpdatedEvent = require("./SystemSceneControllerUpdatedEvent");
+const SystemWindowCoveringUpdatedEvent = require("./SystemWindowCoveringUpdatedEvent");
+const SystemSourceUpdatedEvent = require("./SystemSourceUpdatedEvent");
+const SystemCourtesyUpdatedEvent = require("./SystemCourtesyUpdatedEvent");
+
+const SystemUserUpdatedEvent = require("./SystemUserUpdatedEvent");
+const SystemSpaceUpdatedEvent = require("./SystemSpaceUpdatedEvent");
+const SystemReservationUpdatedEvent = require("./SystemReservationUpdatedEvent");
+
+module.exports = {
+  SystemThermostatUpdatedEvent,
+  SystemDimmerUpdatedEvent,
+  SystemSwitchUpdatedEvent,
+  SystemLockUpdatedEvent,
+  SystemCameraUpdatedEvent,
+  SystemSceneControllerUpdatedEvent,
+  SystemWindowCoveringUpdatedEvent,
+  SystemSourceUpdatedEvent,
+  SystemCourtesyUpdatedEvent,
+  SystemUserUpdatedEvent,
+  SystemSpaceUpdatedEvent,
+  SystemReservationUpdatedEvent,
+};

package/http/handleResponseError.js

@@ -0,0 +1,53 @@
+const defs = require("../defs").http;
+
+module.exports = function handleResponseError(error) {
+  const { config: originalReq } = error;
+  if (!error.response) return Promise.reject(error);
+  const { status, data } = error.response;
+  const errorCode = data && data.error && data.error.code;
+  const errorMessage = data && data.error && data.error.message;
+
+  try {
+    const expectedError = status >= 400 && status < 500;
+
+    if (errorMessage && errorMessage === "Login Required") {
+      this.onLoginRequired();
+      return Promise.reject(error);
+    }
+
+    // prettier-ignore
+    const newTokensNeeded = expectedError && errorCode === 1004 && status === 401;
+
+    if (status === 401 && !newTokensNeeded) {
+      return Promise.reject(error);
+    }
+    if (status === 400 && errorCode === 1010) {
+      this.onLoginRequired();
+      return Promise.reject(error);
+    }
+
+    if (newTokensNeeded) {
+      return this.RefreshToken({
+        headers: {
+          [defs.refreshTokenHeader]: this.refreshToken,
+        },
+      }).then((response) => {
+        // update headers with the new tokens
+        if (
+          response &&
+          response.headers &&
+          response.headers[this.authTokenHeaderKey]
+        ) {
+          const newToken = response.headers[this.authTokenHeaderKey];
+          originalReq.headers[defs.authTokenHeader] = newToken;
+          this.authToken = newToken;
+          return this.http(originalReq);
+        }
+      });
+    }
+  } catch (error) {
+    console.log(error);
+  }
+
+  return Promise.reject(error);
+};

package/http/handleResponseSuccess.js

@@ -0,0 +1,15 @@
+module.exports = function handleResponseSuccess(response) {
+  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;
+};

package/http/index.js

@@ -0,0 +1,165 @@
+const { EventEmitter } = require("events");
+const defs = require("../defs").http;
+const handleResponseError = require("./handleResponseError");
+const handleResponseSuccess = require("./handleResponseSuccess");
+
+const useCases = require("../useCases/http.json");
+
+/*
+Creates methods for each use case in the API
+
+@param {Object} Client - The client class
+@returns undefined
+*/
+
+function useCaseMethodFactory(Client) {
+  const map = new Map(useCases);
+  for (const [useCase, data] of map.entries()) {
+    if (data.http) {
+      const { method, path } = data.http;
+
+      /* 
+        Creates a method for each use case in the API
+        @param {Object} options - The options to send to the API
+        @param {Object} options.headers - The headers to send to the API
+        @param {Object} options.params - The params for the reuquest to build the URL
+        @param {Object} options.data - The body to send to the API. Valid for POST and PUT requests
+        @parms {Object} options.query - The query for the request to build the URL
+        @returns {Promise} The response from the API
+      */
+
+      //eslint-disable-next-line no-inner-declarations
+      function UseCase(requestData, options = {}) {
+        if (!this._init) {
+          // wait a second for the client to initialize
+          return new Promise((resolve) => {
+            setTimeout(() => {
+              resolve(UseCase.call(this, requestData));
+            }, 500);
+          });
+        }
+        if (!requestData) requestData = {};
+
+        // get parameters from path
+        const pathParams = path.match(/:[a-zA-Z0-9]+/g);
+
+        const { data, params, query, headers } = requestData;
+
+        // replace path parameters with values from params
+        let url = path;
+        if (pathParams && params) {
+          for (const param of pathParams) {
+            const paramName = param.replace(":", "");
+            url = url.replace(param, params[paramName]);
+          }
+        }
+
+        // make sure all parameters have been replaced
+        if (url.match(/:[a-zA-Z0-9]+/g)) {
+          const missingParams = url.match(/:[a-zA-Z0-9]+/g);
+          // remove the colon from the parameter name
+          const missing = missingParams.map((param) => param.replace(":", ""));
+          return Promise.reject(
+            new Error(`Missing parameters: ${missing.join(", ")}`)
+          );
+        }
+
+        const config = {
+          method: method.toLowerCase(),
+          url: url,
+          ...options,
+        };
+
+        if (data) config.data = data;
+        if (query) config.params = query;
+        if (headers) config.headers = headers;
+
+        return this._http.request(config);
+      }
+
+      Client.prototype[useCase] = UseCase;
+    }
+  }
+}
+
+class KohostApiClient extends EventEmitter {
+  /* 
+  @param {Object} options - The options to create the client
+  @param {String} options.tenantId - The tenant 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: "",
+      tenantId: "",
+      headers: {},
+    }
+  ) {
+    super();
+    if (!options.url) throw new Error("options.url is required");
+    if (!options.tenantId) throw new Error("options.tenant is required");
+    this.options = options;
+    // eslint-disable-next-line no-undef
+    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",
+          [defs.tenantHeader]: options.tenantId,
+          ...options.headers,
+        },
+      });
+
+      this._http.interceptors.response.use(
+        handleResponseSuccess.bind(this),
+        handleResponseError.bind(this)
+      );
+
+      this._http.interceptors.request.use((config) => {
+        if (!this.isBrowser) {
+          config.headers[defs.authTokenHeader] = this.authToken;
+        }
+        return config;
+      });
+      this._init = true;
+    });
+  }
+
+  get authTokenHeaderKey() {
+    return defs.authTokenHeader.toLowerCase();
+  }
+
+  get refreshTokenHeaderKey() {
+    return defs.refreshTokenHeader.toLowerCase();
+  }
+
+  get lsTokenKey() {
+    return `${this.options.tenantId}_${defs.authTokenHeader}`;
+  }
+
+  get authToken() {
+    return this._authToken;
+  }
+
+  /* 
+  @param {String} token - The token to set
+  @returns undefined
+  */
+
+  set authToken(token) {
+    this._authToken = token;
+  }
+}
+
+useCaseMethodFactory(KohostApiClient);
+
+module.exports = KohostApiClient;

package/index.js

@@ -1,6 +1,23 @@
 const Models = require("./models");
+const Errors = require("./errors");
+const Commands = require("./commands");
+const Events = require("./events");
+const HttpClient = require("./http");
+const defs = require("./defs");
+const getFormalDeviceType = require("./utils/getFormalDeviceType");
+const getDeviceTypes = require("./utils/getDeviceTypes");
 
-// export all classes on the Models object
-module.exports = {
+const Kohost = {
   Models,
+  Errors,
+  Commands,
+  Events,
+  defs,
+  Client: HttpClient,
+  utils: {
+    getFormalDeviceType: getFormalDeviceType,
+    getDeviceTypes: getDeviceTypes,
+  },
 };
+
+module.exports = Kohost;

package/models/acl.js

@@ -0,0 +1,29 @@
+// create the ACL model
+const schemas = require("../utils/schema");
+const schema = require("../schemas/acl.json");
+const Kohost = require("./kohost");
+
+schemas.add(schema);
+const validator = schemas.compile(schema);
+
+class ACL extends Kohost {
+  constructor(data) {
+    super(data);
+  }
+}
+
+Object.defineProperty(ACL.prototype, "schema", {
+  value: schema,
+});
+
+Object.defineProperty(ACL.prototype, "validator", {
+  get: function () {
+    return validator;
+  },
+});
+
+Object.defineProperty(ACL, "validProperties", {
+  value: Object.keys(schema.properties),
+});
+
+module.exports = ACL;

package/models/admin/customer.js

@@ -0,0 +1,28 @@
+const schemas = require("../../utils/schema");
+const schema = require("../../schemas/admin/customer.json");
+const Kohost = require("../kohost");
+
+schemas.add(schema);
+const validator = schemas.compile(schema);
+
+class Customer extends Kohost {
+  constructor(data) {
+    super(data);
+  }
+}
+
+Object.defineProperty(Customer.prototype, "schema", {
+  value: schema,
+});
+
+Object.defineProperty(Customer.prototype, "validator", {
+  get: function () {
+    return validator;
+  },
+});
+
+Object.defineProperty(Customer, "validProperties", {
+  value: Object.keys(schema.properties),
+});
+
+module.exports = Customer;

package/models/admin/property.js

@@ -0,0 +1,28 @@
+const schemas = require("../../utils/schema");
+const schema = require("../../schemas/admin/property.json");
+const Kohost = require("../kohost");
+
+schemas.add(schema);
+const validator = schemas.compile(schema);
+
+class Property extends Kohost {
+  constructor(data) {
+    super(data);
+  }
+}
+
+Object.defineProperty(Property.prototype, "schema", {
+  value: schema,
+});
+
+Object.defineProperty(Property.prototype, "validator", {
+  get: function () {
+    return validator;
+  },
+});
+
+Object.defineProperty(Property, "validProperties", {
+  value: Object.keys(schema.properties),
+});
+
+module.exports = Property;

package/models/alarm.js

@@ -1,7 +1,29 @@
 // create the Alarm Model
-const { createModel } = require("../utils/compiler");
-const alarmSchema = require("../schemas/alarm.json");
+const schemas = require("../utils/schema");
+const schema = require("../schemas/alarm.json");
+const Kohost = require("./kohost");
 
-const Alarm = createModel({ schema: alarmSchema, name: "Alarm" });
+schemas.add(schema);
+const validator = schemas.compile(schema);
+
+class Alarm extends Kohost {
+  constructor(data) {
+    super(data);
+  }
+}
+
+Object.defineProperty(Alarm.prototype, "schema", {
+  value: schema,
+});
+
+Object.defineProperty(Alarm.prototype, "validator", {
+  get: function () {
+    return validator;
+  },
+});
+
+Object.defineProperty(Alarm, "validProperties", {
+  value: Object.keys(schema.properties),
+});
 
 module.exports = Alarm;

package/models/application.js

@@ -0,0 +1,28 @@
+// create the Application model
+const schemas = require("../utils/schema");
+const schema = require("../schemas/application.json");
+const Kohost = require("./kohost");
+
+schemas.add(schema);
+const validator = schemas.compile(schema);
+class Application extends Kohost {
+  constructor(data) {
+    super(data);
+  }
+}
+
+Object.defineProperty(Application.prototype, "schema", {
+  value: schema,
+});
+
+Object.defineProperty(Application.prototype, "validator", {
+  get: function () {
+    return validator;
+  },
+});
+
+Object.defineProperty(Application, "validProperties", {
+  value: Object.keys(schema.properties),
+});
+
+module.exports = Application;

package/models/camera.js

@@ -0,0 +1,29 @@
+// create the Alarm Model
+const schemas = require("../utils/schema");
+const schema = require("../schemas/camera.json");
+const Kohost = require("./kohost");
+
+schemas.add(schema);
+const validator = schemas.compile(schema);
+
+class Camera extends Kohost {
+  constructor(data) {
+    super(data);
+  }
+}
+
+Object.defineProperty(Camera.prototype, "schema", {
+  value: schema,
+});
+
+Object.defineProperty(Camera.prototype, "validator", {
+  get: function () {
+    return validator;
+  },
+});
+
+Object.defineProperty(Camera, "validProperties", {
+  value: Object.keys(schema.properties),
+});
+
+module.exports = Camera;

package/models/courtesy.js

@@ -1,7 +1,33 @@
 // create the Courtesy Model
-const { createModel } = require("../utils/compiler");
-const courtesySchema = require("../schemas/courtesy.json");
+const schemas = require("../utils/schema");
+const schema = require("../schemas/courtesy.json");
+const Kohost = require("./kohost");
 
-const Courtesy = createModel({ schema: courtesySchema, name: "Courtesy" });
+schemas.add(schema);
+const validator = schemas.compile(schema);
+
+class Courtesy extends Kohost {
+  constructor(data) {
+    super(data);
+  }
+}
+
+Object.defineProperty(Courtesy.prototype, "schema", {
+  value: schema,
+});
+
+Object.defineProperty(Courtesy.prototype, "validator", {
+  get: function () {
+    return validator;
+  },
+});
+
+Object.defineProperty(Courtesy, "validProperties", {
+  value: Object.keys(schema.properties),
+});
+
+Object.defineProperty(Courtesy, "actionProperties", {
+  value: ["state"],
+});
 
 module.exports = Courtesy;

package/models/dimmer.js

@@ -1,7 +1,49 @@
 // Create the Dimmer Model
-const { createModel } = require("../utils/compiler");
-const dimmerSchema = require("../schemas/dimmer.json");
+const schemas = require("../utils/schema");
+const schema = require("../schemas/dimmer.json");
+const Kohost = require("./kohost");
 
-const Dimmer = createModel({ schema: dimmerSchema, name: "Dimmer" });
+schemas.add(schema);
+const validator = schemas.compile(schema);
+
+class Dimmer extends Kohost {
+  constructor(data) {
+    super(data);
+  }
+
+  static getActionDelta(old, _new) {
+    const delta = {};
+    for (const action in _new) {
+      if (this.actionProperties?.includes(action)) {
+        if (action === "level") {
+          const oldLevel = old[action];
+          const newLevel = _new[action];
+          delta[action] = newLevel - oldLevel / 100;
+        } else {
+          delta[action] = 1;
+        }
+      }
+    }
+    return delta;
+  }
+}
+
+Object.defineProperty(Dimmer.prototype, "schema", {
+  value: schema,
+});
+
+Object.defineProperty(Dimmer.prototype, "validator", {
+  get: function () {
+    return validator;
+  },
+});
+
+Object.defineProperty(Dimmer, "validProperties", {
+  value: Object.keys(schema.properties),
+});
+
+Object.defineProperty(Dimmer, "actionProperties", {
+  value: ["level"],
+});
 
 module.exports = Dimmer;