@kohost/api-client 3.0.0-beta.47 → 3.0.0-beta.50

package/dist/cjs/AMQPClient/index.js

@@ -0,0 +1,290 @@
+const Errors = require("../Errors");
+const amqp = require("amqplib");
+const crypto = require("crypto");
+const isFatalError = require("amqplib/lib/connection").isFatalError;
+const debug = require("debug")("kohost:amqp-client");
+
+const HEADER_KEY_ORGANIZATION_ID = "X-Organization-Id";
+const HEADER_KEY_PROPERTY_ID = "X-Property-Id";
+const HEADER_KEY_DRIVER = "X-Driver";
+const HEADER_KEY_COMMAND_NAME = "X-Command-Name";
+const HEADER_KEY_EVENT_NAME = "X-Event-Name";
+
+const exchanges = {
+  // routes commands based on `command-name` header and in many cases `property-id` header
+  Commands: {
+    name: "kohost.commands",
+    type: "headers",
+    options: {
+      durable: true,
+    },
+  },
+  // routes events based on routing keys
+  Events: {
+    name: "kohost.events",
+    type: "topic",
+    options: {
+      durable: true,
+    },
+  },
+  Direct: {
+    name: "kohost.direct",
+    type: "direct",
+    options: {
+      durable: true,
+    },
+  },
+  Replies: {
+    name: "kohost.replies",
+    type: "topic",
+    options: {
+      durable: true,
+    },
+  },
+  // dead letter exchange
+  dlx: {
+    name: "kohost.dlx",
+    type: "direct",
+  },
+};
+
+class KohostAMQPClient {
+  static get Message() {
+    return Message;
+  }
+
+  static get exchanges() {
+    return exchanges;
+  }
+  static generateCorrelationId() {
+    return crypto.randomUUID();
+  }
+
+  static validateMessage(message) {
+    if (!message) throw new Error("Message is required");
+  }
+
+  static parseError(err) {
+    let type;
+    let message;
+    let options = {};
+    if (err.message && err.type) {
+      const { message: errMessage, type: errType, ...rest } = err;
+      type = errType;
+      message = errMessage;
+      options = rest;
+    } else {
+      message = "Unknown Error";
+    }
+
+    debug("parseError", type, message, options);
+
+    switch (type) {
+      case "RequestError":
+        return new Errors.RequestError(message, options);
+
+      case "AuthenticationError":
+        return new Errors.AuthenticationError(message, options);
+
+      case "ValidationError":
+        return new Errors.ValidationError(message, options);
+
+      case "NotFoundError":
+        return new Errors.NotFoundError(message, options);
+
+      case "UnprocessableRequestError":
+        return new Errors.UnprocessableRequestError(message, options);
+
+      default:
+        return new Error(message, options);
+    }
+  }
+
+  static parseMessage(message) {
+    debug("parseMessage input %o", message);
+
+    let error = null;
+    let data = {};
+    let query = {};
+    let context = {};
+    let headers = {};
+
+    const isCommand = message?.properties?.type === "Command";
+    const isEvent = message?.properties?.type === "Event";
+
+    const messageHeaders = message?.properties?.headers || {};
+
+    const commandName = messageHeaders[HEADER_KEY_COMMAND_NAME] || null;
+    const eventName = messageHeaders[HEADER_KEY_EVENT_NAME] || null;
+
+    if (message.content) {
+      try {
+        const payload =
+          message.properties?.contentType === "application/json"
+            ? JSON.parse(message.content.toString())
+            : message.content.toString();
+        data = payload?.data || {};
+        error = payload?.error;
+        query = payload?.query || {};
+        context = payload?.context || {};
+      } catch (error) {
+        data = message.content.toString();
+      }
+    }
+
+    if (message?.properties?.headers) {
+      const orgHeader = message.properties.headers[HEADER_KEY_ORGANIZATION_ID];
+      const propertyHeader = message.properties.headers[HEADER_KEY_PROPERTY_ID];
+      const driverHeader = message.properties.headers[HEADER_KEY_DRIVER];
+
+      if (orgHeader) {
+        context.organizationId = orgHeader;
+        headers[HEADER_KEY_ORGANIZATION_ID] = orgHeader;
+      }
+
+      if (propertyHeader) {
+        context.propertyId = propertyHeader;
+        headers[HEADER_KEY_PROPERTY_ID] = propertyHeader;
+      }
+
+      if (driverHeader) {
+        context.driver = driverHeader;
+        headers[HEADER_KEY_DRIVER] = driverHeader;
+      }
+    }
+
+    const parsed = {};
+
+    if (error) parsed.error = this.parseError(error);
+
+    parsed.data = data;
+    parsed.query = query;
+    parsed.context = context;
+    parsed.headers = headers;
+
+    if (isEvent && eventName) parsed.event = eventName;
+    else if (isCommand && commandName) parsed.command = commandName;
+
+    debug("parseMessage parsed %o", parsed);
+
+    return parsed;
+  }
+
+  static getMessage(message) {
+    if (!message?.content) return null;
+    const payload = JSON.parse(message.content.toString());
+    const data = payload?.data;
+    return data;
+  }
+
+  static isFatalError(err) {
+    return isFatalError(err);
+  }
+
+  async createConnection(connection, options = {}) {
+    return await amqp.connect(connection, options);
+  }
+
+  static createMessage(content) {
+    return new Message(content);
+  }
+
+  async createChannel(connection) {
+    const channel = await connection.createChannel();
+    return channel;
+  }
+
+  async assertExchange(channel, { exchange, type, options }) {
+    return await channel.assertExchange(exchange, type, options);
+  }
+
+  async assertQueue(channel, { queue, options }) {
+    return await channel.assertQueue(queue, options);
+  }
+
+  async bindQueue(channel, { queue, exchange, routingKey, args }) {
+    return await channel.bindQueue(queue, exchange, routingKey, args);
+  }
+
+  async bindExchange(channel, { source, destination, routingKey, args }) {
+    return await channel.bindExchange(destination, source, routingKey, args);
+  }
+
+  async subscribeToQueue(channel, { queue, cb, options }) {
+    return await channel.consume(queue, cb, options);
+  }
+
+  publishToExchange(channel, { exchange, routingKey, content, options }) {
+    return channel.publish(exchange, routingKey, content, options);
+  }
+}
+
+class Message {
+  constructor(content) {
+    this.toExchange = null;
+    this.content = content;
+    this.options = {
+      contentType: "application/json",
+    };
+    this.routingKey = "";
+  }
+
+  get correlationId() {
+    return this.options.correlationId || null;
+  }
+
+  to({ exchange }) {
+    if (typeof exchange === "undefined")
+      throw new Error("Exchange is required");
+    this.toExchange = exchange;
+    return this;
+  }
+
+  withType(type) {
+    this.options.type = type;
+    return this;
+  }
+
+  withRoutingKey(routingKey) {
+    this.routingKey = routingKey;
+    return this;
+  }
+
+  withHeaders(headers) {
+    if (!this.options.headers) this.options.headers = {};
+    this.options.headers = { ...this.options.headers, ...headers };
+    return this;
+  }
+
+  withContext(context) {
+    for (let key in context) {
+      this.withHeaders({ [key]: context[key] });
+    }
+    return this;
+  }
+
+  withCorrelationId(correlationId) {
+    this.options.correlationId = correlationId;
+    return this;
+  }
+
+  withReplyTo(queue) {
+    this.options.replyTo = queue;
+    return this;
+  }
+
+  build() {
+    let content = this.content;
+    if (content.build && typeof content.build === "function")
+      content = content.build();
+
+    return {
+      exchange: this.toExchange,
+      content: Buffer.from(JSON.stringify(content)),
+      options: this.options,
+      routingKey: this.routingKey,
+    };
+  }
+}
+
+module.exports = KohostAMQPClient;

package/dist/cjs/Commands/CheckInReservationCommand.js

@@ -0,0 +1,19 @@
+const Command = require("./Command");
+const RequestError = require("../Errors/RequestError");
+
+class CheckInReservationCommand extends Command {
+  constructor({ id }) {
+    if (!id) throw new RequestError("document type is required");
+    super({ id });
+  }
+
+  get name() {
+    return "CheckInReservation";
+  }
+
+  get routingKey() {
+    return `reservation.${this.data.id}.checkin`;
+  }
+}
+
+module.exports = CheckInReservationCommand;

package/dist/cjs/Commands/Command.js

@@ -0,0 +1,34 @@
+class Command {
+  constructor(data) {
+    this.data = {};
+    if (!data) throw new Error("Command data is required");
+    if (typeof data !== "object")
+      throw new Error("Command data must be an object");
+
+    for (const key in data) {
+      this.data[key] = data[key];
+    }
+  }
+
+  get name() {
+    throw new Error("Command name is required");
+  }
+
+  get type() {
+    return "Command";
+  }
+
+  get routingKey() {
+    return "";
+  }
+
+  get exchange() {
+    return "Commands";
+  }
+
+  build() {
+    return { data: { ...this.data } };
+  }
+}
+
+module.exports = Command;

package/dist/cjs/Commands/CreateImageUploadEndpointCommand.js

@@ -0,0 +1,17 @@
+const Command = require("./Command");
+
+class CreateImageUploadEndpointCommand extends Command {
+  constructor({ id, expires, ...rest }) {
+    super({ id, expires, ...rest });
+  }
+
+  get name() {
+    return "CreateImageUploadEndpoint";
+  }
+
+  get routingKey() {
+    return "image.createUploadEndpoint";
+  }
+}
+
+module.exports = CreateImageUploadEndpointCommand;

package/dist/cjs/Commands/CreateShortLinkCommand.js

@@ -0,0 +1,20 @@
+const Command = require("./Command");
+const RequestError = require("../Errors/RequestError");
+
+class CreateShortLinkCommand extends Command {
+  constructor({ title, destination }) {
+    if (!title) throw new RequestError("title is required");
+    if (!destination) throw new RequestError("destination to is required");
+    super({ title, destination });
+  }
+
+  get name() {
+    return "CreateShortLink";
+  }
+
+  get routingKey() {
+    return "comm.shortlink.create";
+  }
+}
+
+module.exports = CreateShortLinkCommand;

package/dist/cjs/Commands/DiscoverReservationRoomTypeUpsellOptionsCommand.js

@@ -0,0 +1,20 @@
+const { RequestError } = require("../Errors");
+const Command = require("./Command");
+
+class DiscoverReservationRoomTypeUpsellOptionsCommand extends Command {
+  constructor(options) {
+    if (!options) throw new RequestError("options are required");
+    const { id, ...rest } = options;
+    super({ id, ...rest });
+  }
+
+  get name() {
+    return "DiscoverReservationRoomTypeUpsellOptions";
+  }
+
+  get routingKey() {
+    return "reservation.discoverRoomUpsells";
+  }
+}
+
+module.exports = DiscoverReservationRoomTypeUpsellOptionsCommand;

package/dist/cjs/Commands/DiscoverReservationsCommand.js

@@ -0,0 +1,20 @@
+const { RequestError } = require("../Errors");
+const Command = require("./Command");
+
+class DiscoverReservationsCommand extends Command {
+  constructor(options) {
+    if (!options) throw new RequestError("options are required");
+    const { id, startDate, endDate, status, ...rest } = options;
+    super({ id, startDate, endDate, status, ...rest });
+  }
+
+  get name() {
+    return "DiscoverReservations";
+  }
+
+  get routingKey() {
+    return "reservation.discover";
+  }
+}
+
+module.exports = DiscoverReservationsCommand;

package/dist/cjs/Commands/DiscoverRoomTypesCommand.js

@@ -0,0 +1,19 @@
+const Command = require("./Command");
+
+class DiscoverRoomTypesCommand extends Command {
+  constructor({ id }) {
+    super({ id });
+  }
+
+  get name() {
+    return "DiscoverRoomTypes";
+  }
+
+  get routingKey() {
+    if (typeof this.data.id === "string") return `rooms.${this.data.id}.get`;
+    if (Array.isArray(this.data.id)) return "rooms.batch.get";
+    return "rooms.get";
+  }
+}
+
+module.exports = DiscoverRoomTypesCommand;

package/dist/cjs/Commands/DiscoverRoomsCommand.js

@@ -0,0 +1,35 @@
+const Command = require("./Command");
+
+class DiscoverRoomsCommand extends Command {
+  constructor({
+    id,
+    types,
+    startDate,
+    endDate,
+    serviceStatus,
+    housekeepingStatus,
+    ...rest
+  }) {
+    super({
+      id,
+      types,
+      startDate,
+      endDate,
+      serviceStatus,
+      housekeepingStatus,
+      ...rest,
+    });
+  }
+
+  get name() {
+    return "DiscoverRooms";
+  }
+
+  get routingKey() {
+    if (typeof this.data.id === "string") return `rooms.${this.data.id}.get`;
+    if (Array.isArray(this.data.id)) return "rooms.batch.get";
+    return "rooms.get";
+  }
+}
+
+module.exports = DiscoverRoomsCommand;

package/dist/cjs/Commands/DiscoverUsersCommand.js

@@ -0,0 +1,19 @@
+const Command = require("./Command");
+
+class DiscoverUsersCommand extends Command {
+  constructor({ id }) {
+    super({ id });
+  }
+
+  get name() {
+    return "DiscoverUsers";
+  }
+
+  get routingKey() {
+    if (typeof this.data.id === "string") return `users.${this.data.id}.get`;
+    if (Array.isArray(this.data.id)) return "users.batch.get";
+    return "users.get";
+  }
+}
+
+module.exports = DiscoverUsersCommand;

package/dist/cjs/Commands/GetMobileKeyCommand.js

@@ -0,0 +1,24 @@
+const Command = require("./Command");
+
+class GetMobileKeyCommand extends Command {
+  constructor({
+    id,
+    phone,
+    beginDateTime,
+    endDateTime,
+    keyToReplace,
+    ...rest
+  }) {
+    super({ id, phone, beginDateTime, endDateTime, keyToReplace, ...rest });
+  }
+
+  get name() {
+    return "GetMobileKey";
+  }
+
+  get routingKey() {
+    return `lock.${this.data.id}.set`;
+  }
+}
+
+module.exports = GetMobileKeyCommand;

package/dist/cjs/Commands/GetProductsCommand.js

@@ -0,0 +1,17 @@
+const Command = require("./Command");
+
+class GetProductsCommand extends Command {
+  constructor({ id, externalSystemId, ...rest }) {
+    super({ id, externalSystemId, ...rest });
+  }
+
+  get name() {
+    return "GetProducts";
+  }
+
+  get routingKey() {
+    return `product.${this.data.id}.get`;
+  }
+}
+
+module.exports = GetProductsCommand;

package/dist/cjs/Commands/OCRDocumentCommand.js

@@ -0,0 +1,15 @@
+const Command = require("./Command");
+const RequestError = require("../Errors/RequestError");
+
+class OCRDocumentCommand extends Command {
+  constructor({ type, image }) {
+    if (!image) throw new RequestError("document image is required");
+    super({ type, image });
+  }
+
+  get name() {
+    return "OCRDocument";
+  }
+}
+
+module.exports = OCRDocumentCommand;

package/dist/cjs/Commands/SellProductsCommand.js

@@ -0,0 +1,17 @@
+const Command = require("./Command");
+
+class SellProductsCommand extends Command {
+  constructor({ reservationId, userId, products, ...rest }) {
+    super({ reservationId, userId, products, ...rest });
+  }
+
+  get name() {
+    return "SellProducts";
+  }
+
+  get routingKey() {
+    return `product.${this.data.id}.sell`;
+  }
+}
+
+module.exports = SellProductsCommand;

package/dist/cjs/Commands/SendEmailCommand.js

@@ -0,0 +1,24 @@
+const Command = require("./Command");
+const RequestError = require("../Errors/RequestError");
+
+class SendEmailCommand extends Command {
+  constructor({ text, html, to, from, subject, ...rest }) {
+    if (!to) throw new RequestError("email to is required");
+    if (!from) throw new RequestError("email from is required");
+    if (!subject) throw new RequestError("email subject is required");
+    if (!text && !html)
+      throw new RequestError("email text or html is required");
+
+    super({ text, html, to, from, subject, ...rest });
+  }
+
+  get name() {
+    return "SendEmail";
+  }
+
+  get routingKey() {
+    return "comm.email.send";
+  }
+}
+
+module.exports = SendEmailCommand;

package/dist/cjs/Commands/SendSMSCommand.js

@@ -0,0 +1,21 @@
+const Command = require("./Command");
+const RequestError = require("../Errors/RequestError");
+
+class SendSMSCommand extends Command {
+  constructor({ id, body, to, from, ...rest }) {
+    if (!body) throw new RequestError("sms body is required");
+    if (!to) throw new RequestError("sms to is required");
+    if (!from) throw new RequestError("sms from is required");
+    super({ id, body, to, from, ...rest });
+  }
+
+  get name() {
+    return "SendSMS";
+  }
+
+  get routingKey() {
+    return "comm.sms.send";
+  }
+}
+
+module.exports = SendSMSCommand;

package/dist/cjs/Commands/SetAlarmCommand.js

@@ -0,0 +1,17 @@
+const Command = require("./Command");
+
+class SetAlarmCommand extends Command {
+  constructor({ id, zones, areas }) {
+    super({ id, zones, areas });
+  }
+
+  get name() {
+    return "SetAlarm";
+  }
+
+  get routingKey() {
+    return `alarm.${this.data.id}.set`;
+  }
+}
+
+module.exports = SetAlarmCommand;

package/dist/cjs/Commands/SetCourtesyCommand.js

@@ -0,0 +1,17 @@
+const Command = require("./Command");
+
+class SetCourtesyCommand extends Command {
+  constructor({ id, state }) {
+    super({ id, state });
+  }
+
+  get name() {
+    return "SetCourtesy";
+  }
+
+  get routingKey() {
+    return `courtesy.${this.data.id}.set`;
+  }
+}
+
+module.exports = SetCourtesyCommand;

package/dist/cjs/Commands/SetDimmerCommand.js

@@ -0,0 +1,17 @@
+const Command = require("./Command");
+
+class SetDimmerCommand extends Command {
+  constructor({ id, level }) {
+    super({ id, level });
+  }
+
+  get name() {
+    return "SetDimmer";
+  }
+
+  get routingKey() {
+    return `dimmer.${this.data.id}.set`;
+  }
+}
+
+module.exports = SetDimmerCommand;

package/dist/cjs/Commands/SetLockCommand.js

@@ -0,0 +1,17 @@
+const Command = require("./Command");
+
+class SetLockCommand extends Command {
+  constructor({ id, state }) {
+    super({ id, state });
+  }
+
+  get name() {
+    return "SetLock";
+  }
+
+  get routingKey() {
+    return `lock.${this.data.id}.set`;
+  }
+}
+
+module.exports = SetLockCommand;