tiny-essentials 1.0.0

package/dist/legacy/firebase/discord/get/randomAvatar.mjs

@@ -0,0 +1,30 @@
+import tinyDice from '../../../libs/dice.mjs';
+/**
+ * Generates a random Discord avatar URL or returns a specified avatar URL based on the provided value.
+ * If no value is provided, a random avatar from the Discord CDN is selected.
+ *
+ * @function
+ * @param {string|number|null} [value=null] - The avatar number or string. If provided, it will return the avatar associated with that number or string.
+ * If no value is provided or the value is invalid, a random avatar will be generated.
+ * @param {string} [url='https://cdn.discordapp.com/embed/avatars/'] - The base URL for the Discord avatars. By default, it uses the CDN URL.
+ *
+ * @returns {string} The URL of the avatar image.
+ *
+ * @example
+ * // Returns a random avatar URL
+ * const avatarURL = randomAvatar();
+ * console.log(avatarURL); // Example output: https://cdn.discordapp.com/embed/avatars/1234.png
+ *
+ * @example
+ * // Returns a specific avatar URL based on the value
+ * const avatarURL = randomAvatar(2);
+ * console.log(avatarURL); // Example output: https://cdn.discordapp.com/embed/avatars/2.png
+ */
+export default function randomAvatar(value = null, url = 'https://cdn.discordapp.com/embed/avatars/') {
+    // Random
+    if (typeof value !== 'number' && typeof value !== 'string')
+        return url + tinyDice.vanilla(4) + '.png';
+    // Nope
+    else
+        return url + 'https://cdn.discordapp.com/embed/avatars/' + value + '.png';
+}

package/dist/legacy/firebase/discord/http/index.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var login = require('./login.cjs');
+var logout = require('./logout.cjs');
+var redirect = require('./redirect.cjs');
+var refreshToken = require('./refreshToken.cjs');
+
+const getItems = {
+  login,
+  logout,
+  redirect,
+  refreshToken,
+};
+
+module.exports = getItems;

package/dist/legacy/firebase/discord/http/index.d.mts

@@ -0,0 +1,11 @@
+export default getItems;
+declare namespace getItems {
+    export { login };
+    export { logout };
+    export { redirect };
+    export { refreshToken };
+}
+import login from './login.mjs';
+import logout from './logout.mjs';
+import redirect from './redirect.mjs';
+import refreshToken from './refreshToken.mjs';

package/dist/legacy/firebase/discord/http/index.mjs

@@ -0,0 +1,11 @@
+import login from './login.mjs';
+import logout from './logout.mjs';
+import redirect from './redirect.mjs';
+import refreshToken from './refreshToken.mjs';
+const getItems = {
+    login,
+    logout,
+    redirect,
+    refreshToken,
+};
+export default getItems;

package/dist/legacy/firebase/discord/http/login.cjs

@@ -0,0 +1,127 @@
+'use strict';
+
+var _ = require('lodash');
+var objType = require('../../../get/objType.cjs');
+var _default = require('../../../crypto/default.cjs');
+var HTTP1_0 = require('../../../http/HTTP-1.0.cjs');
+var getDomainURL = require('../../../http/getDomainURL.cjs');
+var authURLGenerator = require('../get/authURLGenerator.cjs');
+
+/**
+ * Handles the login process by checking the configuration, generating authentication URLs, and redirecting the user to the appropriate destination.
+ * Depending on the configuration type, it handles various authentication methods like login, login_command, and webhook.
+ *
+ * @function
+ * @param {Object} req - The request object, typically provided by the web framework (e.g., Express).
+ * @param {Object} res - The response object, typically provided by the web framework (e.g., Express).
+ * @param {Object} cfg - The configuration object that includes various settings for the login process.
+ * @param {boolean} existSession - A flag indicating whether the user already has an active session.
+ *
+ * @returns {void} This function does not return anything. It sends a redirect response to the user based on the configuration.
+ *
+ * @throws {Error} If any validation or configuration fails, an error response will be sent.
+ *
+ * @example
+ * // Example usage with Express:
+ * app.get('/login', (req, res) => {
+ *   login(req, res, config, sessionExists);
+ * });
+ */
+function login(req, res, cfg, existSession) {
+  // Send Error
+  const sendError = function (data) {
+    if (typeof cfg.errorCallback !== 'function') return HTTP1_0.send(res, data.code);
+    else return cfg.errorCallback(data, req, res);
+  };
+
+  // Detect Config
+  if (
+    objType(cfg, 'object') &&
+    typeof cfg.type === 'string' &&
+    (cfg.type === 'login' || cfg.type === 'login_command' || cfg.type === 'webhook')
+  ) {
+    // Create Settings
+    const tinyCrypto = _.defaultsDeep({}, cfg.crypto, _default);
+
+    // Detect Config
+    if (objType(tinyCrypto, 'object')) {
+      // Create Settings
+      const tinyCfg = _.defaultsDeep({}, cfg.auth, {
+        redirect: 'http://localhost/redirect',
+        discordScope: [],
+        client_id: '',
+      });
+
+      // Validate Config
+      if (objType(tinyCfg, 'object')) {
+        // Default Values State
+        let tinyState = _.defaultsDeep({}, cfg.state, {
+          csrfToken: '',
+          redirect: '',
+          type: cfg.type,
+        });
+
+        // Validate
+        if (typeof tinyState.type !== 'string') tinyState.type = cfg.type;
+
+        // Validate State
+        if (objType(tinyState, 'object')) {
+          // Create Settings
+          const tinyQuery = _.defaultsDeep({}, cfg.query, {
+            redirect: 'redirect',
+          });
+
+          // Exist Cfg
+          if (objType(tinyQuery, 'object')) {
+            // Get Domain
+            const tinyDomain = getDomainURL(req, cfg.port);
+
+            // Redirect
+            let returnRedirect = tinyDomain + '/';
+            if (objType(req.query, 'object')) {
+              if (typeof req.query[tinyQuery.redirect] === 'string') {
+                req.query[tinyQuery.redirect] = req.query[tinyQuery.redirect].trim();
+                if (!req.query[tinyQuery.redirect].startsWith('http')) {
+                  if (req.query[tinyQuery.redirect].startsWith('/'))
+                    req.query[tinyQuery.redirect] = req.query[tinyQuery.redirect].substring(1);
+
+                  // Return Redirect
+                  tinyState.redirect = req.query[tinyQuery.redirect];
+                  returnRedirect = req.query[tinyQuery.redirect];
+
+                  // Fix Redirect
+                  returnRedirect = tinyDomain + '/' + returnRedirect;
+                } else tinyState.redirect = '';
+              } else {
+                tinyState.redirect = '';
+                delete req.query[tinyQuery.redirect];
+              }
+            } else tinyState.redirect = '';
+
+            // Don't exist session
+            if (!existSession || cfg.type === 'login_command' || cfg.type === 'webhook') {
+              // Redirect Result
+              const redirect_discord = authURLGenerator(tinyCfg, tinyState, tinyCrypto, cfg.type);
+              return res.redirect(redirect_discord);
+            }
+
+            // Yes
+            else return res.redirect(returnRedirect);
+          }
+          // Nope
+          else return sendError({ code: 400, message: 'Invalide Request!' });
+        }
+        // Error
+        else return sendError({ code: 400, message: 'Invalide State Config!' });
+      }
+      // Error
+      else return sendError({ code: 500, message: 'Invalide System Config!' });
+    }
+    // Nope
+    else return sendError({ code: 500, message: 'Invalid Crypto Values!' });
+  }
+  // Nope
+  else return sendError({ code: 500, message: 'Invalid Config Values!' });
+}
+
+module.exports = login;

package/dist/legacy/firebase/discord/http/login.d.mts

@@ -0,0 +1,21 @@
+/**
+ * Handles the login process by checking the configuration, generating authentication URLs, and redirecting the user to the appropriate destination.
+ * Depending on the configuration type, it handles various authentication methods like login, login_command, and webhook.
+ *
+ * @function
+ * @param {Object} req - The request object, typically provided by the web framework (e.g., Express).
+ * @param {Object} res - The response object, typically provided by the web framework (e.g., Express).
+ * @param {Object} cfg - The configuration object that includes various settings for the login process.
+ * @param {boolean} existSession - A flag indicating whether the user already has an active session.
+ *
+ * @returns {void} This function does not return anything. It sends a redirect response to the user based on the configuration.
+ *
+ * @throws {Error} If any validation or configuration fails, an error response will be sent.
+ *
+ * @example
+ * // Example usage with Express:
+ * app.get('/login', (req, res) => {
+ *   login(req, res, config, sessionExists);
+ * });
+ */
+export default function login(req: Object, res: Object, cfg: Object, existSession: boolean): void;

package/dist/legacy/firebase/discord/http/login.mjs

@@ -0,0 +1,123 @@
+import _ from 'lodash';
+import objType from '../../../get/objType.mjs';
+import defaultCrypto from '../../../crypto/default.mjs';
+import http_status from '../../../http/HTTP-1.0.mjs';
+import getDomainURL from '../../../http/getDomainURL.mjs';
+import authURLGenerator from '../get/authURLGenerator.mjs';
+/**
+ * Handles the login process by checking the configuration, generating authentication URLs, and redirecting the user to the appropriate destination.
+ * Depending on the configuration type, it handles various authentication methods like login, login_command, and webhook.
+ *
+ * @function
+ * @param {Object} req - The request object, typically provided by the web framework (e.g., Express).
+ * @param {Object} res - The response object, typically provided by the web framework (e.g., Express).
+ * @param {Object} cfg - The configuration object that includes various settings for the login process.
+ * @param {boolean} existSession - A flag indicating whether the user already has an active session.
+ *
+ * @returns {void} This function does not return anything. It sends a redirect response to the user based on the configuration.
+ *
+ * @throws {Error} If any validation or configuration fails, an error response will be sent.
+ *
+ * @example
+ * // Example usage with Express:
+ * app.get('/login', (req, res) => {
+ *   login(req, res, config, sessionExists);
+ * });
+ */
+export default function login(req, res, cfg, existSession) {
+    // Send Error
+    const sendError = function (data) {
+        if (typeof cfg.errorCallback !== 'function')
+            return http_status.send(res, data.code);
+        else
+            return cfg.errorCallback(data, req, res);
+    };
+    // Detect Config
+    if (objType(cfg, 'object') &&
+        typeof cfg.type === 'string' &&
+        (cfg.type === 'login' || cfg.type === 'login_command' || cfg.type === 'webhook')) {
+        // Create Settings
+        const tinyCrypto = _.defaultsDeep({}, cfg.crypto, defaultCrypto);
+        // Detect Config
+        if (objType(tinyCrypto, 'object')) {
+            // Create Settings
+            const tinyCfg = _.defaultsDeep({}, cfg.auth, {
+                redirect: 'http://localhost/redirect',
+                discordScope: [],
+                client_id: '',
+            });
+            // Validate Config
+            if (objType(tinyCfg, 'object')) {
+                // Default Values State
+                let tinyState = _.defaultsDeep({}, cfg.state, {
+                    csrfToken: '',
+                    redirect: '',
+                    type: cfg.type,
+                });
+                // Validate
+                if (typeof tinyState.type !== 'string')
+                    tinyState.type = cfg.type;
+                // Validate State
+                if (objType(tinyState, 'object')) {
+                    // Create Settings
+                    const tinyQuery = _.defaultsDeep({}, cfg.query, {
+                        redirect: 'redirect',
+                    });
+                    // Exist Cfg
+                    if (objType(tinyQuery, 'object')) {
+                        // Get Domain
+                        const tinyDomain = getDomainURL(req, cfg.port);
+                        // Redirect
+                        let returnRedirect = tinyDomain + '/';
+                        if (objType(req.query, 'object')) {
+                            if (typeof req.query[tinyQuery.redirect] === 'string') {
+                                req.query[tinyQuery.redirect] = req.query[tinyQuery.redirect].trim();
+                                if (!req.query[tinyQuery.redirect].startsWith('http')) {
+                                    if (req.query[tinyQuery.redirect].startsWith('/'))
+                                        req.query[tinyQuery.redirect] = req.query[tinyQuery.redirect].substring(1);
+                                    // Return Redirect
+                                    tinyState.redirect = req.query[tinyQuery.redirect];
+                                    returnRedirect = req.query[tinyQuery.redirect];
+                                    // Fix Redirect
+                                    returnRedirect = tinyDomain + '/' + returnRedirect;
+                                }
+                                else
+                                    tinyState.redirect = '';
+                            }
+                            else {
+                                tinyState.redirect = '';
+                                delete req.query[tinyQuery.redirect];
+                            }
+                        }
+                        else
+                            tinyState.redirect = '';
+                        // Don't exist session
+                        if (!existSession || cfg.type === 'login_command' || cfg.type === 'webhook') {
+                            // Redirect Result
+                            const redirect_discord = authURLGenerator(tinyCfg, tinyState, tinyCrypto, cfg.type);
+                            return res.redirect(redirect_discord);
+                        }
+                        // Yes
+                        else
+                            return res.redirect(returnRedirect);
+                    }
+                    // Nope
+                    else
+                        return sendError({ code: 400, message: 'Invalide Request!' });
+                }
+                // Error
+                else
+                    return sendError({ code: 400, message: 'Invalide State Config!' });
+            }
+            // Error
+            else
+                return sendError({ code: 500, message: 'Invalide System Config!' });
+        }
+        // Nope
+        else
+            return sendError({ code: 500, message: 'Invalid Crypto Values!' });
+    }
+    // Nope
+    else
+        return sendError({ code: 500, message: 'Invalid Config Values!' });
+}

package/dist/legacy/firebase/discord/http/logout.cjs

@@ -0,0 +1,155 @@
+'use strict';
+
+var _ = require('lodash');
+var objType = require('../../../get/objType.cjs');
+var revokeToken = require('../api/revokeToken.cjs');
+var getUser = require('../api/getUser.cjs');
+
+/**
+ * Handles the logout process for the user by revoking the token and redirecting.
+ *
+ * @param {Object} req - The HTTP request object.
+ * @param {string|number} access_token - The access token of the user to be revoked.
+ * @param {Object} cfg - Configuration object containing settings for the logout process.
+ * @param {boolean} existSession - A flag indicating whether a session exists.
+ *
+ * @returns {Promise<Object>} Resolves with a result object or rejects with an error.
+ *
+ * @throws {Object} Rejects with an error if configuration or token values are invalid.
+ *
+ * @example
+ * logout(req, 'userAccessToken', cfg, true)
+ *   .then(result => {
+ *     // Handle successful logout
+ *   })
+ *   .catch(err => {
+ *     // Handle error during logout
+ *   });
+ */
+async function logout(req, access_token, cfg, existSession) {
+  return new Promise(function (resolve, reject) {
+    // Detect Config
+    if (objType(cfg, 'object')) {
+      // Create Settings
+      const tinyQuery = _.defaultsDeep({}, cfg.query, {
+        csrfToken: 'csrfToken',
+        redirect: 'redirect',
+      });
+
+      const tinyState = _.defaultsDeep({}, cfg.state, {
+        csrfToken: '',
+        redirect: '',
+      });
+
+      // Exist Query Setting
+      if (objType(tinyQuery, 'object')) {
+        // Exist Query
+        if (
+          typeof tinyState.csrfToken !== 'string' ||
+          tinyState.csrfToken.length < 1 ||
+          (objType(req.query, 'object') &&
+            typeof cfg.csrfToken === 'string' &&
+            tinyState.csrfToken === cfg.csrfToken)
+        ) {
+          // Result
+          const result = {
+            data: null,
+            existSession: existSession,
+            complete: false,
+            state: { csrfToken: cfg.csrfToken },
+          };
+
+          // Prepare Final Redirect
+          result.redirect = '/';
+
+          // Redirect
+          if (typeof tinyState.redirect === 'string' && tinyState.redirect.length > 0) {
+            if (tinyState.redirect.startsWith('/'))
+              result.redirect = tinyState.redirect.substring(1);
+            else result.redirect = tinyState.redirect;
+          }
+
+          // Get Query
+          else if (typeof req.query[tinyQuery.redirect] === 'string') {
+            if (req.query[tinyQuery.redirect].startsWith('/'))
+              result.redirect = req.query[tinyQuery.redirect].substring(1);
+            else result.redirect = req.query[tinyQuery.redirect];
+          }
+
+          // Exist Session
+          if (existSession) {
+            // Exist Token
+            if (
+              (typeof access_token === 'string' && access_token.length > 0) ||
+              (typeof access_token === 'number' && !isNaN(access_token))
+            ) {
+              // Prepare Auth
+              const tinyAuth = _.defaultsDeep({}, cfg.auth, {
+                client_id: '',
+                client_secret: '',
+                redirect_uri: '',
+              });
+
+              // Exist Client ID
+              if (
+                (typeof tinyAuth.client_id === 'string' && tinyAuth.client_id.length > 0) ||
+                (typeof tinyAuth.client_id === 'number' && !isNaN(tinyAuth.client_id))
+              ) {
+                // Exist Client Secret
+                if (
+                  (typeof tinyAuth.client_secret === 'string' &&
+                    tinyAuth.client_secret.length > 0) ||
+                  (typeof tinyAuth.client_secret === 'number' && !isNaN(tinyAuth.client_secret))
+                ) {
+                  // End Discord
+                  const end_discord_session = function () {
+                    // Get API HTTP and Revoke the Token
+                    revokeToken(access_token, tinyAuth)
+                      .then((data) => {
+                        result.data = data;
+                        resolve(result);
+                      })
+                      .catch((err) => {
+                        result.err = err;
+                        reject(result);
+                      });
+                  };
+
+                  // Don't need user info
+                  if (typeof access_token !== 'string' || access_token.length < 1)
+                    end_discord_session();
+                  // Yes
+                  else {
+                    // Get User
+                    getUser(access_token)
+                      .then((data) => {
+                        result.user = data;
+                        end_discord_session();
+                      })
+                      .catch(reject);
+                  }
+                }
+                // Nope
+                else reject({ code: 401, message: 'Invalid Client Secret!' });
+              }
+              // Nope
+              else reject({ code: 401, message: 'Invalid Client ID!' });
+            }
+            // Nope
+            else reject({ code: 401, message: 'Invalid Token Data!' });
+          }
+          // Nope
+          else resolve(result);
+        }
+        // Nope
+        else reject({ code: 401, message: 'Invalid csrfToken!' });
+      }
+      // Nope
+      else reject({ code: 401, message: 'Invalid query setting!' });
+    }
+    // Nope
+    else reject({ code: 500, message: 'Invalid Config Values!' });
+  });
+}
+
+module.exports = logout;

package/dist/legacy/firebase/discord/http/logout.d.mts

@@ -0,0 +1,22 @@
+/**
+ * Handles the logout process for the user by revoking the token and redirecting.
+ *
+ * @param {Object} req - The HTTP request object.
+ * @param {string|number} access_token - The access token of the user to be revoked.
+ * @param {Object} cfg - Configuration object containing settings for the logout process.
+ * @param {boolean} existSession - A flag indicating whether a session exists.
+ *
+ * @returns {Promise<Object>} Resolves with a result object or rejects with an error.
+ *
+ * @throws {Object} Rejects with an error if configuration or token values are invalid.
+ *
+ * @example
+ * logout(req, 'userAccessToken', cfg, true)
+ *   .then(result => {
+ *     // Handle successful logout
+ *   })
+ *   .catch(err => {
+ *     // Handle error during logout
+ *   });
+ */
+export default function logout(req: Object, access_token: string | number, cfg: Object, existSession: boolean): Promise<Object>;

package/dist/legacy/firebase/discord/http/logout.mjs

@@ -0,0 +1,143 @@
+import _ from 'lodash';
+import objType from '../../../get/objType.mjs';
+import revokeToken from '../api/revokeToken.mjs';
+import getUser from '../api/getUser.mjs';
+/**
+ * Handles the logout process for the user by revoking the token and redirecting.
+ *
+ * @param {Object} req - The HTTP request object.
+ * @param {string|number} access_token - The access token of the user to be revoked.
+ * @param {Object} cfg - Configuration object containing settings for the logout process.
+ * @param {boolean} existSession - A flag indicating whether a session exists.
+ *
+ * @returns {Promise<Object>} Resolves with a result object or rejects with an error.
+ *
+ * @throws {Object} Rejects with an error if configuration or token values are invalid.
+ *
+ * @example
+ * logout(req, 'userAccessToken', cfg, true)
+ *   .then(result => {
+ *     // Handle successful logout
+ *   })
+ *   .catch(err => {
+ *     // Handle error during logout
+ *   });
+ */
+export default async function logout(req, access_token, cfg, existSession) {
+    return new Promise(function (resolve, reject) {
+        // Detect Config
+        if (objType(cfg, 'object')) {
+            // Create Settings
+            const tinyQuery = _.defaultsDeep({}, cfg.query, {
+                csrfToken: 'csrfToken',
+                redirect: 'redirect',
+            });
+            const tinyState = _.defaultsDeep({}, cfg.state, {
+                csrfToken: '',
+                redirect: '',
+            });
+            // Exist Query Setting
+            if (objType(tinyQuery, 'object')) {
+                // Exist Query
+                if (typeof tinyState.csrfToken !== 'string' ||
+                    tinyState.csrfToken.length < 1 ||
+                    (objType(req.query, 'object') &&
+                        typeof cfg.csrfToken === 'string' &&
+                        tinyState.csrfToken === cfg.csrfToken)) {
+                    // Result
+                    const result = {
+                        data: null,
+                        existSession: existSession,
+                        complete: false,
+                        state: { csrfToken: cfg.csrfToken },
+                    };
+                    // Prepare Final Redirect
+                    result.redirect = '/';
+                    // Redirect
+                    if (typeof tinyState.redirect === 'string' && tinyState.redirect.length > 0) {
+                        if (tinyState.redirect.startsWith('/'))
+                            result.redirect = tinyState.redirect.substring(1);
+                        else
+                            result.redirect = tinyState.redirect;
+                    }
+                    // Get Query
+                    else if (typeof req.query[tinyQuery.redirect] === 'string') {
+                        if (req.query[tinyQuery.redirect].startsWith('/'))
+                            result.redirect = req.query[tinyQuery.redirect].substring(1);
+                        else
+                            result.redirect = req.query[tinyQuery.redirect];
+                    }
+                    // Exist Session
+                    if (existSession) {
+                        // Exist Token
+                        if ((typeof access_token === 'string' && access_token.length > 0) ||
+                            (typeof access_token === 'number' && !isNaN(access_token))) {
+                            // Prepare Auth
+                            const tinyAuth = _.defaultsDeep({}, cfg.auth, {
+                                client_id: '',
+                                client_secret: '',
+                                redirect_uri: '',
+                            });
+                            // Exist Client ID
+                            if ((typeof tinyAuth.client_id === 'string' && tinyAuth.client_id.length > 0) ||
+                                (typeof tinyAuth.client_id === 'number' && !isNaN(tinyAuth.client_id))) {
+                                // Exist Client Secret
+                                if ((typeof tinyAuth.client_secret === 'string' &&
+                                    tinyAuth.client_secret.length > 0) ||
+                                    (typeof tinyAuth.client_secret === 'number' && !isNaN(tinyAuth.client_secret))) {
+                                    // End Discord
+                                    const end_discord_session = function () {
+                                        // Get API HTTP and Revoke the Token
+                                        revokeToken(access_token, tinyAuth)
+                                            .then((data) => {
+                                            result.data = data;
+                                            resolve(result);
+                                        })
+                                            .catch((err) => {
+                                            result.err = err;
+                                            reject(result);
+                                        });
+                                    };
+                                    // Don't need user info
+                                    if (typeof access_token !== 'string' || access_token.length < 1)
+                                        end_discord_session();
+                                    // Yes
+                                    else {
+                                        // Get User
+                                        getUser(access_token)
+                                            .then((data) => {
+                                            result.user = data;
+                                            end_discord_session();
+                                        })
+                                            .catch(reject);
+                                    }
+                                }
+                                // Nope
+                                else
+                                    reject({ code: 401, message: 'Invalid Client Secret!' });
+                            }
+                            // Nope
+                            else
+                                reject({ code: 401, message: 'Invalid Client ID!' });
+                        }
+                        // Nope
+                        else
+                            reject({ code: 401, message: 'Invalid Token Data!' });
+                    }
+                    // Nope
+                    else
+                        resolve(result);
+                }
+                // Nope
+                else
+                    reject({ code: 401, message: 'Invalid csrfToken!' });
+            }
+            // Nope
+            else
+                reject({ code: 401, message: 'Invalid query setting!' });
+        }
+        // Nope
+        else
+            reject({ code: 500, message: 'Invalid Config Values!' });
+    });
+}