tiny-essentials 1.0.0

package/dist/legacy/firebase/databaseLogger.mjs

@@ -0,0 +1,234 @@
+import objType from '../get/objType.mjs';
+import moment from 'moment-timezone';
+import getDBData from './getDBData.mjs';
+// DB
+const tinyCache = {};
+let lastUpdate = { number: null, moment: null };
+let cacheLimit = 2000;
+// Action
+// Error To JSON
+if (!('toJSON' in Error.prototype)) {
+    Object.defineProperty(Error.prototype, 'toJSON', {
+        value: function () {
+            let alt = {};
+            Object.getOwnPropertyNames(this).forEach(function (key) {
+                alt[key] = this[key];
+            }, this);
+            return alt;
+        },
+        configurable: true,
+        writable: true,
+    });
+}
+/**
+ * Handles various logging actions (log, error, info, warn) and stores them in the database.
+ * Logs data are stored with a timestamp and are counted by type (log, error, info, warn).
+ * When the log count exceeds the specified cache limit, the database is cleared and reset.
+ *
+ * @param {string} where - The location or context where the log is coming from.
+ * @param {string} type - The type of log (log, error, info, or warn).
+ * @param {Array} args - The arguments to log (can include strings, numbers, objects, arrays, or errors).
+ * @returns {Promise<void>} Resolves once the log is stored in the database.
+ */
+const tinyAction = async function (where, type, args) {
+    // Try
+    try {
+        // Production
+        if (!isDebug) {
+            // Date Now
+            const now = moment();
+            // Update Counter
+            let count = tinyCache[where].count[type];
+            tinyCache[where].count[type]++;
+            // New Date
+            if ((lastUpdate.moment && lastUpdate.moment.date() !== now.date()) ||
+                tinyCache[where].count[type] > cacheLimit) {
+                await tinyCache[where].db.remove();
+                for (const item in tinyCache[where].count) {
+                    tinyCache[where].count[item] = 0;
+                }
+            }
+            // Update Time
+            lastUpdate.moment = now;
+            lastUpdate.number = lastUpdate.moment.valueOf();
+            // Check Args
+            const insertArgs = [];
+            for (const item in args) {
+                // Is Error
+                if (args[item] instanceof Error) {
+                    try {
+                        args[item] = JSON.parse(JSON.stringify(args[item]));
+                    }
+                    catch (err) {
+                        console.error(err);
+                    }
+                }
+                // Object Type
+                const type = objType(args[item]);
+                // Insert Args
+                if (type === 'string' || type === 'number' || type === 'object' || type === 'array')
+                    insertArgs.push(args[item]);
+            }
+            // Add Log
+            if (insertArgs.length > 0) {
+                await tinyCache[where].db.child(type).child(count).set({
+                    time: lastUpdate.number,
+                    args: insertArgs,
+                });
+            }
+            // Nope
+            else {
+                tinyCache[where].count[type]--;
+                if (tinyCache[where].count[type] < 0)
+                    tinyCache[where].count[type] = 0;
+            }
+        }
+    }
+    catch (err) {
+        // Error
+        console.error(`ERROR IN ${where} (${type})!`);
+        console.error(err);
+    }
+};
+// Is Debug
+let isDebug = false;
+/**
+ * Updates the last update time with the provided value, if it's newer than the current one.
+ *
+ * @param {number} value - The timestamp of the update to check against the last update.
+ * @returns {void}
+ */
+const checkLastTime = function (value) {
+    // Update
+    if (!lastUpdate.number || value > lastUpdate.number) {
+        lastUpdate.moment = moment(value);
+        lastUpdate.number = lastUpdate.moment.valueOf();
+    }
+};
+/**
+ * Generates a logger object with methods for different types of logging (log, error, info, warn).
+ * Each log type is stored in the database with a timestamp and arguments.
+ *
+ * @param {string} where - The location or context where the log is coming from.
+ * @returns {Object} The logger object with methods for logging (log, error, info, warn).
+ */
+const loggerGenerator = function (where) {
+    // Done
+    return {
+        // Log
+        log: async function () {
+            console.log.apply(console, arguments);
+            tinyAction(where, 'log', arguments);
+        },
+        // Error
+        error: async function () {
+            console.error.apply(console, arguments);
+            tinyAction(where, 'error', arguments);
+        },
+        // Info
+        info: async function () {
+            console.info.apply(console, arguments);
+            tinyAction(where, 'info', arguments);
+        },
+        // Warning
+        warn: async function () {
+            console.warn.apply(console, arguments);
+            tinyAction(where, 'warn', arguments);
+        },
+    };
+};
+/**
+ * Database logger module that manages logging actions and stores logs in a database.
+ * It provides functionality to start the logger with a new database instance,
+ * retrieve the logger instance, change the cache limit, and set debug mode.
+ *
+ * @module databaseLogger
+ */
+const databaseLogger = {
+    /**
+     * Starts the logger with a new database instance and initializes cache values.
+     *
+     * @param {Object} newDB - The new database instance to use for storing logs.
+     * @param {string} where - The context or location where the logger will be used.
+     * @returns {Promise<Object>} The logger instance with methods for logging.
+     */
+    start: async function (newDB, where) {
+        // Prepare
+        tinyCache[where] = { db: newDB, count: { log: 0, error: 0, info: 0, warn: 0 } };
+        let loggerCache = null;
+        if (!isDebug) {
+            loggerCache = await getDBData(tinyCache[where].db);
+            if (loggerCache) {
+                try {
+                    if (loggerCache.log) {
+                        tinyCache[where].count.log = loggerCache.log.length;
+                        for (const item in loggerCache.log) {
+                            if (typeof loggerCache.log[item].time === 'number') {
+                                checkLastTime(loggerCache.log[item].time);
+                            }
+                        }
+                    }
+                    if (loggerCache.error) {
+                        tinyCache[where].count.error = loggerCache.error.length;
+                        for (const item in loggerCache.error) {
+                            if (typeof loggerCache.error[item].time === 'number') {
+                                checkLastTime(loggerCache.error[item].time);
+                            }
+                        }
+                    }
+                    if (loggerCache.info) {
+                        tinyCache[where].count.info = loggerCache.info.length;
+                        for (const item in loggerCache.info) {
+                            if (typeof loggerCache.info[item].time === 'number') {
+                                checkLastTime(loggerCache.info[item].time);
+                            }
+                        }
+                    }
+                    if (loggerCache.warn) {
+                        tinyCache[where].count.warn = loggerCache.warn.length;
+                        for (const item in loggerCache.warn) {
+                            if (typeof loggerCache.warn[item].time === 'number') {
+                                checkLastTime(loggerCache.warn[item].time);
+                            }
+                        }
+                    }
+                }
+                catch (err) {
+                    console.error(err);
+                    isDebug = true;
+                }
+            }
+        }
+        // Complete
+        return loggerGenerator(where);
+    },
+    /**
+     * Retrieves the logger instance for a given context.
+     *
+     * @param {string} where - The context or location where the logger will be used.
+     * @returns {Object} The logger instance with methods for logging.
+     */
+    get: function (where) {
+        return loggerGenerator(where);
+    },
+    /**
+     * Changes the cache limit for the logger.
+     *
+     * @param {number} value - The new cache limit to set.
+     * @returns {void}
+     */
+    changeCacheLimit: function (value) {
+        if (typeof value === 'number')
+            cacheLimit = value;
+    },
+    /**
+     * Enables or disables debug mode.
+     *
+     * @param {boolean} value - `true` to enable debug mode, `false` to disable it.
+     * @returns {void}
+     */
+    setDebugMode: function (value) {
+        isDebug = value;
+    },
+};
+export default databaseLogger;

package/dist/legacy/firebase/discord/api/addGuildMember.cjs

@@ -0,0 +1,71 @@
+'use strict';
+
+var json = require('../../../http/fetch/json.cjs');
+var config = require('../config.cjs');
+var errorValidator = require('../get/errorValidator.cjs');
+
+/**
+ * Adds a member to a Discord guild (server) using a valid OAuth2 access token and a bot token.
+ * This method requires the `guilds.join` OAuth2 scope to be granted by the user.
+ *
+ * @param {string} bot_token - The Bot Token used for authorization (`Bot <token>`).
+ * @param {Object} data - The data required to add the member to the guild.
+ * @param {string} data.guild_id - The ID of the guild (server) the user should be added to.
+ * @param {string} data.user_id - The ID of the user to be added.
+ * @param {string} data.access_token - The OAuth2 access token granted by the user.
+ * @param {string[]} [data.roles] - An optional array of role IDs to assign to the member.
+ * @param {string} [data.nickname] - Optional nickname to assign to the user in the guild.
+ * @param {boolean} [data.mute=false] - Whether the user should be server-muted.
+ * @param {boolean} [data.deaf=false] - Whether the user should be server-deafened.
+ *
+ * @returns {Promise<Object>} Resolves with the user object if successful, or rejects with an error object.
+ *
+ * @throws {Object} If the request fails or Discord returns an error, rejects with an object containing a `code` and `message`.
+ *
+ * @example
+ * const result = await addGuildMember('your_bot_token', {
+ *   guild_id: '1234567890',
+ *   user_id: '0987654321',
+ *   access_token: 'user_access_token',
+ *   roles: ['1122334455'],
+ *   nickname: 'CoolUser',
+ *   mute: false,
+ *   deaf: false,
+ * });
+ */
+function addGuildMember(bot_token, data) {
+  return new Promise(function (resolve, reject) {
+    // API URL
+    const apiURL = config.url;
+
+    // Response
+    json(
+      `${apiURL}guilds/${encodeURIComponent(data.guild_id)}/members/${encodeURIComponent(data.user_id)}`,
+      {
+        method: 'PUT',
+        body: new URLSearchParams({
+          deaf: data.deaf,
+          mute: data.mute,
+          nick: data.nickname,
+          roles: data.roles,
+          access_token: data.access_token,
+        }),
+        headers: {
+          Authorization: `Bot ${bot_token}`,
+          'Content-Type': 'application/json',
+        },
+      },
+    )
+      .then((data) => {
+        // Error Validator
+        const result = errorValidator(data);
+        if (!result.error) resolve(result.data);
+        else reject(result.error);
+      })
+      .catch((err) => {
+        reject({ code: err.response.status, message: err.message });
+      });
+  });
+}
+
+module.exports = addGuildMember;

package/dist/legacy/firebase/discord/api/addGuildMember.d.mts

@@ -0,0 +1,38 @@
+/**
+ * Adds a member to a Discord guild (server) using a valid OAuth2 access token and a bot token.
+ * This method requires the `guilds.join` OAuth2 scope to be granted by the user.
+ *
+ * @param {string} bot_token - The Bot Token used for authorization (`Bot <token>`).
+ * @param {Object} data - The data required to add the member to the guild.
+ * @param {string} data.guild_id - The ID of the guild (server) the user should be added to.
+ * @param {string} data.user_id - The ID of the user to be added.
+ * @param {string} data.access_token - The OAuth2 access token granted by the user.
+ * @param {string[]} [data.roles] - An optional array of role IDs to assign to the member.
+ * @param {string} [data.nickname] - Optional nickname to assign to the user in the guild.
+ * @param {boolean} [data.mute=false] - Whether the user should be server-muted.
+ * @param {boolean} [data.deaf=false] - Whether the user should be server-deafened.
+ *
+ * @returns {Promise<Object>} Resolves with the user object if successful, or rejects with an error object.
+ *
+ * @throws {Object} If the request fails or Discord returns an error, rejects with an object containing a `code` and `message`.
+ *
+ * @example
+ * const result = await addGuildMember('your_bot_token', {
+ *   guild_id: '1234567890',
+ *   user_id: '0987654321',
+ *   access_token: 'user_access_token',
+ *   roles: ['1122334455'],
+ *   nickname: 'CoolUser',
+ *   mute: false,
+ *   deaf: false,
+ * });
+ */
+export default function addGuildMember(bot_token: string, data: {
+    guild_id: string;
+    user_id: string;
+    access_token: string;
+    roles?: string[] | undefined;
+    nickname?: string | undefined;
+    mute?: boolean | undefined;
+    deaf?: boolean | undefined;
+}): Promise<Object>;

package/dist/legacy/firebase/discord/api/addGuildMember.mjs

@@ -0,0 +1,64 @@
+import getJsonFetch from '../../../http/fetch/json.mjs';
+import config from '../config.mjs';
+import errorValidator from '../get/errorValidator.mjs';
+/**
+ * Adds a member to a Discord guild (server) using a valid OAuth2 access token and a bot token.
+ * This method requires the `guilds.join` OAuth2 scope to be granted by the user.
+ *
+ * @param {string} bot_token - The Bot Token used for authorization (`Bot <token>`).
+ * @param {Object} data - The data required to add the member to the guild.
+ * @param {string} data.guild_id - The ID of the guild (server) the user should be added to.
+ * @param {string} data.user_id - The ID of the user to be added.
+ * @param {string} data.access_token - The OAuth2 access token granted by the user.
+ * @param {string[]} [data.roles] - An optional array of role IDs to assign to the member.
+ * @param {string} [data.nickname] - Optional nickname to assign to the user in the guild.
+ * @param {boolean} [data.mute=false] - Whether the user should be server-muted.
+ * @param {boolean} [data.deaf=false] - Whether the user should be server-deafened.
+ *
+ * @returns {Promise<Object>} Resolves with the user object if successful, or rejects with an error object.
+ *
+ * @throws {Object} If the request fails or Discord returns an error, rejects with an object containing a `code` and `message`.
+ *
+ * @example
+ * const result = await addGuildMember('your_bot_token', {
+ *   guild_id: '1234567890',
+ *   user_id: '0987654321',
+ *   access_token: 'user_access_token',
+ *   roles: ['1122334455'],
+ *   nickname: 'CoolUser',
+ *   mute: false,
+ *   deaf: false,
+ * });
+ */
+export default function addGuildMember(bot_token, data) {
+    return new Promise(function (resolve, reject) {
+        // API URL
+        const apiURL = config.url;
+        // Response
+        getJsonFetch(`${apiURL}guilds/${encodeURIComponent(data.guild_id)}/members/${encodeURIComponent(data.user_id)}`, {
+            method: 'PUT',
+            body: new URLSearchParams({
+                deaf: data.deaf,
+                mute: data.mute,
+                nick: data.nickname,
+                roles: data.roles,
+                access_token: data.access_token,
+            }),
+            headers: {
+                Authorization: `Bot ${bot_token}`,
+                'Content-Type': 'application/json',
+            },
+        })
+            .then((data) => {
+            // Error Validator
+            const result = errorValidator(data);
+            if (!result.error)
+                resolve(result.data);
+            else
+                reject(result.error);
+        })
+            .catch((err) => {
+            reject({ code: err.response.status, message: err.message });
+        });
+    });
+}

package/dist/legacy/firebase/discord/api/getGuildWidget.cjs

@@ -0,0 +1,47 @@
+'use strict';
+
+var json = require('../../../http/fetch/json.cjs');
+var config = require('../config.cjs');
+var errorValidator = require('../get/errorValidator.cjs');
+
+/**
+ * Fetches the public widget data for a Discord guild (server).
+ * This includes online members, presence counts, and basic guild information,
+ * but only if the widget is enabled in the server settings.
+ *
+ * @param {string} guildID - The ID of the guild whose widget is to be fetched.
+ *
+ * @returns {Promise<Object>} Resolves with the guild widget data if successful.
+ *
+ * @throws {Object} If the request fails or the widget is disabled, rejects with an object containing a `code` and `message`.
+ *
+ * @example
+ * getGuildWidget('123456789012345678')
+ *   .then((data) => console.log(data))
+ *   .catch((err) => console.error('Widget error:', err));
+ */
+function getGuildWidget(guildID) {
+  return new Promise(function (resolve, reject) {
+    // API URL
+    const apiURL = config.url;
+
+    // Response
+    json(`${apiURL}guilds/${encodeURIComponent(guildID)}/widget.json`, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    })
+      .then((data) => {
+        // Error Validator
+        const result = errorValidator(data);
+        if (!result.error) resolve(result.data);
+        else reject(result.error);
+      })
+      .catch((err) => {
+        reject({ code: err.response.status, message: err.message });
+      });
+  });
+}
+
+module.exports = getGuildWidget;

package/dist/legacy/firebase/discord/api/getGuildWidget.d.mts

@@ -0,0 +1,17 @@
+/**
+ * Fetches the public widget data for a Discord guild (server).
+ * This includes online members, presence counts, and basic guild information,
+ * but only if the widget is enabled in the server settings.
+ *
+ * @param {string} guildID - The ID of the guild whose widget is to be fetched.
+ *
+ * @returns {Promise<Object>} Resolves with the guild widget data if successful.
+ *
+ * @throws {Object} If the request fails or the widget is disabled, rejects with an object containing a `code` and `message`.
+ *
+ * @example
+ * getGuildWidget('123456789012345678')
+ *   .then((data) => console.log(data))
+ *   .catch((err) => console.error('Widget error:', err));
+ */
+export default function getGuildWidget(guildID: string): Promise<Object>;

package/dist/legacy/firebase/discord/api/getGuildWidget.mjs

@@ -0,0 +1,43 @@
+import getJsonFetch from '../../../http/fetch/json.mjs';
+import config from '../config.mjs';
+import errorValidator from '../get/errorValidator.mjs';
+/**
+ * Fetches the public widget data for a Discord guild (server).
+ * This includes online members, presence counts, and basic guild information,
+ * but only if the widget is enabled in the server settings.
+ *
+ * @param {string} guildID - The ID of the guild whose widget is to be fetched.
+ *
+ * @returns {Promise<Object>} Resolves with the guild widget data if successful.
+ *
+ * @throws {Object} If the request fails or the widget is disabled, rejects with an object containing a `code` and `message`.
+ *
+ * @example
+ * getGuildWidget('123456789012345678')
+ *   .then((data) => console.log(data))
+ *   .catch((err) => console.error('Widget error:', err));
+ */
+export default function getGuildWidget(guildID) {
+    return new Promise(function (resolve, reject) {
+        // API URL
+        const apiURL = config.url;
+        // Response
+        getJsonFetch(`${apiURL}guilds/${encodeURIComponent(guildID)}/widget.json`, {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        })
+            .then((data) => {
+            // Error Validator
+            const result = errorValidator(data);
+            if (!result.error)
+                resolve(result.data);
+            else
+                reject(result.error);
+        })
+            .catch((err) => {
+            reject({ code: err.response.status, message: err.message });
+        });
+    });
+}

package/dist/legacy/firebase/discord/api/getToken.cjs

@@ -0,0 +1,67 @@
+'use strict';
+
+var json = require('../../../http/fetch/json.cjs');
+var config = require('../config.cjs');
+var errorValidator = require('../get/errorValidator.cjs');
+
+/**
+ * Exchanges an authorization code for an access token using Discord's OAuth2 API.
+ *
+ * This function is used in the OAuth2 authorization code flow.
+ * It sends a POST request to the `/oauth2/token` endpoint with the required parameters.
+ *
+ * @param {Object} dsData - The data required for the token exchange.
+ * @param {string} dsData.client_id - Your application's client ID.
+ * @param {string} dsData.client_secret - Your application's client secret.
+ * @param {string} dsData.code - The authorization code received from Discord.
+ * @param {string} dsData.redirect_uri - The redirect URI used during the authorization.
+ * @param {string} [dsData.scope] - The OAuth2 scopes being requested (optional but recommended).
+ *
+ * @returns {Promise<Object>} Resolves with the access token data (access_token, token_type, expires_in, refresh_token, scope).
+ *
+ * @throws {Object} If the request fails or Discord returns an error, rejects with an object containing a `code` and `message`.
+ *
+ * @example
+ * getToken({
+ *   client_id: '123456789012345678',
+ *   client_secret: 's3cr3t',
+ *   code: 'authcodefromdiscord',
+ *   redirect_uri: 'https://your.app/redirect',
+ *   scope: 'identify guilds'
+ * })
+ * .then(token => console.log('Access Token:', token.access_token))
+ * .catch(err => console.error('Token error:', err));
+ */
+function getToken(dsData) {
+  return new Promise(function (resolve, reject) {
+    // API URL
+    const apiURL = config.url;
+
+    // Response
+    json(`${apiURL}oauth2/token`, {
+      method: 'POST',
+      body: new URLSearchParams({
+        client_id: dsData.client_id,
+        client_secret: dsData.client_secret,
+        grant_type: 'authorization_code',
+        code: dsData.code,
+        redirect_uri: dsData.redirect_uri,
+        scope: dsData.scope,
+      }),
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+    })
+      .then((data) => {
+        // Error Validator
+        const result = errorValidator(data);
+        if (!result.error) resolve(result.data);
+        else reject(result.error);
+      })
+      .catch((err) => {
+        reject({ code: err.response.status, message: err.message });
+      });
+  });
+}
+
+module.exports = getToken;

package/dist/legacy/firebase/discord/api/getToken.d.mts

@@ -0,0 +1,35 @@
+/**
+ * Exchanges an authorization code for an access token using Discord's OAuth2 API.
+ *
+ * This function is used in the OAuth2 authorization code flow.
+ * It sends a POST request to the `/oauth2/token` endpoint with the required parameters.
+ *
+ * @param {Object} dsData - The data required for the token exchange.
+ * @param {string} dsData.client_id - Your application's client ID.
+ * @param {string} dsData.client_secret - Your application's client secret.
+ * @param {string} dsData.code - The authorization code received from Discord.
+ * @param {string} dsData.redirect_uri - The redirect URI used during the authorization.
+ * @param {string} [dsData.scope] - The OAuth2 scopes being requested (optional but recommended).
+ *
+ * @returns {Promise<Object>} Resolves with the access token data (access_token, token_type, expires_in, refresh_token, scope).
+ *
+ * @throws {Object} If the request fails or Discord returns an error, rejects with an object containing a `code` and `message`.
+ *
+ * @example
+ * getToken({
+ *   client_id: '123456789012345678',
+ *   client_secret: 's3cr3t',
+ *   code: 'authcodefromdiscord',
+ *   redirect_uri: 'https://your.app/redirect',
+ *   scope: 'identify guilds'
+ * })
+ * .then(token => console.log('Access Token:', token.access_token))
+ * .catch(err => console.error('Token error:', err));
+ */
+export default function getToken(dsData: {
+    client_id: string;
+    client_secret: string;
+    code: string;
+    redirect_uri: string;
+    scope?: string | undefined;
+}): Promise<Object>;

package/dist/legacy/firebase/discord/api/getToken.mjs

@@ -0,0 +1,63 @@
+import getJsonFetch from '../../../http/fetch/json.mjs';
+import config from '../config.mjs';
+import errorValidator from '../get/errorValidator.mjs';
+/**
+ * Exchanges an authorization code for an access token using Discord's OAuth2 API.
+ *
+ * This function is used in the OAuth2 authorization code flow.
+ * It sends a POST request to the `/oauth2/token` endpoint with the required parameters.
+ *
+ * @param {Object} dsData - The data required for the token exchange.
+ * @param {string} dsData.client_id - Your application's client ID.
+ * @param {string} dsData.client_secret - Your application's client secret.
+ * @param {string} dsData.code - The authorization code received from Discord.
+ * @param {string} dsData.redirect_uri - The redirect URI used during the authorization.
+ * @param {string} [dsData.scope] - The OAuth2 scopes being requested (optional but recommended).
+ *
+ * @returns {Promise<Object>} Resolves with the access token data (access_token, token_type, expires_in, refresh_token, scope).
+ *
+ * @throws {Object} If the request fails or Discord returns an error, rejects with an object containing a `code` and `message`.
+ *
+ * @example
+ * getToken({
+ *   client_id: '123456789012345678',
+ *   client_secret: 's3cr3t',
+ *   code: 'authcodefromdiscord',
+ *   redirect_uri: 'https://your.app/redirect',
+ *   scope: 'identify guilds'
+ * })
+ * .then(token => console.log('Access Token:', token.access_token))
+ * .catch(err => console.error('Token error:', err));
+ */
+export default function getToken(dsData) {
+    return new Promise(function (resolve, reject) {
+        // API URL
+        const apiURL = config.url;
+        // Response
+        getJsonFetch(`${apiURL}oauth2/token`, {
+            method: 'POST',
+            body: new URLSearchParams({
+                client_id: dsData.client_id,
+                client_secret: dsData.client_secret,
+                grant_type: 'authorization_code',
+                code: dsData.code,
+                redirect_uri: dsData.redirect_uri,
+                scope: dsData.scope,
+            }),
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+            },
+        })
+            .then((data) => {
+            // Error Validator
+            const result = errorValidator(data);
+            if (!result.error)
+                resolve(result.data);
+            else
+                reject(result.error);
+        })
+            .catch((err) => {
+            reject({ code: err.response.status, message: err.message });
+        });
+    });
+}