unb-api 1.2.3 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unb-api",
-  "version": "1.2.3",
+  "version": "1.3.0",
   "description": "API wrapper for UnbelievaBoat Discord Bot API",
   "main": "src/index.js",
   "types": "index.d.ts",

package/src/index.js

@@ -1,5 +1,11 @@
 module.exports = {
-    version: require('../package').version,
-    Client: require('./lib/Client'),
-    User: require('./lib/structures/User')
+    version:              require('../package').version,
+    Client:               require('./lib/Client'),
+    Constants:            require('./lib/Constants'),
+    StoreItem:            require('./lib/structures/items/StoreItem'),
+    StoreItemRequirement: require('./lib/structures/items/StoreItemRequirement'),
+    StoreItemAction:      require('./lib/structures/items/StoreItemAction'),
+    InventoryItem:        require('./lib/structures/items/InventoryItem'),
+    Permission:           require('./lib/structures/Permission'),
+    User:                 require('./lib/structures/User'),
 };

package/src/lib/Client.js

@@ -1,4 +1,5 @@
-const { Guild, Permission, User } = require('./structures');
+const { Guild, Permission, User, StoreItem, InventoryItem } = require('./structures');
+const { toSnakeCaseDeep } = require('./util');
 const RequestHandler = require('./RequestHandler');
 
 class Client {
@@ -170,7 +171,173 @@ class Client {
         if (typeof guildId !== 'string') throw new TypeError('guildId must be a string');
 
         return this._request('GET', `applications/@me/guilds/${guildId}`)
-            .then(data => new Permission(data.permissions));
+          .then(data => new Permission(data.permissions));
+    }
+
+    /**
+     * Get guild store items.
+     *
+     * @public
+     * @param {string} guildId - Guild ID
+     * @param {object} [options] - Options
+     * @param {string[]} [options.sort] - Array of properties to sort the items by (id, price, name, stock_remaining, expires_at)
+     * @param {number} [options.page] - The page to request
+     * @param {number} [options.limit=100] - Maximum number of items to return
+     * @param {string} [options.query] - Search for an item by name
+     * @throws {TypeError}
+     * @returns {Promise<{ items: StoreItem[], page: number, totalPages: number }>}
+     *
+     * @see {@link https://unbelievaboat-api.readme.io/reference/get-store-items|Get Store Items}
+     */
+    getItems(guildId, options) {
+        if (typeof guildId !== 'string') throw new TypeError('guildId must be a string');
+
+        return this._request('GET', `guilds/${guildId}/items`, {}, options)
+          .then(data => {
+              return {
+                  page:       data.page,
+                  totalPages: data.total_pages,
+                  items:      data.items.map(item => new StoreItem(item)),
+              };
+          });
+    }
+
+    /**
+     * Get a single store item.
+     *
+     * @public
+     * @param {string} guildId - Guild ID
+     * @param {string} itemId - Item ID
+     * @throws {TypeError}
+     * @returns {Promise<StoreItem>}
+     *
+     * @see {@link https://unbelievaboat-api.readme.io/reference/get-store-item|Get Store Item}
+     */
+    getItem(guildId, itemId) {
+        if (typeof guildId !== 'string') throw new TypeError('guildId must be a string');
+        if (typeof itemId !== 'string') throw new TypeError('itemId must be a string');
+
+        return this._request('GET', `guilds/${guildId}/items/${itemId}`)
+          .then(data => new StoreItem(data));
+    }
+
+    /**
+     * Edit an item
+     *
+     * @public
+     * @param {string} guildId - Guild ID
+     * @param {string} itemId - Item ID
+     * @param {StoreItem|object} data - Item properties to edit
+     * @param [options]
+     * @param [options.cascadeUpdate=false] - Inventory items will also be updated if set to true
+     * @returns {Promise<StoreItem>}
+     */
+    editItem(guildId, itemId, data, options) {
+        if (typeof guildId !== 'string') throw new TypeError('guildId must be a string');
+        if (typeof itemId !== 'string') throw new TypeError('itemId must be a string');
+
+        return this._request('PATCH', `guilds/${guildId}/items/${itemId}`, toSnakeCaseDeep(data), toSnakeCaseDeep(options))
+          .then(data => new StoreItem(data));
+    }
+
+    /**
+     * Delete an item
+     * @public
+     * @param {string} guildId - Guild ID
+     * @param {string} itemId - Item ID
+     * @param {object} [options]
+     * @param {boolean} [options.cascadeDelete=false] - Inventory items will also be deleted if set to true
+     * @returns {Promise<*>}
+     */
+    deleteItem(guildId, itemId, options) {
+        if (typeof guildId !== 'string') throw new TypeError('guildId must be a string');
+        if (typeof itemId !== 'string') throw new TypeError('itemId must be a string');
+
+        return this._request('DELETE', `guilds/${guildId}/items/${itemId}`, {}, toSnakeCaseDeep(options));
+    }
+
+    /**
+     * Get a users inventory items
+     *
+     * @public
+     * @param {string} guildId
+     * @param {string} userId
+     * @param {object} [options] - Options
+     * @param {string[]} [options.sort] - Array of properties to sort the items by (item_id, name, quantity)
+     * @param {number} [options.page] - The page to request
+     * @param {number} [options.limit=100] - Maximum number of items to return
+     * @param {string} [options.query] - Search for an item by name
+     * @returns {Promise<{totalPages: number, page: number, items: InventoryItem[]}>}
+     */
+    getInventoryItems(guildId, userId, options) {
+        if (typeof guildId !== 'string') throw new TypeError('guildId must be a string');
+        if (typeof userId !== 'string') throw new TypeError('itemId must be a string');
+
+        return this._request('GET', `guilds/${guildId}/users/${userId}/inventory`, {}, options)
+          .then(data => {
+              return {
+                  page:       data.page,
+                  totalPages: data.total_pages,
+                  items:      data.items.map(item => new InventoryItem(item)),
+              };
+          });
+    }
+
+    /**
+     * Get a single inventory item for a user
+     *
+     * @public
+     * @param {string} guildId - Guild ID
+     * @param {string} userId - User ID
+     * @param {string} itemId - Item ID
+     * @returns {Promise<{totalPages: number, page: number, items: InventoryItem[]}>}
+     */
+    getInventoryItem(guildId, userId, itemId) {
+        if (typeof guildId !== 'string') throw new TypeError('guildId must be a string');
+        if (typeof userId !== 'string') throw new TypeError('userId must be a string');
+        if (typeof itemId !== 'string') throw new TypeError('itemId must be a string');
+
+        return this._request('GET', `guilds/${guildId}/users/${userId}/inventory/${itemId}`)
+          .then(data => new InventoryItem(data));
+    }
+
+    /**
+     * Add an item to a users inventory
+     *
+     * @public
+     * @param {string} guildId - Guild ID
+     * @param {string} userId - User ID
+     * @param {string} itemId - Item ID
+     * @param {number|string} [quantity=1] - Quantity to add
+     * @param {object} [options]
+     * @param {string} [options.inventoryUserId] - User ID of the inventory to add the item from (can be used if the item no longer exists in the store or the item settings differ)
+     * @returns {Promise<InventoryItem>}
+     */
+    addInventoryItem(guildId, userId, itemId, quantity, options) {
+        if (typeof guildId !== 'string') throw new TypeError('guildId must be a string');
+        if (typeof userId !== 'string') throw new TypeError('userId must be a string');
+        if (typeof itemId !== 'string') throw new TypeError('itemId must be a string');
+
+        return this._request('POST', `guilds/${guildId}/users/${userId}/inventory`, toSnakeCaseDeep({ itemId, quantity, options }))
+          .then(data => new InventoryItem(data));
+    }
+
+    /**
+     * Add an item to a users inventory
+     *
+     * @public
+     * @param {string} guildId - Guild ID
+     * @param {string} userId - User ID
+     * @param {string} itemId - Item ID
+     * @param {number|string} [quantity=1] - Quantity to remove
+     * @returns {Promise<*>}
+     */
+    removeInventoryItem(guildId, userId, itemId, quantity) {
+        if (typeof guildId !== 'string') throw new TypeError('guildId must be a string');
+        if (typeof userId !== 'string') throw new TypeError('userId must be a string');
+        if (typeof itemId !== 'string') throw new TypeError('itemId must be a string');
+
+        return this._request('DELETE', `guilds/${guildId}/users/${userId}/inventory/${itemId}`, {}, { quantity });
     }
 
     /**
@@ -179,7 +346,7 @@ class Client {
      * @private
      * @param {string} method - The http method to use (GET, PUT, PATCH etc.).
      * @param {string} endpoint - The api endpoint to request.
-     * @param {object} [data={}] - The data to provide provide to the server.
+     * @param {object} [data={}] - The data to provide to the server.
      * @param {object} [query={}] - The query string options to use in the url.
      * @returns {Promise<any>} The raw request data.
      */

package/src/lib/Constants.js

@@ -0,0 +1,36 @@
+const Enum = require('./util/Enum');
+
+/**
+ * Item action type enum
+ * @type {Enum}
+ */
+module.exports.ItemActionType = new Enum({
+  RESPOND:        1,
+  ADD_ROLES:      2,
+  REMOVE_ROLES:   3,
+  ADD_BALANCE:    4,
+  REMOVE_BALANCE: 5,
+  ADD_ITEMS:      6,
+  REMOVE_ITEMS:   7,
+});
+
+/**
+ * Item requirement type enum
+ * @type {Enum}
+ */
+module.exports.ItemRequirementType = new Enum({
+  ROLE:          1,
+  TOTAL_BALANCE: 2,
+  ITEM:          3,
+});
+
+
+/**
+ * Item requirement match type enum
+ * @type {Enum}
+ */
+module.exports.ItemRequirementMatchType = new Enum({
+  EVERY:        1,
+  AT_LEAST_ONE: 2,
+  NONE:         3,
+});

package/src/lib/RequestHandler.js

@@ -1,5 +1,5 @@
 const axios = require('axios');
-const Bucket = require('./structures/Bucket');
+const Bucket = require('./util/Bucket');
 const { APIError, HTTPError } = require('./errors');
 const MajorParams = ['guilds'];
 

package/src/lib/structures/Guild.js

@@ -47,7 +47,7 @@ class Guild {
     }
 
     get iconURL() {
-        return this.icon ? `https://cdn.discordapp.com/icons/${this.id}/${this.icon}.png` : null;
+        return this.icon ? `https://cdn.discordapp.com/icons/${this.id}/${this.icon}.${this.icon.startsWith("a_") ? "gif" : "png"}` : null;
     }
 
 }

package/src/lib/structures/index.js

@@ -1,6 +1,9 @@
 module.exports = {
-    Bucket: require('./Bucket'),
-    Guild: require('./Guild'),
-    Permission: require('./Permission'),
-    User: require('./User')
+  Guild:                require('./Guild'),
+  StoreItem:            require('./items/StoreItem'),
+  StoreItemRequirement: require('./items/StoreItemRequirement'),
+  StoreItemAction:      require('./items/StoreItemAction'),
+  InventoryItem:        require('./items/InventoryItem'),
+  Permission:           require('./Permission'),
+  User:                 require('./User'),
 };

package/src/lib/structures/items/BaseItem.js

@@ -0,0 +1,21 @@
+const StoreItemRequirement = require('./StoreItemRequirement');
+const StoreItemAction = require('./StoreItemAction');
+
+class BaseItem {
+  constructor(data) {
+    this.name = data.name;
+    this.description = data.description;
+    this.isUsable = data.is_usable;
+    this.isSellable = data.is_sellable;
+    this.requirements = data.requirements.map(requirement => new StoreItemRequirement(requirement));
+    this.actions = data.actions.map(action => new StoreItemAction(action));
+    this.emojiUnicode = data.emoji_unicode;
+    this.emojiId = data.emoji_id;
+  }
+
+  get isChicken() {
+    return (this.name || '').toLowerCase().includes('chicken');
+  }
+}
+
+module.exports = BaseItem;

package/src/lib/structures/items/InventoryItem.js

@@ -0,0 +1,11 @@
+const BaseItem = require('./BaseItem');
+
+class InventoryItem extends BaseItem {
+  constructor(data) {
+    super(data);
+    this.itemId = data.item_id;
+    this.quantity = data.quantity;
+  }
+}
+
+module.exports = InventoryItem;

package/src/lib/structures/items/StoreItem.js

@@ -0,0 +1,17 @@
+const BaseItem = require('./BaseItem');
+
+class StoreItem extends BaseItem {
+  constructor(data) {
+    super(data);
+    this.id = data.id;
+    this.price = parseInt(data.price);
+    this.isInventory = data.is_inventory;
+    this.stockRemaining = data.stock_remaining;
+    this.unlimitedStock = data.unlimited_stock;
+    if (data.expires_at) {
+      this.expiresAt = new Date(data.expires_at);
+    }
+  }
+}
+
+module.exports = StoreItem;

package/src/lib/structures/items/StoreItemAction.js

@@ -0,0 +1,33 @@
+const { ItemActionType } = require('../../Constants');
+
+class StoreItemAction {
+  constructor(data) {
+    this.type = ItemActionType.toString(data.type);
+
+    switch (this.type) {
+      case 'RESPOND':
+        this.message = data.message;
+        break;
+      case 'ADD_ROLES':
+      case 'ADD_ITEMS':
+      case 'REMOVE_ROLES':
+      case 'REMOVE_ITEMS':
+        this.ids = data.ids || [];
+        break;
+      case 'ADD_BALANCE':
+      case 'REMOVE_BALANCE':
+        this.balance = data.balance;
+        break;
+    }
+  }
+
+  toJSON() {
+    return {
+      ...this,
+      type: ItemActionType.toNumber(this.type),
+    };
+  }
+
+}
+
+module.exports = StoreItemAction;

package/src/lib/structures/items/StoreItemRequirement.js

@@ -0,0 +1,28 @@
+const { ItemRequirementType, ItemRequirementMatchType } = require('../../Constants');
+
+class StoreItemRequirement {
+  constructor(data) {
+    this.type = ItemRequirementType.toString(data.type);
+
+    switch (this.type) {
+      case 'ROLE':
+      case 'ITEM':
+        this.matchType = ItemRequirementMatchType.toString(data.match_type);
+        this.ids = data.ids || [];
+        break;
+      case 'TOTAL_BALANCE':
+        this.balance = data.balance;
+        break;
+    }
+  }
+
+  toJSON() {
+    return {
+      ...this,
+      type:      ItemRequirementType.toNumber(this.type),
+      matchType: this.matchType ? ItemRequirementMatchType.toNumber(this.matchType) : undefined,
+    };
+  }
+}
+
+module.exports = StoreItemRequirement;

package/src/lib/util/Enum.js

@@ -0,0 +1,71 @@
+class Enum {
+  #keys = [];
+  #values = [];
+
+  constructor(object) {
+    const result = {};
+    for (const [key, value] of Object.entries(object)) {
+      if (key === null) continue;
+      result[key] = value;
+      result[value] = key;
+
+      this.#keys.push(key);
+      this.#values.push(value);
+    }
+
+    this.entries = Object.freeze(result);
+  }
+
+  get keys() {
+    return this.#keys;
+  }
+
+  get values() {
+    return this.#values;
+  }
+
+  /**
+   * Compare if two enum value are equal
+   * @param a
+   * @param b
+   * @returns {boolean}
+   */
+  equal(a, b) {
+    if (!this.entries.hasOwnProperty(a)) return false;
+    if (!this.entries.hasOwnProperty(b)) return false;
+
+    return a === b || this.entries[a] === b;
+  }
+
+  /**
+   * Convert an enum value to string
+   * @param value
+   * @returns {*}
+   */
+  toString(value) {
+    const number = parseInt(value);
+    if (isNaN(number)) return value;
+    return this.entries[number];
+  }
+
+  /**
+   * Convert an enum value to number
+   * @param value
+   * @returns {number}
+   */
+  toNumber(value) {
+    const number = parseInt(value);
+    if (isNaN(number)) return this.entries[value];
+    return number;
+  }
+
+  /**
+   * Check if a value exists
+   * @param value
+   */
+  exists(value) {
+    return !!this.entries[value];
+  }
+}
+
+module.exports = Enum;

package/src/lib/util/index.js

@@ -0,0 +1,21 @@
+module.exports.toSnakeCase = (input) => input.replace(/[A-Z]/g, match => `_${match.toLowerCase()}`);
+
+module.exports.toSnakeCaseDeep = (value) => {
+  if (value && value.toJSON) {
+    value = value.toJSON();
+  }
+
+  if (Array.isArray(value)) {
+    return value.map(exports.toSnakeCaseDeep);
+  }
+
+  if (value !== null && typeof value === 'object') {
+    let obj = {};
+    for (let key of Object.keys(value)) {
+      obj[exports.toSnakeCase(key)] = exports.toSnakeCaseDeep(value[key]);
+    }
+    return obj;
+  }
+
+  return value;
+};