tiny-essentials 1.0.0

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

@@ -0,0 +1,51 @@
+export default firebaseObject;
+declare namespace firebaseObject {
+    /**
+     * Retrieves a Firebase app by its identifier.
+     *
+     * @param {string|number} value - The app identifier to retrieve.
+     * @returns {Object|null} The Firebase app or `null` if not found.
+     */
+    export function get(value: string | number): Object | null;
+    export { AuthSystem as cookieSession };
+    export { domainRedirect };
+    export { database };
+    export { dbEscape as escape };
+    export { mySQL as mysql };
+    export { getDBAsync };
+    export { getDBValue };
+    export { getDBData };
+    export { transactionDBAsync };
+    export { databaseEscape };
+    export let logger: Object;
+    export { isEmulator };
+    /**
+     * Starts Firebase modules based on the provided configuration.
+     * Initializes services such as Database, Auth, Firestore, etc.
+     *
+     * @param {string} value - The Firebase app ID.
+     * @param {Object} item - Configuration for the Firebase app and services to initialize.
+     * @returns {boolean} `true` if the modules were successfully started, `false` otherwise.
+     */
+    export function startModule(value: string, item: Object): boolean;
+    /**
+     * Starts the Firebase app and initializes required services.
+     *
+     * @param {Object} admin - The Firebase Admin SDK.
+     * @param {Object} item - Configuration containing app details and options.
+     * @param {Object} data - Additional data to initialize the app.
+     * @throws {Error} Throws an error if the Firebase file is not found or if the app ID is missing.
+     */
+    export function start(admin: Object, item: Object, data: Object): void;
+}
+import AuthSystem from './cookieSession.mjs';
+import domainRedirect from './domainRedirect.mjs';
+import database from './database/index.mjs';
+import * as dbEscape from './escape.mjs';
+import mySQL from './mySQL.mjs';
+import getDBAsync from './getDBAsync.mjs';
+import getDBValue from './getDBValue.mjs';
+import getDBData from './getDBData.mjs';
+import transactionDBAsync from './transactionDBAsync.mjs';
+import databaseEscape from './databaseEscape.mjs';
+import isEmulator from './isEmulator.mjs';

package/dist/legacy/firebase/index.mjs

@@ -0,0 +1,234 @@
+import path from 'path';
+import fs from 'fs';
+import AuthSystem from './cookieSession.mjs';
+import domainRedirect from './domainRedirect.mjs';
+import database from './database/index.mjs';
+import * as dbEscape from './escape.mjs';
+import mySQL from './mySQL.mjs';
+import getDBAsync from './getDBAsync.mjs';
+import getDBValue from './getDBValue.mjs';
+import getDBData from './getDBData.mjs';
+import transactionDBAsync from './transactionDBAsync.mjs';
+import databaseEscape from './databaseEscape.mjs';
+import isEmulator from './isEmulator.mjs';
+/**
+ * Firebase Object to handle various Firebase services and utilities.
+ * Includes database, authentication, Firestore, storage, and more.
+ *
+ * @namespace firebaseObject
+ */
+const firebaseObject = { apps: {} };
+/**
+ * Retrieves a Firebase app by its identifier.
+ *
+ * @param {string|number} value - The app identifier to retrieve.
+ * @returns {Object|null} The Firebase app or `null` if not found.
+ */
+firebaseObject.get = function (value) {
+    // Check
+    if ((typeof value === 'string' || typeof value === 'number') && firebaseObject.apps[value]) {
+        // Send Item
+        return firebaseObject.apps[value];
+    }
+    // Nope
+    else
+        return null;
+};
+/**
+ * Manages cookie session for authentication.
+ *
+ * @type {AuthSystem}
+ */
+firebaseObject.cookieSession = AuthSystem;
+/**
+ * Manages domain redirection.
+ *
+ * @type {domainRedirect}
+ */
+firebaseObject.domainRedirect = domainRedirect;
+/**
+ * Handles Firebase Database interactions.
+ *
+ * @type {database}
+ */
+firebaseObject.database = database;
+/**
+ * Handles database escaping for safe queries.
+ *
+ * @type {Object}
+ */
+firebaseObject.escape = dbEscape;
+/**
+ * Manages MySQL database interactions.
+ *
+ * @type {mySQL}
+ */
+firebaseObject.mysql = mySQL;
+/**
+ * Retrieves the database asynchronously.
+ *
+ * @type {getDBAsync}
+ */
+firebaseObject.getDBAsync = getDBAsync;
+/**
+ * Retrieves a specific database value.
+ *
+ * @type {getDBValue}
+ */
+firebaseObject.getDBValue = getDBValue;
+/**
+ * Retrieves database data asynchronously.
+ *
+ * @type {getDBData}
+ */
+firebaseObject.getDBData = getDBData;
+/**
+ * Handles asynchronous database transactions.
+ *
+ * @type {transactionDBAsync}
+ */
+firebaseObject.transactionDBAsync = transactionDBAsync;
+/**
+ * Provides database escape functionality for safe querying.
+ *
+ * @type {databaseEscape}
+ */
+firebaseObject.databaseEscape = databaseEscape;
+/**
+ * Logger to log information using Firebase or console.
+ *
+ * @type {Object}
+ */
+firebaseObject.logger = logger;
+/**
+ * Checks if the Firebase environment is running in emulator mode.
+ *
+ * @type {isEmulator}
+ */
+firebaseObject.isEmulator = isEmulator;
+/**
+ * Starts Firebase modules based on the provided configuration.
+ * Initializes services such as Database, Auth, Firestore, etc.
+ *
+ * @param {string} value - The Firebase app ID.
+ * @param {Object} item - Configuration for the Firebase app and services to initialize.
+ * @returns {boolean} `true` if the modules were successfully started, `false` otherwise.
+ */
+firebaseObject.startModule = function (value, item) {
+    // Check
+    if ((typeof value === 'string' || typeof value === 'number') && firebaseObject.apps[value]) {
+        // Confirm Action
+        let action_confirmed = false;
+        // Database
+        if (item.database) {
+            firebaseObject.apps[value].db = firebaseObject.apps[value].root.database();
+            action_confirmed = true;
+        }
+        // Auth
+        if (item.auth) {
+            firebaseObject.apps[value].auth = firebaseObject.apps[value].root.auth();
+            action_confirmed = true;
+        }
+        // Firestore
+        if (item.firestore) {
+            firebaseObject.apps[value].store = firebaseObject.apps[value].root.firestore();
+            action_confirmed = true;
+        }
+        // Storage
+        if (item.storage) {
+            firebaseObject.apps[value].storage = firebaseObject.apps[value].root.storage();
+            action_confirmed = true;
+        }
+        // Cloud Messaging
+        if (item.messaging) {
+            firebaseObject.apps[value].messaging = firebaseObject.apps[value].root.messaging();
+            action_confirmed = true;
+        }
+        // Send positive result
+        return action_confirmed;
+    }
+    // Nope
+    else
+        return false;
+};
+/**
+ * Starts the Firebase app and initializes required services.
+ *
+ * @param {Object} admin - The Firebase Admin SDK.
+ * @param {Object} item - Configuration containing app details and options.
+ * @param {Object} data - Additional data to initialize the app.
+ * @throws {Error} Throws an error if the Firebase file is not found or if the app ID is missing.
+ */
+firebaseObject.start = function (admin, item, data) {
+    // Try
+    try {
+        // Start Firebase
+        const start_firebase = function (json_file = null) {
+            // Check Exist
+            if (!firebaseObject.apps[item.id]) {
+                // Firebase Settings
+                const firebase_settings = {};
+                // Exist File
+                if (json_file)
+                    firebase_settings.credential = admin.credential.cert(json_file);
+                // Read Data
+                if (data) {
+                    for (const data_item in data)
+                        firebase_settings[data_item] = data[data_item];
+                }
+                // Fix Database URL
+                if (typeof firebase_settings.databaseURL === 'string') {
+                    if (!firebase_settings.databaseURL.startsWith('https://') &&
+                        !firebase_settings.databaseURL.endsWith('.firebaseio.com'))
+                        firebase_settings.databaseURL = `https://${firebase_settings.databaseURL}.firebaseio.com`;
+                }
+                // Fix Storage URL
+                if (typeof firebase_settings.storageBucket === 'string')
+                    if (!firebase_settings.storageBucket.endsWith('.appspot.com'))
+                        firebase_settings.storageBucket = `${firebase_settings.storageBucket}.appspot.com`;
+                // Prepare Base
+                firebaseObject.apps[item.id] = {};
+                // Initialize App
+                firebaseObject.apps[item.id].root = admin.initializeApp(firebase_settings, item.id);
+                // Auto Start
+                if (item.autoStart)
+                    firebaseObject.startModule(item.id, item.autoStart);
+            }
+        };
+        // Exist ID
+        if (item && typeof item.id === 'string' && item.id !== 'start') {
+            // Check Variables
+            if (typeof item.appID === 'string') {
+                // Key File
+                let keyFile = null;
+                if (item.keysFolder)
+                    keyFile = path.join(item.keysFolder, item.appID + '.json');
+                // Exist File
+                if (keyFile && fs.existsSync(keyFile) && fs.lstatSync(keyFile).isFile()) {
+                    try {
+                        const jsonData = fs.readFileSync(keyFile, 'utf8');
+                        const parsedKey = JSON.parse(jsonData);
+                        start_firebase(parsedKey);
+                    }
+                    catch (err) {
+                        console.error(new Error('Failed to parse Firebase JSON file: ' + err.message));
+                    }
+                }
+                else
+                    console.error(new Error('Firebase File Not Found.'));
+            }
+            // Nope
+            else
+                start_firebase();
+        }
+        // Nope
+        else
+            console.error(new Error('You need to insert a ID value!'));
+    }
+    catch (err) {
+        // Get Error
+        console.error(err);
+    }
+};
+// Send Module
+export default firebaseObject;

package/dist/legacy/firebase/isEmulator.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+/**
+ * Checks if the Firebase Functions are running in the emulator environment.
+ * This function relies on the environment variable `FUNCTIONS_EMULATOR` to determine
+ * whether the Firebase Functions are being executed locally in an emulator or in production.
+ *
+ * @returns {boolean} `true` if the Firebase Functions are running in the emulator, `false` otherwise.
+ */
+function isEmulator() {
+  return process.env.FUNCTIONS_EMULATOR;
+}
+
+module.exports = isEmulator;

package/dist/legacy/firebase/isEmulator.d.mts

@@ -0,0 +1,8 @@
+/**
+ * Checks if the Firebase Functions are running in the emulator environment.
+ * This function relies on the environment variable `FUNCTIONS_EMULATOR` to determine
+ * whether the Firebase Functions are being executed locally in an emulator or in production.
+ *
+ * @returns {boolean} `true` if the Firebase Functions are running in the emulator, `false` otherwise.
+ */
+export default function isEmulator(): boolean;

package/dist/legacy/firebase/isEmulator.mjs

@@ -0,0 +1,10 @@
+/**
+ * Checks if the Firebase Functions are running in the emulator environment.
+ * This function relies on the environment variable `FUNCTIONS_EMULATOR` to determine
+ * whether the Firebase Functions are being executed locally in an emulator or in production.
+ *
+ * @returns {boolean} `true` if the Firebase Functions are running in the emulator, `false` otherwise.
+ */
+export default function isEmulator() {
+    return process.env.FUNCTIONS_EMULATOR;
+}

package/dist/legacy/firebase/logger.cjs

@@ -0,0 +1,137 @@
+'use strict';
+
+var clone = require('clone');
+var index = require('../../_virtual/index.cjs');
+var objType = require('../get/objType.cjs');
+var isEmulator = require('./isEmulator.cjs');
+
+/**
+ * Recursively handles nested objects and arrays, converting any `BigInt` values
+ * into an object with the type `_type_object: 'BIGINT'` and the `value` as a string.
+ * This ensures that `BigInt` values are properly serialized and handled.
+ *
+ * @param {Object|Array} data - The data to process, which can be an object or an array.
+ * @returns {Object|Array} The processed data with `BigInt` values converted into objects.
+ */
+const loopInteraction = function (data) {
+  const checkData = function (item) {
+    // Checking
+    if (objType(data[item], 'object') || Array.isArray(data[item])) {
+      loopInteraction(data[item]);
+    }
+
+    // BigInt
+    else if (objType(data[item], 'bigint'))
+      data[item] = { _type_object: 'BIGINT', value: data[item].toString() };
+  };
+
+  // Data
+  if (objType(data, 'object') || Array.isArray(data)) for (const item in data) checkData(item);
+  else {
+    // Get BigInt
+    if (objType(data, 'bigint')) data = { _type_object: 'BIGINT', value: data.toString() };
+  }
+
+  // Complete
+  return data;
+};
+
+/**
+ * A utility function that handles logging messages based on the environment.
+ * If the environment is production and the `firebase-functions/logger` is available,
+ * it will use Firebase's logger. Otherwise, it falls back to using the native JavaScript console.
+ * The function also handles special cases like `BigInt` serialization and nested objects/arrays.
+ *
+ * @param {string} type - The type of log message (e.g., `log`, `info`, `warn`, `error`).
+ * @param {Arguments} args - The arguments to be logged.
+ * @returns {Promise<Object>} A promise resolving with the result of the logging operation,
+ * or the result of logging to the native console if Firebase logger is not available.
+ */
+const logBase = async function (type, args) {
+  // Production
+  if (!isEmulator()) {
+    // Exist Log
+    if (index) {
+      let consoleData;
+      if (objType(args, 'error'))
+        consoleData = JSON.parse(JSON.stringify(args, Object.getOwnPropertyNames(args)));
+      else consoleData = args;
+
+      for (const item in consoleData) {
+        let argData = clone(consoleData[item]);
+        loopInteraction(argData);
+
+        if (objType(argData, 'object') || Array.isArray(argData))
+          argData = JSON.stringify(argData, null, 2);
+
+        consoleData[item] = argData;
+      }
+
+      const result = await index[type].apply(index, consoleData);
+
+      return {
+        result: result,
+        type: 'firebase-functions/logger',
+      };
+    }
+
+    // Nope
+    else
+      return {
+        result: console[type].apply(console, args),
+        type: 'console/javascript-vanilla',
+      };
+  }
+
+  // Nope
+  else
+    return {
+      result: console[type].apply(console, args),
+      type: 'console/javascript-vanilla',
+    };
+};
+
+// Module
+const fbLogger = {
+  /**
+   * Logs a message with the `log` level. If not in emulator mode, it uses Firebase's logger.
+   *
+   * @param {...*} args - The arguments to log.
+   * @returns {Promise<Object>} A promise resolving with the logging result.
+   */
+  log: function () {
+    return logBase('log', arguments);
+  },
+
+  /**
+   * Logs a message with the `info` level. If not in emulator mode, it uses Firebase's logger.
+   *
+   * @param {...*} args - The arguments to log.
+   * @returns {Promise<Object>} A promise resolving with the logging result.
+   */
+  info: function () {
+    return logBase('info', arguments);
+  },
+
+  /**
+   * Logs a message with the `warn` level. If not in emulator mode, it uses Firebase's logger.
+   *
+   * @param {...*} args - The arguments to log.
+   * @returns {Promise<Object>} A promise resolving with the logging result.
+   */
+  warn: function () {
+    return logBase('warn', arguments);
+  },
+
+  /**
+   * Logs a message with the `error` level. If not in emulator mode, it uses Firebase's logger.
+   *
+   * @param {...*} args - The arguments to log.
+   * @returns {Promise<Object>} A promise resolving with the logging result.
+   */
+  error: function () {
+    return logBase('error', arguments);
+  },
+};
+
+module.exports = fbLogger;

package/dist/legacy/firebase/logger.d.mts

@@ -0,0 +1,7 @@
+export default fbLogger;
+declare namespace fbLogger {
+    function log(...args: any[]): Promise<Object>;
+    function info(...args: any[]): Promise<Object>;
+    function warn(...args: any[]): Promise<Object>;
+    function error(...args: any[]): Promise<Object>;
+}

package/dist/legacy/firebase/logger.mjs

@@ -0,0 +1,125 @@
+import clone from 'clone';
+import logger from 'firebase-functions/logger';
+import objType from '../get/objType.mjs';
+import isEmulator from './isEmulator.mjs';
+/**
+ * Recursively handles nested objects and arrays, converting any `BigInt` values
+ * into an object with the type `_type_object: 'BIGINT'` and the `value` as a string.
+ * This ensures that `BigInt` values are properly serialized and handled.
+ *
+ * @param {Object|Array} data - The data to process, which can be an object or an array.
+ * @returns {Object|Array} The processed data with `BigInt` values converted into objects.
+ */
+const loopInteraction = function (data) {
+    // Check Data
+    const interaction = {};
+    const checkData = function (item) {
+        // Checking
+        if (objType(data[item], 'object') || Array.isArray(data[item])) {
+            interaction[item] = {};
+            interaction[item] = loopInteraction(data[item]);
+        }
+        // BigInt
+        else if (objType(data[item], 'bigint'))
+            data[item] = { _type_object: 'BIGINT', value: data[item].toString() };
+    };
+    // Data
+    if (objType(data, 'object') || Array.isArray(data))
+        for (const item in data)
+            checkData(item);
+    else {
+        // Get BigInt
+        if (objType(data, 'bigint'))
+            data = { _type_object: 'BIGINT', value: data.toString() };
+    }
+    // Complete
+    return data;
+};
+/**
+ * A utility function that handles logging messages based on the environment.
+ * If the environment is production and the `firebase-functions/logger` is available,
+ * it will use Firebase's logger. Otherwise, it falls back to using the native JavaScript console.
+ * The function also handles special cases like `BigInt` serialization and nested objects/arrays.
+ *
+ * @param {string} type - The type of log message (e.g., `log`, `info`, `warn`, `error`).
+ * @param {Arguments} args - The arguments to be logged.
+ * @returns {Promise<Object>} A promise resolving with the result of the logging operation,
+ * or the result of logging to the native console if Firebase logger is not available.
+ */
+const logBase = async function (type, args) {
+    // Production
+    if (!isEmulator()) {
+        // Exist Log
+        if (logger) {
+            let consoleData;
+            if (objType(args, 'error'))
+                consoleData = JSON.parse(JSON.stringify(args, Object.getOwnPropertyNames(args)));
+            else
+                consoleData = args;
+            for (const item in consoleData) {
+                let argData = clone(consoleData[item]);
+                loopInteraction(argData);
+                if (objType(argData, 'object') || Array.isArray(argData))
+                    argData = JSON.stringify(argData, null, 2);
+                consoleData[item] = argData;
+            }
+            const result = await logger[type].apply(logger, consoleData);
+            return {
+                result: result,
+                type: 'firebase-functions/logger',
+            };
+        }
+        // Nope
+        else
+            return {
+                result: console[type].apply(console, args),
+                type: 'console/javascript-vanilla',
+            };
+    }
+    // Nope
+    else
+        return {
+            result: console[type].apply(console, args),
+            type: 'console/javascript-vanilla',
+        };
+};
+// Module
+const fbLogger = {
+    /**
+     * Logs a message with the `log` level. If not in emulator mode, it uses Firebase's logger.
+     *
+     * @param {...*} args - The arguments to log.
+     * @returns {Promise<Object>} A promise resolving with the logging result.
+     */
+    log: function () {
+        return logBase('log', arguments);
+    },
+    /**
+     * Logs a message with the `info` level. If not in emulator mode, it uses Firebase's logger.
+     *
+     * @param {...*} args - The arguments to log.
+     * @returns {Promise<Object>} A promise resolving with the logging result.
+     */
+    info: function () {
+        return logBase('info', arguments);
+    },
+    /**
+     * Logs a message with the `warn` level. If not in emulator mode, it uses Firebase's logger.
+     *
+     * @param {...*} args - The arguments to log.
+     * @returns {Promise<Object>} A promise resolving with the logging result.
+     */
+    warn: function () {
+        return logBase('warn', arguments);
+    },
+    /**
+     * Logs a message with the `error` level. If not in emulator mode, it uses Firebase's logger.
+     *
+     * @param {...*} args - The arguments to log.
+     * @returns {Promise<Object>} A promise resolving with the logging result.
+     */
+    error: function () {
+        return logBase('error', arguments);
+    },
+};
+export default fbLogger;

package/dist/legacy/firebase/mySQL.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+require('clone');
+
+/**
+ * Connects to a MySQL database using the provided configuration and credentials.
+ * The function utilizes `mySqlConnector.create` to establish the connection.
+ *
+ * @param {Object} mysql - The MySQL module instance.
+ * @param {Array|string} databases - The list of databases to connect to, or a single database name.
+ * @param {Object} cfg - The configuration object containing connection details (e.g., host, user, password).
+ * @returns {Promise} Resolves with the connection object or rejects with an error.
+ */
+function mySQL(mysql, databases, cfg) {
+  return new Promise(function (resolve, reject) {
+    // Get Module
+    try {
+      mySqlConnector.create(mysql, databases, cfg, 'firebase').then(resolve).catch(reject);
+    } catch (err) {
+      // Error
+      reject(err);
+    }
+  });
+}
+
+module.exports = mySQL;

package/dist/legacy/firebase/mySQL.d.mts

@@ -0,0 +1,10 @@
+/**
+ * Connects to a MySQL database using the provided configuration and credentials.
+ * The function utilizes `mySqlConnector.create` to establish the connection.
+ *
+ * @param {Object} mysql - The MySQL module instance.
+ * @param {Array|string} databases - The list of databases to connect to, or a single database name.
+ * @param {Object} cfg - The configuration object containing connection details (e.g., host, user, password).
+ * @returns {Promise} Resolves with the connection object or rejects with an error.
+ */
+export default function mySQL(mysql: Object, databases: any[] | string, cfg: Object): Promise<any>;

package/dist/legacy/firebase/mySQL.mjs

@@ -0,0 +1,22 @@
+import mysqlConnector from './mysqlConnector/index.mjs';
+/**
+ * Connects to a MySQL database using the provided configuration and credentials.
+ * The function utilizes `mySqlConnector.create` to establish the connection.
+ *
+ * @param {Object} mysql - The MySQL module instance.
+ * @param {Array|string} databases - The list of databases to connect to, or a single database name.
+ * @param {Object} cfg - The configuration object containing connection details (e.g., host, user, password).
+ * @returns {Promise} Resolves with the connection object or rejects with an error.
+ */
+export default function mySQL(mysql, databases, cfg) {
+    return new Promise(function (resolve, reject) {
+        // Get Module
+        try {
+            mySqlConnector.create(mysql, databases, cfg, 'firebase').then(resolve).catch(reject);
+        }
+        catch (err) {
+            // Error
+            reject(err);
+        }
+    });
+}