Updates

2025-01-28 19:43:16 +01:00
parent 81cf010cb5
commit 35fec57590
856 changed files with 5362 additions and 2266 deletions
@@ -1,16 +1,14 @@
-// @ts-check
-
 import sanitizeHtml from "sanitize-html";
 import sanitizeHtmlOptions from "../html/sanitizeHtmlOptions";
 import updateDbEntry from "./updateDbEntry";
 import _ from "lodash";
-import DB_HANDLER from "../../../utils/backend/global-db/DB_HANDLER";
-import DSQL_USER_DB_HANDLER from "../../../utils/backend/global-db/DSQL_USER_DB_HANDLER";
 import encrypt from "../../dsql/encrypt";
-import LOCAL_DB_HANDLER from "../../../utils/backend/global-db/LOCAL_DB_HANDLER";
+import connDbHandler from "../../../utils/db/conn-db-handler";
+import checkIfIsMaster from "../../../utils/check-if-is-master";
+import { DbContextsArray } from "./runQuery";

 type Param = {
-    dbContext?: "Master" | "Dsql User";
+    dbContext?: (typeof DbContextsArray)[number];
    paradigm?: "Read Only" | "Full Access";
    dbFullName?: string;
    tableName: string;
@@ -21,32 +19,10 @@ type Param = {
    update?: boolean;
    encryptionKey?: string;
    encryptionSalt?: string;
-    useLocal?: boolean;
 };

 /**
 * Add a db Entry Function
- * ==============================================================================
- * @description Description
- * @async
- *
- * @param {object} params - An object containing the function parameters.
- * @param {("Master" | "Dsql User")} [params.dbContext] - What is the database context? "Master"
- * or "Dsql User". Defaults to "Master"
- * @param {("Read Only" | "Full Access")} [params.paradigm] - What is the paradigm for "Dsql User"?
- * "Read only" or "Full Access"? Defaults to "Read Only"
- * @param {string} [params.dbFullName] - Database full name
- * @param {string} params.tableName - Table name
- * @param {any} params.data - Data to add
- * @param {import("../../../types").DSQL_TableSchemaType} [params.tableSchema] - Table schema
- * @param {string} [params.duplicateColumnName] - Duplicate column name
- * @param {string} [params.duplicateColumnValue] - Duplicate column value
- * @param {boolean} [params.update] - Update this row if it exists
- * @param {string} [params.encryptionKey] - Update this row if it exists
- * @param {string} [params.encryptionSalt] - Update this row if it exists
- * @param {boolean} [params.useLocal]
- *
- * @returns {Promise<any>}
 */
 export default async function addDbEntry({
    dbContext,
@@ -60,25 +36,18 @@ export default async function addDbEntry({
    update,
    encryptionKey,
    encryptionSalt,
-    useLocal,
 }: Param): Promise<any> {
    /**
     * Initialize variables
     */
-    const isMaster = useLocal
-        ? true
-        : dbContext?.match(/dsql.user/i)
-        ? false
-        : dbFullName && !dbFullName.match(/^datasquirel$/)
-        ? false
-        : true;
+    const isMaster = checkIfIsMaster({ dbContext, dbFullName });

-    /** @type { any } */
-    const dbHandler: any = useLocal
-        ? LOCAL_DB_HANDLER
-        : isMaster
-        ? DB_HANDLER
-        : DSQL_USER_DB_HANDLER;
+    const DB_CONN = isMaster
+        ? global.DSQL_DB_CONN
+        : global.DSQL_FULL_ACCESS_DB_CONN || global.DSQL_DB_CONN;
+    const DB_RO_CONN = isMaster
+        ? global.DSQL_DB_CONN
+        : global.DSQL_READ_ONLY_DB_CONN || global.DSQL_DB_CONN;

    ////////////////////////////////////////
    ////////////////////////////////////////
@@ -95,28 +64,22 @@ export default async function addDbEntry({
    ////////////////////////////////////////
    ////////////////////////////////////////

-    /**
-     * Handle function logic
-     */
-
    if (duplicateColumnName && typeof duplicateColumnName === "string") {
-        const duplicateValue = isMaster
-            ? await dbHandler(
-                  `SELECT * FROM \`${tableName}\` WHERE \`${duplicateColumnName}\`=?`,
-                  [duplicateColumnValue]
-              )
-            : await dbHandler({
-                  paradigm: "Read Only",
-                  queryString: `SELECT * FROM \`${dbFullName}\`.\`${tableName}\` WHERE \`${duplicateColumnName}\`=?`,
-                  queryValues: [duplicateColumnValue],
-              });
+        const checkDuplicateQuery = `SELECT * FROM ${
+            isMaster ? "" : `\`${dbFullName}\`.`
+        }\`${tableName}\` WHERE \`${duplicateColumnName}\`=?`;
+
+        const duplicateValue = await connDbHandler(
+            DB_RO_CONN,
+            checkDuplicateQuery,
+            [duplicateColumnValue]
+        );

        if (duplicateValue?.[0] && !update) {
            return null;
        } else if (duplicateValue && duplicateValue[0] && update) {
            return await updateDbEntry({
                dbContext,
-                paradigm,
                dbFullName,
                tableName,
                data,
@@ -201,7 +164,7 @@ export default async function addDbEntry({
            } else {
                insertValuesArray.push(value);
            }
-        } catch (/** @type {any} */ error: any) {
+        } catch (error: any) {
            console.log("DSQL: Error in parsing data keys =>", error.message);
            continue;
        }
@@ -233,18 +196,14 @@ export default async function addDbEntry({

    ////////////////////////////////////////

-    const query = `INSERT INTO \`${dbFullName}\`.\`${tableName}\` (${insertKeysArray.join(
-        ","
-    )}) VALUES (${insertValuesArray.map(() => "?").join(",")})`;
+    const query = `INSERT INTO ${
+        isMaster ? "" : `\`${dbFullName}\`.`
+    }\`${tableName}\` (${insertKeysArray.join(",")}) VALUES (${insertValuesArray
+        .map(() => "?")
+        .join(",")})`;
    const queryValuesArray = insertValuesArray;

-    const newInsert = isMaster
-        ? await dbHandler(query, queryValuesArray)
-        : await dbHandler({
-              paradigm,
-              queryString: query,
-              queryValues: queryValuesArray,
-          });
+    const newInsert = await connDbHandler(DB_CONN, query, queryValuesArray);

    /**
     * Return statement
@@ -1,16 +1,14 @@
-import DB_HANDLER from "../../../utils/backend/global-db/DB_HANDLER";
-import DSQL_USER_DB_HANDLER from "../../../utils/backend/global-db/DSQL_USER_DB_HANDLER";
-import LOCAL_DB_HANDLER from "../../../utils/backend/global-db/LOCAL_DB_HANDLER";
+import checkIfIsMaster from "../../../utils/check-if-is-master";
+import connDbHandler from "../../../utils/db/conn-db-handler";
+import { DbContextsArray } from "./runQuery";

 type Param = {
-    dbContext?: string;
-    paradigm?: "Read Only" | "Full Access";
+    dbContext?: (typeof DbContextsArray)[number];
    dbFullName: string;
    tableName: string;
    tableSchema?: import("../../../types").DSQL_TableSchemaType;
    identifierColumnName: string;
    identifierValue: string | number;
-    useLocal?: boolean;
 };

 /**
@@ -19,43 +17,33 @@ type Param = {
 */
 export default async function deleteDbEntry({
    dbContext,
-    paradigm,
    dbFullName,
    tableName,
    identifierColumnName,
    identifierValue,
-    useLocal,
 }: Param): Promise<object | null> {
    try {
-        const isMaster = useLocal
-            ? true
-            : dbContext?.match(/dsql.user/i)
-            ? false
-            : dbFullName && !dbFullName.match(/^datasquirel$/)
-            ? false
-            : true;
+        const isMaster = checkIfIsMaster({ dbContext, dbFullName });

-        /** @type { (a1:any, a2?:any) => any } */
-        const dbHandler: (a1: any, a2?: any) => any = useLocal
-            ? LOCAL_DB_HANDLER
-            : isMaster
-            ? DB_HANDLER
-            : DSQL_USER_DB_HANDLER;
+        const DB_CONN = isMaster
+            ? global.DSQL_DB_CONN
+            : global.DSQL_FULL_ACCESS_DB_CONN || global.DSQL_DB_CONN;
+        const DB_RO_CONN = isMaster
+            ? global.DSQL_DB_CONN
+            : global.DSQL_READ_ONLY_DB_CONN || global.DSQL_DB_CONN;

        /**
         * Execution
         *
         * @description
         */
-        const query = `DELETE FROM \`${dbFullName}\`.\`${tableName}\` WHERE \`${identifierColumnName}\`=?`;
+        const query = `DELETE FROM ${
+            isMaster ? "" : `\`${dbFullName}\`.`
+        }\`${tableName}\` WHERE \`${identifierColumnName}\`=?`;

-        const deletedEntry = isMaster
-            ? await dbHandler(query, [identifierValue])
-            : await dbHandler({
-                  paradigm,
-                  queryString: query,
-                  queryValues: [identifierValue],
-              });
+        const deletedEntry = await connDbHandler(DB_CONN, query, [
+            identifierValue,
+        ]);

        /**
         * Return statement
@@ -7,11 +7,14 @@ import deleteDbEntry from "./deleteDbEntry";
 import trimSql from "../../../utils/trim-sql";
 import { DSQL_TableSchemaType } from "../../../types";

+export const DbContextsArray = ["Master", "Dsql User"] as const;
+
 type Param = {
+    dbContext?: (typeof DbContextsArray)[number];
    dbFullName: string;
    query: string | any;
    readOnly?: boolean;
-    local?: boolean;
+    debug?: boolean;
    dbSchema?: import("../../../types").DSQL_DatabaseSchemaType;
    queryValuesArray?: (string | number)[];
    tableName?: string;
@@ -27,7 +30,8 @@ export default async function runQuery({
    dbSchema,
    queryValuesArray,
    tableName,
-    local,
+    debug,
+    dbContext,
 }: Param): Promise<any> {
    /**
     * Declare variables
@@ -66,6 +70,10 @@ export default async function runQuery({
        if (typeof query === "string") {
            const formattedQuery = trimSql(query);

+            if (debug && global.DSQL_USE_LOCAL) {
+                console.log("runQuery:formattedQuery", formattedQuery);
+            }
+
            /**
             * Input Validation
             *
@@ -85,14 +93,12 @@ export default async function runQuery({
                    queryString: formattedQuery,
                    queryValuesArray: queryValuesArray?.map((vl) => String(vl)),
                    tableSchema,
-                    useLocal: local,
                });
            } else {
                result = await fullAccessDbHandler({
                    queryString: formattedQuery,
                    queryValuesArray: queryValuesArray?.map((vl) => String(vl)),
                    tableSchema,
-                    local,
                });
            }
        } else if (typeof query === "object") {
@@ -115,8 +121,7 @@ export default async function runQuery({
            switch (action.toLowerCase()) {
                case "insert":
                    result = await addDbEntry({
-                        dbContext: local ? "Master" : "Dsql User",
-                        paradigm: "Full Access",
+                        dbContext,
                        dbFullName: dbFullName,
                        tableName: table,
                        data: data,
@@ -124,7 +129,6 @@ export default async function runQuery({
                        duplicateColumnName,
                        duplicateColumnValue,
                        tableSchema,
-                        useLocal: local,
                    });

                    if (!result?.insertId) {
@@ -135,29 +139,25 @@ export default async function runQuery({

                case "update":
                    result = await updateDbEntry({
-                        dbContext: local ? "Master" : "Dsql User",
-                        paradigm: "Full Access",
+                        dbContext,
                        dbFullName: dbFullName,
                        tableName: table,
                        data: data,
                        identifierColumnName,
                        identifierValue,
                        tableSchema,
-                        useLocal: local,
                    });

                    break;

                case "delete":
                    result = await deleteDbEntry({
-                        dbContext: local ? "Master" : "Dsql User",
-                        paradigm: "Full Access",
+                        dbContext,
                        dbFullName: dbFullName,
                        tableName: table,
                        identifierColumnName,
                        identifierValue,
                        tableSchema,
-                        useLocal: local,
                    });

                    break;
@@ -167,11 +167,16 @@ export default async function runQuery({
                    break;
            }
        }
-    } catch (/** @type {any} */ error: any) {
+    } catch (error: any) {
        serverError({
            component: "functions/backend/runQuery",
            message: error.message,
        });
+
+        if (debug && global.DSQL_USE_LOCAL) {
+            console.log("runQuery:error", error.message);
+        }
+
        result = null;
        error = error.message;
    }
@@ -1,13 +1,12 @@
 import sanitizeHtml from "sanitize-html";
 import sanitizeHtmlOptions from "../html/sanitizeHtmlOptions";
-import DB_HANDLER from "../../../utils/backend/global-db/DB_HANDLER";
-import DSQL_USER_DB_HANDLER from "../../../utils/backend/global-db/DSQL_USER_DB_HANDLER";
 import encrypt from "../../dsql/encrypt";
-import LOCAL_DB_HANDLER from "../../../utils/backend/global-db/LOCAL_DB_HANDLER";
+import checkIfIsMaster from "../../../utils/check-if-is-master";
+import connDbHandler from "../../../utils/db/conn-db-handler";
+import { DbContextsArray } from "./runQuery";

 type Param = {
-    dbContext?: "Master" | "Dsql User";
-    paradigm?: "Read Only" | "Full Access";
+    dbContext?: (typeof DbContextsArray)[number];
    dbFullName?: string;
    tableName: string;
    encryptionKey?: string;
@@ -16,7 +15,6 @@ type Param = {
    tableSchema?: import("../../../types").DSQL_TableSchemaType;
    identifierColumnName: string;
    identifierValue: string | number;
-    useLocal?: boolean;
 };

 /**
@@ -25,7 +23,6 @@ type Param = {
 */
 export default async function updateDbEntry({
    dbContext,
-    paradigm,
    dbFullName,
    tableName,
    data,
@@ -34,27 +31,20 @@ export default async function updateDbEntry({
    identifierValue,
    encryptionKey,
    encryptionSalt,
-    useLocal,
 }: Param): Promise<object | null> {
    /**
     * Check if data is valid
     */
    if (!data || !Object.keys(data).length) return null;

-    const isMaster = useLocal
-        ? true
-        : dbContext?.match(/dsql.user/i)
-        ? false
-        : dbFullName && !dbFullName.match(/^datasquirel$/)
-        ? false
-        : true;
+    const isMaster = checkIfIsMaster({ dbContext, dbFullName });

-    /** @type {(a1:any, a2?:any)=> any } */
-    const dbHandler: (a1: any, a2?: any) => any = useLocal
-        ? LOCAL_DB_HANDLER
-        : isMaster
-        ? DB_HANDLER
-        : DSQL_USER_DB_HANDLER;
+    const DB_CONN = isMaster
+        ? global.DSQL_DB_CONN
+        : global.DSQL_FULL_ACCESS_DB_CONN || global.DSQL_DB_CONN;
+    const DB_RO_CONN = isMaster
+        ? global.DSQL_DB_CONN
+        : global.DSQL_READ_ONLY_DB_CONN || global.DSQL_DB_CONN;

    ////////////////////////////////////////
    ////////////////////////////////////////
@@ -164,19 +154,15 @@ export default async function updateDbEntry({
    ////////////////////////////////////////
    ////////////////////////////////////////

-    const query = `UPDATE \`${dbFullName}\`.\`${tableName}\` SET ${updateKeyValueArray.join(
+    const query = `UPDATE ${
+        isMaster ? "" : `\`${dbFullName}\`.`
+    }\`${tableName}\` SET ${updateKeyValueArray.join(
        ","
    )} WHERE \`${identifierColumnName}\`=?`;

    updateValues.push(identifierValue);

-    const updatedEntry = isMaster
-        ? await dbHandler(query, updateValues)
-        : await dbHandler({
-              paradigm,
-              queryString: query,
-              queryValues: updateValues,
-          });
+    const updatedEntry = await connDbHandler(DB_CONN, query, updateValues);

    /**
     * Return statement