tiny-essentials 1.23.2 → 1.24.1

package/dist/legacy/http/check_domain.mjs

@@ -1,98 +0,0 @@
-/**
- * @module check_domain
- *
- * Utility module to validate or retrieve the domain from a request object.
- * It supports multiple methods to check the domain, including:
- * - `x-forwarded-host`
- * - `req.hostname`
- * - `req.headers.host`
- *
- * Can be used to check if the incoming request matches a specific domain or to
- * simply retrieve the current domain of the request.
- */
-const check_domain = {
-    /**
-     * A list of domain validators using different request properties.
-     *
-     * Each validator includes a `type` and a `callback` function that checks or returns the domain.
-     * If a domain (`the_domain`) is passed, the function returns a boolean.
-     * If not, it returns the found domain string or `null`.
-     *
-     */
-    validators: [
-        {
-            type: 'x-forwarded-host',
-            /**
-             * @deprecated
-             */
-            callback: function (
-            /** @type {import('express').Request} */ req, 
-            /** @type {string} */ the_domain) {
-                const isString = typeof req.headers['x-forwarded-host'] === 'string';
-                if (the_domain)
-                    return isString && req.headers['x-forwarded-host'] === the_domain;
-                return isString ? req.headers['x-forwarded-host'] : null;
-            },
-        },
-        {
-            type: 'hostname',
-            /**
-             * @deprecated
-             */
-            callback: function (
-            /** @type {import('express').Request} */ req, 
-            /** @type {string} */ the_domain) {
-                const isString = typeof req.hostname === 'string';
-                if (the_domain)
-                    return isString && req.hostname === the_domain;
-                return isString ? req.hostname : null;
-            },
-        },
-        {
-            type: 'hostname',
-            /**
-             * @deprecated
-             */
-            callback: function (
-            /** @type {import('express').Request} */ req, 
-            /** @type {string} */ the_domain) {
-                const isString = typeof req.headers.host === 'string';
-                if (the_domain)
-                    return isString && req.headers.host === the_domain;
-                return isString ? req.headers.host : null;
-            },
-        },
-    ],
-    /**
-     * Validates the request against a given domain using all available validators.
-     *
-     * @function
-     * @param {import('express').Request} req - The request object from Express.
-     * @param {string} the_domain - The domain to validate against.
-     * @returns {boolean} True if any validator matches the domain.
-     * @deprecated
-     */
-    validator: function (req, the_domain) {
-        for (const item in check_domain.validators)
-            if (check_domain.validators[item].callback(req, the_domain))
-                return true;
-        return false;
-    },
-    /**
-     * Returns the domain found from the first valid source in the request object.
-     *
-     * @function
-     * @param {import('express').Request} req - The request object from Express.
-     * @returns {string|true|string[]|null} The found domain string or `null` if none matched.
-     * @deprecated
-     */
-    get: function (req) {
-        for (const item in check_domain.validators) {
-            const result = check_domain.validators[item].callback(req);
-            if (result)
-                return result;
-        }
-        return null;
-    },
-};
-export default check_domain;

package/dist/legacy/http/csrfTokenAnalyze.cjs

@@ -1,50 +0,0 @@
-'use strict';
-
-/**
- * @function csrfTokenAnalyze
- *
- * Checks if the CSRF token in the request body matches the expected token from the session.
- * If invalid, returns a 401 response and optionally executes a custom callback.
- *
- * @param {import('express').Request} req - The Express request object. Should contain:
- *   - `req.csrfToken.now`: The expected CSRF token.
- *   - `req.body.csrfToken`: The token provided by the client.
- * @param {import('express').Response} res - The Express response object.
- * @param {Function} [callback] - Optional custom callback to execute when CSRF validation fails.
- *
- * @returns {boolean} Returns `true` if the token is invalid and a response was sent, otherwise `false`.
- * @deprecated
- *
- * @example
- * app.post('/submit', (req, res) => {
- *   if (csrfTokenAnalyze(req, res)) return;
- *   // Continue with request logic if CSRF is valid
- * });
- */
-function csrfTokenAnalyze(req, res, callback) {
-  // Check Values
-  if (
-    // @ts-ignore
-    req.csrfToken &&
-    // @ts-ignore
-    typeof req.csrfToken.now === 'string' &&
-    // @ts-ignore
-    (typeof req.body.csrfToken !== 'string' || req.body.csrfToken !== req.csrfToken.now)
-  ) {
-    // Result
-    res.status(401);
-
-    // Normal Callback
-    if (typeof callback !== 'function') res.json({ code: 401, text: 'CSRFToken!' });
-    // Custom
-    else callback();
-
-    // Complete
-    return true;
-  }
-
-  // Nope
-  else return false;
-}
-
-module.exports = csrfTokenAnalyze;

package/dist/legacy/http/csrfTokenAnalyze.d.mts

@@ -1,23 +0,0 @@
-/**
- * @function csrfTokenAnalyze
- *
- * Checks if the CSRF token in the request body matches the expected token from the session.
- * If invalid, returns a 401 response and optionally executes a custom callback.
- *
- * @param {import('express').Request} req - The Express request object. Should contain:
- *   - `req.csrfToken.now`: The expected CSRF token.
- *   - `req.body.csrfToken`: The token provided by the client.
- * @param {import('express').Response} res - The Express response object.
- * @param {Function} [callback] - Optional custom callback to execute when CSRF validation fails.
- *
- * @returns {boolean} Returns `true` if the token is invalid and a response was sent, otherwise `false`.
- * @deprecated
- *
- * @example
- * app.post('/submit', (req, res) => {
- *   if (csrfTokenAnalyze(req, res)) return;
- *   // Continue with request logic if CSRF is valid
- * });
- */
-export default function csrfTokenAnalyze(req: import("express").Request, res: import("express").Response, callback?: Function): boolean;
-//# sourceMappingURL=csrfTokenAnalyze.d.mts.map

package/dist/legacy/http/csrfTokenAnalyze.mjs

@@ -1,45 +0,0 @@
-/**
- * @function csrfTokenAnalyze
- *
- * Checks if the CSRF token in the request body matches the expected token from the session.
- * If invalid, returns a 401 response and optionally executes a custom callback.
- *
- * @param {import('express').Request} req - The Express request object. Should contain:
- *   - `req.csrfToken.now`: The expected CSRF token.
- *   - `req.body.csrfToken`: The token provided by the client.
- * @param {import('express').Response} res - The Express response object.
- * @param {Function} [callback] - Optional custom callback to execute when CSRF validation fails.
- *
- * @returns {boolean} Returns `true` if the token is invalid and a response was sent, otherwise `false`.
- * @deprecated
- *
- * @example
- * app.post('/submit', (req, res) => {
- *   if (csrfTokenAnalyze(req, res)) return;
- *   // Continue with request logic if CSRF is valid
- * });
- */
-export default function csrfTokenAnalyze(req, res, callback) {
-    // Check Values
-    if (
-    // @ts-ignore
-    req.csrfToken &&
-        // @ts-ignore
-        typeof req.csrfToken.now === 'string' &&
-        // @ts-ignore
-        (typeof req.body.csrfToken !== 'string' || req.body.csrfToken !== req.csrfToken.now)) {
-        // Result
-        res.status(401);
-        // Normal Callback
-        if (typeof callback !== 'function')
-            res.json({ code: 401, text: 'CSRFToken!' });
-        // Custom
-        else
-            callback();
-        // Complete
-        return true;
-    }
-    // Nope
-    else
-        return false;
-}

package/dist/legacy/http/domainValidator.cjs

@@ -1,106 +0,0 @@
-'use strict';
-
-var check_domain = require('./check_domain.cjs');
-var objFilter = require('../../v1/basics/objFilter.cjs');
-var isEmulator = require('../firebase/isEmulator.cjs');
-
-/**
- * @typedef {{
- *  verified: boolean; // Whether the domain is verified.
- *  domain: string|null|true|string[]; // The detected domain from the request.
- *  isStaticPath: boolean // Whether the request matches a static path.
- * }} DomainResult
- */
-
-/**
- * @function domainValidator
- *
- * Validates the request's domain and optionally checks if the request is for a static path.
- * This is useful for filtering requests by origin or allowing access from specific domains only.
- * Also detects if Firebase is running in emulator mode, which bypasses domain validation.
- *
- * @param {import('express').Request} req - The Express request object.
- *   - `req.url`: Full URL path.
- *   - `req.headers`: Expected to contain 'host', 'x-forwarded-host', etc.
- * @param {Record<string, any>} cfg - Configuration object.
- *   @property {string|string[]} cfg.domain - The allowed domain(s) to validate against.
- *   @property {string[]} [cfg.staticPath] - Optional list of static paths to validate.
- *
- * @returns {DomainResult}
- * @deprecated
- *
- * @example
- * const result = domainValidator(req, {
- *   domain: ['example.com', 'sub.example.com'],
- *   staticPath: ['/assets/', '/static/']
- * });
- *
- * if (result.verified) {
- *   console.log('Domain OK:', result.domain);
- * }
- */
-
-function domainValidator(req, cfg) {
-  // Start Domain Verification
-  let domainStatus = { verified: false, domain: check_domain.get(req), isStaticPath: false };
-
-  // Path
-  var prepareUrlPath = req.url.split('/');
-  // @ts-ignore
-  req.url_path = [];
-  for (const item in prepareUrlPath) {
-    if (Number(item) > 0) {
-      // Insert URL Path
-      // @ts-ignore
-      req.url_path.push(prepareUrlPath[item].split(/[?#]/)[0]);
-    }
-  }
-
-  // Is Obj
-  if (objFilter.objType(cfg, 'object')) {
-    // Firebase Is Emulator
-    let firebaseIsEmulator = false;
-    if (isEmulator) {
-      firebaseIsEmulator = isEmulator();
-    }
-
-    // Verify String
-    if (
-      (typeof cfg.domain === 'string' && cfg.domain === domainStatus.domain) ||
-      firebaseIsEmulator
-    ) {
-      domainStatus.verified = true;
-    }
-
-    // Array Domains
-    else if (Array.isArray(cfg.domain)) {
-      for (const item in cfg.domain) {
-        if (typeof cfg.domain[item] === 'string' && cfg.domain[item] === domainStatus.domain) {
-          domainStatus.verified = true;
-          break;
-        }
-      }
-    }
-
-    // is Valid
-    if (domainStatus.verified) {
-      // Validate Static Path
-      if (Array.isArray(cfg.staticPath)) {
-        for (const item in cfg.staticPath) {
-          if (
-            typeof cfg.staticPath[item] === 'string' &&
-            req.url.startsWith(cfg.staticPath[item])
-          ) {
-            domainStatus.isStaticPath = true;
-            break;
-          }
-        }
-      }
-    }
-  }
-
-  // Result
-  return domainStatus;
-}
-
-module.exports = domainValidator;

package/dist/legacy/http/domainValidator.d.mts

@@ -1,41 +0,0 @@
-/**
- * @typedef {{
- *  verified: boolean; // Whether the domain is verified.
- *  domain: string|null|true|string[]; // The detected domain from the request.
- *  isStaticPath: boolean // Whether the request matches a static path.
- * }} DomainResult
- */
-/**
- * @function domainValidator
- *
- * Validates the request's domain and optionally checks if the request is for a static path.
- * This is useful for filtering requests by origin or allowing access from specific domains only.
- * Also detects if Firebase is running in emulator mode, which bypasses domain validation.
- *
- * @param {import('express').Request} req - The Express request object.
- *   - `req.url`: Full URL path.
- *   - `req.headers`: Expected to contain 'host', 'x-forwarded-host', etc.
- * @param {Record<string, any>} cfg - Configuration object.
- *   @property {string|string[]} cfg.domain - The allowed domain(s) to validate against.
- *   @property {string[]} [cfg.staticPath] - Optional list of static paths to validate.
- *
- * @returns {DomainResult}
- * @deprecated
- *
- * @example
- * const result = domainValidator(req, {
- *   domain: ['example.com', 'sub.example.com'],
- *   staticPath: ['/assets/', '/static/']
- * });
- *
- * if (result.verified) {
- *   console.log('Domain OK:', result.domain);
- * }
- */
-export default function domainValidator(req: import("express").Request, cfg: Record<string, any>): DomainResult;
-export type DomainResult = {
-    verified: boolean;
-    domain: string | null | true | string[];
-    isStaticPath: boolean;
-};
-//# sourceMappingURL=domainValidator.d.mts.map

package/dist/legacy/http/domainValidator.mjs

@@ -1,89 +0,0 @@
-import checkDomain from './check_domain.mjs';
-import objType from '../get/objType.mjs';
-import isEmulator from '../firebase/isEmulator.mjs';
-/**
- * @typedef {{
- *  verified: boolean; // Whether the domain is verified.
- *  domain: string|null|true|string[]; // The detected domain from the request.
- *  isStaticPath: boolean // Whether the request matches a static path.
- * }} DomainResult
- */
-/**
- * @function domainValidator
- *
- * Validates the request's domain and optionally checks if the request is for a static path.
- * This is useful for filtering requests by origin or allowing access from specific domains only.
- * Also detects if Firebase is running in emulator mode, which bypasses domain validation.
- *
- * @param {import('express').Request} req - The Express request object.
- *   - `req.url`: Full URL path.
- *   - `req.headers`: Expected to contain 'host', 'x-forwarded-host', etc.
- * @param {Record<string, any>} cfg - Configuration object.
- *   @property {string|string[]} cfg.domain - The allowed domain(s) to validate against.
- *   @property {string[]} [cfg.staticPath] - Optional list of static paths to validate.
- *
- * @returns {DomainResult}
- * @deprecated
- *
- * @example
- * const result = domainValidator(req, {
- *   domain: ['example.com', 'sub.example.com'],
- *   staticPath: ['/assets/', '/static/']
- * });
- *
- * if (result.verified) {
- *   console.log('Domain OK:', result.domain);
- * }
- */
-export default function domainValidator(req, cfg) {
-    // Start Domain Verification
-    let domainStatus = { verified: false, domain: checkDomain.get(req), isStaticPath: false };
-    // Path
-    var prepareUrlPath = req.url.split('/');
-    // @ts-ignore
-    req.url_path = [];
-    for (const item in prepareUrlPath) {
-        if (Number(item) > 0) {
-            // Insert URL Path
-            // @ts-ignore
-            req.url_path.push(prepareUrlPath[item].split(/[?#]/)[0]);
-        }
-    }
-    // Is Obj
-    if (objType(cfg, 'object')) {
-        // Firebase Is Emulator
-        let firebaseIsEmulator = false;
-        if (isEmulator) {
-            firebaseIsEmulator = isEmulator();
-        }
-        // Verify String
-        if ((typeof cfg.domain === 'string' && cfg.domain === domainStatus.domain) ||
-            firebaseIsEmulator) {
-            domainStatus.verified = true;
-        }
-        // Array Domains
-        else if (Array.isArray(cfg.domain)) {
-            for (const item in cfg.domain) {
-                if (typeof cfg.domain[item] === 'string' && cfg.domain[item] === domainStatus.domain) {
-                    domainStatus.verified = true;
-                    break;
-                }
-            }
-        }
-        // is Valid
-        if (domainStatus.verified) {
-            // Validate Static Path
-            if (Array.isArray(cfg.staticPath)) {
-                for (const item in cfg.staticPath) {
-                    if (typeof cfg.staticPath[item] === 'string' &&
-                        req.url.startsWith(cfg.staticPath[item])) {
-                        domainStatus.isStaticPath = true;
-                        break;
-                    }
-                }
-            }
-        }
-    }
-    // Result
-    return domainStatus;
-}

package/dist/legacy/http/errorsCallback.cjs

@@ -1,64 +0,0 @@
-'use strict';
-
-/**
- * @function errorsCallback
- *
- * Creates an Express error-handling middleware that filters and handles HTTP errors
- * with a status code >= 400 using a custom callback function.
- *
- * If the error does not meet the criteria (e.g., status not defined or < 400), it delegates to the next middleware.
- *
- * @param {function(import('express').Request, import('express').Response, import('express').NextFunction, {
- *  code: number,
- *  path: string,
- *  originalUrl: string,
- *  err: Error
- * }): void} callback - A function called when an error with valid status is detected.
- *   Receives parameters: (req, res, next, info)
- *   - `info.code`: HTTP status code.
- *   - `info.path`: `req.url` value.
- *   - `info.originalUrl`: `req.originalUrl` value.
- *   - `info.err`: The original error object.
- *
- * @returns {function(Error, import('express').Request, import('express').Response, import('express').NextFunction): void} Express middleware function: (err, req, res, next)
- * @deprecated
- *
- * @example
- * import errorsCallback from './errorsCallback.mjs';
- *
- * app.use(errorsCallback((req, res, next, info) => {
- *   res.status(info.code).json({
- *     error: true,
- *     message: info.err.message || 'Unknown error',
- *     path: info.path
- *   });
- * }));
- */
-function errorsCallback(callback) {
-  return function (err, req, res, next) {
-    // Err Code
-    // @ts-ignore
-    const errCode = Number(err.status);
-
-    // Error
-    if (
-      // @ts-ignore
-      (typeof err.status !== 'number' && typeof err.status !== 'string') ||
-      isNaN(errCode) ||
-      !isFinite(errCode) ||
-      errCode < 400
-    )
-      next();
-    // Nope
-    else
-      callback(req, res, next, {
-        // @ts-ignore
-        code: err.status,
-        path: req.url,
-        originalUrl: req.originalUrl,
-        err: err,
-      });
-  };
-}
-
-module.exports = errorsCallback;

package/dist/legacy/http/errorsCallback.d.mts

@@ -1,41 +0,0 @@
-/**
- * @function errorsCallback
- *
- * Creates an Express error-handling middleware that filters and handles HTTP errors
- * with a status code >= 400 using a custom callback function.
- *
- * If the error does not meet the criteria (e.g., status not defined or < 400), it delegates to the next middleware.
- *
- * @param {function(import('express').Request, import('express').Response, import('express').NextFunction, {
- *  code: number,
- *  path: string,
- *  originalUrl: string,
- *  err: Error
- * }): void} callback - A function called when an error with valid status is detected.
- *   Receives parameters: (req, res, next, info)
- *   - `info.code`: HTTP status code.
- *   - `info.path`: `req.url` value.
- *   - `info.originalUrl`: `req.originalUrl` value.
- *   - `info.err`: The original error object.
- *
- * @returns {function(Error, import('express').Request, import('express').Response, import('express').NextFunction): void} Express middleware function: (err, req, res, next)
- * @deprecated
- *
- * @example
- * import errorsCallback from './errorsCallback.mjs';
- *
- * app.use(errorsCallback((req, res, next, info) => {
- *   res.status(info.code).json({
- *     error: true,
- *     message: info.err.message || 'Unknown error',
- *     path: info.path
- *   });
- * }));
- */
-export default function errorsCallback(callback: (arg0: import("express").Request, arg1: import("express").Response, arg2: import("express").NextFunction, arg3: {
-    code: number;
-    path: string;
-    originalUrl: string;
-    err: Error;
-}) => void): (arg0: Error, arg1: import("express").Request, arg2: import("express").Response, arg3: import("express").NextFunction) => void;
-//# sourceMappingURL=errorsCallback.d.mts.map

package/dist/legacy/http/errorsCallback.mjs

@@ -1,58 +0,0 @@
-/**
- * @function errorsCallback
- *
- * Creates an Express error-handling middleware that filters and handles HTTP errors
- * with a status code >= 400 using a custom callback function.
- *
- * If the error does not meet the criteria (e.g., status not defined or < 400), it delegates to the next middleware.
- *
- * @param {function(import('express').Request, import('express').Response, import('express').NextFunction, {
- *  code: number,
- *  path: string,
- *  originalUrl: string,
- *  err: Error
- * }): void} callback - A function called when an error with valid status is detected.
- *   Receives parameters: (req, res, next, info)
- *   - `info.code`: HTTP status code.
- *   - `info.path`: `req.url` value.
- *   - `info.originalUrl`: `req.originalUrl` value.
- *   - `info.err`: The original error object.
- *
- * @returns {function(Error, import('express').Request, import('express').Response, import('express').NextFunction): void} Express middleware function: (err, req, res, next)
- * @deprecated
- *
- * @example
- * import errorsCallback from './errorsCallback.mjs';
- *
- * app.use(errorsCallback((req, res, next, info) => {
- *   res.status(info.code).json({
- *     error: true,
- *     message: info.err.message || 'Unknown error',
- *     path: info.path
- *   });
- * }));
- */
-export default function errorsCallback(callback) {
-    return function (err, req, res, next) {
-        // Err Code
-        // @ts-ignore
-        const errCode = Number(err.status);
-        // Error
-        if (
-        // @ts-ignore
-        (typeof err.status !== 'number' && typeof err.status !== 'string') ||
-            isNaN(errCode) ||
-            !isFinite(errCode) ||
-            errCode < 400)
-            next();
-        // Nope
-        else
-            callback(req, res, next, {
-                // @ts-ignore
-                code: err.status,
-                path: req.url,
-                originalUrl: req.originalUrl,
-                err: err,
-            });
-    };
-}

package/dist/legacy/http/fetch/json.cjs

@@ -1,50 +0,0 @@
-'use strict';
-
-var fetch = require('node-fetch');
-
-/**
- * Performs a `fetch` request using any provided arguments and returns a Promise
- * that resolves with the parsed JSON response.
- *
- * This function acts as a wrapper around `fetch`, automatically parsing the
- * response body as JSON and handling errors both at the network level and
- * during JSON parsing.
- *
- * @function getJsonFetch
- * @param {...any} arguments - All arguments are forwarded directly to the `fetch` function.
- *                            Common usage is `getJsonFetch(url, options)`.
- *
- * @returns {Promise<any>} A Promise that resolves with the parsed JSON data
- *                         if the request succeeds and the response is valid JSON,
- *                         or rejects with an error if the request or parsing fails.
- * @deprecated
- *
- * @example
- * getJsonFetch('https://api.example.com/data')
- *   .then(data => console.log(data))
- *   .catch(err => console.error('Fetch error:', err));
- */
-function getJsonFetch() {
-  const tinyArgs = arguments;
-  return new Promise((resolve, reject) =>
-    fetch
-      // @ts-ignore
-      .apply(fetch, tinyArgs)
-      .then((response) => {
-        // Get Response
-        response
-          .json()
-          .then((data) => {
-            resolve(data);
-          })
-          .catch((err) => {
-            reject(err);
-          });
-      })
-      .catch((err) => {
-        reject(err);
-      }),
-  );
-}
-
-module.exports = getJsonFetch;