tiny-essentials 1.0.0

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

@@ -0,0 +1,73 @@
+import getJsonFetch from '../../../http/fetch/json.mjs';
+import config from '../config.mjs';
+import errorValidator from '../get/errorValidator.mjs';
+/**
+ * Refreshes the Discord OAuth2 access token using a valid refresh token.
+ *
+ * This function makes a `POST` request to the Discord API's `/oauth2/token` endpoint
+ * to obtain a new access token and refresh token. It uses the `refresh_token` grant type.
+ *
+ * @param {Object} dsData - The Discord OAuth2 data required for token refresh.
+ * @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 original authorization code (optional but may be required by some flows).
+ * @param {string} dsData.refresh_token - The current valid refresh token.
+ * @param {string} dsData.redirect_uri - The redirect URI used in the original OAuth2 flow.
+ * @param {string} dsData.scope - The scope(s) to request (e.g., 'identify guilds').
+ *
+ * @returns {Promise<Object>} Resolves with a new token object from the Discord API:
+ * {
+ *   access_token: string,
+ *   token_type: string,
+ *   expires_in: number,
+ *   refresh_token: string,
+ *   scope: string
+ * }
+ *
+ * @throws {Object} If the request fails, rejects with an error object containing `code` and `message`.
+ *
+ * @example
+ * refreshToken({
+ *   client_id: '1234567890',
+ *   client_secret: 'mySecret',
+ *   code: 'optional-code',
+ *   refresh_token: 'old-refresh-token',
+ *   redirect_uri: 'https://myapp.com/callback',
+ *   scope: 'identify guilds'
+ * })
+ *   .then(newTokens => console.log('New Access Token:', newTokens.access_token))
+ *   .catch(err => console.error('Failed to refresh token:', err));
+ */
+export default function refreshToken(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: 'refresh_token',
+                code: dsData.code,
+                refresh_token: dsData.refresh_token,
+                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 });
+        });
+    });
+}

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

@@ -0,0 +1,61 @@
+'use strict';
+
+var json = require('../../../http/fetch/json.cjs');
+var config = require('../config.cjs');
+var errorValidator = require('../get/errorValidator.cjs');
+
+/**
+ * Revokes an OAuth2 access token from the Discord API.
+ *
+ * This function makes a `POST` request to the `/oauth2/token/revoke` endpoint to invalidate
+ * a user's access token. This is useful for logout or unlink flows, and requires HTTP Basic Auth
+ * using the application's client ID and client secret encoded in base64.
+ *
+ * @param {string} access_token - The Discord OAuth2 access token to be revoked.
+ * @param {Object} tinyAuth - An object with the client_id and client_secret used to generate the Basic Auth credentials.
+ * @param {string} tinyAuth.client_id - The Discord application client ID.
+ * @param {string} tinyAuth.client_secret - The Discord application client secret.
+ *
+ * @returns {Promise<Object>} Resolves when the token is successfully revoked.
+ * The response may not contain any body if successful, so `result.data` may be empty.
+ *
+ * @throws {Object} If the request fails, rejects with an error object containing `code` and `message`.
+ *
+ * @example
+ * revokeToken('user-access-token', {
+ *   client_id: '1234567890',
+ *   client_secret: 'superSecret'
+ * })
+ *   .then(() => console.log('Token revoked'))
+ *   .catch(err => console.error('Failed to revoke token:', err));
+ */
+function revokeToken(access_token, tinyAuth) {
+  return new Promise(function (resolve, reject) {
+    // API URL
+    const apiURL = config.url;
+    const credentials = credentials(tinyAuth);
+
+    // Response
+    json(`${apiURL}oauth2/token/revoke`, {
+      method: 'POST',
+      body: new URLSearchParams({
+        token: access_token,
+      }),
+      headers: {
+        Authorization: `Basic ${credentials}`,
+        '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 = revokeToken;

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

@@ -0,0 +1,29 @@
+/**
+ * Revokes an OAuth2 access token from the Discord API.
+ *
+ * This function makes a `POST` request to the `/oauth2/token/revoke` endpoint to invalidate
+ * a user's access token. This is useful for logout or unlink flows, and requires HTTP Basic Auth
+ * using the application's client ID and client secret encoded in base64.
+ *
+ * @param {string} access_token - The Discord OAuth2 access token to be revoked.
+ * @param {Object} tinyAuth - An object with the client_id and client_secret used to generate the Basic Auth credentials.
+ * @param {string} tinyAuth.client_id - The Discord application client ID.
+ * @param {string} tinyAuth.client_secret - The Discord application client secret.
+ *
+ * @returns {Promise<Object>} Resolves when the token is successfully revoked.
+ * The response may not contain any body if successful, so `result.data` may be empty.
+ *
+ * @throws {Object} If the request fails, rejects with an error object containing `code` and `message`.
+ *
+ * @example
+ * revokeToken('user-access-token', {
+ *   client_id: '1234567890',
+ *   client_secret: 'superSecret'
+ * })
+ *   .then(() => console.log('Token revoked'))
+ *   .catch(err => console.error('Failed to revoke token:', err));
+ */
+export default function revokeToken(access_token: string, tinyAuth: {
+    client_id: string;
+    client_secret: string;
+}): Promise<Object>;

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

@@ -0,0 +1,58 @@
+import getJsonFetch from '../../../http/fetch/json.mjs';
+import config from '../config.mjs';
+import credentials from '../get/credentials.mjs';
+import errorValidator from '../get/errorValidator.mjs';
+/**
+ * Revokes an OAuth2 access token from the Discord API.
+ *
+ * This function makes a `POST` request to the `/oauth2/token/revoke` endpoint to invalidate
+ * a user's access token. This is useful for logout or unlink flows, and requires HTTP Basic Auth
+ * using the application's client ID and client secret encoded in base64.
+ *
+ * @param {string} access_token - The Discord OAuth2 access token to be revoked.
+ * @param {Object} tinyAuth - An object with the client_id and client_secret used to generate the Basic Auth credentials.
+ * @param {string} tinyAuth.client_id - The Discord application client ID.
+ * @param {string} tinyAuth.client_secret - The Discord application client secret.
+ *
+ * @returns {Promise<Object>} Resolves when the token is successfully revoked.
+ * The response may not contain any body if successful, so `result.data` may be empty.
+ *
+ * @throws {Object} If the request fails, rejects with an error object containing `code` and `message`.
+ *
+ * @example
+ * revokeToken('user-access-token', {
+ *   client_id: '1234567890',
+ *   client_secret: 'superSecret'
+ * })
+ *   .then(() => console.log('Token revoked'))
+ *   .catch(err => console.error('Failed to revoke token:', err));
+ */
+export default function revokeToken(access_token, tinyAuth) {
+    return new Promise(function (resolve, reject) {
+        // API URL
+        const apiURL = config.url;
+        const credentials = credentials(tinyAuth);
+        // Response
+        getJsonFetch(`${apiURL}oauth2/token/revoke`, {
+            method: 'POST',
+            body: new URLSearchParams({
+                token: access_token,
+            }),
+            headers: {
+                Authorization: `Basic ${credentials}`,
+                '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 });
+        });
+    });
+}

package/dist/legacy/firebase/discord/config.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+/**
+ * Configuration object containing Discord API and OAuth2 URLs.
+ *
+ * @typedef {Object} Config
+ * @property {string} url - The base URL for the Discord API.
+ * @property {string} oauth2 - The OAuth2 authorization URL for Discord.
+ */
+
+/**
+ * The configuration object for the Discord API and OAuth2.
+ *
+ * @type {Config}
+ */
+const config = {
+  url: 'https://discord.com/api/',
+  oauth2: 'https://discord.com/oauth2/authorize',
+};
+
+module.exports = config;

package/dist/legacy/firebase/discord/config.d.mts

@@ -0,0 +1,27 @@
+export default config;
+/**
+ * Configuration object containing Discord API and OAuth2 URLs.
+ */
+export type Config = {
+    /**
+     * - The base URL for the Discord API.
+     */
+    url: string;
+    /**
+     * - The OAuth2 authorization URL for Discord.
+     */
+    oauth2: string;
+};
+/**
+ * Configuration object containing Discord API and OAuth2 URLs.
+ *
+ * @typedef {Object} Config
+ * @property {string} url - The base URL for the Discord API.
+ * @property {string} oauth2 - The OAuth2 authorization URL for Discord.
+ */
+/**
+ * The configuration object for the Discord API and OAuth2.
+ *
+ * @type {Config}
+ */
+declare const config: Config;

package/dist/legacy/firebase/discord/config.mjs

@@ -0,0 +1,17 @@
+/**
+ * Configuration object containing Discord API and OAuth2 URLs.
+ *
+ * @typedef {Object} Config
+ * @property {string} url - The base URL for the Discord API.
+ * @property {string} oauth2 - The OAuth2 authorization URL for Discord.
+ */
+/**
+ * The configuration object for the Discord API and OAuth2.
+ *
+ * @type {Config}
+ */
+const config = {
+    url: 'https://discord.com/api/',
+    oauth2: 'https://discord.com/oauth2/authorize',
+};
+export default config;

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

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

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

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

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

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

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

@@ -0,0 +1,110 @@
+'use strict';
+
+/**
+ * Handles Firebase authentication using a custom token, CSRF protection,
+ * and final redirection logic after login.
+ *
+ * This function signs in the user with a custom Firebase token, waits for
+ * the auth state to change, retrieves the ID token, sends it to the current
+ * server endpoint along with a CSRF token, and then redirects the user to
+ * the specified URL or executes a callback.
+ *
+ * @namespace login
+ */
+const login = {
+  /**
+   * Executes the login process with Firebase Auth and handles redirection.
+   *
+   * @param {string} token - The Firebase custom token used for authentication.
+   * @param {string} redirect_url - The relative URL to redirect the user after login.
+   *                                If it starts with "/", it will be adjusted.
+   * @param {string} csrfToken - A CSRF protection token to be sent to the backend.
+   * @param {function} [callback] - Optional callback to be called after authentication.
+   *                                Signature: `(err, redirectFunction, user)`
+   *                                - If omitted, default redirection is used.
+   *
+   * @example
+   * login.run(firebaseToken, '/dashboard', csrfToken);
+   *
+   * @example
+   * login.run(firebaseToken, '/dashboard', csrfToken, (err, redirect, user) => {
+   *   if (err) {
+   *     console.error('Login failed:', err);
+   *     return;
+   *   }
+   *   console.log('Logged in as', user.displayName);
+   *   redirect(); // manually trigger the redirect
+   * });
+   */
+  run: function (token, redirect_url, csrfToken, callback) {
+    // Fix Redirect
+    if (typeof redirect_url === 'string') {
+      if (redirect_url.startsWith('/')) redirect_url = redirect_url.substring(1);
+      else if (redirect_url.startsWith(window.location.origin))
+        redirect_url = redirect_url.substring(window.location.origin.length + 1);
+    }
+
+    // Nope
+    else redirect_url = '';
+
+    // Prepare Redirect
+    const final_redirect = function (err, user) {
+      // The Redirect
+      const start_redirect = function () {
+        window.location.href = window.location.origin + '/' + redirect_url;
+      };
+
+      // Default Redirect
+      if (typeof callback !== 'function') {
+        // Show Error
+        if (err) alert(err.message);
+        // Redirect Now
+        start_redirect();
+      }
+
+      // Custom Redirect
+      else callback(err, start_redirect, user);
+    };
+
+    // Firebase Auth
+    firebase.auth().onAuthStateChanged(function (user) {
+      if (user) {
+        user
+          .getIdToken()
+          .then(function (idToken) {
+            // Fetch
+            fetch(window.location.pathname, {
+              method: 'POST',
+              headers: {
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+              },
+              body: JSON.stringify({ token: idToken, csrfToken: csrfToken }),
+            })
+              .then((response) => {
+                response
+                  .json()
+                  .then((data) => {
+                    // Show Error Message
+                    if (!data.success) final_redirect(new Error(data.error));
+                    // Complete
+                    else final_redirect(null, user);
+                  })
+                  .catch(final_redirect);
+              })
+              .catch(final_redirect);
+          })
+          .catch(final_redirect);
+      }
+    });
+
+    // Sign In
+    firebase
+      .auth()
+      .signInWithCustomToken(token)
+      // Fail
+      .catch(final_redirect);
+  },
+};
+
+module.exports = login;

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

@@ -0,0 +1,4 @@
+export default login;
+declare namespace login {
+    function run(token: string, redirect_url: string, csrfToken: string, callback?: Function): void;
+}

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

@@ -0,0 +1,107 @@
+/**
+ * Handles Firebase authentication using a custom token, CSRF protection,
+ * and final redirection logic after login.
+ *
+ * This function signs in the user with a custom Firebase token, waits for
+ * the auth state to change, retrieves the ID token, sends it to the current
+ * server endpoint along with a CSRF token, and then redirects the user to
+ * the specified URL or executes a callback.
+ *
+ * @namespace login
+ */
+const login = {
+    /**
+     * Executes the login process with Firebase Auth and handles redirection.
+     *
+     * @param {string} token - The Firebase custom token used for authentication.
+     * @param {string} redirect_url - The relative URL to redirect the user after login.
+     *                                If it starts with "/", it will be adjusted.
+     * @param {string} csrfToken - A CSRF protection token to be sent to the backend.
+     * @param {function} [callback] - Optional callback to be called after authentication.
+     *                                Signature: `(err, redirectFunction, user)`
+     *                                - If omitted, default redirection is used.
+     *
+     * @example
+     * login.run(firebaseToken, '/dashboard', csrfToken);
+     *
+     * @example
+     * login.run(firebaseToken, '/dashboard', csrfToken, (err, redirect, user) => {
+     *   if (err) {
+     *     console.error('Login failed:', err);
+     *     return;
+     *   }
+     *   console.log('Logged in as', user.displayName);
+     *   redirect(); // manually trigger the redirect
+     * });
+     */
+    run: function (token, redirect_url, csrfToken, callback) {
+        // Fix Redirect
+        if (typeof redirect_url === 'string') {
+            if (redirect_url.startsWith('/'))
+                redirect_url = redirect_url.substring(1);
+            else if (redirect_url.startsWith(window.location.origin))
+                redirect_url = redirect_url.substring(window.location.origin.length + 1);
+        }
+        // Nope
+        else
+            redirect_url = '';
+        // Prepare Redirect
+        const final_redirect = function (err, user) {
+            // The Redirect
+            const start_redirect = function () {
+                window.location.href = window.location.origin + '/' + redirect_url;
+            };
+            // Default Redirect
+            if (typeof callback !== 'function') {
+                // Show Error
+                if (err)
+                    alert(err.message);
+                // Redirect Now
+                start_redirect();
+            }
+            // Custom Redirect
+            else
+                callback(err, start_redirect, user);
+        };
+        // Firebase Auth
+        firebase.auth().onAuthStateChanged(function (user) {
+            if (user) {
+                user
+                    .getIdToken()
+                    .then(function (idToken) {
+                    // Fetch
+                    fetch(window.location.pathname, {
+                        method: 'POST',
+                        headers: {
+                            Accept: 'application/json',
+                            'Content-Type': 'application/json',
+                        },
+                        body: JSON.stringify({ token: idToken, csrfToken: csrfToken }),
+                    })
+                        .then((response) => {
+                        response
+                            .json()
+                            .then((data) => {
+                            // Show Error Message
+                            if (!data.success)
+                                final_redirect(new Error(data.error));
+                            // Complete
+                            else
+                                final_redirect(null, user);
+                        })
+                            .catch(final_redirect);
+                    })
+                        .catch(final_redirect);
+                })
+                    .catch(final_redirect);
+            }
+        });
+        // Sign In
+        firebase
+            .auth()
+            .signInWithCustomToken(token)
+            // Fail
+            .catch(final_redirect);
+    },
+};
+export default login;

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

@@ -0,0 +1,100 @@
+'use strict';
+
+/**
+ * Handles the logout process by signing out from Firebase Auth,
+ * verifying CSRF token, and redirecting the user.
+ *
+ * The `run` function signs out the user, sends a logout request to the server
+ * along with CSRF protection, and then redirects the user to the specified URL
+ * or executes a custom callback.
+ *
+ * @namespace logout
+ */
+const logout = {
+  /**
+   * Executes the logout process, verifying CSRF token, signing out
+   * the user, and handling redirection.
+   *
+   * @param {string} token - The authentication token used to identify the user.
+   * @param {string} redirect_url - The relative URL to redirect the user after logout.
+   *                                If it starts with "/", it will be adjusted.
+   * @param {string} csrfToken - The CSRF token provided in the request.
+   * @param {string} original_csrfToken - The CSRF token that was initially generated.
+   * @param {function} [callback] - Optional callback to be called after logout.
+   *                                Signature: `(err, redirectFunction)`
+   *                                - If omitted, default redirection is used.
+   *
+   * @example
+   * logout.run(userToken, '/home', csrfToken, originalCsrfToken);
+   *
+   * @example
+   * logout.run(userToken, '/home', csrfToken, originalCsrfToken, (err, redirect) => {
+   *   if (err) {
+   *     console.error('Logout failed:', err);
+   *     return;
+   *   }
+   *   console.log('Logged out successfully');
+   *   redirect(); // manually trigger the redirect
+   * });
+   */
+  run: function (token, redirect_url, csrfToken, original_csrfToken, callback) {
+    // Compare CSRF Token
+    if (original_csrfToken.length < 1 || original_csrfToken === csrfToken) {
+      // Fix Redirect
+      if (typeof redirect_url === 'string') {
+        if (redirect_url.startsWith('/')) redirect_url = redirect_url.substring(1);
+      }
+
+      // Nope
+      else redirect_url = '';
+
+      // Prepare Redirect
+      const final_redirect = function (err) {
+        // The Redirect
+        const start_redirect = function () {
+          window.location.href = window.location.origin + '/' + redirect_url;
+        };
+
+        // Default Redirect
+        if (typeof callback !== 'function') {
+          // Show Error
+          if (err) alert(err.message);
+          // Redirect Now
+          start_redirect();
+        }
+
+        // Custom Redirect
+        else callback(err, start_redirect);
+      };
+
+      // Sign Out
+      firebase
+        .auth()
+        .signOut()
+        // Success
+        .then(() => {
+          fetch(window.location.pathname, {
+            method: 'POST',
+            headers: {
+              Accept: 'application/json',
+              'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ token: token, csrfToken: csrfToken }),
+          })
+            .then((response) => {
+              response
+                .json()
+                .then(() => final_redirect())
+                .catch(final_redirect);
+            })
+            .catch(final_redirect);
+        })
+        // Fail
+        .catch(final_redirect);
+    }
+    // Invalid
+    else final_redirect(new Error('Invalid csrfToken!'));
+  },
+};
+
+module.exports = logout;

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

@@ -0,0 +1,4 @@
+export default logout;
+declare namespace logout {
+    function run(token: string, redirect_url: string, csrfToken: string, original_csrfToken: string, callback?: Function): void;
+}