tiny-essentials 1.0.0

package/dist/legacy/http/csrfTokenAnalyze.cjs

@@ -0,0 +1,46 @@
+'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 {Object} req - The Express request object. Should contain:
+ *   - `req.csrfToken.now`: The expected CSRF token.
+ *   - `req.body.csrfToken`: The token provided by the client.
+ * @param {Object} 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`.
+ *
+ * @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 (
+    req.csrfToken &&
+    typeof req.csrfToken.now === 'string' &&
+    (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

@@ -0,0 +1,21 @@
+/**
+ * @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 {Object} req - The Express request object. Should contain:
+ *   - `req.csrfToken.now`: The expected CSRF token.
+ *   - `req.body.csrfToken`: The token provided by the client.
+ * @param {Object} 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`.
+ *
+ * @example
+ * app.post('/submit', (req, res) => {
+ *   if (csrfTokenAnalyze(req, res)) return;
+ *   // Continue with request logic if CSRF is valid
+ * });
+ */
+export default function csrfTokenAnalyze(req: Object, res: Object, callback?: Function): boolean;

package/dist/legacy/http/csrfTokenAnalyze.mjs

@@ -0,0 +1,40 @@
+/**
+ * @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 {Object} req - The Express request object. Should contain:
+ *   - `req.csrfToken.now`: The expected CSRF token.
+ *   - `req.body.csrfToken`: The token provided by the client.
+ * @param {Object} 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`.
+ *
+ * @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 (req.csrfToken &&
+        typeof req.csrfToken.now === 'string' &&
+        (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

@@ -0,0 +1,98 @@
+'use strict';
+
+var check_domain = require('./check_domain.cjs');
+var objType = require('../get/objType.cjs');
+var isEmulator = require('../firebase/isEmulator.cjs');
+
+/**
+ * @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 {Object} req - The Express request object.
+ *   - `req.url`: Full URL path.
+ *   - `req.headers`: Expected to contain 'host', 'x-forwarded-host', etc.
+ * @param {Object} 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 {Object} Returns an object with the following structure:
+ *   @property {boolean} verified - Whether the domain is verified.
+ *   @property {string|null} domain - The detected domain from the request.
+ *   @property {boolean} isStaticPath - Whether the request matches a static path.
+ *
+ * @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('/');
+  req.url_path = [];
+  for (const item in prepareUrlPath) {
+    if (Number(item) > 0) {
+      // Insert URL Path
+      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;
+}
+
+module.exports = domainValidator;

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

@@ -0,0 +1,30 @@
+/**
+ * @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 {Object} req - The Express request object.
+ *   - `req.url`: Full URL path.
+ *   - `req.headers`: Expected to contain 'host', 'x-forwarded-host', etc.
+ * @param {Object} 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 {Object} Returns an object with the following structure:
+ *   @property {boolean} verified - Whether the domain is verified.
+ *   @property {string|null} domain - The detected domain from the request.
+ *   @property {boolean} isStaticPath - Whether the request matches a static path.
+ *
+ * @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: Object, cfg: Object): Object;

package/dist/legacy/http/domainValidator.mjs

@@ -0,0 +1,82 @@
+import checkDomain from './check_domain.mjs';
+import objType from '../get/objType.mjs';
+import isEmulator from '../firebase/isEmulator.mjs';
+/**
+ * @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 {Object} req - The Express request object.
+ *   - `req.url`: Full URL path.
+ *   - `req.headers`: Expected to contain 'host', 'x-forwarded-host', etc.
+ * @param {Object} 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 {Object} Returns an object with the following structure:
+ *   @property {boolean} verified - Whether the domain is verified.
+ *   @property {string|null} domain - The detected domain from the request.
+ *   @property {boolean} isStaticPath - Whether the request matches a static path.
+ *
+ * @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('/');
+    req.url_path = [];
+    for (const item in prepareUrlPath) {
+        if (Number(item) > 0) {
+            // Insert URL Path
+            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

@@ -0,0 +1,55 @@
+'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} 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} Express middleware function: (err, req, res, next)
+ *
+ * @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
+    const errCode = Number(err.status);
+
+    // Error
+    if (
+      (typeof err.status !== 'number' && typeof err.status !== 'string') ||
+      isNaN(errCode) ||
+      !isFinite(errCode) ||
+      errCode < 400
+    )
+      next();
+    // Nope
+    else
+      callback(req, res, next, {
+        code: err.status,
+        path: req.url,
+        originalUrl: req.originalUrl,
+        err: err,
+      });
+  };
+}
+
+module.exports = errorsCallback;

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

@@ -0,0 +1,29 @@
+/**
+ * @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} 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} Express middleware function: (err, req, res, next)
+ *
+ * @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: Function): Function;

package/dist/legacy/http/errorsCallback.mjs

@@ -0,0 +1,48 @@
+/**
+ * @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} 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} Express middleware function: (err, req, res, next)
+ *
+ * @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
+        const errCode = Number(err.status);
+        // Error
+        if ((typeof err.status !== 'number' && typeof err.status !== 'string') ||
+            isNaN(errCode) ||
+            !isFinite(errCode) ||
+            errCode < 400)
+            next();
+        // Nope
+        else
+            callback(req, res, next, {
+                code: err.status,
+                path: req.url,
+                originalUrl: req.originalUrl,
+                err: err,
+            });
+    };
+}

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

@@ -0,0 +1,48 @@
+'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.
+ *
+ * @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
+      .apply(fetch, tinyArgs)
+      .then((response) => {
+        // Get Response
+        response
+          .json()
+          .then((data) => {
+            resolve(data);
+          })
+          .catch((err) => {
+            reject(err);
+          });
+      })
+      .catch((err) => {
+        reject(err);
+      }),
+  );
+}
+
+module.exports = getJsonFetch;

package/dist/legacy/http/fetch/json.d.mts

@@ -0,0 +1,22 @@
+/**
+ * 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.
+ *
+ * @example
+ * getJsonFetch('https://api.example.com/data')
+ *   .then(data => console.log(data))
+ *   .catch(err => console.error('Fetch error:', err));
+ */
+export default function getJsonFetch(...args: any[]): Promise<any>;

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

@@ -0,0 +1,41 @@
+import fetch from '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.
+ *
+ * @example
+ * getJsonFetch('https://api.example.com/data')
+ *   .then(data => console.log(data))
+ *   .catch(err => console.error('Fetch error:', err));
+ */
+export default function getJsonFetch() {
+    const tinyArgs = arguments;
+    return new Promise((resolve, reject) => fetch
+        .apply(fetch, tinyArgs)
+        .then((response) => {
+        // Get Response
+        response
+            .json()
+            .then((data) => {
+            resolve(data);
+        })
+            .catch((err) => {
+            reject(err);
+        });
+    })
+        .catch((err) => {
+        reject(err);
+    }));
+}

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

@@ -0,0 +1,47 @@
+'use strict';
+
+var fetch = require('node-fetch');
+
+/**
+ * Performs a `fetch` request using any provided arguments and returns a Promise
+ * that resolves with the raw text response.
+ *
+ * This function is a wrapper around `fetch`, automatically extracting the response body
+ * as plain text. It handles both network errors and issues during text parsing.
+ *
+ * @function getTextFetch
+ * @param {...any} arguments - All arguments are forwarded directly to the `fetch` function.
+ *                             Typically used as `getTextFetch(url, options)`.
+ *
+ * @returns {Promise<string>} A Promise that resolves with the response text
+ *                            if the request is successful and parsing succeeds,
+ *                            or rejects with an error if the request or text conversion fails.
+ *
+ * @example
+ * getTextFetch('https://example.com/page')
+ *   .then(text => console.log(text))
+ *   .catch(err => console.error('Fetch error:', err));
+ */
+function getTextFetch() {
+  const tinyArgs = arguments;
+  return new Promise((resolve, reject) =>
+    fetch
+      .apply(fetch, tinyArgs)
+      .then((response) => {
+        // Get Response
+        response
+          .text()
+          .then((data) => {
+            resolve(data);
+          })
+          .catch((err) => {
+            reject(err);
+          });
+      })
+      .catch((err) => {
+        reject(err);
+      }),
+  );
+}
+
+module.exports = getTextFetch;

package/dist/legacy/http/fetch/text.d.mts

@@ -0,0 +1,21 @@
+/**
+ * Performs a `fetch` request using any provided arguments and returns a Promise
+ * that resolves with the raw text response.
+ *
+ * This function is a wrapper around `fetch`, automatically extracting the response body
+ * as plain text. It handles both network errors and issues during text parsing.
+ *
+ * @function getTextFetch
+ * @param {...any} arguments - All arguments are forwarded directly to the `fetch` function.
+ *                             Typically used as `getTextFetch(url, options)`.
+ *
+ * @returns {Promise<string>} A Promise that resolves with the response text
+ *                            if the request is successful and parsing succeeds,
+ *                            or rejects with an error if the request or text conversion fails.
+ *
+ * @example
+ * getTextFetch('https://example.com/page')
+ *   .then(text => console.log(text))
+ *   .catch(err => console.error('Fetch error:', err));
+ */
+export default function getTextFetch(...args: any[]): Promise<string>;

package/dist/legacy/http/fetch/text.mjs

@@ -0,0 +1,40 @@
+import fetch from 'node-fetch';
+/**
+ * Performs a `fetch` request using any provided arguments and returns a Promise
+ * that resolves with the raw text response.
+ *
+ * This function is a wrapper around `fetch`, automatically extracting the response body
+ * as plain text. It handles both network errors and issues during text parsing.
+ *
+ * @function getTextFetch
+ * @param {...any} arguments - All arguments are forwarded directly to the `fetch` function.
+ *                             Typically used as `getTextFetch(url, options)`.
+ *
+ * @returns {Promise<string>} A Promise that resolves with the response text
+ *                            if the request is successful and parsing succeeds,
+ *                            or rejects with an error if the request or text conversion fails.
+ *
+ * @example
+ * getTextFetch('https://example.com/page')
+ *   .then(text => console.log(text))
+ *   .catch(err => console.error('Fetch error:', err));
+ */
+export default function getTextFetch() {
+    const tinyArgs = arguments;
+    return new Promise((resolve, reject) => fetch
+        .apply(fetch, tinyArgs)
+        .then((response) => {
+        // Get Response
+        response
+            .text()
+            .then((data) => {
+            resolve(data);
+        })
+            .catch((err) => {
+            reject(err);
+        });
+    })
+        .catch((err) => {
+        reject(err);
+    }));
+}