tiny-essentials 1.0.0

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

@@ -0,0 +1,188 @@
+'use strict';
+
+var _ = require('lodash');
+var _default = require('../../../crypto/default.cjs');
+var objType = require('../../../get/objType.cjs');
+var decrypt = require('../../../crypto/decrypt.cjs');
+var getToken = require('../api/getToken.cjs');
+var getUser = require('../api/getUser.cjs');
+
+/**
+ * Handles the redirection logic for the OAuth flow, including state validation, token retrieval, and user session management.
+ * This function is used for handling Discord OAuth redirects and session creation or restoration.
+ *
+ * @param {Object} req - The request object from the client, which contains query parameters such as `state`, `code`, and `csrfToken`.
+ * @param {Object} cfg - The configuration object containing settings like `crypto`, `auth`, and `discordScope`.
+ * @param {boolean} existSession - Indicates if the user already has an active session.
+ *
+ * @returns {Promise<Object>} - A promise that resolves with an object containing the redirection URL and session information.
+ * If a new session is created, it also includes user data and the token request.
+ *
+ * @throws {Object} - Throws an error with a `code` and `message` if any validation fails (e.g., missing token, invalid state).
+ *
+ * @example
+ * // Example usage of redirect function
+ * redirect(req, cfg, true)
+ *   .then((result) => {
+ *     console.log('Redirection successful', result);
+ *   })
+ *   .catch((err) => {
+ *     console.error('Error during redirect', err);
+ *   });
+ */
+async function redirect(req, cfg, existSession) {
+  return new Promise(function (resolve, reject) {
+    // Detect Config
+    if (objType(cfg, 'object')) {
+      // 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: '',
+          client_secret: '',
+          first_get_user: true,
+        });
+
+        // Check Type
+        if (req.query.state.type === 'login_command') {
+          tinyCfg.discordScope = ['applications.commands', 'applications.commands.update'];
+        }
+
+        // Detect Query
+        if (objType(req.query, 'object')) {
+          // Get State
+          if (typeof req.query.state === 'string') {
+            // Crypto
+            req.query.state = decrypt.decrypt(tinyCrypto, req.query.state);
+
+            // Convert
+            try {
+              req.query.state = JSON.parse(req.query.state);
+            } catch (err) {
+              req.query.state = {};
+            }
+          } else {
+            req.query.state = {};
+          }
+
+          // Detect State
+          if (objType(req.query.state, 'object')) {
+            // Check Session
+            if (
+              typeof tinyCfg.csrfToken !== 'string' ||
+              tinyCfg.csrfToken.length < 1 ||
+              (typeof req.query.state.csrfToken === 'string' &&
+                req.query.state.csrfToken === tinyCfg.csrfToken)
+            ) {
+              // Prepare Resolve Data
+              const resolveData = { newSession: false, state: req.query.state };
+
+              // Final Redirect
+              resolveData.redirect = '/';
+              if (typeof req.query.state.redirect === 'string') {
+                resolveData.redirect += req.query.state.redirect;
+              }
+
+              // Exist Session
+              if (!existSession || req.query.state.type === 'webhook') {
+                if (
+                  (typeof req.query.code === 'string' && req.query.code.length > 0) ||
+                  (typeof req.query.code === 'number' && !isNaN(req.query.code))
+                ) {
+                  // Discord Token
+                  getToken({
+                    client_id: tinyCfg.client_id,
+                    client_secret: tinyCfg.client_secret,
+                    code: req.query.code,
+                    redirect_uri: tinyCfg.redirect,
+                    scope: tinyCfg.discordScope.join(' '),
+                  })
+                    // Success
+                    .then((json) => {
+                      // Valid Json Data
+                      if (objType(json, 'object')) {
+                        // Check Token
+                        if (
+                          typeof json.access_token === 'string' ||
+                          typeof json.access_token === 'number'
+                        ) {
+                          // Token
+                          resolveData.tokenRequest = json;
+
+                          // Login Type
+                          if (req.query.state.type === 'login') {
+                            // Check New Session
+                            resolveData.newSession = true;
+
+                            // Get User Data
+                            if (tinyCfg.first_get_user) {
+                              // Get User
+                              getUser(json.access_token)
+                                // Get User
+                                .then((dsUser) => {
+                                  // Validate Data
+                                  if (objType(dsUser, 'object')) {
+                                    resolveData.user = dsUser;
+                                    resolve(resolveData);
+                                  }
+
+                                  // Nope
+                                  else reject({ code: 500, message: 'Invalid JSON User Data!' });
+                                })
+                                // Fail
+                                .catch(reject);
+                            }
+
+                            // Nope
+                            else {
+                              // Return Result
+                              resolve(resolveData);
+                            }
+                          }
+
+                          // Webhook Type
+                          else if (req.query.state.type === 'webhook') {
+                            // Guild ID
+                            if (typeof req.query.guild_id === 'string')
+                              resolveData.guild_id = req.query.guild_id;
+
+                            // Return Result
+                            resolve(resolveData);
+                          }
+
+                          // Unknown
+                          else reject({ code: 400, message: 'Invalid State Type!' });
+                        }
+                        // Nope
+                        else reject({ code: 500, message: 'Invalid User Token Data!' });
+                      }
+                      // Nope
+                      else reject({ code: 500, message: 'Invalid JSON Token Data!' });
+                    })
+
+                    // Fail
+                    .catch(reject);
+                } else reject({ code: 401, message: 'Invalid Discord Code!' });
+              } else resolve({ newSession: false });
+            } else reject({ code: 401, message: 'Incorrect csrfToken!' });
+          }
+          // Nope
+          else reject({ code: 401, message: 'Invalid State Query!' });
+        }
+        // Nope
+        else reject({ code: 401, message: 'Invalid Query URL!' });
+      }
+      // Nope
+      else reject({ code: 500, message: 'Invalid Crypto Values!' });
+    }
+    // Nope
+    else reject({ code: 500, message: 'Invalid Config Values!' });
+  });
+}
+
+module.exports = redirect;

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

@@ -0,0 +1,24 @@
+/**
+ * Handles the redirection logic for the OAuth flow, including state validation, token retrieval, and user session management.
+ * This function is used for handling Discord OAuth redirects and session creation or restoration.
+ *
+ * @param {Object} req - The request object from the client, which contains query parameters such as `state`, `code`, and `csrfToken`.
+ * @param {Object} cfg - The configuration object containing settings like `crypto`, `auth`, and `discordScope`.
+ * @param {boolean} existSession - Indicates if the user already has an active session.
+ *
+ * @returns {Promise<Object>} - A promise that resolves with an object containing the redirection URL and session information.
+ * If a new session is created, it also includes user data and the token request.
+ *
+ * @throws {Object} - Throws an error with a `code` and `message` if any validation fails (e.g., missing token, invalid state).
+ *
+ * @example
+ * // Example usage of redirect function
+ * redirect(req, cfg, true)
+ *   .then((result) => {
+ *     console.log('Redirection successful', result);
+ *   })
+ *   .catch((err) => {
+ *     console.error('Error during redirect', err);
+ *   });
+ */
+export default function redirect(req: Object, cfg: Object, existSession: boolean): Promise<Object>;

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

@@ -0,0 +1,178 @@
+import _ from 'lodash';
+import defaultCrypto from '../../../crypto/default.mjs';
+import objType from '../../../get/objType.mjs';
+import { decrypt } from '../../../crypto/decrypt.mjs';
+import getToken from '../api/getToken.mjs';
+import getUser from '../api/getUser.mjs';
+/**
+ * Handles the redirection logic for the OAuth flow, including state validation, token retrieval, and user session management.
+ * This function is used for handling Discord OAuth redirects and session creation or restoration.
+ *
+ * @param {Object} req - The request object from the client, which contains query parameters such as `state`, `code`, and `csrfToken`.
+ * @param {Object} cfg - The configuration object containing settings like `crypto`, `auth`, and `discordScope`.
+ * @param {boolean} existSession - Indicates if the user already has an active session.
+ *
+ * @returns {Promise<Object>} - A promise that resolves with an object containing the redirection URL and session information.
+ * If a new session is created, it also includes user data and the token request.
+ *
+ * @throws {Object} - Throws an error with a `code` and `message` if any validation fails (e.g., missing token, invalid state).
+ *
+ * @example
+ * // Example usage of redirect function
+ * redirect(req, cfg, true)
+ *   .then((result) => {
+ *     console.log('Redirection successful', result);
+ *   })
+ *   .catch((err) => {
+ *     console.error('Error during redirect', err);
+ *   });
+ */
+export default async function redirect(req, cfg, existSession) {
+    return new Promise(function (resolve, reject) {
+        // Detect Config
+        if (objType(cfg, 'object')) {
+            // 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: '',
+                    client_secret: '',
+                    first_get_user: true,
+                });
+                // Check Type
+                if (req.query.state.type === 'login_command') {
+                    tinyCfg.discordScope = ['applications.commands', 'applications.commands.update'];
+                }
+                // Detect Query
+                if (objType(req.query, 'object')) {
+                    // Get State
+                    if (typeof req.query.state === 'string') {
+                        // Crypto
+                        req.query.state = decrypt(tinyCrypto, req.query.state);
+                        // Convert
+                        try {
+                            req.query.state = JSON.parse(req.query.state);
+                        }
+                        catch (err) {
+                            req.query.state = {};
+                        }
+                    }
+                    else {
+                        req.query.state = {};
+                    }
+                    // Detect State
+                    if (objType(req.query.state, 'object')) {
+                        // Check Session
+                        if (typeof tinyCfg.csrfToken !== 'string' ||
+                            tinyCfg.csrfToken.length < 1 ||
+                            (typeof req.query.state.csrfToken === 'string' &&
+                                req.query.state.csrfToken === tinyCfg.csrfToken)) {
+                            // Prepare Resolve Data
+                            const resolveData = { newSession: false, state: req.query.state };
+                            // Final Redirect
+                            resolveData.redirect = '/';
+                            if (typeof req.query.state.redirect === 'string') {
+                                resolveData.redirect += req.query.state.redirect;
+                            }
+                            // Exist Session
+                            if (!existSession || req.query.state.type === 'webhook') {
+                                if ((typeof req.query.code === 'string' && req.query.code.length > 0) ||
+                                    (typeof req.query.code === 'number' && !isNaN(req.query.code))) {
+                                    // Discord Token
+                                    getToken({
+                                        client_id: tinyCfg.client_id,
+                                        client_secret: tinyCfg.client_secret,
+                                        code: req.query.code,
+                                        redirect_uri: tinyCfg.redirect,
+                                        scope: tinyCfg.discordScope.join(' '),
+                                    })
+                                        // Success
+                                        .then((json) => {
+                                        // Valid Json Data
+                                        if (objType(json, 'object')) {
+                                            // Check Token
+                                            if (typeof json.access_token === 'string' ||
+                                                typeof json.access_token === 'number') {
+                                                // Token
+                                                resolveData.tokenRequest = json;
+                                                // Login Type
+                                                if (req.query.state.type === 'login') {
+                                                    // Check New Session
+                                                    resolveData.newSession = true;
+                                                    // Get User Data
+                                                    if (tinyCfg.first_get_user) {
+                                                        // Get User
+                                                        getUser(json.access_token)
+                                                            // Get User
+                                                            .then((dsUser) => {
+                                                            // Validate Data
+                                                            if (objType(dsUser, 'object')) {
+                                                                resolveData.user = dsUser;
+                                                                resolve(resolveData);
+                                                            }
+                                                            // Nope
+                                                            else
+                                                                reject({ code: 500, message: 'Invalid JSON User Data!' });
+                                                        })
+                                                            // Fail
+                                                            .catch(reject);
+                                                    }
+                                                    // Nope
+                                                    else {
+                                                        // Return Result
+                                                        resolve(resolveData);
+                                                    }
+                                                }
+                                                // Webhook Type
+                                                else if (req.query.state.type === 'webhook') {
+                                                    // Guild ID
+                                                    if (typeof req.query.guild_id === 'string')
+                                                        resolveData.guild_id = req.query.guild_id;
+                                                    // Return Result
+                                                    resolve(resolveData);
+                                                }
+                                                // Unknown
+                                                else
+                                                    reject({ code: 400, message: 'Invalid State Type!' });
+                                            }
+                                            // Nope
+                                            else
+                                                reject({ code: 500, message: 'Invalid User Token Data!' });
+                                        }
+                                        // Nope
+                                        else
+                                            reject({ code: 500, message: 'Invalid JSON Token Data!' });
+                                    })
+                                        // Fail
+                                        .catch(reject);
+                                }
+                                else
+                                    reject({ code: 401, message: 'Invalid Discord Code!' });
+                            }
+                            else
+                                resolve({ newSession: false });
+                        }
+                        else
+                            reject({ code: 401, message: 'Incorrect csrfToken!' });
+                    }
+                    // Nope
+                    else
+                        reject({ code: 401, message: 'Invalid State Query!' });
+                }
+                // Nope
+                else
+                    reject({ code: 401, message: 'Invalid Query URL!' });
+            }
+            // Nope
+            else
+                reject({ code: 500, message: 'Invalid Crypto Values!' });
+        }
+        // Nope
+        else
+            reject({ code: 500, message: 'Invalid Config Values!' });
+    });
+}

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

@@ -0,0 +1,133 @@
+'use strict';
+
+var _ = require('lodash');
+var objType = require('../../../get/objType.cjs');
+var refreshToken$1 = require('../api/refreshToken.cjs');
+
+/**
+ * Refreshes the Discord token using the provided refresh token.
+ *
+ * @async
+ * @function refreshToken
+ * @param {Object} req - The request object containing query parameters and csrfToken.
+ * @param {Object} cfg - The configuration object containing auth and state configurations.
+ * @param {boolean} existSession - A flag indicating if the user session exists.
+ *
+ * @returns {Promise<Object>} Resolves to an object containing the status of the refresh and the new token data, or rejects with an error object.
+ *
+ * @throws {Object} Rejects with an error object containing the following properties:
+ *   - `code` {number} The error code (e.g., 401 for invalid CSRF token, 500 for server errors).
+ *   - `message` {string} The error message describing the issue.
+ *
+ * @example
+ * const result = await refreshToken(req, cfg, existSession);
+ * if (result.refreshed) {
+ *   console.log('Token refreshed:', result.tokenRequest);
+ * } else {
+ *   console.log('Token refresh failed');
+ * }
+ */
+async function refreshToken(req, cfg, existSession) {
+  return new Promise(function (resolve, reject) {
+    // Detect Config
+    if (objType(cfg, 'object')) {
+      // Create Settings
+      const tinyCfg = _.defaultsDeep({}, cfg.auth, {
+        redirect: 'http://localhost/redirect',
+        discordScope: [],
+        client_id: '',
+        client_secret: '',
+      });
+
+      // Check Session
+      if (
+        typeof tinyCfg.csrfToken !== 'string' ||
+        tinyCfg.csrfToken.length < 1 ||
+        (typeof req.csrfToken.now.value === 'string' &&
+          req.csrfToken.now.value === tinyCfg.csrfToken)
+      ) {
+        // Prepare more settings
+        const tinyQuery = _.defaultsDeep({}, cfg.auth, {
+          redirect: 'redirect',
+        });
+
+        const tinyState = _.defaultsDeep({}, cfg.state, {
+          redirect: '',
+        });
+
+        // Result
+        const result = { refreshed: false };
+
+        // 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 (
+          objType(tinyQuery, 'object') &&
+          objType(req.query, 'object') &&
+          typeof tinyQuery.redirect === 'string' &&
+          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) {
+          if (
+            (typeof cfg.refresh_token === 'string' && cfg.refresh_token.length > 0) ||
+            (typeof cfg.refresh_token === 'number' && !isNaN(cfg.refresh_token))
+          ) {
+            // Discord Token
+            refreshToken$1({
+              client_id: tinyCfg.client_id,
+              client_secret: tinyCfg.client_secret,
+              refresh_token: cfg.refresh_token,
+              redirect_uri: tinyCfg.redirect,
+              scope: tinyCfg.discordScope.join(' '),
+            })
+              // Success
+              .then((json) => {
+                // Valid Json Data
+                if (objType(json, 'object')) {
+                  // Check Token
+                  if (
+                    typeof json.access_token === 'string' ||
+                    typeof json.access_token === 'number'
+                  ) {
+                    // Token
+                    result.refreshed = true;
+                    result.tokenRequest = json;
+
+                    // Return Result
+                    resolve(result);
+                  }
+                  // Nope
+                  else reject({ code: 500, message: 'Invalid User Token Data!' });
+                }
+                // Nope
+                else reject({ code: 500, message: 'Invalid JSON Token Data!' });
+              })
+              // Fail
+              .catch(reject);
+          }
+
+          // Nope
+          else reject({ code: 401, message: 'Invalid Refresh Token Data!' });
+        } else resolve(result);
+      } else reject({ code: 401, message: 'Incorrect csrfToken!' });
+    }
+
+    // Nope
+    else reject({ code: 500, message: 'Invalid Config Values!' });
+  });
+}
+
+module.exports = refreshToken;

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

@@ -0,0 +1,24 @@
+/**
+ * Refreshes the Discord token using the provided refresh token.
+ *
+ * @async
+ * @function refreshToken
+ * @param {Object} req - The request object containing query parameters and csrfToken.
+ * @param {Object} cfg - The configuration object containing auth and state configurations.
+ * @param {boolean} existSession - A flag indicating if the user session exists.
+ *
+ * @returns {Promise<Object>} Resolves to an object containing the status of the refresh and the new token data, or rejects with an error object.
+ *
+ * @throws {Object} Rejects with an error object containing the following properties:
+ *   - `code` {number} The error code (e.g., 401 for invalid CSRF token, 500 for server errors).
+ *   - `message` {string} The error message describing the issue.
+ *
+ * @example
+ * const result = await refreshToken(req, cfg, existSession);
+ * if (result.refreshed) {
+ *   console.log('Token refreshed:', result.tokenRequest);
+ * } else {
+ *   console.log('Token refresh failed');
+ * }
+ */
+export default function refreshToken(req: Object, cfg: Object, existSession: boolean): Promise<Object>;

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

@@ -0,0 +1,121 @@
+import _ from 'lodash';
+import objType from '../../../get/objType.mjs';
+import refreshTokenApi from '../api/refreshToken.mjs';
+/**
+ * Refreshes the Discord token using the provided refresh token.
+ *
+ * @async
+ * @function refreshToken
+ * @param {Object} req - The request object containing query parameters and csrfToken.
+ * @param {Object} cfg - The configuration object containing auth and state configurations.
+ * @param {boolean} existSession - A flag indicating if the user session exists.
+ *
+ * @returns {Promise<Object>} Resolves to an object containing the status of the refresh and the new token data, or rejects with an error object.
+ *
+ * @throws {Object} Rejects with an error object containing the following properties:
+ *   - `code` {number} The error code (e.g., 401 for invalid CSRF token, 500 for server errors).
+ *   - `message` {string} The error message describing the issue.
+ *
+ * @example
+ * const result = await refreshToken(req, cfg, existSession);
+ * if (result.refreshed) {
+ *   console.log('Token refreshed:', result.tokenRequest);
+ * } else {
+ *   console.log('Token refresh failed');
+ * }
+ */
+export default async function refreshToken(req, cfg, existSession) {
+    return new Promise(function (resolve, reject) {
+        // Detect Config
+        if (objType(cfg, 'object')) {
+            // Create Settings
+            const tinyCfg = _.defaultsDeep({}, cfg.auth, {
+                redirect: 'http://localhost/redirect',
+                discordScope: [],
+                client_id: '',
+                client_secret: '',
+            });
+            // Check Session
+            if (typeof tinyCfg.csrfToken !== 'string' ||
+                tinyCfg.csrfToken.length < 1 ||
+                (typeof req.csrfToken.now.value === 'string' &&
+                    req.csrfToken.now.value === tinyCfg.csrfToken)) {
+                // Prepare more settings
+                const tinyQuery = _.defaultsDeep({}, cfg.auth, {
+                    redirect: 'redirect',
+                });
+                const tinyState = _.defaultsDeep({}, cfg.state, {
+                    redirect: '',
+                });
+                // Result
+                const result = { refreshed: false };
+                // 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 (objType(tinyQuery, 'object') &&
+                    objType(req.query, 'object') &&
+                    typeof tinyQuery.redirect === 'string' &&
+                    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) {
+                    if ((typeof cfg.refresh_token === 'string' && cfg.refresh_token.length > 0) ||
+                        (typeof cfg.refresh_token === 'number' && !isNaN(cfg.refresh_token))) {
+                        // Discord Token
+                        refreshTokenApi({
+                            client_id: tinyCfg.client_id,
+                            client_secret: tinyCfg.client_secret,
+                            refresh_token: cfg.refresh_token,
+                            redirect_uri: tinyCfg.redirect,
+                            scope: tinyCfg.discordScope.join(' '),
+                        })
+                            // Success
+                            .then((json) => {
+                            // Valid Json Data
+                            if (objType(json, 'object')) {
+                                // Check Token
+                                if (typeof json.access_token === 'string' ||
+                                    typeof json.access_token === 'number') {
+                                    // Token
+                                    result.refreshed = true;
+                                    result.tokenRequest = json;
+                                    // Return Result
+                                    resolve(result);
+                                }
+                                // Nope
+                                else
+                                    reject({ code: 500, message: 'Invalid User Token Data!' });
+                            }
+                            // Nope
+                            else
+                                reject({ code: 500, message: 'Invalid JSON Token Data!' });
+                        })
+                            // Fail
+                            .catch(reject);
+                    }
+                    // Nope
+                    else
+                        reject({ code: 401, message: 'Invalid Refresh Token Data!' });
+                }
+                else
+                    resolve(result);
+            }
+            else
+                reject({ code: 401, message: 'Incorrect csrfToken!' });
+        }
+        // Nope
+        else
+            reject({ code: 500, message: 'Invalid Config Values!' });
+    });
+}