Updates

dist/package-shared/functions/api/query-dsql-api.d.ts

@@ -0,0 +1,20 @@
+import { APIResponseObject, DataCrudRequestMethods, DataCrudRequestMethodsLowerCase } from "../../types";
+type Param<T = {
+    [k: string]: any;
+}> = {
+    key?: string;
+    body?: T;
+    query?: T;
+    useDefault?: boolean;
+    path: string;
+    method?: (typeof DataCrudRequestMethods)[number] | (typeof DataCrudRequestMethodsLowerCase)[number];
+};
+/**
+ * # Query DSQL API
+ */
+export default function queryDSQLAPI<T = {
+    [k: string]: any;
+}, P = {
+    [k: string]: any;
+}>({ key, body, query, useDefault, path: passedPath, method, }: Param<T>): Promise<APIResponseObject<P>>;
+export {};

dist/package-shared/functions/api/query-dsql-api.js

@@ -0,0 +1,73 @@
+import path from "path";
+import grabHostNames from "../../utils/grab-host-names";
+import serializeQuery from "../../utils/serialize-query";
+/**
+ * # Query DSQL API
+ */
+export default async function queryDSQLAPI({ key, body, query, useDefault, path: passedPath, method, }) {
+    const grabedHostNames = grabHostNames({ useDefault });
+    const { host, port, scheme } = grabedHostNames;
+    try {
+        /**
+         * Make https request
+         *
+         * @description make a request to datasquirel.com
+         */
+        const httpResponse = await new Promise((resolve, reject) => {
+            const reqPayload = body ? JSON.stringify(body) : undefined;
+            let headers = {
+                "Content-Type": "application/json",
+                Authorization: key ||
+                    (!method || method == "GET" || method == "get"
+                        ? process.env.DSQL_READ_ONLY_API_KEY
+                        : undefined) ||
+                    process.env.DSQL_FULL_ACCESS_API_KEY ||
+                    process.env.DSQL_API_KEY,
+            };
+            if (reqPayload) {
+                headers["Content-Length"] = Buffer.from(reqPayload).length;
+            }
+            let finalPath = path.join("/", passedPath);
+            if (query) {
+                const queryString = serializeQuery(query);
+                finalPath += `${queryString}`;
+            }
+            const httpsRequest = scheme.request({
+                method: method || "GET",
+                headers,
+                port,
+                hostname: host,
+                path: finalPath,
+            }, 
+            /**
+             * Callback Function
+             *
+             * @description https request callback
+             */
+            (response) => {
+                var str = "";
+                response.on("data", function (chunk) {
+                    str += chunk;
+                });
+                response.on("end", function () {
+                    resolve(JSON.parse(str));
+                });
+                response.on("error", (err) => {
+                    reject(err);
+                });
+            });
+            if (reqPayload) {
+                httpsRequest.write(reqPayload);
+            }
+            httpsRequest.end();
+        });
+        return httpResponse;
+    }
+    catch (error) {
+        return {
+            success: false,
+            payload: undefined,
+            msg: error.message,
+        };
+    }
+}

dist/package-shared/functions/api/query/get.js

@@ -1,94 +1,74 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = apiGet;
-const lodash_1 = __importDefault(require("lodash"));
-const serverError_1 = __importDefault(require("../../backend/serverError"));
-const runQuery_1 = __importDefault(require("../../backend/db/runQuery"));
-const grab_query_and_values_1 = __importDefault(require("../../../utils/grab-query-and-values"));
+import _ from "lodash";
+import serverError from "../../backend/serverError";
+import runQuery from "../../backend/db/runQuery";
+import apiGetGrabQueryAndValues from "../../../utils/grab-query-and-values";
 /**
  * # Get Function FOr API
  */
-function apiGet(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ query, dbFullName, queryValues, tableName, dbSchema, debug, dbContext, forceLocal, }) {
-        var _b, _c;
-        const queryAndValues = (0, grab_query_and_values_1.default)({
-            query,
-            values: queryValues,
-        });
-        if (typeof query == "string" && query.match(/^alter|^delete|^create/i)) {
-            return { success: false, msg: "Wrong Input." };
-        }
-        let results;
-        try {
-            let { result, error } = yield (0, runQuery_1.default)({
-                dbFullName: dbFullName,
-                query: queryAndValues.query,
-                queryValuesArray: queryAndValues.values,
-                readOnly: true,
-                dbSchema,
-                tableName,
-                dbContext,
-                debug,
-                forceLocal,
-            });
-            if (debug && global.DSQL_USE_LOCAL) {
-                console.log("apiGet:result", result);
-                console.log("apiGet:error", error);
-            }
-            let tableSchema;
-            if (dbSchema) {
-                const targetTable = (_b = dbSchema.tables) === null || _b === void 0 ? void 0 : _b.find((table) => table.tableName === tableName);
-                if (targetTable) {
-                    const clonedTargetTable = lodash_1.default.cloneDeep(targetTable);
-                    delete clonedTargetTable.childTable;
-                    delete clonedTargetTable.childTableDbFullName;
-                    delete clonedTargetTable.childTableName;
-                    delete clonedTargetTable.childrenTables;
-                    delete clonedTargetTable.updateData;
-                    delete clonedTargetTable.tableNameOld;
-                    delete clonedTargetTable.indexes;
-                    tableSchema = clonedTargetTable;
-                }
-            }
-            if (error)
-                throw error;
-            if (result.error)
-                throw new Error(result.error);
-            results = result;
-            const resObject = {
-                success: true,
-                payload: results,
-                schema: tableName && tableSchema ? tableSchema : undefined,
-            };
-            return resObject;
-        }
-        catch (error) {
-            (0, serverError_1.default)({
-                component: "/api/query/get/lines-85-94",
-                message: error.message,
-            });
-            (_c = global.ERROR_CALLBACK) === null || _c === void 0 ? void 0 : _c.call(global, `API Get Error`, error);
-            if (debug && global.DSQL_USE_LOCAL) {
-                console.log("apiGet:error", error.message);
-                console.log("queryAndValues", queryAndValues);
-            }
-            return {
-                success: false,
-                payload: null,
-                error: error.message,
-            };
-        }
+export default async function apiGet({ query, dbFullName, queryValues, tableName, dbSchema, debug, dbContext, forceLocal, }) {
+    var _a, _b;
+    const queryAndValues = apiGetGrabQueryAndValues({
+        query,
+        values: queryValues,
     });
+    if (typeof query == "string" && query.match(/^alter|^delete|^create/i)) {
+        return { success: false, msg: "Wrong Input." };
+    }
+    let results;
+    try {
+        let { result, error } = await runQuery({
+            dbFullName: dbFullName,
+            query: queryAndValues.query,
+            queryValuesArray: queryAndValues.values,
+            readOnly: true,
+            dbSchema,
+            tableName,
+            dbContext,
+            debug,
+            forceLocal,
+        });
+        if (debug && global.DSQL_USE_LOCAL) {
+            console.log("apiGet:result", result);
+            console.log("apiGet:error", error);
+        }
+        let tableSchema;
+        if (dbSchema) {
+            const targetTable = (_a = dbSchema.tables) === null || _a === void 0 ? void 0 : _a.find((table) => table.tableName === tableName);
+            if (targetTable) {
+                const clonedTargetTable = _.cloneDeep(targetTable);
+                delete clonedTargetTable.childTable;
+                delete clonedTargetTable.childrenTables;
+                delete clonedTargetTable.updateData;
+                delete clonedTargetTable.indexes;
+                tableSchema = clonedTargetTable;
+            }
+        }
+        if (error)
+            throw error;
+        if (result.error)
+            throw new Error(result.error);
+        results = result;
+        const resObject = {
+            success: true,
+            payload: results,
+            schema: tableName && tableSchema ? tableSchema : undefined,
+        };
+        return resObject;
+    }
+    catch (error) {
+        serverError({
+            component: "/api/query/get/lines-85-94",
+            message: error.message,
+        });
+        (_b = global.ERROR_CALLBACK) === null || _b === void 0 ? void 0 : _b.call(global, `API Get Error`, error);
+        if (debug && global.DSQL_USE_LOCAL) {
+            console.log("apiGet:error", error.message);
+            console.log("queryAndValues", queryAndValues);
+        }
+        return {
+            success: false,
+            payload: null,
+            error: error.message,
+        };
+    }
 }

dist/package-shared/functions/api/query/post.js

@@ -1,100 +1,80 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = apiPost;
-const lodash_1 = __importDefault(require("lodash"));
-const serverError_1 = __importDefault(require("../../backend/serverError"));
-const runQuery_1 = __importDefault(require("../../backend/db/runQuery"));
-const debug_log_1 = __importDefault(require("../../../utils/logging/debug-log"));
+import _ from "lodash";
+import serverError from "../../backend/serverError";
+import runQuery from "../../backend/db/runQuery";
+import debugLog from "../../../utils/logging/debug-log";
 /**
  * # Post Function For API
  */
-function apiPost(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ query, dbFullName, queryValues, tableName, dbSchema, dbContext, forceLocal, debug, }) {
-        var _b, _c;
-        if (typeof query === "string" && (query === null || query === void 0 ? void 0 : query.match(/^create |^alter |^drop /i))) {
-            return { success: false, msg: "Wrong Input" };
-        }
-        if (typeof query === "object" &&
-            ((_b = query === null || query === void 0 ? void 0 : query.action) === null || _b === void 0 ? void 0 : _b.match(/^create |^alter |^drop /i))) {
-            return { success: false, msg: "Wrong Input" };
-        }
-        let results;
-        /**
-         * Create new user folder and file
-         *
-         * @description Create new user folder and file
-         */
-        try {
-            let { result, error } = yield (0, runQuery_1.default)({
-                dbFullName: dbFullName,
-                query: query,
-                dbSchema: dbSchema,
-                queryValuesArray: queryValues,
-                tableName,
-                dbContext,
-                forceLocal,
-                debug,
+export default async function apiPost({ query, dbFullName, queryValues, tableName, dbSchema, dbContext, forceLocal, debug, }) {
+    var _a, _b;
+    if (typeof query === "string" && (query === null || query === void 0 ? void 0 : query.match(/^create |^alter |^drop /i))) {
+        return { success: false, msg: "Wrong Input" };
+    }
+    if (typeof query === "object" &&
+        ((_a = query === null || query === void 0 ? void 0 : query.action) === null || _a === void 0 ? void 0 : _a.match(/^create |^alter |^drop /i))) {
+        return { success: false, msg: "Wrong Input" };
+    }
+    let results;
+    /**
+     * Create new user folder and file
+     *
+     * @description Create new user folder and file
+     */
+    try {
+        let { result, error } = await runQuery({
+            dbFullName,
+            query,
+            dbSchema,
+            queryValuesArray: queryValues,
+            tableName,
+            dbContext,
+            forceLocal,
+            debug,
+        });
+        if (debug) {
+            debugLog({
+                log: result,
+                addTime: true,
+                label: "result",
             });
-            if (debug) {
-                (0, debug_log_1.default)({
-                    log: result,
-                    addTime: true,
-                    label: "result",
-                });
-                (0, debug_log_1.default)({
-                    log: query,
-                    addTime: true,
-                    label: "query",
-                });
-            }
-            results = result;
-            if (error)
-                throw new Error(error);
-            let tableSchema;
-            if (dbSchema) {
-                const targetTable = dbSchema.tables.find((table) => table.tableName === tableName);
-                if (targetTable) {
-                    const clonedTargetTable = lodash_1.default.cloneDeep(targetTable);
-                    delete clonedTargetTable.childTable;
-                    delete clonedTargetTable.childTableDbFullName;
-                    delete clonedTargetTable.childTableName;
-                    delete clonedTargetTable.childrenTables;
-                    delete clonedTargetTable.updateData;
-                    delete clonedTargetTable.tableNameOld;
-                    delete clonedTargetTable.indexes;
-                    tableSchema = clonedTargetTable;
-                }
-            }
-            return {
-                success: true,
-                payload: results,
-                error: error,
-                schema: tableName && tableSchema ? tableSchema : undefined,
-            };
-        }
-        catch (error) {
-            (0, serverError_1.default)({
-                component: "/api/query/post/lines-132-142",
-                message: error.message,
+            debugLog({
+                log: query,
+                addTime: true,
+                label: "query",
             });
-            (_c = global.ERROR_CALLBACK) === null || _c === void 0 ? void 0 : _c.call(global, `API Post Error`, error);
-            return {
-                success: false,
-                payload: results,
-                error: error.message,
-            };
         }
-    });
+        results = result;
+        if (error)
+            throw new Error(error);
+        let tableSchema;
+        if (dbSchema) {
+            const targetTable = dbSchema.tables.find((table) => table.tableName === tableName);
+            if (targetTable) {
+                const clonedTargetTable = _.cloneDeep(targetTable);
+                delete clonedTargetTable.childTable;
+                delete clonedTargetTable.childrenTables;
+                delete clonedTargetTable.updateData;
+                delete clonedTargetTable.indexes;
+                tableSchema = clonedTargetTable;
+            }
+        }
+        return {
+            success: true,
+            payload: results,
+            error: error,
+            schema: tableName && tableSchema ? tableSchema : undefined,
+        };
+    }
+    catch (error) {
+        serverError({
+            component: "/api/query/post/lines-132-142",
+            message: error.message,
+        });
+        (_b = global.ERROR_CALLBACK) === null || _b === void 0 ? void 0 : _b.call(global, `API Post Error`, error);
+        return {
+            success: false,
+            payload: results,
+            error: error.message,
+        };
+    }
 }

dist/package-shared/functions/api/social-login/facebookLogin.js

@@ -1,35 +1,19 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = facebookLogin;
-const DB_HANDLER_1 = __importDefault(require("../../../utils/backend/global-db/DB_HANDLER"));
-const serverError_1 = __importDefault(require("../../backend/serverError"));
-const hashPassword_1 = __importDefault(require("../../dsql/hashPassword"));
+import DB_HANDLER from "../../../utils/backend/global-db/DB_HANDLER";
+import serverError from "../../backend/serverError";
+import hashPassword from "../../dsql/hashPassword";
 /**
  * # Facebook Login
  */
-function facebookLogin(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ usertype, body, }) {
-        try {
-            const foundUser = yield (0, DB_HANDLER_1.default)(`SELECT * FROM users WHERE email='${body.facebookUserEmail}' AND social_login='1'`);
-            if (foundUser && foundUser[0]) {
-                return foundUser[0];
-            }
-            let socialHashedPassword = (0, hashPassword_1.default)({
-                password: body.facebookUserId,
-            });
-            let newUser = yield (0, DB_HANDLER_1.default)(`INSERT INTO ${usertype} (
+export default async function facebookLogin({ usertype, body, }) {
+    try {
+        const foundUser = await DB_HANDLER(`SELECT * FROM users WHERE email='${body.facebookUserEmail}' AND social_login='1'`);
+        if (foundUser && foundUser[0]) {
+            return foundUser[0];
+        }
+        let socialHashedPassword = hashPassword({
+            password: body.facebookUserId,
+        });
+        let newUser = await DB_HANDLER(`INSERT INTO ${usertype} (
             first_name,
             last_name,
             social_platform,
@@ -49,8 +33,8 @@ function facebookLogin(_a) {
                 '${body.facebookUserLastName}',
                 'facebook',
                 'facebook_${body.facebookUserEmail
-                ? body.facebookUserEmail.replace(/@.*/, "")
-                : body.facebookUserFirstName.toLowerCase()}',
+            ? body.facebookUserEmail.replace(/@.*/, "")
+            : body.facebookUserFirstName.toLowerCase()}',
                 '${body.facebookUserEmail}',
                 '${body.facebookUserImage}',
                 '${body.facebookUserImage}',
@@ -62,17 +46,16 @@ function facebookLogin(_a) {
                 '${Date()}',
                 '${Date.now()}'
                 )`);
-            const newFoundUser = yield (0, DB_HANDLER_1.default)(`SELECT * FROM ${usertype} WHERE id='${newUser.insertId}'`);
-        }
-        catch ( /** @type {any} */error) {
-            (0, serverError_1.default)({
-                component: "functions/backend/facebookLogin",
-                message: error.message,
-            });
-        }
-        return {
-            isFacebookAuthValid: false,
-            newFoundUser: null,
-        };
-    });
+        const newFoundUser = await DB_HANDLER(`SELECT * FROM ${usertype} WHERE id='${newUser.insertId}'`);
+    }
+    catch ( /** @type {any} */error) {
+        serverError({
+            component: "functions/backend/facebookLogin",
+            message: error.message,
+        });
+    }
+    return {
+        isFacebookAuthValid: false,
+        newFoundUser: null,
+    };
 }

dist/package-shared/functions/api/social-login/githubLogin.js

@@ -1,62 +1,45 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = githubLogin;
-const DB_HANDLER_1 = __importDefault(require("../../../utils/backend/global-db/DB_HANDLER"));
-const httpsRequest_1 = __importDefault(require("../../backend/httpsRequest"));
+import DB_HANDLER from "../../../utils/backend/global-db/DB_HANDLER";
+import httpsRequest from "../../backend/httpsRequest";
 /**
  * # Login/signup a github user
  */
-function githubLogin(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ code, clientId, clientSecret, }) {
-        let gitHubUser;
-        try {
-            const response = yield (0, httpsRequest_1.default)({
-                method: "POST",
-                hostname: "github.com",
-                path: `/login/oauth/access_token?client_id=${clientId}&client_secret=${clientSecret}&code=${code}`,
-                headers: {
-                    Accept: "application/json",
-                    "User-Agent": "*",
-                },
-                scheme: "https",
-            });
-            const accessTokenObject = JSON.parse(response);
-            if (!(accessTokenObject === null || accessTokenObject === void 0 ? void 0 : accessTokenObject.access_token)) {
-                return gitHubUser;
-            }
-            const userDataResponse = yield (0, httpsRequest_1.default)({
-                method: "GET",
-                hostname: "api.github.com",
-                path: "/user",
-                headers: {
-                    Authorization: `Bearer ${accessTokenObject.access_token}`,
-                    "User-Agent": "*",
-                },
-                scheme: "https",
-            });
-            gitHubUser = JSON.parse(userDataResponse);
-            if (!(gitHubUser === null || gitHubUser === void 0 ? void 0 : gitHubUser.email) && gitHubUser) {
-                const existingGithubUser = yield (0, DB_HANDLER_1.default)(`SELECT email FROM users WHERE social_login='1' AND social_platform='github' AND social_id='${gitHubUser.id}'`);
-                if (existingGithubUser && existingGithubUser[0]) {
-                    gitHubUser.email = existingGithubUser[0].email;
-                }
+export default async function githubLogin({ code, clientId, clientSecret, }) {
+    let gitHubUser;
+    try {
+        const response = await httpsRequest({
+            method: "POST",
+            hostname: "github.com",
+            path: `/login/oauth/access_token?client_id=${clientId}&client_secret=${clientSecret}&code=${code}`,
+            headers: {
+                Accept: "application/json",
+                "User-Agent": "*",
+            },
+            scheme: "https",
+        });
+        const accessTokenObject = JSON.parse(response);
+        if (!(accessTokenObject === null || accessTokenObject === void 0 ? void 0 : accessTokenObject.access_token)) {
+            return gitHubUser;
+        }
+        const userDataResponse = await httpsRequest({
+            method: "GET",
+            hostname: "api.github.com",
+            path: "/user",
+            headers: {
+                Authorization: `Bearer ${accessTokenObject.access_token}`,
+                "User-Agent": "*",
+            },
+            scheme: "https",
+        });
+        gitHubUser = JSON.parse(userDataResponse);
+        if (!(gitHubUser === null || gitHubUser === void 0 ? void 0 : gitHubUser.email) && gitHubUser) {
+            const existingGithubUser = await DB_HANDLER(`SELECT email FROM users WHERE social_login='1' AND social_platform='github' AND social_id='${gitHubUser.id}'`);
+            if (existingGithubUser && existingGithubUser[0]) {
+                gitHubUser.email = existingGithubUser[0].email;
             }
         }
-        catch ( /** @type {any} */error) {
-            console.log("ERROR in githubLogin.ts backend function =>", error.message);
-        }
-        return gitHubUser;
-    });
+    }
+    catch ( /** @type {any} */error) {
+        console.log("ERROR in githubLogin.ts backend function =>", error.message);
+    }
+    return gitHubUser;
 }

dist/package-shared/functions/api/social-login/googleLogin.js

@@ -1,82 +1,66 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = googleLogin;
-const google_auth_library_1 = require("google-auth-library");
-const serverError_1 = __importDefault(require("../../backend/serverError"));
-const DB_HANDLER_1 = __importDefault(require("../../../utils/backend/global-db/DB_HANDLER"));
-const hashPassword_1 = __importDefault(require("../../dsql/hashPassword"));
+import { OAuth2Client } from "google-auth-library";
+import serverError from "../../backend/serverError";
+import DB_HANDLER from "../../../utils/backend/global-db/DB_HANDLER";
+import hashPassword from "../../dsql/hashPassword";
 /**
  * # Google Login
  */
-function googleLogin(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ usertype, foundUser, isSocialValidated, isUserValid, reqBody, serverRes, loginFailureReason, }) {
-        var _b, _c;
-        const client = new google_auth_library_1.OAuth2Client(process.env.DSQL_GOOGLE_CLIENT_ID);
-        let isGoogleAuthValid = false;
-        let newFoundUser = null;
+export default async function googleLogin({ usertype, foundUser, isSocialValidated, isUserValid, reqBody, serverRes, loginFailureReason, }) {
+    var _a, _b;
+    const client = new OAuth2Client(process.env.DSQL_GOOGLE_CLIENT_ID);
+    let isGoogleAuthValid = false;
+    let newFoundUser = null;
+    ////////////////////////////////////////////////
+    ////////////////////////////////////////////////
+    ////////////////////////////////////////////////
+    try {
+        const ticket = await client.verifyIdToken({
+            idToken: reqBody.token,
+            audience: process.env.DSQL_GOOGLE_CLIENT_ID, // Specify the CLIENT_ID of the app that accesses the backend
+            // Or, if multiple clients access the backend:
+            //[CLIENT_ID_1, CLIENT_ID_2, CLIENT_ID_3]
+        });
+        const payload = ticket.getPayload();
+        const userid = payload === null || payload === void 0 ? void 0 : payload["sub"];
+        if (!payload)
+            throw new Error("Google login failed. Credentials invalid");
+        isUserValid = Boolean(payload.email_verified);
+        if (!isUserValid || !payload || !payload.email_verified)
+            return;
+        serverRes.isUserValid = payload.email_verified;
+        isSocialValidated = payload.email_verified;
+        isGoogleAuthValid = payload.email_verified;
+        ////// If request specified a G Suite domain:
+        ////// const domain = payload['hd'];
+        let socialHashedPassword = hashPassword({
+            password: payload.at_hash || "",
+        });
         ////////////////////////////////////////////////
         ////////////////////////////////////////////////
         ////////////////////////////////////////////////
-        try {
-            const ticket = yield client.verifyIdToken({
-                idToken: reqBody.token,
-                audience: process.env.DSQL_GOOGLE_CLIENT_ID, // Specify the CLIENT_ID of the app that accesses the backend
-                // Or, if multiple clients access the backend:
-                //[CLIENT_ID_1, CLIENT_ID_2, CLIENT_ID_3]
-            });
-            const payload = ticket.getPayload();
-            const userid = payload === null || payload === void 0 ? void 0 : payload["sub"];
-            if (!payload)
-                throw new Error("Google login failed. Credentials invalid");
-            isUserValid = Boolean(payload.email_verified);
-            if (!isUserValid || !payload || !payload.email_verified)
-                return;
-            serverRes.isUserValid = payload.email_verified;
-            isSocialValidated = payload.email_verified;
-            isGoogleAuthValid = payload.email_verified;
-            ////// If request specified a G Suite domain:
-            ////// const domain = payload['hd'];
-            let socialHashedPassword = (0, hashPassword_1.default)({
-                password: payload.at_hash || "",
-            });
-            ////////////////////////////////////////////////
-            ////////////////////////////////////////////////
-            ////////////////////////////////////////////////
-            let existinEmail = yield (0, DB_HANDLER_1.default)(`SELECT * FROM ${usertype} WHERE email='${payload.email}' AND social_login!='1' AND social_platform!='google'`);
-            if (existinEmail && existinEmail[0]) {
-                loginFailureReason = "Email Exists Already";
-                isGoogleAuthValid = false;
-                return {
-                    isGoogleAuthValid: isGoogleAuthValid,
-                    newFoundUser: newFoundUser,
-                    loginFailureReason: loginFailureReason,
-                };
-            }
-            ////////////////////////////////////////
-            foundUser = yield (0, DB_HANDLER_1.default)(`SELECT * FROM ${usertype} WHERE email='${payload.email}' AND social_login='1' AND social_platform='google'`);
-            if (foundUser && foundUser[0]) {
-                newFoundUser = foundUser;
-                return {
-                    isGoogleAuthValid: isGoogleAuthValid,
-                    newFoundUser: newFoundUser,
-                };
-            }
-            ////////////////////////////////////////////////
-            ////////////////////////////////////////////////
-            ////////////////////////////////////////////////
-            let newUser = yield (0, DB_HANDLER_1.default)(`INSERT INTO ${usertype} (
+        let existinEmail = await DB_HANDLER(`SELECT * FROM ${usertype} WHERE email='${payload.email}' AND social_login!='1' AND social_platform!='google'`);
+        if (existinEmail && existinEmail[0]) {
+            loginFailureReason = "Email Exists Already";
+            isGoogleAuthValid = false;
+            return {
+                isGoogleAuthValid: isGoogleAuthValid,
+                newFoundUser: newFoundUser,
+                loginFailureReason: loginFailureReason,
+            };
+        }
+        ////////////////////////////////////////
+        foundUser = await DB_HANDLER(`SELECT * FROM ${usertype} WHERE email='${payload.email}' AND social_login='1' AND social_platform='google'`);
+        if (foundUser && foundUser[0]) {
+            newFoundUser = foundUser;
+            return {
+                isGoogleAuthValid: isGoogleAuthValid,
+                newFoundUser: newFoundUser,
+            };
+        }
+        ////////////////////////////////////////////////
+        ////////////////////////////////////////////////
+        ////////////////////////////////////////////////
+        let newUser = await DB_HANDLER(`INSERT INTO ${usertype} (
             first_name,
             last_name,
             social_platform,
@@ -95,7 +79,7 @@ function googleLogin(_a) {
             '${payload.given_name}',
             '${payload.family_name}',
             'google',
-            'google_${(_b = payload.email) === null || _b === void 0 ? void 0 : _b.replace(/@.*/, "")}',
+            'google_${(_a = payload.email) === null || _a === void 0 ? void 0 : _a.replace(/@.*/, "")}',
             '${payload.sub}',
             '${payload.email}',
             '${payload.picture}',
@@ -107,18 +91,17 @@ function googleLogin(_a) {
             '${Date()}',
             '${Date.now()}'
         )`);
-            newFoundUser = yield (0, DB_HANDLER_1.default)(`SELECT * FROM ${usertype} WHERE id='${newUser.insertId}'`);
-        }
-        catch (error) {
-            (0, serverError_1.default)({
-                component: "googleLogin",
-                message: error.message,
-            });
-            (_c = global.ERROR_CALLBACK) === null || _c === void 0 ? void 0 : _c.call(global, `Google Login Error`, error);
-            loginFailureReason = error;
-            isUserValid = false;
-            isSocialValidated = false;
-        }
-        return { isGoogleAuthValid: isGoogleAuthValid, newFoundUser: newFoundUser };
-    });
+        newFoundUser = await DB_HANDLER(`SELECT * FROM ${usertype} WHERE id='${newUser.insertId}'`);
+    }
+    catch (error) {
+        serverError({
+            component: "googleLogin",
+            message: error.message,
+        });
+        (_b = global.ERROR_CALLBACK) === null || _b === void 0 ? void 0 : _b.call(global, `Google Login Error`, error);
+        loginFailureReason = error;
+        isUserValid = false;
+        isSocialValidated = false;
+    }
+    return { isGoogleAuthValid: isGoogleAuthValid, newFoundUser: newFoundUser };
 }

dist/package-shared/functions/api/social-login/handleSocialDb.js

@@ -1,217 +1,201 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = handleSocialDb;
-const fs_1 = __importDefault(require("fs"));
-const handleNodemailer_1 = __importDefault(require("../../backend/handleNodemailer"));
-const path_1 = __importDefault(require("path"));
-const addMariadbUser_1 = __importDefault(require("../../backend/addMariadbUser"));
-const varDatabaseDbHandler_1 = __importDefault(require("../../backend/varDatabaseDbHandler"));
-const encrypt_1 = __importDefault(require("../../dsql/encrypt"));
-const addDbEntry_1 = __importDefault(require("../../backend/db/addDbEntry"));
-const loginSocialUser_1 = __importDefault(require("./loginSocialUser"));
+import fs from "fs";
+import handleNodemailer from "../../backend/handleNodemailer";
+import path from "path";
+import addMariadbUser from "../../backend/addMariadbUser";
+import varDatabaseDbHandler from "../../backend/varDatabaseDbHandler";
+import encrypt from "../../dsql/encrypt";
+import addDbEntry from "../../backend/db/addDbEntry";
+import loginSocialUser from "./loginSocialUser";
+import grabDirNames from "../../../utils/backend/names/grab-dir-names";
 /**
  * # Handle Social DB
  */
-function handleSocialDb(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ database, email, social_platform, payload, invitation, supEmail, additionalFields, debug, loginOnly, }) {
-        var _b;
-        try {
-            const finalDbName = global.DSQL_USE_LOCAL
-                ? undefined
-                : database
-                    ? database
-                    : "datasquirel";
-            const dbAppend = global.DSQL_USE_LOCAL ? "" : `${finalDbName}.`;
-            const existingSocialUserQUery = `SELECT * FROM ${dbAppend}users WHERE email = ? AND social_login='1' AND social_platform = ? `;
-            const existingSocialUserValues = [email, social_platform];
-            if (debug) {
-                console.log("handleSocialDb:existingSocialUserQUery", existingSocialUserQUery);
-                console.log("handleSocialDb:existingSocialUserValues", existingSocialUserValues);
-            }
-            let existingSocialUser = yield (0, varDatabaseDbHandler_1.default)({
-                database: finalDbName,
-                queryString: existingSocialUserQUery,
-                queryValuesArray: existingSocialUserValues,
-                debug,
-            });
-            if (debug) {
-                console.log("handleSocialDb:existingSocialUser", existingSocialUser);
-            }
-            if (existingSocialUser === null || existingSocialUser === void 0 ? void 0 : existingSocialUser[0]) {
-                return yield (0, loginSocialUser_1.default)({
-                    user: existingSocialUser[0],
-                    social_platform,
-                    invitation,
-                    database: finalDbName,
-                    additionalFields,
-                    debug,
-                });
-            }
-            else if (loginOnly) {
-                return {
-                    success: false,
-                    payload: null,
-                    msg: "User Does not Exist",
-                };
-            }
-            const finalEmail = email ? email : supEmail ? supEmail : null;
-            if (!finalEmail) {
-                return {
-                    success: false,
-                    payload: null,
-                    msg: "No Email Present",
-                };
-            }
-            const existingEmailOnlyQuery = `SELECT * FROM ${dbAppend}users WHERE email='${finalEmail}'`;
-            if (debug) {
-                console.log("handleSocialDb:existingEmailOnlyQuery", existingEmailOnlyQuery);
-            }
-            let existingEmailOnly = yield (0, varDatabaseDbHandler_1.default)({
-                database: finalDbName,
-                queryString: existingEmailOnlyQuery,
-                debug,
-            });
-            if (debug) {
-                console.log("handleSocialDb:existingEmailOnly", existingEmailOnly);
-            }
-            if (existingEmailOnly === null || existingEmailOnly === void 0 ? void 0 : existingEmailOnly[0]) {
-                return yield (0, loginSocialUser_1.default)({
-                    user: existingEmailOnly[0],
-                    social_platform,
-                    invitation,
-                    database: finalDbName,
-                    additionalFields,
-                    debug,
-                });
-            }
-            else if (loginOnly) {
-                return {
-                    success: false,
-                    payload: null,
-                    msg: "Social Account Creation Not allowed",
-                };
-            }
-            const socialHashedPassword = (0, encrypt_1.default)({
-                data: email,
-            });
-            const data = {
-                social_login: "1",
-                verification_status: supEmail ? "0" : "1",
-                password: socialHashedPassword,
-            };
-            Object.keys(payload).forEach((key) => {
-                data[key] = payload[key];
-            });
-            const newUser = yield (0, addDbEntry_1.default)({
-                dbContext: finalDbName ? "Dsql User" : undefined,
-                paradigm: finalDbName ? "Full Access" : undefined,
-                dbFullName: finalDbName,
-                tableName: "users",
-                duplicateColumnName: "email",
-                duplicateColumnValue: finalEmail,
-                data: Object.assign(Object.assign({}, data), { email: finalEmail }),
-            });
-            if (newUser === null || newUser === void 0 ? void 0 : newUser.insertId) {
-                if (!database) {
-                    /**
-                     * Add a Mariadb User for this User
-                     */
-                    yield (0, addMariadbUser_1.default)({ userId: newUser.insertId });
-                }
-                const newUserQueriedQuery = `SELECT * FROM ${dbAppend}users WHERE id='${newUser.insertId}'`;
-                const newUserQueried = yield (0, varDatabaseDbHandler_1.default)({
-                    database: finalDbName,
-                    queryString: newUserQueriedQuery,
-                    debug,
-                });
-                if (!newUserQueried || !newUserQueried[0])
-                    return {
-                        success: false,
-                        payload: null,
-                        msg: "User Insertion Failed!",
-                    };
-                if (supEmail && (database === null || database === void 0 ? void 0 : database.match(/^datasquirel$/))) {
-                    /**
-                     * Send email Verification
-                     *
-                     * @description Send verification email to newly created agent
-                     */
-                    let generatedToken = (0, encrypt_1.default)({
-                        data: JSON.stringify({
-                            id: newUser.insertId,
-                            email: supEmail,
-                            dateCode: Date.now(),
-                        }),
-                    });
-                    (0, handleNodemailer_1.default)({
-                        to: supEmail,
-                        subject: "Verify Email Address",
-                        text: "Please click the link to verify your email address",
-                        html: fs_1.default
-                            .readFileSync("./email/send-email-verification-link.html", "utf8")
-                            .replace(/{{host}}/, process.env.DSQL_HOST || "")
-                            .replace(/{{token}}/, generatedToken || ""),
-                    }).then(() => { });
-                }
-                const STATIC_ROOT = process.env.DSQL_STATIC_SERVER_DIR;
-                if (!STATIC_ROOT) {
-                    console.log("Static File ENV not Found!");
-                    return {
-                        success: false,
-                        payload: null,
-                        msg: "Static File ENV not Found!",
-                    };
-                }
-                /**
-                 * Create new user folder and file
-                 *
-                 * @description Create new user folder and file
-                 */
-                if (!database || (database === null || database === void 0 ? void 0 : database.match(/^datasquirel$/))) {
-                    let newUserSchemaFolderPath = `${process.env.DSQL_USER_DB_SCHEMA_PATH}/user-${newUser.insertId}`;
-                    let newUserMediaFolderPath = path_1.default.join(STATIC_ROOT, `images/user-images/user-${newUser.insertId}`);
-                    fs_1.default.mkdirSync(newUserSchemaFolderPath);
-                    fs_1.default.mkdirSync(newUserMediaFolderPath);
-                    fs_1.default.writeFileSync(`${newUserSchemaFolderPath}/main.json`, JSON.stringify([]), "utf8");
-                }
-                return yield (0, loginSocialUser_1.default)({
-                    user: newUserQueried[0],
-                    social_platform,
-                    invitation,
-                    database: finalDbName,
-                    additionalFields,
-                    debug,
-                });
-            }
-            else {
-                console.log("Social User Failed to insert in 'handleSocialDb.ts' backend function =>", newUser);
-                return {
-                    success: false,
-                    payload: null,
-                    msg: "Social User Failed to insert in 'handleSocialDb.ts' backend function",
-                };
-            }
+export default async function handleSocialDb({ database, email, social_platform, payload, invitation, supEmail, additionalFields, debug, loginOnly, }) {
+    var _a, _b;
+    try {
+        const finalDbName = global.DSQL_USE_LOCAL
+            ? undefined
+            : database
+                ? database
+                : "datasquirel";
+        const dbAppend = global.DSQL_USE_LOCAL ? "" : `${finalDbName}.`;
+        const existingSocialUserQUery = `SELECT * FROM ${dbAppend}users WHERE email = ? AND social_login='1' AND social_platform = ? `;
+        const existingSocialUserValues = [email, social_platform];
+        if (debug) {
+            console.log("handleSocialDb:existingSocialUserQUery", existingSocialUserQUery);
+            console.log("handleSocialDb:existingSocialUserValues", existingSocialUserValues);
         }
-        catch (error) {
-            console.log("ERROR in 'handleSocialDb.ts' backend function =>", error.message);
-            (_b = global.ERROR_CALLBACK) === null || _b === void 0 ? void 0 : _b.call(global, `Handle Social DB Error`, error);
+        let existingSocialUser = await varDatabaseDbHandler({
+            database: finalDbName,
+            queryString: existingSocialUserQUery,
+            queryValuesArray: existingSocialUserValues,
+            debug,
+        });
+        if (debug) {
+            console.log("handleSocialDb:existingSocialUser", existingSocialUser);
+        }
+        if (existingSocialUser === null || existingSocialUser === void 0 ? void 0 : existingSocialUser[0]) {
+            return await loginSocialUser({
+                user: existingSocialUser[0],
+                social_platform,
+                invitation,
+                database: finalDbName,
+                additionalFields,
+                debug,
+            });
+        }
+        else if (loginOnly) {
             return {
                 success: false,
                 payload: null,
-                msg: error.message,
+                msg: "User Does not Exist",
             };
         }
-    });
+        const finalEmail = email ? email : supEmail ? supEmail : null;
+        if (!finalEmail) {
+            return {
+                success: false,
+                payload: null,
+                msg: "No Email Present",
+            };
+        }
+        const existingEmailOnlyQuery = `SELECT * FROM ${dbAppend}users WHERE email='${finalEmail}'`;
+        if (debug) {
+            console.log("handleSocialDb:existingEmailOnlyQuery", existingEmailOnlyQuery);
+        }
+        let existingEmailOnly = await varDatabaseDbHandler({
+            database: finalDbName,
+            queryString: existingEmailOnlyQuery,
+            debug,
+        });
+        if (debug) {
+            console.log("handleSocialDb:existingEmailOnly", existingEmailOnly);
+        }
+        if (existingEmailOnly === null || existingEmailOnly === void 0 ? void 0 : existingEmailOnly[0]) {
+            return await loginSocialUser({
+                user: existingEmailOnly[0],
+                social_platform,
+                invitation,
+                database: finalDbName,
+                additionalFields,
+                debug,
+            });
+        }
+        else if (loginOnly) {
+            return {
+                success: false,
+                payload: null,
+                msg: "Social Account Creation Not allowed",
+            };
+        }
+        const socialHashedPassword = encrypt({
+            data: email,
+        });
+        const data = {
+            social_login: "1",
+            verification_status: supEmail ? "0" : "1",
+            password: socialHashedPassword,
+        };
+        Object.keys(payload).forEach((key) => {
+            data[key] = payload[key];
+        });
+        const newUser = await addDbEntry({
+            dbContext: finalDbName ? "Dsql User" : undefined,
+            paradigm: finalDbName ? "Full Access" : undefined,
+            dbFullName: finalDbName,
+            tableName: "users",
+            duplicateColumnName: "email",
+            duplicateColumnValue: finalEmail,
+            data: Object.assign(Object.assign({}, data), { email: finalEmail }),
+        });
+        if ((_a = newUser === null || newUser === void 0 ? void 0 : newUser.payload) === null || _a === void 0 ? void 0 : _a.insertId) {
+            if (!database) {
+                /**
+                 * Add a Mariadb User for this User
+                 */
+                await addMariadbUser({ userId: newUser.payload.insertId });
+            }
+            const newUserQueriedQuery = `SELECT * FROM ${dbAppend}users WHERE id='${newUser.payload.insertId}'`;
+            const newUserQueried = await varDatabaseDbHandler({
+                database: finalDbName,
+                queryString: newUserQueriedQuery,
+                debug,
+            });
+            if (!newUserQueried || !newUserQueried[0])
+                return {
+                    success: false,
+                    payload: null,
+                    msg: "User Insertion Failed!",
+                };
+            if (supEmail && (database === null || database === void 0 ? void 0 : database.match(/^datasquirel$/))) {
+                /**
+                 * Send email Verification
+                 *
+                 * @description Send verification email to newly created agent
+                 */
+                let generatedToken = encrypt({
+                    data: JSON.stringify({
+                        id: newUser.payload.insertId,
+                        email: supEmail,
+                        dateCode: Date.now(),
+                    }),
+                });
+                handleNodemailer({
+                    to: supEmail,
+                    subject: "Verify Email Address",
+                    text: "Please click the link to verify your email address",
+                    html: fs
+                        .readFileSync("./email/send-email-verification-link.html", "utf8")
+                        .replace(/{{host}}/, process.env.DSQL_HOST || "")
+                        .replace(/{{token}}/, generatedToken || ""),
+                }).then(() => { });
+            }
+            const { STATIC_ROOT } = grabDirNames();
+            if (!STATIC_ROOT) {
+                console.log("Static File ENV not Found!");
+                return {
+                    success: false,
+                    payload: null,
+                    msg: "Static File ENV not Found!",
+                };
+            }
+            /**
+             * Create new user folder and file
+             *
+             * @description Create new user folder and file
+             */
+            if (!database || (database === null || database === void 0 ? void 0 : database.match(/^datasquirel$/))) {
+                let newUserSchemaFolderPath = `${process.env.DSQL_USER_DB_SCHEMA_PATH}/user-${newUser.payload.insertId}`;
+                let newUserMediaFolderPath = path.join(STATIC_ROOT, `images/user-images/user-${newUser.payload.insertId}`);
+                fs.mkdirSync(newUserSchemaFolderPath);
+                fs.mkdirSync(newUserMediaFolderPath);
+                fs.writeFileSync(`${newUserSchemaFolderPath}/main.json`, JSON.stringify([]), "utf8");
+            }
+            return await loginSocialUser({
+                user: newUserQueried[0],
+                social_platform,
+                invitation,
+                database: finalDbName,
+                additionalFields,
+                debug,
+            });
+        }
+        else {
+            console.log("Social User Failed to insert in 'handleSocialDb.ts' backend function =>", newUser);
+            return {
+                success: false,
+                payload: null,
+                msg: "Social User Failed to insert in 'handleSocialDb.ts' backend function",
+            };
+        }
+    }
+    catch (error) {
+        console.log("ERROR in 'handleSocialDb.ts' backend function =>", error.message);
+        (_b = global.ERROR_CALLBACK) === null || _b === void 0 ? void 0 : _b.call(global, `Handle Social DB Error`, error);
+        return {
+            success: false,
+            payload: null,
+            msg: error.message,
+        };
+    }
 }

dist/package-shared/functions/api/social-login/loginSocialUser.js

@@ -1,81 +1,64 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = loginSocialUser;
-const addAdminUserOnLogin_1 = __importDefault(require("../../backend/addAdminUserOnLogin"));
-const varDatabaseDbHandler_1 = __importDefault(require("../../backend/varDatabaseDbHandler"));
+import addAdminUserOnLogin from "../../backend/addAdminUserOnLogin";
+import varDatabaseDbHandler from "../../backend/varDatabaseDbHandler";
 /**
  * Function to login social user
  * ==============================================================================
  * @description This function logs in the user after 'handleSocialDb' function finishes
  * the user creation or confirmation process
  */
-function loginSocialUser(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ user, social_platform, invitation, database, additionalFields, debug, }) {
-        const finalDbName = database ? database : "datasquirel";
-        const dbAppend = database ? `\`${finalDbName}\`.` : "";
-        const foundUserQuery = `SELECT * FROM ${dbAppend}\`users\` WHERE email=?`;
-        const foundUserValues = [user.email];
-        const foundUser = yield (0, varDatabaseDbHandler_1.default)({
-            database: finalDbName,
-            queryString: foundUserQuery,
-            queryValuesArray: foundUserValues,
-            debug,
-        });
-        if (!(foundUser === null || foundUser === void 0 ? void 0 : foundUser[0]))
-            return {
-                success: false,
-                payload: null,
-                msg: "Couldn't find Social User.",
-            };
-        let csrfKey = Math.random().toString(36).substring(2) +
-            "-" +
-            Math.random().toString(36).substring(2);
-        let userPayload = {
-            id: foundUser[0].id,
-            uuid: foundUser[0].uuid,
-            first_name: foundUser[0].first_name,
-            last_name: foundUser[0].last_name,
-            username: foundUser[0].username,
-            user_type: foundUser[0].user_type,
-            email: foundUser[0].email,
-            social_id: foundUser[0].social_id,
-            image: foundUser[0].image,
-            image_thumbnail: foundUser[0].image_thumbnail,
-            verification_status: foundUser[0].verification_status,
-            social_login: foundUser[0].social_login,
-            social_platform: foundUser[0].social_platform,
-            csrf_k: csrfKey,
-            logged_in_status: true,
-            date: Date.now(),
-        };
-        if (additionalFields === null || additionalFields === void 0 ? void 0 : additionalFields[0]) {
-            additionalFields.forEach((key) => {
-                userPayload[key] = foundUser[0][key];
-            });
-        }
-        if (invitation && (!database || (database === null || database === void 0 ? void 0 : database.match(/^datasquirel$/)))) {
-            (0, addAdminUserOnLogin_1.default)({
-                query: invitation,
-                user: userPayload,
-            });
-        }
-        let result = {
-            success: true,
-            payload: userPayload,
-            csrf: csrfKey,
-        };
-        return result;
+export default async function loginSocialUser({ user, social_platform, invitation, database, additionalFields, debug, }) {
+    const finalDbName = database ? database : "datasquirel";
+    const dbAppend = database ? `\`${finalDbName}\`.` : "";
+    const foundUserQuery = `SELECT * FROM ${dbAppend}\`users\` WHERE email=?`;
+    const foundUserValues = [user.email];
+    const foundUser = await varDatabaseDbHandler({
+        database: finalDbName,
+        queryString: foundUserQuery,
+        queryValuesArray: foundUserValues,
+        debug,
     });
+    if (!(foundUser === null || foundUser === void 0 ? void 0 : foundUser[0]))
+        return {
+            success: false,
+            payload: null,
+            msg: "Couldn't find Social User.",
+        };
+    let csrfKey = Math.random().toString(36).substring(2) +
+        "-" +
+        Math.random().toString(36).substring(2);
+    let userPayload = {
+        id: foundUser[0].id,
+        uuid: foundUser[0].uuid,
+        first_name: foundUser[0].first_name,
+        last_name: foundUser[0].last_name,
+        username: foundUser[0].username,
+        user_type: foundUser[0].user_type,
+        email: foundUser[0].email,
+        social_id: foundUser[0].social_id,
+        image: foundUser[0].image,
+        image_thumbnail: foundUser[0].image_thumbnail,
+        verification_status: foundUser[0].verification_status,
+        social_login: foundUser[0].social_login,
+        social_platform: foundUser[0].social_platform,
+        csrf_k: csrfKey,
+        logged_in_status: true,
+        date: Date.now(),
+    };
+    if (additionalFields === null || additionalFields === void 0 ? void 0 : additionalFields[0]) {
+        additionalFields.forEach((key) => {
+            userPayload[key] = foundUser[0][key];
+        });
+    }
+    if (invitation && (!database || (database === null || database === void 0 ? void 0 : database.match(/^datasquirel$/)))) {
+        addAdminUserOnLogin({
+            query: invitation,
+            user: userPayload,
+        });
+    }
+    let result = {
+        success: true,
+        payload: userPayload,
+        csrf: csrfKey,
+    };
+    return result;
 }

dist/package-shared/functions/api/users/api-create-user.d.ts

@@ -20,6 +20,6 @@ export default function apiCreateUser({ encryptionKey, payload, database, userId
 } | {
     success: boolean;
     msg: string;
-    sqlResult: import("../../../types").PostInsertReturn | null;
+    sqlResult: import("../../../types").APIResponseObject<import("../../../types").PostInsertReturn>;
     payload: null;
 }>;

dist/package-shared/functions/api/users/api-create-user.js

@@ -1,143 +1,140 @@
-"use strict";
-// @ts-check
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = apiCreateUser;
-const addUsersTableToDb_1 = __importDefault(require("../../backend/addUsersTableToDb"));
-const addDbEntry_1 = __importDefault(require("../../backend/db/addDbEntry"));
-const updateUsersTableSchema_1 = __importDefault(require("../../backend/updateUsersTableSchema"));
-const varDatabaseDbHandler_1 = __importDefault(require("../../backend/varDatabaseDbHandler"));
-const hashPassword_1 = __importDefault(require("../../dsql/hashPassword"));
-const validate_email_1 = __importDefault(require("../../email/fns/validate-email"));
+import { findDbNameInSchemaDir } from "../../../shell/createDbFromSchema/grab-required-database-schemas";
+import addUsersTableToDb from "../../backend/addUsersTableToDb";
+import addDbEntry from "../../backend/db/addDbEntry";
+import updateUsersTableSchema from "../../backend/updateUsersTableSchema";
+import varDatabaseDbHandler from "../../backend/varDatabaseDbHandler";
+import hashPassword from "../../dsql/hashPassword";
+import validateEmail from "../../email/fns/validate-email";
 /**
  * # API Create User
  */
-function apiCreateUser(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ encryptionKey, payload, database, userId, }) {
-        const dbFullName = database;
-        const API_USER_ID = userId || process.env.DSQL_API_USER_ID;
-        const finalEncryptionKey = encryptionKey || process.env.DSQL_ENCRYPTION_PASSWORD;
-        if (!finalEncryptionKey) {
-            return {
-                success: false,
-                msg: "No encryption key provided",
-                payload: null,
-            };
-        }
-        if (!(finalEncryptionKey === null || finalEncryptionKey === void 0 ? void 0 : finalEncryptionKey.match(/.{8,}/))) {
-            return {
-                success: false,
-                msg: "Encryption key must be at least 8 characters long",
-                payload: null,
-            };
-        }
-        const hashedPassword = (0, hashPassword_1.default)({
-            encryptionKey: finalEncryptionKey,
-            password: String(payload.password),
+export default async function apiCreateUser({ encryptionKey, payload, database, userId, }) {
+    var _a;
+    const dbFullName = database;
+    const API_USER_ID = userId || process.env.DSQL_API_USER_ID;
+    const finalEncryptionKey = encryptionKey || process.env.DSQL_ENCRYPTION_PASSWORD;
+    if (!finalEncryptionKey) {
+        return {
+            success: false,
+            msg: "No encryption key provided",
+            payload: null,
+        };
+    }
+    if (!(finalEncryptionKey === null || finalEncryptionKey === void 0 ? void 0 : finalEncryptionKey.match(/.{8,}/))) {
+        return {
+            success: false,
+            msg: "Encryption key must be at least 8 characters long",
+            payload: null,
+        };
+    }
+    const targetDbSchema = findDbNameInSchemaDir({
+        dbName: dbFullName,
+        userId,
+    });
+    if (!(targetDbSchema === null || targetDbSchema === void 0 ? void 0 : targetDbSchema.id)) {
+        return {
+            success: false,
+            msg: "targetDbSchema not found",
+            payload: null,
+        };
+    }
+    const hashedPassword = hashPassword({
+        encryptionKey: finalEncryptionKey,
+        password: String(payload.password),
+    });
+    payload.password = hashedPassword;
+    const fieldsQuery = `SHOW COLUMNS FROM ${dbFullName}.users`;
+    let fields = await varDatabaseDbHandler({
+        queryString: fieldsQuery,
+        database: dbFullName,
+    });
+    if (!(fields === null || fields === void 0 ? void 0 : fields[0])) {
+        const newTable = await addUsersTableToDb({
+            userId: Number(API_USER_ID),
+            database: dbFullName,
+            payload: payload,
+            dbId: targetDbSchema.id,
         });
-        payload.password = hashedPassword;
-        const fieldsQuery = `SHOW COLUMNS FROM ${dbFullName}.users`;
-        let fields = yield (0, varDatabaseDbHandler_1.default)({
+        fields = await varDatabaseDbHandler({
             queryString: fieldsQuery,
             database: dbFullName,
         });
-        if (!(fields === null || fields === void 0 ? void 0 : fields[0])) {
-            const newTable = yield (0, addUsersTableToDb_1.default)({
+    }
+    if (!(fields === null || fields === void 0 ? void 0 : fields[0])) {
+        return {
+            success: false,
+            msg: "Could not create users table",
+        };
+    }
+    const fieldsTitles = fields.map((fieldObject) => fieldObject.Field);
+    let invalidField = null;
+    for (let i = 0; i < Object.keys(payload).length; i++) {
+        const key = Object.keys(payload)[i];
+        if (!fieldsTitles.includes(key)) {
+            await updateUsersTableSchema({
                 userId: Number(API_USER_ID),
                 database: dbFullName,
-                payload: payload,
-            });
-            fields = yield (0, varDatabaseDbHandler_1.default)({
-                queryString: fieldsQuery,
-                database: dbFullName,
+                newPayload: {
+                    [key]: payload[key],
+                },
+                dbId: targetDbSchema.id,
             });
         }
-        if (!(fields === null || fields === void 0 ? void 0 : fields[0])) {
-            return {
-                success: false,
-                msg: "Could not create users table",
-            };
-        }
-        const fieldsTitles = fields.map((fieldObject) => fieldObject.Field);
-        let invalidField = null;
-        for (let i = 0; i < Object.keys(payload).length; i++) {
-            const key = Object.keys(payload)[i];
-            if (!fieldsTitles.includes(key)) {
-                yield (0, updateUsersTableSchema_1.default)({
-                    userId: Number(API_USER_ID),
-                    database: dbFullName,
-                    newPayload: {
-                        [key]: payload[key],
-                    },
-                });
-            }
-        }
-        if (invalidField) {
-            return {
-                success: false,
-                msg: `${invalidField} is not a valid field!`,
-            };
-        }
-        const existingUserQuery = `SELECT * FROM ${dbFullName}.users WHERE email = ?${payload.username ? " OR username = ?" : ""}`;
-        const existingUserValues = payload.username
-            ? [payload.email, payload.username]
-            : [payload.email];
-        const existingUser = yield (0, varDatabaseDbHandler_1.default)({
-            queryString: existingUserQuery,
-            queryValuesArray: existingUserValues,
+    }
+    if (invalidField) {
+        return {
+            success: false,
+            msg: `${invalidField} is not a valid field!`,
+        };
+    }
+    const existingUserQuery = `SELECT * FROM ${dbFullName}.users WHERE email = ?${payload.username ? " OR username = ?" : ""}`;
+    const existingUserValues = payload.username
+        ? [payload.email, payload.username]
+        : [payload.email];
+    const existingUser = await varDatabaseDbHandler({
+        queryString: existingUserQuery,
+        queryValuesArray: existingUserValues,
+        database: dbFullName,
+    });
+    if (existingUser === null || existingUser === void 0 ? void 0 : existingUser[0]) {
+        return {
+            success: false,
+            msg: "User Already Exists",
+            payload: null,
+        };
+    }
+    const isEmailValid = await validateEmail({ email: payload.email });
+    if (!isEmailValid.isValid) {
+        return {
+            success: false,
+            msg: isEmailValid.message,
+            payload: null,
+        };
+    }
+    const addUser = await addDbEntry({
+        dbFullName: dbFullName,
+        tableName: "users",
+        data: Object.assign(Object.assign({}, payload), { image: process.env.DSQL_DEFAULT_USER_IMAGE ||
+                "/images/user-preset.png", image_thumbnail: process.env.DSQL_DEFAULT_USER_IMAGE ||
+                "/images/user-preset-thumbnail.png" }),
+    });
+    if ((_a = addUser === null || addUser === void 0 ? void 0 : addUser.payload) === null || _a === void 0 ? void 0 : _a.insertId) {
+        const newlyAddedUserQuery = `SELECT id,uuid,first_name,last_name,email,username,image,image_thumbnail,verification_status FROM ${dbFullName}.users WHERE id='${addUser.payload.insertId}'`;
+        const newlyAddedUser = await varDatabaseDbHandler({
+            queryString: newlyAddedUserQuery,
             database: dbFullName,
         });
-        if (existingUser === null || existingUser === void 0 ? void 0 : existingUser[0]) {
-            return {
-                success: false,
-                msg: "User Already Exists",
-                payload: null,
-            };
-        }
-        const isEmailValid = yield (0, validate_email_1.default)({ email: payload.email });
-        if (!isEmailValid.isValid) {
-            return {
-                success: false,
-                msg: isEmailValid.message,
-                payload: null,
-            };
-        }
-        const addUser = yield (0, addDbEntry_1.default)({
-            dbFullName: dbFullName,
-            tableName: "users",
-            data: Object.assign(Object.assign({}, payload), { image: process.env.DSQL_DEFAULT_USER_IMAGE ||
-                    "/images/user-preset.png", image_thumbnail: process.env.DSQL_DEFAULT_USER_IMAGE ||
-                    "/images/user-preset-thumbnail.png" }),
-        });
-        if (addUser === null || addUser === void 0 ? void 0 : addUser.insertId) {
-            const newlyAddedUserQuery = `SELECT id,uuid,first_name,last_name,email,username,image,image_thumbnail,verification_status FROM ${dbFullName}.users WHERE id='${addUser.insertId}'`;
-            const newlyAddedUser = yield (0, varDatabaseDbHandler_1.default)({
-                queryString: newlyAddedUserQuery,
-                database: dbFullName,
-            });
-            return {
-                success: true,
-                payload: newlyAddedUser[0],
-            };
-        }
-        else {
-            return {
-                success: false,
-                msg: "Could not create user",
-                sqlResult: addUser,
-                payload: null,
-            };
-        }
-    });
+        return {
+            success: true,
+            payload: newlyAddedUser[0],
+        };
+    }
+    else {
+        return {
+            success: false,
+            msg: "Could not create user",
+            sqlResult: addUser,
+            payload: null,
+        };
+    }
 }

dist/package-shared/functions/api/users/api-delete-user.js

@@ -1,48 +1,31 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = apiDeleteUser;
-const deleteDbEntry_1 = __importDefault(require("../../backend/db/deleteDbEntry"));
-const varDatabaseDbHandler_1 = __importDefault(require("../../backend/varDatabaseDbHandler"));
+import deleteDbEntry from "../../backend/db/deleteDbEntry";
+import varDatabaseDbHandler from "../../backend/varDatabaseDbHandler";
 /**
  * # Update API User Function
  */
-function apiDeleteUser(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ dbFullName, deletedUserId, }) {
-        const existingUserQuery = `SELECT * FROM ${dbFullName}.users WHERE id = ?`;
-        const existingUserValues = [deletedUserId];
-        const existingUser = yield (0, varDatabaseDbHandler_1.default)({
-            queryString: existingUserQuery,
-            queryValuesArray: existingUserValues,
-            database: dbFullName,
-        });
-        if (!(existingUser === null || existingUser === void 0 ? void 0 : existingUser[0])) {
-            return {
-                success: false,
-                msg: "User not found",
-            };
-        }
-        const deleteUser = yield (0, deleteDbEntry_1.default)({
-            dbContext: "Dsql User",
-            dbFullName,
-            tableName: "users",
-            identifierColumnName: "id",
-            identifierValue: deletedUserId,
-        });
-        return {
-            success: true,
-            result: deleteUser,
-        };
+export default async function apiDeleteUser({ dbFullName, deletedUserId, }) {
+    const existingUserQuery = `SELECT * FROM ${dbFullName}.users WHERE id = ?`;
+    const existingUserValues = [deletedUserId];
+    const existingUser = await varDatabaseDbHandler({
+        queryString: existingUserQuery,
+        queryValuesArray: existingUserValues,
+        database: dbFullName,
     });
+    if (!(existingUser === null || existingUser === void 0 ? void 0 : existingUser[0])) {
+        return {
+            success: false,
+            msg: "User not found",
+        };
+    }
+    const deleteUser = await deleteDbEntry({
+        dbContext: "Dsql User",
+        dbFullName,
+        tableName: "users",
+        identifierColumnName: "id",
+        identifierValue: deletedUserId,
+    });
+    return {
+        success: true,
+        result: deleteUser,
+    };
 }

dist/package-shared/functions/api/users/api-get-user.js

@@ -1,41 +1,24 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = apiGetUser;
-const varDatabaseDbHandler_1 = __importDefault(require("../../backend/varDatabaseDbHandler"));
+import varDatabaseDbHandler from "../../backend/varDatabaseDbHandler";
 /**
  * # API Get User
  */
-function apiGetUser(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ fields, dbFullName, userId, }) {
-        const finalDbName = dbFullName.replace(/[^a-z0-9_]/g, "");
-        const query = `SELECT ${fields.join(",")} FROM ${finalDbName}.users WHERE id=?`;
-        const API_USER_ID = userId || process.env.DSQL_API_USER_ID;
-        let foundUser = yield (0, varDatabaseDbHandler_1.default)({
-            queryString: query,
-            queryValuesArray: [API_USER_ID],
-            database: finalDbName,
-        });
-        if (!foundUser || !foundUser[0]) {
-            return {
-                success: false,
-                payload: null,
-            };
-        }
-        return {
-            success: true,
-            payload: foundUser[0],
-        };
+export default async function apiGetUser({ fields, dbFullName, userId, }) {
+    const finalDbName = dbFullName.replace(/[^a-z0-9_]/g, "");
+    const query = `SELECT ${fields.join(",")} FROM ${finalDbName}.users WHERE id=?`;
+    const API_USER_ID = userId || process.env.DSQL_API_USER_ID;
+    let foundUser = await varDatabaseDbHandler({
+        queryString: query,
+        queryValuesArray: [API_USER_ID],
+        database: finalDbName,
     });
+    if (!foundUser || !foundUser[0]) {
+        return {
+            success: false,
+            payload: null,
+        };
+    }
+    return {
+        success: true,
+        payload: foundUser[0],
+    };
 }

dist/package-shared/functions/api/users/api-login.js

@@ -1,162 +1,154 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = apiLoginUser;
-const grab_db_full_name_1 = __importDefault(require("../../../utils/grab-db-full-name"));
-const varDatabaseDbHandler_1 = __importDefault(require("../../backend/varDatabaseDbHandler"));
-const hashPassword_1 = __importDefault(require("../../dsql/hashPassword"));
+import grabDbFullName from "../../../utils/grab-db-full-name";
+import varDatabaseDbHandler from "../../backend/varDatabaseDbHandler";
+import hashPassword from "../../dsql/hashPassword";
 /**
  * # API Login
  */
-function apiLoginUser(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ encryptionKey, email, username, password, database, additionalFields, email_login, email_login_code, email_login_field, skipPassword, social, dbUserId, debug, }) {
-        const dbFullName = (0, grab_db_full_name_1.default)({ dbName: database, userId: dbUserId });
-        const dbAppend = global.DSQL_USE_LOCAL ? "" : `${dbFullName}.`;
-        /**
-         * Check input validity
-         *
-         * @description Check input validity
-         */
-        if ((email === null || email === void 0 ? void 0 : email.match(/ /)) ||
-            (username && (username === null || username === void 0 ? void 0 : username.match(/ /))) ||
-            (password && (password === null || password === void 0 ? void 0 : password.match(/ /)))) {
-            return {
-                success: false,
-                msg: "Invalid Email/Password format",
-            };
-        }
-        /**
-         * Password hash
-         *
-         * @description Password hash
-         */
-        let hashedPassword = password
-            ? (0, hashPassword_1.default)({
-                encryptionKey: encryptionKey,
-                password: password,
-            })
-            : null;
+export default async function apiLoginUser({ encryptionKey, email, username, password, database, additionalFields, email_login, email_login_code, email_login_field, skipPassword, social, dbUserId, debug, }) {
+    const dbFullName = grabDbFullName({ dbName: database, userId: dbUserId });
+    if (!dbFullName) {
+        console.log(`Database Full Name couldn't be grabbed`);
+        return {
+            success: false,
+            msg: `Database Full Name couldn't be grabbed`,
+        };
+    }
+    const dbAppend = global.DSQL_USE_LOCAL ? "" : `${dbFullName}.`;
+    /**
+     * Check input validity
+     *
+     * @description Check input validity
+     */
+    if ((email === null || email === void 0 ? void 0 : email.match(/ /)) ||
+        (username && (username === null || username === void 0 ? void 0 : username.match(/ /))) ||
+        (password && (password === null || password === void 0 ? void 0 : password.match(/ /)))) {
+        return {
+            success: false,
+            msg: "Invalid Email/Password format",
+        };
+    }
+    /**
+     * Password hash
+     *
+     * @description Password hash
+     */
+    let hashedPassword = password
+        ? hashPassword({
+            encryptionKey: encryptionKey,
+            password: password,
+        })
+        : null;
+    if (debug) {
+        console.log("apiLoginUser:database:", dbFullName);
+        console.log("apiLoginUser:Finding User ...");
+    }
+    let foundUser = await varDatabaseDbHandler({
+        queryString: `SELECT * FROM ${dbAppend}users WHERE email = ? OR username = ?`,
+        queryValuesArray: [email, username],
+        database: dbFullName,
+        debug,
+    });
+    if (debug) {
+        console.log("apiLoginUser:foundUser:", foundUser);
+    }
+    if ((!foundUser || !foundUser[0]) && !social)
+        return {
+            success: false,
+            payload: null,
+            msg: "No user found",
+        };
+    let isPasswordCorrect = false;
+    if (debug) {
+        console.log("apiLoginUser:isPasswordCorrect:", isPasswordCorrect);
+    }
+    if ((foundUser === null || foundUser === void 0 ? void 0 : foundUser[0]) && !email_login && skipPassword) {
+        isPasswordCorrect = true;
+    }
+    else if ((foundUser === null || foundUser === void 0 ? void 0 : foundUser[0]) && !email_login) {
         if (debug) {
-            console.log("apiLoginUser:database:", dbFullName);
-            console.log("apiLoginUser:Finding User ...");
+            console.log("apiLoginUser:hashedPassword:", hashedPassword);
+            console.log("apiLoginUser:foundUser[0].password:", foundUser[0].password);
         }
-        let foundUser = yield (0, varDatabaseDbHandler_1.default)({
-            queryString: `SELECT * FROM ${dbAppend}users WHERE email = ? OR username = ?`,
+        isPasswordCorrect = hashedPassword === foundUser[0].password;
+    }
+    else if (foundUser &&
+        foundUser[0] &&
+        email_login &&
+        email_login_code &&
+        email_login_field) {
+        const tempCode = foundUser[0][email_login_field];
+        if (debug) {
+            console.log("apiLoginUser:tempCode:", tempCode);
+        }
+        if (!tempCode)
+            throw new Error("No code Found!");
+        const tempCodeArray = tempCode.split("-");
+        const [code, codeDate] = tempCodeArray;
+        const millisecond15mins = 1000 * 60 * 15;
+        if (Date.now() - Number(codeDate) > millisecond15mins) {
+            throw new Error("Code Expired");
+        }
+        isPasswordCorrect = code === email_login_code;
+    }
+    let socialUserValid = false;
+    if (!isPasswordCorrect && !socialUserValid) {
+        return {
+            success: false,
+            msg: "Wrong password, no social login validity",
+            payload: null,
+        };
+    }
+    if (debug) {
+        console.log("apiLoginUser:isPasswordCorrect:", isPasswordCorrect);
+        console.log("apiLoginUser:email_login:", email_login);
+    }
+    if (isPasswordCorrect && email_login) {
+        const resetTempCode = await varDatabaseDbHandler({
+            queryString: `UPDATE ${dbAppend}users SET ${email_login_field} = '' WHERE email = ? OR username = ?`,
             queryValuesArray: [email, username],
             database: dbFullName,
-            debug,
         });
-        if (debug) {
-            console.log("apiLoginUser:foundUser:", foundUser);
-        }
-        if ((!foundUser || !foundUser[0]) && !social)
-            return {
-                success: false,
-                payload: null,
-                msg: "No user found",
-            };
-        let isPasswordCorrect = false;
-        if (debug) {
-            console.log("apiLoginUser:isPasswordCorrect:", isPasswordCorrect);
-        }
-        if ((foundUser === null || foundUser === void 0 ? void 0 : foundUser[0]) && !email_login && skipPassword) {
-            isPasswordCorrect = true;
-        }
-        else if ((foundUser === null || foundUser === void 0 ? void 0 : foundUser[0]) && !email_login) {
-            if (debug) {
-                console.log("apiLoginUser:hashedPassword:", hashedPassword);
-                console.log("apiLoginUser:foundUser[0].password:", foundUser[0].password);
-            }
-            isPasswordCorrect = hashedPassword === foundUser[0].password;
-        }
-        else if (foundUser &&
-            foundUser[0] &&
-            email_login &&
-            email_login_code &&
-            email_login_field) {
-            const tempCode = foundUser[0][email_login_field];
-            if (debug) {
-                console.log("apiLoginUser:tempCode:", tempCode);
-            }
-            if (!tempCode)
-                throw new Error("No code Found!");
-            const tempCodeArray = tempCode.split("-");
-            const [code, codeDate] = tempCodeArray;
-            const millisecond15mins = 1000 * 60 * 15;
-            if (Date.now() - Number(codeDate) > millisecond15mins) {
-                throw new Error("Code Expired");
-            }
-            isPasswordCorrect = code === email_login_code;
-        }
-        let socialUserValid = false;
-        if (!isPasswordCorrect && !socialUserValid) {
-            return {
-                success: false,
-                msg: "Wrong password, no social login validity",
-                payload: null,
-            };
-        }
-        if (debug) {
-            console.log("apiLoginUser:isPasswordCorrect:", isPasswordCorrect);
-            console.log("apiLoginUser:email_login:", email_login);
-        }
-        if (isPasswordCorrect && email_login) {
-            const resetTempCode = yield (0, varDatabaseDbHandler_1.default)({
-                queryString: `UPDATE ${dbAppend}users SET ${email_login_field} = '' WHERE email = ? OR username = ?`,
-                queryValuesArray: [email, username],
-                database: dbFullName,
-            });
-        }
-        let csrfKey = Math.random().toString(36).substring(2) +
-            "-" +
-            Math.random().toString(36).substring(2);
-        let userPayload = {
-            id: foundUser[0].id,
-            first_name: foundUser[0].first_name,
-            last_name: foundUser[0].last_name,
-            username: foundUser[0].username,
-            email: foundUser[0].email,
-            phone: foundUser[0].phone,
-            social_id: foundUser[0].social_id,
-            image: foundUser[0].image,
-            image_thumbnail: foundUser[0].image_thumbnail,
-            verification_status: foundUser[0].verification_status,
-            social_login: foundUser[0].social_login,
-            social_platform: foundUser[0].social_platform,
-            csrf_k: csrfKey,
-            more_data: foundUser[0].more_user_data,
-            logged_in_status: true,
-            date: Date.now(),
-        };
-        if (debug) {
-            console.log("apiLoginUser:userPayload:", userPayload);
-            console.log("apiLoginUser:Sending Response Object ...");
-        }
-        const resposeObject = {
-            success: true,
-            msg: "Login Successful",
-            payload: userPayload,
-            userId: foundUser[0].id,
-            csrf: csrfKey,
-        };
-        if (additionalFields &&
-            Array.isArray(additionalFields) &&
-            additionalFields.length > 0) {
-            additionalFields.forEach((key) => {
-                userPayload[key] = foundUser[0][key];
-            });
-        }
-        return resposeObject;
-    });
+    }
+    let csrfKey = Math.random().toString(36).substring(2) +
+        "-" +
+        Math.random().toString(36).substring(2);
+    let userPayload = {
+        id: foundUser[0].id,
+        uid: foundUser[0].uid,
+        uuid: foundUser[0].uuid,
+        first_name: foundUser[0].first_name,
+        last_name: foundUser[0].last_name,
+        username: foundUser[0].username,
+        email: foundUser[0].email,
+        phone: foundUser[0].phone,
+        social_id: foundUser[0].social_id,
+        image: foundUser[0].image,
+        image_thumbnail: foundUser[0].image_thumbnail,
+        verification_status: foundUser[0].verification_status,
+        social_login: foundUser[0].social_login,
+        social_platform: foundUser[0].social_platform,
+        csrf_k: csrfKey,
+        more_data: foundUser[0].more_user_data,
+        logged_in_status: true,
+        date: Date.now(),
+    };
+    if (debug) {
+        console.log("apiLoginUser:userPayload:", userPayload);
+        console.log("apiLoginUser:Sending Response Object ...");
+    }
+    const resposeObject = {
+        success: true,
+        msg: "Login Successful",
+        payload: userPayload,
+        userId: foundUser[0].id,
+        csrf: csrfKey,
+    };
+    if (additionalFields &&
+        Array.isArray(additionalFields) &&
+        additionalFields.length > 0) {
+        additionalFields.forEach((key) => {
+            userPayload[key] = foundUser[0][key];
+        });
+    }
+    return resposeObject;
 }

dist/package-shared/functions/api/users/api-reauth-user.js

@@ -1,75 +1,58 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = apiReauthUser;
-const varDatabaseDbHandler_1 = __importDefault(require("../../backend/varDatabaseDbHandler"));
+import varDatabaseDbHandler from "../../backend/varDatabaseDbHandler";
 /**
  * # Re-authenticate API user
  */
-function apiReauthUser(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ existingUser, database, additionalFields, }) {
-        const dbAppend = global.DSQL_USE_LOCAL
-            ? ""
-            : database
-                ? `${database}.`
-                : "";
-        let foundUser = (existingUser === null || existingUser === void 0 ? void 0 : existingUser.id) && existingUser.id.toString().match(/./)
-            ? yield (0, varDatabaseDbHandler_1.default)({
-                queryString: `SELECT * FROM ${dbAppend}users WHERE id=?`,
-                queryValuesArray: [existingUser.id.toString()],
-                database,
-            })
-            : null;
-        if (!foundUser || !foundUser[0])
-            return {
-                success: false,
-                payload: null,
-                msg: "No user found",
-            };
-        let csrfKey = Math.random().toString(36).substring(2) +
-            "-" +
-            Math.random().toString(36).substring(2);
-        let userPayload = {
-            id: foundUser[0].id,
-            first_name: foundUser[0].first_name,
-            last_name: foundUser[0].last_name,
-            username: foundUser[0].username,
-            email: foundUser[0].email,
-            phone: foundUser[0].phone,
-            social_id: foundUser[0].social_id,
-            image: foundUser[0].image,
-            image_thumbnail: foundUser[0].image_thumbnail,
-            verification_status: foundUser[0].verification_status,
-            social_login: foundUser[0].social_login,
-            social_platform: foundUser[0].social_platform,
-            csrf_k: csrfKey,
-            more_data: foundUser[0].more_user_data,
-            logged_in_status: true,
-            date: Date.now(),
-        };
-        if (additionalFields &&
-            Array.isArray(additionalFields) &&
-            additionalFields.length > 0) {
-            additionalFields.forEach((key) => {
-                userPayload[key] = foundUser[0][key];
-            });
-        }
+export default async function apiReauthUser({ existingUser, database, additionalFields, }) {
+    const dbAppend = global.DSQL_USE_LOCAL
+        ? ""
+        : database
+            ? `${database}.`
+            : "";
+    let foundUser = (existingUser === null || existingUser === void 0 ? void 0 : existingUser.id) && existingUser.id.toString().match(/./)
+        ? await varDatabaseDbHandler({
+            queryString: `SELECT * FROM ${dbAppend}users WHERE id=?`,
+            queryValuesArray: [existingUser.id.toString()],
+            database,
+        })
+        : null;
+    if (!foundUser || !foundUser[0])
         return {
-            success: true,
-            msg: "Login Successful",
-            payload: userPayload,
-            csrf: csrfKey,
+            success: false,
+            payload: null,
+            msg: "No user found",
         };
-    });
+    let csrfKey = Math.random().toString(36).substring(2) +
+        "-" +
+        Math.random().toString(36).substring(2);
+    let userPayload = {
+        id: foundUser[0].id,
+        first_name: foundUser[0].first_name,
+        last_name: foundUser[0].last_name,
+        username: foundUser[0].username,
+        email: foundUser[0].email,
+        phone: foundUser[0].phone,
+        social_id: foundUser[0].social_id,
+        image: foundUser[0].image,
+        image_thumbnail: foundUser[0].image_thumbnail,
+        verification_status: foundUser[0].verification_status,
+        social_login: foundUser[0].social_login,
+        social_platform: foundUser[0].social_platform,
+        csrf_k: csrfKey,
+        more_data: foundUser[0].more_user_data,
+        logged_in_status: true,
+        date: Date.now(),
+    };
+    if (additionalFields &&
+        Array.isArray(additionalFields) &&
+        additionalFields.length > 0) {
+        additionalFields.forEach((key) => {
+            userPayload[key] = foundUser[0][key];
+        });
+    }
+    return {
+        success: true,
+        msg: "Login Successful",
+        payload: userPayload,
+        csrf: csrfKey,
+    };
 }

dist/package-shared/functions/api/users/api-send-email-code.js

@@ -1,132 +1,115 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = apiSendEmailCode;
-const varDatabaseDbHandler_1 = __importDefault(require("../../backend/varDatabaseDbHandler"));
-const nodemailer_1 = __importDefault(require("nodemailer"));
-const get_auth_cookie_names_1 = __importDefault(require("../../backend/cookies/get-auth-cookie-names"));
-const encrypt_1 = __importDefault(require("../../dsql/encrypt"));
-const serialize_cookies_1 = __importDefault(require("../../../utils/serialize-cookies"));
+import varDatabaseDbHandler from "../../backend/varDatabaseDbHandler";
+import nodemailer from "nodemailer";
+import getAuthCookieNames from "../../backend/cookies/get-auth-cookie-names";
+import encrypt from "../../dsql/encrypt";
+import serializeCookies from "../../../utils/serialize-cookies";
 /**
  * # Send Email Login Code
  */
-function apiSendEmailCode(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ email, database, email_login_field, mail_domain, mail_port, sender, mail_username, mail_password, html, response, extraCookies, }) {
-        if (email === null || email === void 0 ? void 0 : email.match(/ /)) {
-            return {
-                success: false,
-                msg: "Invalid Email/Password format",
-            };
+export default async function apiSendEmailCode({ email, database, email_login_field, mail_domain, mail_port, sender, mail_username, mail_password, html, response, extraCookies, }) {
+    if (email === null || email === void 0 ? void 0 : email.match(/ /)) {
+        return {
+            success: false,
+            msg: "Invalid Email/Password format",
+        };
+    }
+    const createdAt = Date.now();
+    const foundUserQuery = `SELECT * FROM ${database}.users WHERE email = ?`;
+    const foundUserValues = [email];
+    let foundUser = await varDatabaseDbHandler({
+        queryString: foundUserQuery,
+        queryValuesArray: foundUserValues,
+        database,
+    });
+    ////////////////////////////////////////
+    ////////////////////////////////////////
+    ////////////////////////////////////////
+    if (!foundUser || !foundUser[0]) {
+        return {
+            success: false,
+            msg: "No user found",
+        };
+    }
+    function generateCode() {
+        const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+        let code = "";
+        for (let i = 0; i < 8; i++) {
+            code += chars[Math.floor(Math.random() * chars.length)];
         }
-        const createdAt = Date.now();
-        const foundUserQuery = `SELECT * FROM ${database}.users WHERE email = ?`;
-        const foundUserValues = [email];
-        let foundUser = yield (0, varDatabaseDbHandler_1.default)({
-            queryString: foundUserQuery,
-            queryValuesArray: foundUserValues,
+        return code;
+    }
+    if ((foundUser === null || foundUser === void 0 ? void 0 : foundUser[0]) && email_login_field) {
+        const tempCode = generateCode();
+        let transporter = nodemailer.createTransport({
+            host: mail_domain || process.env.DSQL_MAIL_HOST,
+            port: mail_port
+                ? mail_port
+                : process.env.DSQL_MAIL_PORT
+                    ? Number(process.env.DSQL_MAIL_PORT)
+                    : 465,
+            secure: true,
+            auth: {
+                user: mail_username || process.env.DSQL_MAIL_EMAIL,
+                pass: mail_password || process.env.DSQL_MAIL_PASSWORD,
+            },
+        });
+        let mailObject = {};
+        mailObject["from"] = `"Datasquirel SSO" <${sender || "support@datasquirel.com"}>`;
+        mailObject["sender"] = sender || "support@datasquirel.com";
+        mailObject["to"] = email;
+        mailObject["subject"] = "One Time Login Code";
+        mailObject["html"] = html.replace(/{{code}}/, tempCode);
+        const info = await transporter.sendMail(mailObject);
+        if (!(info === null || info === void 0 ? void 0 : info.accepted))
+            throw new Error("Mail not Sent!");
+        const setTempCodeQuery = `UPDATE ${database}.users SET ${email_login_field} = ? WHERE email = ?`;
+        const setTempCodeValues = [tempCode + `-${createdAt}`, email];
+        let setTempCode = await varDatabaseDbHandler({
+            queryString: setTempCodeQuery,
+            queryValuesArray: setTempCodeValues,
             database,
         });
-        ////////////////////////////////////////
-        ////////////////////////////////////////
-        ////////////////////////////////////////
-        if (!foundUser || !foundUser[0]) {
-            return {
-                success: false,
-                msg: "No user found",
-            };
-        }
-        function generateCode() {
-            const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
-            let code = "";
-            for (let i = 0; i < 8; i++) {
-                code += chars[Math.floor(Math.random() * chars.length)];
+        /** @type {import("../../../types").SendOneTimeCodeEmailResponse} */
+        const resObject = {
+            success: true,
+            code: tempCode,
+            email: email,
+            createdAt,
+            msg: "Success",
+        };
+        if (response) {
+            const cookieKeyNames = getAuthCookieNames();
+            const oneTimeCodeCookieName = cookieKeyNames.oneTimeCodeName;
+            const encryptedPayload = encrypt({
+                data: JSON.stringify(resObject),
+            });
+            if (!encryptedPayload) {
+                throw new Error("apiSendEmailCode Error: Failed to encrypt payload");
             }
-            return code;
-        }
-        if ((foundUser === null || foundUser === void 0 ? void 0 : foundUser[0]) && email_login_field) {
-            const tempCode = generateCode();
-            let transporter = nodemailer_1.default.createTransport({
-                host: mail_domain || process.env.DSQL_MAIL_HOST,
-                port: mail_port
-                    ? mail_port
-                    : process.env.DSQL_MAIL_PORT
-                        ? Number(process.env.DSQL_MAIL_PORT)
-                        : 465,
+            /** @type {import("../../../../package-shared/types").CookieObject} */
+            const oneTimeCookieObject = {
+                name: oneTimeCodeCookieName,
+                value: encryptedPayload,
+                sameSite: "Strict",
+                path: "/",
+                httpOnly: true,
                 secure: true,
-                auth: {
-                    user: mail_username || process.env.DSQL_MAIL_EMAIL,
-                    pass: mail_password || process.env.DSQL_MAIL_PASSWORD,
-                },
-            });
-            let mailObject = {};
-            mailObject["from"] = `"Datasquirel SSO" <${sender || "support@datasquirel.com"}>`;
-            mailObject["sender"] = sender || "support@datasquirel.com";
-            mailObject["to"] = email;
-            mailObject["subject"] = "One Time Login Code";
-            mailObject["html"] = html.replace(/{{code}}/, tempCode);
-            const info = yield transporter.sendMail(mailObject);
-            if (!(info === null || info === void 0 ? void 0 : info.accepted))
-                throw new Error("Mail not Sent!");
-            const setTempCodeQuery = `UPDATE ${database}.users SET ${email_login_field} = ? WHERE email = ?`;
-            const setTempCodeValues = [tempCode + `-${createdAt}`, email];
-            let setTempCode = yield (0, varDatabaseDbHandler_1.default)({
-                queryString: setTempCodeQuery,
-                queryValuesArray: setTempCodeValues,
-                database,
-            });
-            /** @type {import("../../../types").SendOneTimeCodeEmailResponse} */
-            const resObject = {
-                success: true,
-                code: tempCode,
-                email: email,
-                createdAt,
-                msg: "Success",
             };
-            if (response) {
-                const cookieKeyNames = (0, get_auth_cookie_names_1.default)();
-                const oneTimeCodeCookieName = cookieKeyNames.oneTimeCodeName;
-                const encryptedPayload = (0, encrypt_1.default)({
-                    data: JSON.stringify(resObject),
-                });
-                if (!encryptedPayload) {
-                    throw new Error("apiSendEmailCode Error: Failed to encrypt payload");
-                }
-                /** @type {import("../../../../package-shared/types").CookieObject} */
-                const oneTimeCookieObject = {
-                    name: oneTimeCodeCookieName,
-                    value: encryptedPayload,
-                    sameSite: "Strict",
-                    path: "/",
-                    httpOnly: true,
-                    secure: true,
-                };
-                /** @type {import("../../../../package-shared/types").CookieObject[]} */
-                const cookiesObjectArray = extraCookies
-                    ? [...extraCookies, oneTimeCookieObject]
-                    : [oneTimeCookieObject];
-                const serializedCookies = (0, serialize_cookies_1.default)({
-                    cookies: cookiesObjectArray,
-                });
-                response.setHeader("Set-Cookie", serializedCookies);
-            }
-            return resObject;
+            /** @type {import("../../../../package-shared/types").CookieObject[]} */
+            const cookiesObjectArray = extraCookies
+                ? [...extraCookies, oneTimeCookieObject]
+                : [oneTimeCookieObject];
+            const serializedCookies = serializeCookies({
+                cookies: cookiesObjectArray,
+            });
+            response.setHeader("Set-Cookie", serializedCookies);
         }
-        else {
-            return {
-                success: false,
-                msg: "Invalid Email/Password format",
-            };
-        }
-    });
+        return resObject;
+    }
+    else {
+        return {
+            success: false,
+            msg: "Invalid Email/Password format",
+        };
+    }
 }

dist/package-shared/functions/api/users/api-update-user.js

@@ -1,81 +1,64 @@
-"use strict";
 // @ts-check
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = apiUpdateUser;
-const updateDbEntry_1 = __importDefault(require("../../backend/db/updateDbEntry"));
-const encrypt_1 = __importDefault(require("../../dsql/encrypt"));
-const hashPassword_1 = __importDefault(require("../../dsql/hashPassword"));
-const varDatabaseDbHandler_1 = __importDefault(require("../../backend/varDatabaseDbHandler"));
+import updateDbEntry from "../../backend/db/updateDbEntry";
+import encrypt from "../../dsql/encrypt";
+import hashPassword from "../../dsql/hashPassword";
+import varDatabaseDbHandler from "../../backend/varDatabaseDbHandler";
 /**
  * # Update API User Function
  */
-function apiUpdateUser(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ payload, dbFullName, updatedUserId, dbSchema, }) {
-        const existingUserQuery = `SELECT * FROM ${dbFullName}.users WHERE id = ?`;
-        const existingUserValues = [updatedUserId];
-        const existingUser = yield (0, varDatabaseDbHandler_1.default)({
-            queryString: existingUserQuery,
-            queryValuesArray: existingUserValues,
-            database: dbFullName,
-        });
-        if (!(existingUser === null || existingUser === void 0 ? void 0 : existingUser[0])) {
-            return {
-                success: false,
-                msg: "User not found",
-            };
-        }
-        const data = (() => {
-            const reqBodyKeys = Object.keys(payload);
-            const targetTableSchema = (() => {
-                var _a;
-                try {
-                    const targetDatabaseSchema = (_a = dbSchema === null || dbSchema === void 0 ? void 0 : dbSchema.tables) === null || _a === void 0 ? void 0 : _a.find((tbl) => tbl.tableName == "users");
-                    return targetDatabaseSchema;
-                }
-                catch (error) {
-                    return undefined;
-                }
-            })();
-            /** @type {any} */
-            const finalData = {};
-            reqBodyKeys.forEach((key) => {
-                var _a;
-                const targetFieldSchema = (_a = targetTableSchema === null || targetTableSchema === void 0 ? void 0 : targetTableSchema.fields) === null || _a === void 0 ? void 0 : _a.find((field) => field.fieldName == key);
-                if (key === null || key === void 0 ? void 0 : key.match(/^date_|^id$|^uuid$/))
-                    return;
-                let value = payload[key];
-                if (targetFieldSchema === null || targetFieldSchema === void 0 ? void 0 : targetFieldSchema.encrypted) {
-                    value = (0, encrypt_1.default)({ data: value });
-                }
-                finalData[key] = value;
-            });
-            if (finalData.password && typeof finalData.password == "string") {
-                finalData.password = (0, hashPassword_1.default)({ password: finalData.password });
-            }
-            return finalData;
-        })();
-        const updateUser = yield (0, updateDbEntry_1.default)({
-            dbFullName,
-            tableName: "users",
-            identifierColumnName: "id",
-            identifierValue: updatedUserId,
-            data: data,
-        });
-        return {
-            success: true,
-            payload: updateUser,
-        };
+export default async function apiUpdateUser({ payload, dbFullName, updatedUserId, dbSchema, }) {
+    const existingUserQuery = `SELECT * FROM ${dbFullName}.users WHERE id = ?`;
+    const existingUserValues = [updatedUserId];
+    const existingUser = await varDatabaseDbHandler({
+        queryString: existingUserQuery,
+        queryValuesArray: existingUserValues,
+        database: dbFullName,
     });
+    if (!(existingUser === null || existingUser === void 0 ? void 0 : existingUser[0])) {
+        return {
+            success: false,
+            msg: "User not found",
+        };
+    }
+    const data = (() => {
+        const reqBodyKeys = Object.keys(payload);
+        const targetTableSchema = (() => {
+            var _a;
+            try {
+                const targetDatabaseSchema = (_a = dbSchema === null || dbSchema === void 0 ? void 0 : dbSchema.tables) === null || _a === void 0 ? void 0 : _a.find((tbl) => tbl.tableName == "users");
+                return targetDatabaseSchema;
+            }
+            catch (error) {
+                return undefined;
+            }
+        })();
+        /** @type {any} */
+        const finalData = {};
+        reqBodyKeys.forEach((key) => {
+            var _a;
+            const targetFieldSchema = (_a = targetTableSchema === null || targetTableSchema === void 0 ? void 0 : targetTableSchema.fields) === null || _a === void 0 ? void 0 : _a.find((field) => field.fieldName == key);
+            if (key === null || key === void 0 ? void 0 : key.match(/^date_|^id$|^uuid$/))
+                return;
+            let value = payload[key];
+            if (targetFieldSchema === null || targetFieldSchema === void 0 ? void 0 : targetFieldSchema.encrypted) {
+                value = encrypt({ data: value });
+            }
+            finalData[key] = value;
+        });
+        if (finalData.password && typeof finalData.password == "string") {
+            finalData.password = hashPassword({ password: finalData.password });
+        }
+        return finalData;
+    })();
+    const updateUser = await updateDbEntry({
+        dbFullName,
+        tableName: "users",
+        identifierColumnName: "id",
+        identifierValue: updatedUserId,
+        data: data,
+    });
+    return {
+        success: true,
+        payload: updateUser,
+    };
 }

dist/package-shared/functions/api/users/reset-password/(utils)/encrypt-url.js

@@ -1,18 +1,12 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = encryptReserPasswordUrl;
-const ejson_1 = __importDefault(require("../../../../../utils/ejson"));
-const encrypt_1 = __importDefault(require("../../../../dsql/encrypt"));
-function encryptReserPasswordUrl({ email, encryptionKey, encryptionSalt, }) {
+import EJSON from "../../../../../utils/ejson";
+import encrypt from "../../../../dsql/encrypt";
+export default function encryptReserPasswordUrl({ email, encryptionKey, encryptionSalt, }) {
     const encryptObject = {
         email,
         createdAt: Date.now(),
     };
-    const encryptStr = (0, encrypt_1.default)({
-        data: ejson_1.default.stringify(encryptObject),
+    const encryptStr = encrypt({
+        data: EJSON.stringify(encryptObject),
         encryptionKey,
         encryptionSalt,
     });

dist/package-shared/functions/api/users/reset-password/api-send-reset-password-link.js

@@ -1,52 +1,36 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = apiSendResetPasswordLink;
-const grab_db_full_name_1 = __importDefault(require("../../../../utils/grab-db-full-name"));
-const varDatabaseDbHandler_1 = __importDefault(require("../../../backend/varDatabaseDbHandler"));
+import grabDbFullName from "../../../../utils/grab-db-full-name";
+import varDatabaseDbHandler from "../../../backend/varDatabaseDbHandler";
 /**
  * # API Login
  */
-function apiSendResetPasswordLink(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ database, email, dbUserId, debug, }) {
-        const dbFullName = (0, grab_db_full_name_1.default)({ dbName: database, userId: dbUserId });
-        /**
-         * Check input validity
-         *
-         * @description Check input validity
-         */
-        if (email === null || email === void 0 ? void 0 : email.match(/ /)) {
-            return {
-                success: false,
-                msg: "Invalid Email/Password format",
-            };
-        }
-        let foundUser = yield (0, varDatabaseDbHandler_1.default)({
-            queryString: `SELECT * FROM ${dbFullName}.users WHERE email = ? OR username = ?`,
-            queryValuesArray: [email, email],
-            database: dbFullName,
-            debug,
-        });
-        if (debug) {
-            console.log("apiSendResetPassword:foundUser:", foundUser);
-        }
-        const targetUser = foundUser === null || foundUser === void 0 ? void 0 : foundUser[0];
-        if (!targetUser)
-            return {
-                success: false,
-                msg: "No user found",
-            };
-        return { success: true };
+export default async function apiSendResetPasswordLink({ database, email, dbUserId, debug, }) {
+    const dbFullName = grabDbFullName({ dbName: database, userId: dbUserId });
+    if (!dbFullName) {
+        return {
+            success: false,
+            msg: `Couldn't get database full name`,
+        };
+    }
+    if (email === null || email === void 0 ? void 0 : email.match(/ /)) {
+        return {
+            success: false,
+            msg: "Invalid Email/Password format",
+        };
+    }
+    let foundUser = await varDatabaseDbHandler({
+        queryString: `SELECT * FROM ${dbFullName}.users WHERE email = ? OR username = ?`,
+        queryValuesArray: [email, email],
+        database: dbFullName,
+        debug,
     });
+    if (debug) {
+        console.log("apiSendResetPassword:foundUser:", foundUser);
+    }
+    const targetUser = foundUser === null || foundUser === void 0 ? void 0 : foundUser[0];
+    if (!targetUser)
+        return {
+            success: false,
+            msg: "No user found",
+        };
+    return { success: true };
 }

dist/package-shared/functions/api/users/social/api-github-login.js

@@ -1,88 +1,71 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = apiGithubLogin;
-const handleSocialDb_1 = __importDefault(require("../../social-login/handleSocialDb"));
-const githubLogin_1 = __importDefault(require("../../social-login/githubLogin"));
-const camelJoinedtoCamelSpace_1 = __importDefault(require("../../../../utils/camelJoinedtoCamelSpace"));
+import handleSocialDb from "../../social-login/handleSocialDb";
+import githubLogin from "../../social-login/githubLogin";
+import camelJoinedtoCamelSpace from "../../../../utils/camelJoinedtoCamelSpace";
 /**
  * # API Login with Github
  */
-function apiGithubLogin(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ code, clientId, clientSecret, database, additionalFields, email, additionalData, }) {
-        if (!code || !clientId || !clientSecret || !database) {
-            return {
-                success: false,
-                msg: "Missing query params",
-            };
-        }
-        if (typeof code !== "string" ||
-            typeof clientId !== "string" ||
-            typeof clientSecret !== "string" ||
-            typeof database !== "string") {
-            return {
-                success: false,
-                msg: "Wrong Parameters",
-            };
-        }
-        /**
-         * Create new user folder and file
-         *
-         * @description Create new user folder and file
-         */
-        const gitHubUser = yield (0, githubLogin_1.default)({
-            code: code,
-            clientId: clientId,
-            clientSecret: clientSecret,
-        });
-        if (!gitHubUser) {
-            return {
-                success: false,
-                msg: "No github user returned",
-            };
-        }
-        const socialId = gitHubUser.name || gitHubUser.id || gitHubUser.login;
-        const targetName = gitHubUser.name || gitHubUser.login;
-        const nameArray = (targetName === null || targetName === void 0 ? void 0 : targetName.match(/ /))
-            ? targetName === null || targetName === void 0 ? void 0 : targetName.split(" ")
-            : (targetName === null || targetName === void 0 ? void 0 : targetName.match(/\-/))
-                ? targetName === null || targetName === void 0 ? void 0 : targetName.split("-")
-                : [targetName];
-        let payload = {
-            email: gitHubUser.email,
-            first_name: (0, camelJoinedtoCamelSpace_1.default)(nameArray[0]),
-            last_name: (0, camelJoinedtoCamelSpace_1.default)(nameArray[1]),
-            social_id: socialId,
-            social_platform: "github",
-            image: gitHubUser.avatar_url,
-            image_thumbnail: gitHubUser.avatar_url,
-            username: "github-user-" + socialId,
+export default async function apiGithubLogin({ code, clientId, clientSecret, database, additionalFields, email, additionalData, }) {
+    if (!code || !clientId || !clientSecret || !database) {
+        return {
+            success: false,
+            msg: "Missing query params",
         };
-        if (additionalData) {
-            payload = Object.assign(Object.assign({}, payload), additionalData);
-        }
-        const loggedInGithubUser = yield (0, handleSocialDb_1.default)({
-            database,
-            email: gitHubUser.email,
-            payload,
-            social_platform: "github",
-            supEmail: email,
-            additionalFields,
-        });
-        ////////////////////////////////////////////////
-        ////////////////////////////////////////////////
-        ////////////////////////////////////////////////
-        return Object.assign({}, loggedInGithubUser);
+    }
+    if (typeof code !== "string" ||
+        typeof clientId !== "string" ||
+        typeof clientSecret !== "string" ||
+        typeof database !== "string") {
+        return {
+            success: false,
+            msg: "Wrong Parameters",
+        };
+    }
+    /**
+     * Create new user folder and file
+     *
+     * @description Create new user folder and file
+     */
+    const gitHubUser = await githubLogin({
+        code: code,
+        clientId: clientId,
+        clientSecret: clientSecret,
     });
+    if (!gitHubUser) {
+        return {
+            success: false,
+            msg: "No github user returned",
+        };
+    }
+    const socialId = gitHubUser.name || gitHubUser.id || gitHubUser.login;
+    const targetName = gitHubUser.name || gitHubUser.login;
+    const nameArray = (targetName === null || targetName === void 0 ? void 0 : targetName.match(/ /))
+        ? targetName === null || targetName === void 0 ? void 0 : targetName.split(" ")
+        : (targetName === null || targetName === void 0 ? void 0 : targetName.match(/\-/))
+            ? targetName === null || targetName === void 0 ? void 0 : targetName.split("-")
+            : [targetName];
+    let payload = {
+        email: gitHubUser.email,
+        first_name: camelJoinedtoCamelSpace(nameArray[0]),
+        last_name: camelJoinedtoCamelSpace(nameArray[1]),
+        social_id: socialId,
+        social_platform: "github",
+        image: gitHubUser.avatar_url,
+        image_thumbnail: gitHubUser.avatar_url,
+        username: "github-user-" + socialId,
+    };
+    if (additionalData) {
+        payload = Object.assign(Object.assign({}, payload), additionalData);
+    }
+    const loggedInGithubUser = await handleSocialDb({
+        database,
+        email: gitHubUser.email,
+        payload,
+        social_platform: "github",
+        supEmail: email,
+        additionalFields,
+    });
+    ////////////////////////////////////////////////
+    ////////////////////////////////////////////////
+    ////////////////////////////////////////////////
+    return Object.assign({}, loggedInGithubUser);
 }

dist/package-shared/functions/api/users/social/api-google-login.js

@@ -1,89 +1,72 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = apiGoogleLogin;
-const https_1 = __importDefault(require("https"));
-const handleSocialDb_1 = __importDefault(require("../../social-login/handleSocialDb"));
-const ejson_1 = __importDefault(require("../../../../utils/ejson"));
+import https from "https";
+import handleSocialDb from "../../social-login/handleSocialDb";
+import EJSON from "../../../../utils/ejson";
 /**
  * # API google login
  */
-function apiGoogleLogin(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ token, database, additionalFields, additionalData, debug, loginOnly, }) {
-        try {
-            const gUser = yield new Promise((resolve, reject) => {
-                https_1.default
-                    .request({
-                    method: "GET",
-                    hostname: "www.googleapis.com",
-                    path: "/oauth2/v3/userinfo",
-                    headers: {
-                        Authorization: `Bearer ${token}`,
-                    },
-                }, (res) => {
-                    let data = "";
-                    res.on("data", (chunk) => {
-                        data += chunk;
-                    });
-                    res.on("end", () => {
-                        resolve(ejson_1.default.parse(data));
-                    });
-                })
-                    .end();
-            });
-            if (!(gUser === null || gUser === void 0 ? void 0 : gUser.email_verified))
-                throw new Error("No Google User.");
-            /**
-             * Create new user folder and file
-             *
-             * @description Create new user folder and file
-             */
-            const { given_name, family_name, email, sub, picture } = gUser;
-            let payloadObject = {
-                email: email,
-                first_name: given_name,
-                last_name: family_name,
-                social_id: sub,
-                social_platform: "google",
-                image: picture,
-                image_thumbnail: picture,
-                username: `google-user-${sub}`,
-            };
-            if (additionalData) {
-                payloadObject = Object.assign(Object.assign({}, payloadObject), additionalData);
-            }
-            const loggedInGoogleUser = yield (0, handleSocialDb_1.default)({
-                database,
-                email: email || "",
-                payload: payloadObject,
-                social_platform: "google",
-                additionalFields,
-                debug,
-                loginOnly,
-            });
-            ////////////////////////////////////////
-            ////////////////////////////////////////
-            ////////////////////////////////////////
-            return Object.assign({}, loggedInGoogleUser);
+export default async function apiGoogleLogin({ token, database, additionalFields, additionalData, debug, loginOnly, }) {
+    try {
+        const gUser = await new Promise((resolve, reject) => {
+            https
+                .request({
+                method: "GET",
+                hostname: "www.googleapis.com",
+                path: "/oauth2/v3/userinfo",
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                },
+            }, (res) => {
+                let data = "";
+                res.on("data", (chunk) => {
+                    data += chunk;
+                });
+                res.on("end", () => {
+                    resolve(EJSON.parse(data));
+                });
+            })
+                .end();
+        });
+        if (!(gUser === null || gUser === void 0 ? void 0 : gUser.email_verified))
+            throw new Error("No Google User.");
+        /**
+         * Create new user folder and file
+         *
+         * @description Create new user folder and file
+         */
+        const { given_name, family_name, email, sub, picture } = gUser;
+        let payloadObject = {
+            email: email,
+            first_name: given_name,
+            last_name: family_name,
+            social_id: sub,
+            social_platform: "google",
+            image: picture,
+            image_thumbnail: picture,
+            username: `google-user-${sub}`,
+        };
+        if (additionalData) {
+            payloadObject = Object.assign(Object.assign({}, payloadObject), additionalData);
         }
-        catch ( /** @type {any} */error) {
-            console.log(`api-google-login.ts ERROR: ${error.message}`);
-            return {
-                success: false,
-                payload: undefined,
-                msg: error.message,
-            };
-        }
-    });
+        const loggedInGoogleUser = await handleSocialDb({
+            database,
+            email: email || "",
+            payload: payloadObject,
+            social_platform: "google",
+            additionalFields,
+            debug,
+            loginOnly,
+        });
+        ////////////////////////////////////////
+        ////////////////////////////////////////
+        ////////////////////////////////////////
+        return Object.assign({}, loggedInGoogleUser);
+    }
+    catch ( /** @type {any} */error) {
+        console.log(`api-google-login.ts ERROR: ${error.message}`);
+        return {
+            success: false,
+            payload: undefined,
+            msg: error.message,
+        };
+    }
 }

dist/package-shared/functions/backend/addAdminUserOnLogin.js

@@ -1,22 +1,7 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = addAdminUserOnLogin;
-const serverError_1 = __importDefault(require("./serverError"));
-const DB_HANDLER_1 = __importDefault(require("../../utils/backend/global-db/DB_HANDLER"));
-const addDbEntry_1 = __importDefault(require("./db/addDbEntry"));
-const LOCAL_DB_HANDLER_1 = __importDefault(require("../../utils/backend/global-db/LOCAL_DB_HANDLER"));
+import serverError from "./serverError";
+import DB_HANDLER from "../../utils/backend/global-db/DB_HANDLER";
+import addDbEntry from "./db/addDbEntry";
+import LOCAL_DB_HANDLER from "../../utils/backend/global-db/LOCAL_DB_HANDLER";
 /**
  * Add Admin User on Login
  * ==============================================================================
@@ -25,88 +10,86 @@ const LOCAL_DB_HANDLER_1 = __importDefault(require("../../utils/backend/global-d
  * admin user. This fires when the invited user has been logged in or a new account
  * has been created for the invited user
  */
-function addAdminUserOnLogin(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ query, user, }) {
-        var _b;
-        try {
-            const finalDbHandler = global.DSQL_USE_LOCAL
-                ? LOCAL_DB_HANDLER_1.default
-                : DB_HANDLER_1.default;
-            const { invite, database_access, priviledge, email } = query;
-            const lastInviteTimeQuery = `SELECT date_created_code FROM invitations WHERE inviting_user_id=? AND invited_user_email=?`;
-            const lastInviteTimeValues = [invite, email];
-            const lastInviteTimeArray = yield finalDbHandler(lastInviteTimeQuery, lastInviteTimeValues);
-            if (!lastInviteTimeArray || !lastInviteTimeArray[0]) {
-                throw new Error("No Invitation Found");
+export default async function addAdminUserOnLogin({ query, user, }) {
+    var _a;
+    try {
+        const finalDbHandler = global.DSQL_USE_LOCAL
+            ? LOCAL_DB_HANDLER
+            : DB_HANDLER;
+        const { invite, database_access, priviledge, email } = query;
+        const lastInviteTimeQuery = `SELECT date_created_code FROM invitations WHERE inviting_user_id=? AND invited_user_email=?`;
+        const lastInviteTimeValues = [invite, email];
+        const lastInviteTimeArray = await finalDbHandler(lastInviteTimeQuery, lastInviteTimeValues);
+        if (!lastInviteTimeArray || !lastInviteTimeArray[0]) {
+            throw new Error("No Invitation Found");
+        }
+        ////////////////////////////////////////////////
+        ////////////////////////////////////////////////
+        ////////////////////////////////////////////////
+        const invitingUserDbQuery = `SELECT first_name,last_name,email FROM users WHERE id=?`;
+        const invitingUserDbValues = [invite];
+        const invitingUserDb = await finalDbHandler(invitingUserDbQuery, invitingUserDbValues);
+        if (invitingUserDb === null || invitingUserDb === void 0 ? void 0 : invitingUserDb[0]) {
+            const existingUserUser = await finalDbHandler(`SELECT email FROM user_users WHERE user_id=? AND invited_user_id=? AND user_type='admin' AND email=?`, [invite, user.id, email]);
+            if (existingUserUser === null || existingUserUser === void 0 ? void 0 : existingUserUser[0]) {
+                console.log("User already added");
             }
-            ////////////////////////////////////////////////
-            ////////////////////////////////////////////////
-            ////////////////////////////////////////////////
-            const invitingUserDbQuery = `SELECT first_name,last_name,email FROM users WHERE id=?`;
-            const invitingUserDbValues = [invite];
-            const invitingUserDb = yield finalDbHandler(invitingUserDbQuery, invitingUserDbValues);
-            if (invitingUserDb === null || invitingUserDb === void 0 ? void 0 : invitingUserDb[0]) {
-                const existingUserUser = yield finalDbHandler(`SELECT email FROM user_users WHERE user_id=? AND invited_user_id=? AND user_type='admin' AND email=?`, [invite, user.id, email]);
-                if (existingUserUser === null || existingUserUser === void 0 ? void 0 : existingUserUser[0]) {
-                    console.log("User already added");
-                }
-                else {
-                    (0, addDbEntry_1.default)({
-                        dbFullName: "datasquirel",
-                        tableName: "user_users",
-                        data: {
-                            user_id: invite,
-                            invited_user_id: user.id,
-                            database_access: database_access,
-                            first_name: user.first_name,
-                            last_name: user.last_name,
-                            phone: user.phone,
-                            email: user.email,
-                            username: user.username,
-                            user_type: "admin",
-                            user_priviledge: priviledge,
-                            image: user.image,
-                            image_thumbnail: user.image_thumbnail,
-                        },
-                    });
-                    ////////////////////////////////////////////////
-                    ////////////////////////////////////////////////
-                    ////////////////////////////////////////////////
-                    const dbTableData = yield finalDbHandler(`SELECT db_tables_data FROM invitations WHERE inviting_user_id=? AND invited_user_email=?`, [invite, email]);
-                    const clearEntries = yield finalDbHandler(`DELETE FROM delegated_user_tables WHERE root_user_id=? AND delegated_user_id=?`, [invite, user.id]);
-                    ////////////////////////////////////////////////
-                    ////////////////////////////////////////////////
-                    ////////////////////////////////////////////////
-                    if (dbTableData && dbTableData[0]) {
-                        const dbTableEntries = dbTableData[0].db_tables_data.split("|");
-                        for (let i = 0; i < dbTableEntries.length; i++) {
-                            const dbTableEntry = dbTableEntries[i];
-                            const dbTableEntryArray = dbTableEntry.split("-");
-                            const [db_slug, table_slug] = dbTableEntryArray;
-                            const newEntry = yield (0, addDbEntry_1.default)({
-                                dbFullName: "datasquirel",
-                                tableName: "delegated_user_tables",
-                                data: {
-                                    delegated_user_id: user.id,
-                                    root_user_id: invite,
-                                    database: db_slug,
-                                    table: table_slug,
-                                    priviledge: priviledge,
-                                },
-                            });
-                        }
+            else {
+                addDbEntry({
+                    dbFullName: "datasquirel",
+                    tableName: "user_users",
+                    data: {
+                        user_id: invite,
+                        invited_user_id: user.id,
+                        database_access: database_access,
+                        first_name: user.first_name,
+                        last_name: user.last_name,
+                        phone: user.phone,
+                        email: user.email,
+                        username: user.username,
+                        user_type: "admin",
+                        user_priviledge: priviledge,
+                        image: user.image,
+                        image_thumbnail: user.image_thumbnail,
+                    },
+                });
+                ////////////////////////////////////////////////
+                ////////////////////////////////////////////////
+                ////////////////////////////////////////////////
+                const dbTableData = await finalDbHandler(`SELECT db_tables_data FROM invitations WHERE inviting_user_id=? AND invited_user_email=?`, [invite, email]);
+                const clearEntries = await finalDbHandler(`DELETE FROM delegated_user_tables WHERE root_user_id=? AND delegated_user_id=?`, [invite, user.id]);
+                ////////////////////////////////////////////////
+                ////////////////////////////////////////////////
+                ////////////////////////////////////////////////
+                if (dbTableData && dbTableData[0]) {
+                    const dbTableEntries = dbTableData[0].db_tables_data.split("|");
+                    for (let i = 0; i < dbTableEntries.length; i++) {
+                        const dbTableEntry = dbTableEntries[i];
+                        const dbTableEntryArray = dbTableEntry.split("-");
+                        const [db_slug, table_slug] = dbTableEntryArray;
+                        const newEntry = await addDbEntry({
+                            dbFullName: "datasquirel",
+                            tableName: "delegated_user_tables",
+                            data: {
+                                delegated_user_id: user.id,
+                                root_user_id: invite,
+                                database: db_slug,
+                                table: table_slug,
+                                priviledge: priviledge,
+                            },
+                        });
                     }
                 }
-                const inviteAccepted = yield finalDbHandler(`UPDATE invitations SET invitation_status='Accepted' WHERE inviting_user_id=? AND invited_user_email=?`, [invite, email]);
             }
+            const inviteAccepted = await finalDbHandler(`UPDATE invitations SET invitation_status='Accepted' WHERE inviting_user_id=? AND invited_user_email=?`, [invite, email]);
         }
-        catch (error) {
-            (_b = global.ERROR_CALLBACK) === null || _b === void 0 ? void 0 : _b.call(global, `Add Admin User On Login Error`, error);
-            (0, serverError_1.default)({
-                component: "addAdminUserOnLogin",
-                message: error.message,
-                user: user,
-            });
-        }
-    });
+    }
+    catch (error) {
+        (_a = global.ERROR_CALLBACK) === null || _a === void 0 ? void 0 : _a.call(global, `Add Admin User On Login Error`, error);
+        serverError({
+            component: "addAdminUserOnLogin",
+            message: error.message,
+            user: user,
+        });
+    }
 }

dist/package-shared/functions/backend/addMariadbUser.js

@@ -1,70 +1,54 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = addMariadbUser;
-const generate_password_1 = __importDefault(require("generate-password"));
-const DB_HANDLER_1 = __importDefault(require("../../utils/backend/global-db/DB_HANDLER"));
-const NO_DB_HANDLER_1 = __importDefault(require("../../utils/backend/global-db/NO_DB_HANDLER"));
-const addDbEntry_1 = __importDefault(require("./db/addDbEntry"));
-const encrypt_1 = __importDefault(require("../dsql/encrypt"));
-const LOCAL_DB_HANDLER_1 = __importDefault(require("../../utils/backend/global-db/LOCAL_DB_HANDLER"));
+import generator from "generate-password";
+import DB_HANDLER from "../../utils/backend/global-db/DB_HANDLER";
+import NO_DB_HANDLER from "../../utils/backend/global-db/NO_DB_HANDLER";
+import addDbEntry from "./db/addDbEntry";
+import encrypt from "../dsql/encrypt";
+import LOCAL_DB_HANDLER from "../../utils/backend/global-db/LOCAL_DB_HANDLER";
+import grabSQLKeyName from "../../utils/grab-sql-key-name";
 /**
  * # Add Mariadb User
  */
-function addMariadbUser(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ userId }) {
-        try {
-            const defaultMariadbUserHost = process.env.DSQL_DB_HOST || "127.0.0.1";
-            const username = `dsql_user_${userId}`;
-            const password = generate_password_1.default.generate({
-                length: 16,
-                numbers: true,
-                symbols: true,
-                uppercase: true,
-                exclude: "*#.'`\"",
-            });
-            const encryptedPassword = (0, encrypt_1.default)({ data: password });
-            const createMariadbUsersQuery = `CREATE USER IF NOT EXISTS '${username}'@'127.0.0.1' IDENTIFIED BY '${password}'`;
-            if (global.DSQL_USE_LOCAL) {
-                yield (0, LOCAL_DB_HANDLER_1.default)(createMariadbUsersQuery);
-            }
-            else {
-                yield (0, NO_DB_HANDLER_1.default)(createMariadbUsersQuery);
-            }
-            const updateUserQuery = `UPDATE users SET mariadb_user = ?, mariadb_host = '127.0.0.1', mariadb_pass = ? WHERE id = ?`;
-            const updateUserValues = [username, encryptedPassword, userId];
-            const updateUser = global.DSQL_USE_LOCAL
-                ? yield (0, LOCAL_DB_HANDLER_1.default)(updateUserQuery, updateUserValues)
-                : yield (0, DB_HANDLER_1.default)(updateUserQuery, updateUserValues);
-            const addMariadbUser = yield (0, addDbEntry_1.default)({
-                tableName: "mariadb_users",
-                data: {
-                    user_id: userId,
-                    username,
-                    host: defaultMariadbUserHost,
-                    password: encryptedPassword,
-                    primary: "1",
-                    grants: '[{"database":"*","table":"*","privileges":["ALL"]}]',
-                },
-                dbContext: "Master",
-            });
-            console.log(`User ${userId} SQL credentials successfully added.`);
+export default async function addMariadbUser({ userId }) {
+    try {
+        const defaultMariadbUserHost = process.env.DSQL_DB_HOST || "127.0.0.1";
+        const username = grabSQLKeyName({ type: "user", userId });
+        const password = generator.generate({
+            length: 16,
+            numbers: true,
+            symbols: true,
+            uppercase: true,
+            exclude: "*#.'`\"",
+        });
+        const encryptedPassword = encrypt({ data: password });
+        const createMariadbUsersQuery = `CREATE USER IF NOT EXISTS '${username}'@'127.0.0.1' IDENTIFIED BY '${password}'`;
+        if (global.DSQL_USE_LOCAL) {
+            await LOCAL_DB_HANDLER(createMariadbUsersQuery);
         }
-        catch ( /** @type {any} */error) {
-            console.log(`Error in adding SQL user in 'addMariadbUser' function =>`, error.message);
+        else {
+            await NO_DB_HANDLER(createMariadbUsersQuery);
         }
-    });
+        const updateUserQuery = `UPDATE users SET mariadb_user = ?, mariadb_host = '127.0.0.1', mariadb_pass = ? WHERE id = ?`;
+        const updateUserValues = [username, encryptedPassword, userId];
+        const updateUser = global.DSQL_USE_LOCAL
+            ? await LOCAL_DB_HANDLER(updateUserQuery, updateUserValues)
+            : await DB_HANDLER(updateUserQuery, updateUserValues);
+        const addMariadbUser = await addDbEntry({
+            tableName: "mariadb_users",
+            data: {
+                user_id: userId,
+                username,
+                host: defaultMariadbUserHost,
+                password: encryptedPassword,
+                primary: "1",
+                grants: '[{"database":"*","table":"*","privileges":["ALL"]}]',
+            },
+            dbContext: "Master",
+        });
+        console.log(`User ${userId} SQL credentials successfully added.`);
+    }
+    catch ( /** @type {any} */error) {
+        console.log(`Error in adding SQL user in 'addMariadbUser' function =>`, error.message);
+    }
 }
 ////////////////////////////////////////////////
 ////////////////////////////////////////////////

dist/package-shared/functions/backend/addUsersTableToDb.d.ts

@@ -4,9 +4,10 @@ type Param = {
     payload?: {
         [s: string]: any;
     };
+    dbId: string | number;
 };
 /**
  * # Add User Table to Database
  */
-export default function addUsersTableToDb({ userId, database, payload, }: Param): Promise<any>;
+export default function addUsersTableToDb({ userId, database, payload, dbId, }: Param): Promise<any>;
 export {};

dist/package-shared/functions/backend/addUsersTableToDb.js

@@ -1,81 +1,63 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = addUsersTableToDb;
-const serverError_1 = __importDefault(require("./serverError"));
-const DB_HANDLER_1 = __importDefault(require("../../utils/backend/global-db/DB_HANDLER"));
-const grabUserSchemaData_1 = __importDefault(require("./grabUserSchemaData"));
-const setUserSchemaData_1 = __importDefault(require("./setUserSchemaData"));
-const addDbEntry_1 = __importDefault(require("./db/addDbEntry"));
-const createDbFromSchema_1 = __importDefault(require("../../shell/createDbFromSchema"));
-const LOCAL_DB_HANDLER_1 = __importDefault(require("../../utils/backend/global-db/LOCAL_DB_HANDLER"));
-const grabNewUsersTableSchema_1 = __importDefault(require("./grabNewUsersTableSchema"));
+import serverError from "./serverError";
+import DB_HANDLER from "../../utils/backend/global-db/DB_HANDLER";
+import addDbEntry from "./db/addDbEntry";
+import createDbFromSchema from "../../shell/createDbFromSchema";
+import LOCAL_DB_HANDLER from "../../utils/backend/global-db/LOCAL_DB_HANDLER";
+import grabNewUsersTableSchema from "./grabNewUsersTableSchema";
+import { grabPrimaryRequiredDbSchema, writeUpdatedDbSchema, } from "../../shell/createDbFromSchema/grab-required-database-schemas";
 /**
  * # Add User Table to Database
  */
-function addUsersTableToDb(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ userId, database, payload, }) {
-        try {
-            const dbFullName = database;
-            const userPreset = (0, grabNewUsersTableSchema_1.default)({ payload });
-            if (!userPreset)
-                throw new Error("Couldn't Get User Preset!");
-            const userSchemaData = (0, grabUserSchemaData_1.default)({ userId });
-            if (!userSchemaData)
-                throw new Error("User schema data not found!");
-            let targetDatabase = userSchemaData.find((db) => db.dbFullName === database);
-            if (!targetDatabase) {
-                throw new Error("Couldn't Find Target Database!");
-            }
-            let existingTableIndex = targetDatabase === null || targetDatabase === void 0 ? void 0 : targetDatabase.tables.findIndex((table) => table.tableName === "users");
-            if (typeof existingTableIndex == "number" && existingTableIndex > 0) {
-                targetDatabase.tables[existingTableIndex] = userPreset;
-            }
-            else {
-                targetDatabase.tables.push(userPreset);
-            }
-            (0, setUserSchemaData_1.default)({ schemaData: userSchemaData, userId });
-            const targetDb = global.DSQL_USE_LOCAL
-                ? yield (0, LOCAL_DB_HANDLER_1.default)(`SELECT id FROM user_databases WHERE user_id=? AND db_slug=?`, [userId, database])
-                : yield (0, DB_HANDLER_1.default)(`SELECT id FROM user_databases WHERE user_id=? AND db_slug=?`, [userId, database]);
-            if (targetDb === null || targetDb === void 0 ? void 0 : targetDb[0]) {
-                const newTableEntry = yield (0, addDbEntry_1.default)({
-                    dbFullName: "datasquirel",
-                    tableName: "user_database_tables",
-                    data: {
-                        user_id: userId,
-                        db_id: targetDb[0].id,
-                        db_slug: targetDatabase.dbSlug,
-                        table_name: "Users",
-                        table_slug: "users",
-                    },
-                });
-            }
-            const dbShellUpdate = yield (0, createDbFromSchema_1.default)({
-                userId,
-                targetDatabase: dbFullName,
-            });
-            return `Done!`;
+export default async function addUsersTableToDb({ userId, database, payload, dbId, }) {
+    try {
+        const dbFullName = database;
+        const userPreset = grabNewUsersTableSchema({ payload });
+        if (!userPreset)
+            throw new Error("Couldn't Get User Preset!");
+        let targetDatabase = grabPrimaryRequiredDbSchema({
+            dbId,
+            userId,
+        });
+        if (!targetDatabase) {
+            throw new Error("Couldn't Find Target Database!");
         }
-        catch ( /** @type {any} */error) {
-            console.log(`addUsersTableToDb.ts ERROR: ${error.message}`);
-            (0, serverError_1.default)({
-                component: "addUsersTableToDb",
-                message: error.message,
-                user: { id: userId },
-            });
-            return error.message;
+        let existingTableIndex = targetDatabase === null || targetDatabase === void 0 ? void 0 : targetDatabase.tables.findIndex((table) => table.tableName === "users");
+        if (typeof existingTableIndex == "number" && existingTableIndex > 0) {
+            targetDatabase.tables[existingTableIndex] = userPreset;
         }
-    });
+        else {
+            targetDatabase.tables.push(userPreset);
+        }
+        writeUpdatedDbSchema({ dbSchema: targetDatabase, userId });
+        const targetDb = global.DSQL_USE_LOCAL
+            ? await LOCAL_DB_HANDLER(`SELECT id FROM user_databases WHERE user_id=? AND db_slug=?`, [userId, database])
+            : await DB_HANDLER(`SELECT id FROM user_databases WHERE user_id=? AND db_slug=?`, [userId, database]);
+        if (targetDb === null || targetDb === void 0 ? void 0 : targetDb[0]) {
+            const newTableEntry = await addDbEntry({
+                dbFullName: "datasquirel",
+                tableName: "user_database_tables",
+                data: {
+                    user_id: userId,
+                    db_id: targetDb[0].id,
+                    db_slug: targetDatabase.dbSlug,
+                    table_name: "Users",
+                    table_slug: "users",
+                },
+            });
+        }
+        const dbShellUpdate = await createDbFromSchema({
+            userId,
+            targetDatabase: dbFullName,
+        });
+        return `Done!`;
+    }
+    catch ( /** @type {any} */error) {
+        console.log(`addUsersTableToDb.ts ERROR: ${error.message}`);
+        serverError({
+            component: "addUsersTableToDb",
+            message: error.message,
+            user: { id: userId },
+        });
+        return error.message;
+    }
 }

dist/package-shared/functions/backend/api-cred.d.ts

@@ -1,6 +1,4 @@
-import { CheckApiCredentialsFn } from "../../types";
+export {};
 /**
  * # Grap API Credentials
  */
-declare const grabApiCred: CheckApiCredentialsFn;
-export default grabApiCred;

dist/package-shared/functions/backend/api-cred.js

@@ -1,49 +1,47 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = __importDefault(require("fs"));
-const decrypt_1 = __importDefault(require("../dsql/decrypt"));
+export {};
 /**
  * # Grap API Credentials
  */
-const grabApiCred = ({ key, database, table, user_id, media, }) => {
-    var _a, _b;
-    if (!key)
-        return null;
-    if (!user_id)
-        return null;
-    try {
-        const allowedKeysPath = process.env.DSQL_API_KEYS_PATH;
-        if (!allowedKeysPath)
-            throw new Error("process.env.DSQL_API_KEYS_PATH variable not found");
-        const ApiJSON = (0, decrypt_1.default)({ encryptedString: key });
-        const ApiObject = JSON.parse(ApiJSON || "");
-        const isApiKeyValid = fs_1.default.existsSync(`${allowedKeysPath}/${ApiObject.sign}`);
-        if (String(ApiObject.user_id) !== String(user_id))
-            return null;
-        if (!isApiKeyValid)
-            return null;
-        if (!ApiObject.target_database)
-            return ApiObject;
-        if (media)
-            return ApiObject;
-        if (!database && ApiObject.target_database)
-            return null;
-        const isDatabaseAllowed = (_a = ApiObject.target_database) === null || _a === void 0 ? void 0 : _a.split(",").includes(String(database));
-        if (isDatabaseAllowed && !ApiObject.target_table)
-            return ApiObject;
-        if (isDatabaseAllowed && !table && ApiObject.target_table)
-            return null;
-        const isTableAllowed = (_b = ApiObject.target_table) === null || _b === void 0 ? void 0 : _b.split(",").includes(String(table));
-        if (isTableAllowed)
-            return ApiObject;
-        return null;
-    }
-    catch (error) {
-        console.log(`api-cred ERROR: ${error.message}`);
-        return { error: `api-cred ERROR: ${error.message}` };
-    }
-};
-exports.default = grabApiCred;
+// const grabApiCred: CheckApiCredentialsFn = ({
+//     key,
+//     database,
+//     table,
+//     user_id,
+//     media,
+// }) => {
+//     if (!key) return null;
+//     if (!user_id) return null;
+//     try {
+//         const allowedKeysPath = process.env.DSQL_API_KEYS_PATH;
+//         if (!allowedKeysPath)
+//             throw new Error(
+//                 "process.env.DSQL_API_KEYS_PATH variable not found"
+//             );
+//         const ApiJSON = decrypt({ encryptedString: key });
+//         const ApiObject: import("../../types").ApiKeyObject = JSON.parse(
+//             ApiJSON || ""
+//         );
+//         const isApiKeyValid = fs.existsSync(
+//             `${allowedKeysPath}/${ApiObject.sign}`
+//         );
+//         if (String(ApiObject.user_id) !== String(user_id)) return null;
+//         if (!isApiKeyValid) return null;
+//         if (!ApiObject.target_database) return ApiObject;
+//         if (media) return ApiObject;
+//         if (!database && ApiObject.target_database) return null;
+//         const isDatabaseAllowed = ApiObject.target_database
+//             ?.split(",")
+//             .includes(String(database));
+//         if (isDatabaseAllowed && !ApiObject.target_table) return ApiObject;
+//         if (isDatabaseAllowed && !table && ApiObject.target_table) return null;
+//         const isTableAllowed = ApiObject.target_table
+//             ?.split(",")
+//             .includes(String(table));
+//         if (isTableAllowed) return ApiObject;
+//         return null;
+//     } catch (error: any) {
+//         console.log(`api-cred ERROR: ${error.message}`);
+//         return { error: `api-cred ERROR: ${error.message}` };
+//     }
+// };
+// export default grabApiCred;

dist/package-shared/functions/backend/auth/write-auth-files.js

@@ -1,33 +1,26 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkAuthFile = exports.deleteAuthFile = exports.getAuthFile = exports.cleanupUserAuthFiles = exports.writeAuthFile = exports.initAuthFiles = exports.grabAuthDirs = void 0;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const ejson_1 = __importDefault(require("../../../utils/ejson"));
-const debug_log_1 = __importDefault(require("../../../utils/logging/debug-log"));
+import fs from "fs";
+import path from "path";
+import EJSON from "../../../utils/ejson";
+import debugLog from "../../../utils/logging/debug-log";
 function debugFn(log, label) {
-    (0, debug_log_1.default)({ log, addTime: true, title: "write-auth-files", label });
+    debugLog({ log, addTime: true, title: "write-auth-files", label });
 }
-const grabAuthDirs = () => {
+export const grabAuthDirs = () => {
     const DSQL_AUTH_DIR = process.env.DSQL_AUTH_DIR;
     const ROOT_DIR = (DSQL_AUTH_DIR === null || DSQL_AUTH_DIR === void 0 ? void 0 : DSQL_AUTH_DIR.match(/./))
         ? DSQL_AUTH_DIR
-        : path_1.default.resolve(process.cwd(), "./.tmp");
-    const AUTH_DIR = path_1.default.join(ROOT_DIR, "logins");
+        : path.resolve(process.cwd(), "./.tmp");
+    const AUTH_DIR = path.join(ROOT_DIR, "logins");
     return { root: ROOT_DIR, auth: AUTH_DIR };
 };
-exports.grabAuthDirs = grabAuthDirs;
-const initAuthFiles = () => {
+export const initAuthFiles = () => {
     var _a;
     try {
-        const authDirs = (0, exports.grabAuthDirs)();
-        if (!fs_1.default.existsSync(authDirs.root))
-            fs_1.default.mkdirSync(authDirs.root, { recursive: true });
-        if (!fs_1.default.existsSync(authDirs.auth))
-            fs_1.default.mkdirSync(authDirs.auth, { recursive: true });
+        const authDirs = grabAuthDirs();
+        if (!fs.existsSync(authDirs.root))
+            fs.mkdirSync(authDirs.root, { recursive: true });
+        if (!fs.existsSync(authDirs.auth))
+            fs.mkdirSync(authDirs.auth, { recursive: true });
         return true;
     }
     catch (error) {
@@ -36,18 +29,17 @@ const initAuthFiles = () => {
         return false;
     }
 };
-exports.initAuthFiles = initAuthFiles;
 /**
  * # Write Auth Files
  */
-const writeAuthFile = (name, data, cleanup) => {
-    (0, exports.initAuthFiles)();
+export const writeAuthFile = (name, data, cleanup) => {
+    initAuthFiles();
     try {
-        const { auth } = (0, exports.grabAuthDirs)();
+        const { auth } = grabAuthDirs();
         if (cleanup) {
-            (0, exports.cleanupUserAuthFiles)(cleanup.userId);
+            cleanupUserAuthFiles(cleanup.userId);
         }
-        fs_1.default.writeFileSync(path_1.default.join(auth, name), data);
+        fs.writeFileSync(path.join(auth, name), data);
         return true;
     }
     catch (error) {
@@ -55,22 +47,21 @@ const writeAuthFile = (name, data, cleanup) => {
         return false;
     }
 };
-exports.writeAuthFile = writeAuthFile;
 /**
  * # Clean up User Auth Files
  */
-const cleanupUserAuthFiles = (userId) => {
-    (0, exports.initAuthFiles)();
+export const cleanupUserAuthFiles = (userId) => {
+    initAuthFiles();
     try {
-        const { auth } = (0, exports.grabAuthDirs)();
-        const loginFiles = fs_1.default.readdirSync(auth);
+        const { auth } = grabAuthDirs();
+        const loginFiles = fs.readdirSync(auth);
         for (let i = 0; i < loginFiles.length; i++) {
             const loginFile = loginFiles[i];
-            const loginFilePath = path_1.default.join(auth, loginFile);
+            const loginFilePath = path.join(auth, loginFile);
             try {
-                const authPayload = ejson_1.default.parse(fs_1.default.readFileSync(loginFilePath, "utf-8"));
+                const authPayload = EJSON.parse(fs.readFileSync(loginFilePath, "utf-8"));
                 if (authPayload.id == userId) {
-                    fs_1.default.unlinkSync(loginFilePath);
+                    fs.unlinkSync(loginFilePath);
                 }
             }
             catch (error) { }
@@ -82,42 +73,39 @@ const cleanupUserAuthFiles = (userId) => {
         return false;
     }
 };
-exports.cleanupUserAuthFiles = cleanupUserAuthFiles;
 /**
  * # Get Auth Files
  */
-const getAuthFile = (name) => {
+export const getAuthFile = (name) => {
     try {
-        const authFilePath = path_1.default.join((0, exports.grabAuthDirs)().auth, name);
-        return fs_1.default.readFileSync(authFilePath, "utf-8");
+        const authFilePath = path.join(grabAuthDirs().auth, name);
+        return fs.readFileSync(authFilePath, "utf-8");
     }
     catch (error) {
         console.log(`Error getting Auth File: ${error.message}`);
         return null;
     }
 };
-exports.getAuthFile = getAuthFile;
 /**
  * # Delete Auth Files
  * @param {string} name
  */
-const deleteAuthFile = (name) => {
+export const deleteAuthFile = (name) => {
     try {
-        return fs_1.default.rmSync(path_1.default.join((0, exports.grabAuthDirs)().auth, name));
+        return fs.rmSync(path.join(grabAuthDirs().auth, name));
     }
     catch (error) {
         console.log(`Error deleting Auth File: ${error.message}`);
         return null;
     }
 };
-exports.deleteAuthFile = deleteAuthFile;
 /**
  * # Delete Auth Files
  * @param {string} name
  */
-const checkAuthFile = (name) => {
+export const checkAuthFile = (name) => {
     try {
-        return fs_1.default.existsSync(path_1.default.join((0, exports.grabAuthDirs)().auth, name));
+        return fs.existsSync(path.join(grabAuthDirs().auth, name));
         return true;
     }
     catch (error) {
@@ -125,4 +113,3 @@ const checkAuthFile = (name) => {
         return false;
     }
 };
-exports.checkAuthFile = checkAuthFile;

dist/package-shared/functions/backend/cookies/get-auth-cookie-names.js

@@ -1,21 +1,16 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = getAuthCookieNames;
-const get_csrf_header_name_1 = __importDefault(require("../../../actions/get-csrf-header-name"));
+import getCsrfHeaderName from "../../../actions/get-csrf-header-name";
+import { AppNames } from "../../../dict/app-names";
 /**
  * # Grab Auth Cookie Names
  */
-function getAuthCookieNames(params) {
+export default function getAuthCookieNames(params) {
     var _a, _b;
     const cookiesPrefix = process.env.DSQL_COOKIES_PREFIX || "dsql_";
     const cookiesKeyName = process.env.DSQL_COOKIES_KEY_NAME || "key";
-    const cookiesCSRFName = (0, get_csrf_header_name_1.default)();
+    const cookiesCSRFName = getCsrfHeaderName();
     const cookieOneTimeCodeName = process.env.DSQL_COOKIES_ONE_TIME_CODE_NAME || "one-time-code";
-    const targetDatabase = ((_a = params === null || params === void 0 ? void 0 : params.database) === null || _a === void 0 ? void 0 : _a.replace(/^datasquirel_user_\d+_/, "")) ||
-        ((_b = process.env.DSQL_DB_NAME) === null || _b === void 0 ? void 0 : _b.replace(/^datasquirel_user_\d+_/, ""));
+    const targetDatabase = ((_a = params === null || params === void 0 ? void 0 : params.database) === null || _a === void 0 ? void 0 : _a.replace(new RegExp(`^${AppNames["DsqlDbPrefix"]}\\d+_`), "")) ||
+        ((_b = process.env.DSQL_DB_NAME) === null || _b === void 0 ? void 0 : _b.replace(new RegExp(`^${AppNames["DsqlDbPrefix"]}\\d+_`), ""));
     let keyCookieName = cookiesPrefix;
     if (params === null || params === void 0 ? void 0 : params.userId)
         keyCookieName += `user_${params.userId}_`;

dist/package-shared/functions/backend/createDbSchemaFromDb.d.ts

@@ -2,6 +2,7 @@ import { DSQL_DATASQUIREL_USER_DATABASES } from "../../types/dsql";
 type Params = {
     userId: number | string;
     database: DSQL_DATASQUIREL_USER_DATABASES;
+    dbId?: string | number;
 };
-export default function createDbSchemaFromDb({ userId, database, }: Params): Promise<boolean | undefined>;
+export default function createDbSchemaFromDb({ userId, database, dbId, }: Params): Promise<boolean | undefined>;
 export {};

dist/package-shared/functions/backend/createDbSchemaFromDb.js

@@ -1,132 +1,120 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = createDbSchemaFromDb;
-const varDatabaseDbHandler_1 = __importDefault(require("../../functions/backend/varDatabaseDbHandler"));
-const grabUserSchemaData_1 = __importDefault(require("../../functions/backend/grabUserSchemaData"));
-const setUserSchemaData_1 = __importDefault(require("../../functions/backend/setUserSchemaData"));
-const addDbEntry_1 = __importDefault(require("../../functions/backend/db/addDbEntry"));
-const slugToCamelTitle_1 = __importDefault(require("../../shell/utils/slugToCamelTitle"));
-function createDbSchemaFromDb(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ userId, database, }) {
-        var _b, _c, _d, _e, _f, _g;
-        try {
-            if (!userId) {
-                console.log("No user Id provided");
-                return;
-            }
-            const userSchemaData = (0, grabUserSchemaData_1.default)({ userId });
-            if (!userSchemaData)
-                throw new Error("User schema data not found!");
-            const targetDb = userSchemaData.filter((dbObject) => dbObject.dbFullName === database.db_full_name)[0];
-            const existingTables = yield (0, varDatabaseDbHandler_1.default)({
-                database: database.db_full_name,
-                queryString: `SHOW TABLES FROM ${database.db_full_name}`,
+import varDatabaseDbHandler from "../../functions/backend/varDatabaseDbHandler";
+import addDbEntry from "../../functions/backend/db/addDbEntry";
+import slugToCamelTitle from "../../shell/utils/slugToCamelTitle";
+import grabDSQLSchemaIndexComment from "../../shell/utils/grab-dsql-schema-index-comment";
+import { grabPrimaryRequiredDbSchema, writeUpdatedDbSchema, } from "../../shell/createDbFromSchema/grab-required-database-schemas";
+import _n from "../../utils/numberfy";
+import dataTypeParser from "../../utils/db/schema/data-type-parser";
+import dataTypeConstructor from "../../utils/db/schema/data-type-constructor";
+export default async function createDbSchemaFromDb({ userId, database, dbId, }) {
+    var _a, _b, _c, _d, _e, _f;
+    try {
+        if (!userId) {
+            console.log("No user Id provided");
+            return;
+        }
+        const targetDb = grabPrimaryRequiredDbSchema({
+            userId,
+            dbId: database.db_schema_id || dbId,
+        });
+        if (!targetDb)
+            throw new Error(`Target Db not found!`);
+        const existingTables = await varDatabaseDbHandler({
+            database: database.db_full_name,
+            queryString: `SHOW TABLES FROM ${database.db_full_name}`,
+        });
+        if (!existingTables)
+            throw new Error("No Existing Tables");
+        for (let i = 0; i < existingTables.length; i++) {
+            const table = existingTables[i];
+            const tableName = Object.values(table)[0];
+            const tableInsert = await addDbEntry({
+                dbFullName: "datasquirel",
+                tableName: "user_database_tables",
+                data: {
+                    user_id: _n(userId),
+                    db_id: database.id,
+                    db_slug: database.db_slug,
+                    table_name: slugToCamelTitle(tableName) || undefined,
+                    table_slug: tableName,
+                },
             });
-            if (!existingTables)
-                throw new Error("No Existing Tables");
-            for (let i = 0; i < existingTables.length; i++) {
-                const table = existingTables[i];
-                const tableName = Object.values(table)[0];
-                const tableInsert = yield (0, addDbEntry_1.default)({
-                    dbFullName: "datasquirel",
-                    tableName: "user_database_tables",
-                    data: {
-                        user_id: userId,
-                        db_id: database.id,
-                        db_slug: database.db_slug,
-                        table_name: (0, slugToCamelTitle_1.default)(tableName),
-                        table_slug: tableName,
-                    },
-                });
-                const tableObject = {
-                    tableName: tableName,
-                    tableFullName: (0, slugToCamelTitle_1.default)(tableName) || "",
-                    fields: [],
-                    indexes: [],
-                };
-                const tableColumns = yield (0, varDatabaseDbHandler_1.default)({
-                    database: database.db_full_name,
-                    queryString: `SHOW COLUMNS FROM ${database.db_full_name}.${tableName}`,
-                });
-                if (tableColumns) {
-                    for (let k = 0; k < tableColumns.length; k++) {
-                        const tableColumn = tableColumns[k];
-                        const { Field, Type, Null, Key, Default, Extra } = tableColumn;
-                        const fieldObject = {
-                            fieldName: Field,
-                            dataType: Type.toUpperCase(),
-                        };
-                        if (Null === null || Null === void 0 ? void 0 : Null.match(/^no$/i))
-                            fieldObject.notNullValue = true;
-                        if (Key === null || Key === void 0 ? void 0 : Key.match(/^pri$/i))
-                            fieldObject.primaryKey = true;
-                        if ((_b = Default === null || Default === void 0 ? void 0 : Default.toString()) === null || _b === void 0 ? void 0 : _b.match(/./))
-                            fieldObject.defaultValue = Default;
-                        if ((_c = Default === null || Default === void 0 ? void 0 : Default.toString()) === null || _c === void 0 ? void 0 : _c.match(/timestamp/i)) {
-                            delete fieldObject.defaultValue;
-                            fieldObject.defaultValueLiteral = Default;
-                        }
-                        if ((_d = Extra === null || Extra === void 0 ? void 0 : Extra.toString()) === null || _d === void 0 ? void 0 : _d.match(/auto_increment/i))
-                            fieldObject.autoIncrement = true;
-                        tableObject.fields.push(fieldObject);
+            const tableObject = {
+                tableName: tableName,
+                fields: [],
+                indexes: [],
+            };
+            const tableColumns = await varDatabaseDbHandler({
+                database: database.db_full_name,
+                queryString: `SHOW COLUMNS FROM ${database.db_full_name}.${tableName}`,
+            });
+            if (tableColumns) {
+                for (let k = 0; k < tableColumns.length; k++) {
+                    const tableColumn = tableColumns[k];
+                    const { Field, Type, Null, Key, Default, Extra } = tableColumn;
+                    const parsedDataType = dataTypeParser(Type.toUpperCase());
+                    const fieldObject = {
+                        fieldName: Field,
+                        dataType: dataTypeConstructor(parsedDataType.type, parsedDataType.limit, parsedDataType.decimal),
+                    };
+                    if (Null === null || Null === void 0 ? void 0 : Null.match(/^no$/i))
+                        fieldObject.notNullValue = true;
+                    if (Key === null || Key === void 0 ? void 0 : Key.match(/^pri$/i))
+                        fieldObject.primaryKey = true;
+                    if ((_a = Default === null || Default === void 0 ? void 0 : Default.toString()) === null || _a === void 0 ? void 0 : _a.match(/./))
+                        fieldObject.defaultValue = Default;
+                    if ((_b = Default === null || Default === void 0 ? void 0 : Default.toString()) === null || _b === void 0 ? void 0 : _b.match(/timestamp/i)) {
+                        delete fieldObject.defaultValue;
+                        fieldObject.defaultValueLiteral = Default;
                     }
+                    if ((_c = Extra === null || Extra === void 0 ? void 0 : Extra.toString()) === null || _c === void 0 ? void 0 : _c.match(/auto_increment/i))
+                        fieldObject.autoIncrement = true;
+                    tableObject.fields.push(fieldObject);
                 }
-                const tableIndexes = yield (0, varDatabaseDbHandler_1.default)({
-                    database: database.db_full_name,
-                    queryString: `SHOW INDEXES FROM ${database.db_full_name}.${tableName}`,
-                });
-                if (tableIndexes) {
-                    for (let m = 0; m < tableIndexes.length; m++) {
-                        const indexObject = tableIndexes[m];
-                        const { Table, Key_name, Column_name, Null, Index_type, Index_comment, } = indexObject;
-                        if (!(Index_comment === null || Index_comment === void 0 ? void 0 : Index_comment.match(/^schema_index$/)))
-                            continue;
-                        const indexNewObject = {
-                            indexType: (Index_type === null || Index_type === void 0 ? void 0 : Index_type.match(/fulltext/i))
-                                ? "fullText"
-                                : "regular",
-                            indexName: Key_name,
-                            indexTableFields: [],
-                        };
-                        const targetTableFieldObject = tableColumns === null || tableColumns === void 0 ? void 0 : tableColumns.filter((col) => col.Field === Column_name)[0];
-                        const existingIndexField = (_e = tableObject.indexes) === null || _e === void 0 ? void 0 : _e.filter((indx) => indx.indexName == Key_name);
-                        if (existingIndexField && existingIndexField[0]) {
-                            (_f = existingIndexField[0].indexTableFields) === null || _f === void 0 ? void 0 : _f.push({
+            }
+            const tableIndexes = await varDatabaseDbHandler({
+                database: database.db_full_name,
+                queryString: `SHOW INDEXES FROM ${database.db_full_name}.${tableName}`,
+            });
+            if (tableIndexes) {
+                for (let m = 0; m < tableIndexes.length; m++) {
+                    const indexObject = tableIndexes[m];
+                    const { Table, Key_name, Column_name, Null, Index_type, Index_comment, } = indexObject;
+                    if (!(Index_comment === null || Index_comment === void 0 ? void 0 : Index_comment.match(new RegExp(grabDSQLSchemaIndexComment()))))
+                        continue;
+                    const indexNewObject = {
+                        indexType: (Index_type === null || Index_type === void 0 ? void 0 : Index_type.match(/fulltext/i))
+                            ? "full_text"
+                            : "regular",
+                        indexName: Key_name,
+                        indexTableFields: [],
+                    };
+                    const targetTableFieldObject = tableColumns === null || tableColumns === void 0 ? void 0 : tableColumns.filter((col) => col.Field === Column_name)[0];
+                    const existingIndexField = (_d = tableObject.indexes) === null || _d === void 0 ? void 0 : _d.filter((indx) => indx.indexName == Key_name);
+                    if (existingIndexField && existingIndexField[0]) {
+                        (_e = existingIndexField[0].indexTableFields) === null || _e === void 0 ? void 0 : _e.push({
+                            value: Column_name,
+                            dataType: targetTableFieldObject.Type.toUpperCase(),
+                        });
+                    }
+                    else {
+                        indexNewObject.indexTableFields = [
+                            {
                                 value: Column_name,
                                 dataType: targetTableFieldObject.Type.toUpperCase(),
-                            });
-                        }
-                        else {
-                            indexNewObject.indexTableFields = [
-                                {
-                                    value: Column_name,
-                                    dataType: targetTableFieldObject.Type.toUpperCase(),
-                                },
-                            ];
-                            (_g = tableObject.indexes) === null || _g === void 0 ? void 0 : _g.push(indexNewObject);
-                        }
+                            },
+                        ];
+                        (_f = tableObject.indexes) === null || _f === void 0 ? void 0 : _f.push(indexNewObject);
                     }
                 }
-                targetDb.tables.push(tableObject);
             }
-            (0, setUserSchemaData_1.default)({ schemaData: userSchemaData, userId });
-            return true;
+            targetDb.tables.push(tableObject);
         }
-        catch (error) {
-            console.log(error);
-            return false;
-        }
-    });
+        writeUpdatedDbSchema({ dbSchema: targetDb, userId });
+        return true;
+    }
+    catch (error) {
+        console.log(error);
+        return false;
+    }
 }

dist/package-shared/functions/backend/db/addDbEntry.d.ts

@@ -1,16 +1,21 @@
 import { DbContextsArray } from "./runQuery";
-import { PostInsertReturn } from "../../../types";
-type Param<T extends {
+import { APIResponseObject, DSQL_TableSchemaType, PostInsertReturn } from "../../../types";
+export type AddDbEntryParam<T extends {
     [k: string]: any;
-} = any> = {
+} = any, K extends string = string> = {
     dbContext?: (typeof DbContextsArray)[number];
     paradigm?: "Read Only" | "Full Access";
     dbFullName?: string;
-    tableName: string;
-    data: T;
-    tableSchema?: import("../../../types").DSQL_TableSchemaType;
-    duplicateColumnName?: string;
-    duplicateColumnValue?: string;
+    tableName: K;
+    data?: T;
+    batchData?: T[];
+    tableSchema?: DSQL_TableSchemaType;
+    duplicateColumnName?: keyof T;
+    duplicateColumnValue?: string | number;
+    /**
+     * Update Entry if a duplicate is found.
+     * Requires `duplicateColumnName` and `duplicateColumnValue` parameters
+     */
     update?: boolean;
     encryptionKey?: string;
     encryptionSalt?: string;
@@ -22,5 +27,4 @@ type Param<T extends {
  */
 export default function addDbEntry<T extends {
     [k: string]: any;
-} = any>({ dbContext, paradigm, dbFullName, tableName, data, tableSchema, duplicateColumnName, duplicateColumnValue, update, encryptionKey, encryptionSalt, forceLocal, debug, }: Param<T>): Promise<PostInsertReturn | null>;
-export {};
+} = any, K extends string = string>({ dbContext, paradigm, dbFullName, tableName, data, batchData, tableSchema, duplicateColumnName, duplicateColumnValue, update, encryptionKey, encryptionSalt, forceLocal, debug, }: AddDbEntryParam<T, K>): Promise<APIResponseObject<PostInsertReturn>>;

dist/package-shared/functions/backend/db/addDbEntry.js

@@ -1,100 +1,89 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = addDbEntry;
-const sanitize_html_1 = __importDefault(require("sanitize-html"));
-const sanitizeHtmlOptions_1 = __importDefault(require("../html/sanitizeHtmlOptions"));
-const updateDbEntry_1 = __importDefault(require("./updateDbEntry"));
-const encrypt_1 = __importDefault(require("../../dsql/encrypt"));
-const conn_db_handler_1 = __importDefault(require("../../../utils/db/conn-db-handler"));
-const check_if_is_master_1 = __importDefault(require("../../../utils/check-if-is-master"));
-const debug_log_1 = __importDefault(require("../../../utils/logging/debug-log"));
+import sanitizeHtml from "sanitize-html";
+import sanitizeHtmlOptions from "../html/sanitizeHtmlOptions";
+import updateDbEntry from "./updateDbEntry";
+import _ from "lodash";
+import encrypt from "../../dsql/encrypt";
+import connDbHandler from "../../../utils/db/conn-db-handler";
+import checkIfIsMaster from "../../../utils/check-if-is-master";
+import debugLog from "../../../utils/logging/debug-log";
+import purgeDefaultFields from "../../../utils/purge-default-fields";
 /**
  * Add a db Entry Function
  */
-function addDbEntry(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ dbContext, paradigm, dbFullName, tableName, data, tableSchema, duplicateColumnName, duplicateColumnValue, update, encryptionKey, encryptionSalt, forceLocal, debug, }) {
-        var _b, _c, _d;
-        const isMaster = forceLocal
-            ? true
-            : (0, check_if_is_master_1.default)({ dbContext, dbFullName });
-        if (debug) {
-            (0, debug_log_1.default)({
-                log: isMaster,
-                addTime: true,
-                label: "isMaster",
+export default async function addDbEntry({ dbContext, paradigm, dbFullName, tableName, data, batchData, tableSchema, duplicateColumnName, duplicateColumnValue, update, encryptionKey, encryptionSalt, forceLocal, debug, }) {
+    const isMaster = forceLocal
+        ? true
+        : checkIfIsMaster({ dbContext, dbFullName });
+    if (debug) {
+        debugLog({
+            log: isMaster,
+            addTime: true,
+            label: "isMaster",
+        });
+    }
+    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;
+    let newData = _.cloneDeep(data);
+    if (newData) {
+        newData = purgeDefaultFields(newData);
+    }
+    let newBatchData = _.cloneDeep(batchData);
+    if (newBatchData) {
+        newBatchData = purgeDefaultFields(newBatchData);
+    }
+    if (duplicateColumnName &&
+        typeof duplicateColumnName === "string" &&
+        newData) {
+        const checkDuplicateQuery = `SELECT * FROM ${isMaster ? "" : `\`${dbFullName}\`.`}\`${tableName}\` WHERE \`${duplicateColumnName}\`=?`;
+        const duplicateValue = await connDbHandler(DB_RO_CONN, checkDuplicateQuery, [duplicateColumnValue]);
+        if ((duplicateValue === null || duplicateValue === void 0 ? void 0 : duplicateValue[0]) && !update) {
+            return {
+                success: false,
+                payload: undefined,
+                msg: "Duplicate entry found",
+            };
+        }
+        else if ((duplicateValue === null || duplicateValue === void 0 ? void 0 : duplicateValue[0]) && update) {
+            return await updateDbEntry({
+                dbContext,
+                dbFullName,
+                tableName,
+                data: newData,
+                tableSchema,
+                encryptionKey,
+                encryptionSalt,
+                identifierColumnName: duplicateColumnName,
+                identifierValue: duplicateColumnValue || "",
             });
         }
-        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;
-        if (data === null || data === void 0 ? void 0 : data["date_created_timestamp"])
-            delete data["date_created_timestamp"];
-        if (data === null || data === void 0 ? void 0 : data["date_updated_timestamp"])
-            delete data["date_updated_timestamp"];
-        if (data === null || data === void 0 ? void 0 : data["date_updated"])
-            delete data["date_updated"];
-        if (data === null || data === void 0 ? void 0 : data["date_updated_code"])
-            delete data["date_updated_code"];
-        if (data === null || data === void 0 ? void 0 : data["date_created"])
-            delete data["date_created"];
-        if (data === null || data === void 0 ? void 0 : data["date_created_code"])
-            delete data["date_created_code"];
-        if (duplicateColumnName && typeof duplicateColumnName === "string") {
-            const checkDuplicateQuery = `SELECT * FROM ${isMaster ? "" : `\`${dbFullName}\`.`}\`${tableName}\` WHERE \`${duplicateColumnName}\`=?`;
-            const duplicateValue = yield (0, conn_db_handler_1.default)(DB_RO_CONN, checkDuplicateQuery, [duplicateColumnValue]);
-            if ((duplicateValue === null || duplicateValue === void 0 ? void 0 : duplicateValue[0]) && !update) {
-                return null;
-            }
-            else if (duplicateValue && duplicateValue[0] && update) {
-                return yield (0, updateDbEntry_1.default)({
-                    dbContext,
-                    dbFullName,
-                    tableName,
-                    data,
-                    tableSchema,
-                    encryptionKey,
-                    encryptionSalt,
-                    identifierColumnName: duplicateColumnName,
-                    identifierValue: duplicateColumnValue || "",
-                });
-            }
-        }
+    }
+    function generateQuery(data) {
+        var _a, _b, _c;
         const dataKeys = Object.keys(data);
         let insertKeysArray = [];
         let insertValuesArray = [];
         for (let i = 0; i < dataKeys.length; i++) {
             try {
                 const dataKey = dataKeys[i];
-                let value = data === null || data === void 0 ? void 0 : data[dataKey];
+                let value = data[dataKey];
                 const targetFieldSchemaArray = tableSchema
-                    ? (_b = tableSchema === null || tableSchema === void 0 ? void 0 : tableSchema.fields) === null || _b === void 0 ? void 0 : _b.filter((field) => field.fieldName == dataKey)
+                    ? (_a = tableSchema === null || tableSchema === void 0 ? void 0 : tableSchema.fields) === null || _a === void 0 ? void 0 : _a.filter((field) => field.fieldName == dataKey)
                     : null;
                 const targetFieldSchema = targetFieldSchemaArray && targetFieldSchemaArray[0]
                     ? targetFieldSchemaArray[0]
                     : null;
                 if (value == null || value == undefined)
                     continue;
-                if (((_c = targetFieldSchema === null || targetFieldSchema === void 0 ? void 0 : targetFieldSchema.dataType) === null || _c === void 0 ? void 0 : _c.match(/int$/i)) &&
+                if (((_b = targetFieldSchema === null || targetFieldSchema === void 0 ? void 0 : targetFieldSchema.dataType) === null || _b === void 0 ? void 0 : _b.match(/int$/i)) &&
                     typeof value == "string" &&
                     !(value === null || value === void 0 ? void 0 : value.match(/./)))
                     continue;
                 if (targetFieldSchema === null || targetFieldSchema === void 0 ? void 0 : targetFieldSchema.encrypted) {
-                    value = (0, encrypt_1.default)({
+                    value = encrypt({
                         data: value,
                         encryptionKey,
                         encryptionSalt,
@@ -102,8 +91,9 @@ function addDbEntry(_a) {
                     console.log("DSQL: Encrypted value =>", value);
                 }
                 const htmlRegex = /<[^>]+>/g;
-                if ((targetFieldSchema === null || targetFieldSchema === void 0 ? void 0 : targetFieldSchema.richText) || String(value).match(htmlRegex)) {
-                    value = (0, sanitize_html_1.default)(value, sanitizeHtmlOptions_1.default);
+                if ((targetFieldSchema === null || targetFieldSchema === void 0 ? void 0 : targetFieldSchema.richText) ||
+                    String(value).match(htmlRegex)) {
+                    value = sanitizeHtml(value, sanitizeHtmlOptions);
                 }
                 if (targetFieldSchema === null || targetFieldSchema === void 0 ? void 0 : targetFieldSchema.pattern) {
                     const pattern = new RegExp(targetFieldSchema.pattern, targetFieldSchema.patternFlags || "");
@@ -125,55 +115,74 @@ function addDbEntry(_a) {
             }
             catch (error) {
                 console.log("DSQL: Error in parsing data keys =>", error.message);
-                (_d = global.ERROR_CALLBACK) === null || _d === void 0 ? void 0 : _d.call(global, `Error parsing Data Keys`, error);
+                (_c = global.ERROR_CALLBACK) === null || _c === void 0 ? void 0 : _c.call(global, `Error parsing Data Keys`, error);
                 continue;
             }
         }
-        if (!(data === null || data === void 0 ? void 0 : data["date_created"])) {
-            insertKeysArray.push("`date_created`");
-            insertValuesArray.push(Date());
-        }
-        if (!(data === null || data === void 0 ? void 0 : data["date_created_code"])) {
-            insertKeysArray.push("`date_created_code`");
-            insertValuesArray.push(Date.now());
-        }
-        if (!(data === null || data === void 0 ? void 0 : data["date_updated"])) {
-            insertKeysArray.push("`date_updated`");
-            insertValuesArray.push(Date());
-        }
-        if (!(data === null || data === void 0 ? void 0 : data["date_updated_code"])) {
-            insertKeysArray.push("`date_updated_code`");
-            insertValuesArray.push(Date.now());
-        }
-        const query = `INSERT INTO ${isMaster ? "" : `\`${dbFullName}\`.`}\`${tableName}\` (${insertKeysArray.join(",")}) VALUES (${insertValuesArray
-            .map(() => "?")
-            .join(",")})`;
+        insertKeysArray.push("`date_created`");
+        insertValuesArray.push(Date());
+        insertKeysArray.push("`date_created_code`");
+        insertValuesArray.push(Date.now());
+        insertKeysArray.push("`date_updated`");
+        insertValuesArray.push(Date());
+        insertKeysArray.push("`date_updated_code`");
+        insertValuesArray.push(Date.now());
         const queryValuesArray = insertValuesArray;
-        if (debug) {
-            (0, debug_log_1.default)({
-                log: DB_CONN === null || DB_CONN === void 0 ? void 0 : DB_CONN.getConfig(),
-                addTime: true,
-                label: "DB_CONN Config",
-            });
-            (0, debug_log_1.default)({
-                log: query,
-                addTime: true,
-                label: "query",
-            });
-            (0, debug_log_1.default)({
-                log: queryValuesArray,
-                addTime: true,
-                label: "queryValuesArray",
-            });
+        return { queryValuesArray, insertValuesArray, insertKeysArray };
+    }
+    if (newData) {
+        const { insertKeysArray, insertValuesArray, queryValuesArray } = generateQuery(newData);
+        const query = `INSERT INTO ${isMaster && !dbFullName ? "" : `\`${dbFullName}\`.`}\`${tableName}\` (${insertKeysArray.join(",")}) VALUES (${insertValuesArray.map(() => "?").join(",")})`;
+        const newInsert = await connDbHandler(DB_CONN, query, queryValuesArray, debug);
+        return {
+            success: Boolean(newInsert === null || newInsert === void 0 ? void 0 : newInsert.insertId),
+            payload: newInsert,
+            queryObject: {
+                sql: query,
+                params: queryValuesArray,
+            },
+        };
+    }
+    else if (newBatchData) {
+        let batchInsertKeysArray;
+        let batchInsertValuesArray = [];
+        let batchQueryValuesArray = [];
+        for (let i = 0; i < newBatchData.length; i++) {
+            const singleBatchData = newBatchData[i];
+            const { insertKeysArray, insertValuesArray, queryValuesArray } = generateQuery(singleBatchData);
+            if (!batchInsertKeysArray) {
+                batchInsertKeysArray = insertKeysArray;
+            }
+            batchInsertValuesArray.push(insertValuesArray);
+            batchQueryValuesArray.push(queryValuesArray);
         }
-        const newInsert = yield (0, conn_db_handler_1.default)(DB_CONN, query, queryValuesArray, debug);
+        const query = `INSERT INTO ${isMaster && !dbFullName ? "" : `\`${dbFullName}\`.`}\`${tableName}\` (${batchInsertKeysArray === null || batchInsertKeysArray === void 0 ? void 0 : batchInsertKeysArray.join(",")}) VALUES ${batchInsertValuesArray
+            .map((vl) => `(${vl.map(() => "?").join(",")})`)
+            .join(",")}`;
+        console.log("query", query);
+        console.log("batchQueryValuesArray", batchQueryValuesArray);
+        const newInsert = await connDbHandler(DB_CONN, query, batchQueryValuesArray.flat(), debug);
         if (debug) {
-            (0, debug_log_1.default)({
+            debugLog({
                 log: newInsert,
                 addTime: true,
                 label: "newInsert",
             });
         }
-        return newInsert;
-    });
+        return {
+            success: Boolean(newInsert === null || newInsert === void 0 ? void 0 : newInsert.insertId),
+            payload: newInsert,
+            queryObject: {
+                sql: query,
+                params: batchQueryValuesArray.flat(),
+            },
+        };
+    }
+    else {
+        return {
+            success: false,
+            payload: undefined,
+            msg: "No data provided",
+        };
+    }
 }

dist/package-shared/functions/backend/db/deleteDbEntry.d.ts

@@ -1,10 +1,13 @@
+import { DSQL_TableSchemaType, PostInsertReturn } from "../../../types";
 import { DbContextsArray } from "./runQuery";
-type Param = {
+type Param<T extends {
+    [k: string]: any;
+} = any, K extends string = string> = {
     dbContext?: (typeof DbContextsArray)[number];
-    dbFullName: string;
-    tableName: string;
-    tableSchema?: import("../../../types").DSQL_TableSchemaType;
-    identifierColumnName: string;
+    dbFullName?: string;
+    tableName: K;
+    tableSchema?: DSQL_TableSchemaType;
+    identifierColumnName: keyof T;
     identifierValue: string | number;
     forceLocal?: boolean;
 };
@@ -12,5 +15,7 @@ type Param = {
  * # Delete DB Entry Function
  * @description
  */
-export default function deleteDbEntry({ dbContext, dbFullName, tableName, identifierColumnName, identifierValue, forceLocal, }: Param): Promise<object | null>;
+export default function deleteDbEntry<T extends {
+    [k: string]: any;
+} = any, K extends string = string>({ dbContext, dbFullName, tableName, identifierColumnName, identifierValue, forceLocal, }: Param<T, K>): Promise<PostInsertReturn | null>;
 export {};

dist/package-shared/functions/backend/db/deleteDbEntry.js

@@ -1,54 +1,34 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = deleteDbEntry;
-const check_if_is_master_1 = __importDefault(require("../../../utils/check-if-is-master"));
-const conn_db_handler_1 = __importDefault(require("../../../utils/db/conn-db-handler"));
+import checkIfIsMaster from "../../../utils/check-if-is-master";
+import connDbHandler from "../../../utils/db/conn-db-handler";
 /**
  * # Delete DB Entry Function
  * @description
  */
-function deleteDbEntry(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ dbContext, dbFullName, tableName, identifierColumnName, identifierValue, forceLocal, }) {
-        var _b;
-        try {
-            const isMaster = forceLocal
-                ? true
-                : (0, check_if_is_master_1.default)({ dbContext, dbFullName });
-            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 ${isMaster ? "" : `\`${dbFullName}\`.`}\`${tableName}\` WHERE \`${identifierColumnName}\`=?`;
-            const deletedEntry = yield (0, conn_db_handler_1.default)(DB_CONN, query, [
-                identifierValue,
-            ]);
-            /**
-             * Return statement
-             */
-            return deletedEntry;
-        }
-        catch (error) {
-            (_b = global.ERROR_CALLBACK) === null || _b === void 0 ? void 0 : _b.call(global, `Error Deleting Entry`, error);
-            return null;
-        }
-    });
+export default async function deleteDbEntry({ dbContext, dbFullName, tableName, identifierColumnName, identifierValue, forceLocal, }) {
+    var _a;
+    try {
+        const isMaster = forceLocal
+            ? true
+            : checkIfIsMaster({ dbContext, dbFullName });
+        const DB_CONN = isMaster
+            ? global.DSQL_DB_CONN
+            : global.DSQL_FULL_ACCESS_DB_CONN || global.DSQL_DB_CONN;
+        /**
+         * Execution
+         *
+         * @description
+         */
+        const query = `DELETE FROM ${isMaster && !dbFullName ? "" : `\`${dbFullName}\`.`}\`${tableName}\` WHERE \`${identifierColumnName.toString()}\`=?`;
+        const deletedEntry = await connDbHandler(DB_CONN, query, [
+            identifierValue,
+        ]);
+        /**
+         * Return statement
+         */
+        return deletedEntry;
+    }
+    catch (error) {
+        (_a = global.ERROR_CALLBACK) === null || _a === void 0 ? void 0 : _a.call(global, `Error Deleting Entry`, error);
+        return null;
+    }
 }

dist/package-shared/functions/backend/db/pathTraversalCheck.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = pathTraversalCheck;
 /**
  * # Path Traversal Check
  * @returns {string}
  */
-function pathTraversalCheck(text) {
+export default function pathTraversalCheck(text) {
     return text.toString().replace(/\//g, "");
 }

dist/package-shared/functions/backend/db/runQuery.js

@@ -1,155 +1,137 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DbContextsArray = void 0;
-exports.default = runQuery;
-const fullAccessDbHandler_1 = __importDefault(require("../fullAccessDbHandler"));
-const varReadOnlyDatabaseDbHandler_1 = __importDefault(require("../varReadOnlyDatabaseDbHandler"));
-const serverError_1 = __importDefault(require("../serverError"));
-const addDbEntry_1 = __importDefault(require("./addDbEntry"));
-const updateDbEntry_1 = __importDefault(require("./updateDbEntry"));
-const deleteDbEntry_1 = __importDefault(require("./deleteDbEntry"));
-const trim_sql_1 = __importDefault(require("../../../utils/trim-sql"));
-exports.DbContextsArray = ["Master", "Dsql User"];
+import fullAccessDbHandler from "../fullAccessDbHandler";
+import varReadOnlyDatabaseDbHandler from "../varReadOnlyDatabaseDbHandler";
+import serverError from "../serverError";
+import addDbEntry from "./addDbEntry";
+import updateDbEntry from "./updateDbEntry";
+import deleteDbEntry from "./deleteDbEntry";
+import trimSql from "../../../utils/trim-sql";
+export const DbContextsArray = ["Master", "Dsql User"];
 /**
  * # Run DSQL users queries
  */
-function runQuery(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ dbFullName, query, readOnly, dbSchema, queryValuesArray, tableName, debug, dbContext, forceLocal, }) {
-        /**
-         * Declare variables
-         *
-         * @description Declare "results" variable
-         */
-        let result;
-        let error;
-        let tableSchema;
-        if (dbSchema) {
-            try {
-                const table = tableName
-                    ? tableName
-                    : typeof query == "string"
-                        ? null
-                        : query
-                            ? query === null || query === void 0 ? void 0 : query.table
-                            : null;
-                if (!table)
-                    throw new Error("No table name provided");
-                tableSchema = dbSchema.tables.filter((tb) => (tb === null || tb === void 0 ? void 0 : tb.tableName) === table)[0];
-            }
-            catch (_err) {
-                // console.log("ERROR getting tableSchema: ", _err.message);
-            }
-        }
-        /**
-         * Declare variables
-         *
-         * @description Declare "results" variable
-         */
+export default async function runQuery({ dbFullName, query, readOnly, dbSchema, queryValuesArray, tableName, debug, dbContext, forceLocal, }) {
+    /**
+     * Declare variables
+     *
+     * @description Declare "results" variable
+     */
+    let result;
+    let error;
+    let tableSchema;
+    if (dbSchema) {
         try {
-            if (typeof query === "string") {
-                const formattedQuery = (0, trim_sql_1.default)(query);
-                if (debug && global.DSQL_USE_LOCAL) {
-                    console.log("runQuery:formattedQuery", formattedQuery);
-                }
-                /**
-                 * Input Validation
-                 *
-                 * @description Input Validation
-                 */
-                if (readOnly && formattedQuery.match(/^alter|^delete|^create/i)) {
-                    throw new Error("Wrong Input!");
-                }
-                if (readOnly) {
-                    result = yield (0, varReadOnlyDatabaseDbHandler_1.default)({
-                        queryString: formattedQuery,
-                        queryValuesArray: queryValuesArray === null || queryValuesArray === void 0 ? void 0 : queryValuesArray.map((vl) => String(vl)),
-                        tableSchema,
-                        forceLocal,
-                    });
-                }
-                else {
-                    result = yield (0, fullAccessDbHandler_1.default)({
-                        queryString: formattedQuery,
-                        queryValuesArray: queryValuesArray === null || queryValuesArray === void 0 ? void 0 : queryValuesArray.map((vl) => String(vl)),
-                        tableSchema,
-                        forceLocal,
-                    });
-                }
-            }
-            else if (typeof query === "object") {
-                /**
-                 * Declare variables
-                 *
-                 * @description Declare "results" variable
-                 */
-                const { data, action, table, identifierColumnName, identifierValue, update, duplicateColumnName, duplicateColumnValue, } = query;
-                switch (action.toLowerCase()) {
-                    case "insert":
-                        result = yield (0, addDbEntry_1.default)({
-                            dbContext,
-                            dbFullName: dbFullName,
-                            tableName: table,
-                            data: data,
-                            update,
-                            duplicateColumnName,
-                            duplicateColumnValue,
-                            tableSchema,
-                            debug,
-                        });
-                        if (!(result === null || result === void 0 ? void 0 : result.insertId)) {
-                            error = "Couldn't insert data";
-                        }
-                        break;
-                    case "update":
-                        result = yield (0, updateDbEntry_1.default)({
-                            dbContext,
-                            dbFullName: dbFullName,
-                            tableName: table,
-                            data: data,
-                            identifierColumnName,
-                            identifierValue,
-                            tableSchema,
-                        });
-                        break;
-                    case "delete":
-                        result = yield (0, deleteDbEntry_1.default)({
-                            dbContext,
-                            dbFullName: dbFullName,
-                            tableName: table,
-                            identifierColumnName,
-                            identifierValue,
-                            tableSchema,
-                        });
-                        break;
-                    default:
-                        result = null;
-                        break;
-                }
-            }
+            const table = tableName
+                ? tableName
+                : typeof query == "string"
+                    ? null
+                    : query
+                        ? query === null || query === void 0 ? void 0 : query.table
+                        : null;
+            if (!table)
+                throw new Error("No table name provided");
+            tableSchema = dbSchema.tables.filter((tb) => (tb === null || tb === void 0 ? void 0 : tb.tableName) === table)[0];
         }
-        catch (err) {
-            (0, serverError_1.default)({
-                component: "functions/backend/runQuery",
-                message: err.message,
-            });
+        catch (_err) {
+            // console.log("ERROR getting tableSchema: ", _err.message);
+        }
+    }
+    /**
+     * Declare variables
+     *
+     * @description Declare "results" variable
+     */
+    try {
+        if (typeof query === "string") {
+            const formattedQuery = trimSql(query);
             if (debug && global.DSQL_USE_LOCAL) {
-                console.log("runQuery:error", err.message);
+                console.log("runQuery:formattedQuery", formattedQuery);
+            }
+            /**
+             * Input Validation
+             *
+             * @description Input Validation
+             */
+            if (readOnly && formattedQuery.match(/^alter|^delete|^create/i)) {
+                throw new Error("Wrong Input!");
+            }
+            if (readOnly) {
+                result = await varReadOnlyDatabaseDbHandler({
+                    queryString: formattedQuery,
+                    queryValuesArray: queryValuesArray === null || queryValuesArray === void 0 ? void 0 : queryValuesArray.map((vl) => String(vl)),
+                    tableSchema,
+                    forceLocal,
+                });
+            }
+            else {
+                result = await fullAccessDbHandler({
+                    queryString: formattedQuery,
+                    queryValuesArray: queryValuesArray === null || queryValuesArray === void 0 ? void 0 : queryValuesArray.map((vl) => String(vl)),
+                    tableSchema,
+                    forceLocal,
+                });
             }
-            result = null;
-            error = err.message;
         }
-        return { result, error };
-    });
+        else if (typeof query === "object") {
+            /**
+             * Declare variables
+             *
+             * @description Declare "results" variable
+             */
+            const { data, action, table, identifierColumnName, identifierValue, update, duplicateColumnName, duplicateColumnValue, } = query;
+            switch (action.toLowerCase()) {
+                case "insert":
+                    result = await addDbEntry({
+                        dbContext,
+                        dbFullName,
+                        tableName: table,
+                        data: data,
+                        update,
+                        duplicateColumnName,
+                        duplicateColumnValue,
+                        tableSchema,
+                        debug,
+                    });
+                    if (!(result === null || result === void 0 ? void 0 : result.insertId)) {
+                        error = "Couldn't insert data";
+                    }
+                    break;
+                case "update":
+                    result = await updateDbEntry({
+                        dbContext,
+                        dbFullName,
+                        tableName: table,
+                        data: data,
+                        identifierColumnName,
+                        identifierValue,
+                        tableSchema,
+                    });
+                    break;
+                case "delete":
+                    result = await deleteDbEntry({
+                        dbContext,
+                        dbFullName,
+                        tableName: table,
+                        identifierColumnName,
+                        identifierValue,
+                        tableSchema,
+                    });
+                    break;
+                default:
+                    result = null;
+                    break;
+            }
+        }
+    }
+    catch (err) {
+        serverError({
+            component: "functions/backend/runQuery",
+            message: err.message,
+        });
+        if (debug && global.DSQL_USE_LOCAL) {
+            console.log("runQuery:error", err.message);
+        }
+        result = null;
+        error = err.message;
+    }
+    return { result, error };
 }

dist/package-shared/functions/backend/db/sanitizeSql.js

@@ -1,9 +1,4 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const lodash_1 = __importDefault(require("lodash"));
+import _ from "lodash";
 /**
  * Sanitize SQL function
  * ==============================================================================
@@ -89,7 +84,7 @@ function sanitizeObjects(object, spaces) {
  * @returns {string[]|number[]|object[]}
  */
 function sanitizeArrays(array, spaces) {
-    let arrayUpdated = lodash_1.default.cloneDeep(array);
+    let arrayUpdated = _.cloneDeep(array);
     arrayUpdated.forEach((item, index) => {
         const value = item;
         if (!value) {
@@ -108,4 +103,4 @@ function sanitizeArrays(array, spaces) {
     });
     return arrayUpdated;
 }
-exports.default = sanitizeSql;
+export default sanitizeSql;

dist/package-shared/functions/backend/db/updateDbEntry.d.ts

@@ -1,5 +1,5 @@
 import { DbContextsArray } from "./runQuery";
-import { PostInsertReturn } from "../../../types";
+import { APIResponseObject, DSQL_TableSchemaType, PostInsertReturn } from "../../../types";
 type Param<T extends {
     [k: string]: any;
 } = any> = {
@@ -8,8 +8,8 @@ type Param<T extends {
     tableName: string;
     encryptionKey?: string;
     encryptionSalt?: string;
-    data: any;
-    tableSchema?: import("../../../types").DSQL_TableSchemaType;
+    data?: T;
+    tableSchema?: DSQL_TableSchemaType;
     identifierColumnName: keyof T;
     identifierValue: string | number;
     forceLocal?: boolean;
@@ -20,5 +20,5 @@ type Param<T extends {
  */
 export default function updateDbEntry<T extends {
     [k: string]: any;
-} = any>({ dbContext, dbFullName, tableName, data, tableSchema, identifierColumnName, identifierValue, encryptionKey, encryptionSalt, forceLocal, }: Param<T>): Promise<PostInsertReturn | null>;
+} = any>({ dbContext, dbFullName, tableName, data, tableSchema, identifierColumnName, identifierValue, encryptionKey, encryptionSalt, forceLocal, }: Param<T>): Promise<APIResponseObject<PostInsertReturn>>;
 export {};

dist/package-shared/functions/backend/db/updateDbEntry.js

@@ -1,129 +1,127 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = updateDbEntry;
-const sanitize_html_1 = __importDefault(require("sanitize-html"));
-const sanitizeHtmlOptions_1 = __importDefault(require("../html/sanitizeHtmlOptions"));
-const encrypt_1 = __importDefault(require("../../dsql/encrypt"));
-const check_if_is_master_1 = __importDefault(require("../../../utils/check-if-is-master"));
-const conn_db_handler_1 = __importDefault(require("../../../utils/db/conn-db-handler"));
+import sanitizeHtml from "sanitize-html";
+import sanitizeHtmlOptions from "../html/sanitizeHtmlOptions";
+import encrypt from "../../dsql/encrypt";
+import checkIfIsMaster from "../../../utils/check-if-is-master";
+import connDbHandler from "../../../utils/db/conn-db-handler";
+import _ from "lodash";
+import purgeDefaultFields from "../../../utils/purge-default-fields";
 /**
  * # Update DB Function
  * @description
  */
-function updateDbEntry(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ dbContext, dbFullName, tableName, data, tableSchema, identifierColumnName, identifierValue, encryptionKey, encryptionSalt, forceLocal, }) {
-        var _b;
-        /**
-         * Check if data is valid
-         */
-        if (!data || !Object.keys(data).length)
-            return null;
-        const isMaster = forceLocal
-            ? true
-            : (0, check_if_is_master_1.default)({ dbContext, dbFullName });
-        const DB_CONN = isMaster
-            ? global.DSQL_DB_CONN
-            : global.DSQL_FULL_ACCESS_DB_CONN || global.DSQL_DB_CONN;
-        ////////////////////////////////////////
-        ////////////////////////////////////////
-        ////////////////////////////////////////
-        /**
-         * Declare variables
-         *
-         * @description Declare "results" variable
-         */
-        const dataKeys = Object.keys(data);
-        let updateKeyValueArray = [];
-        let updateValues = [];
-        for (let i = 0; i < dataKeys.length; i++) {
-            try {
-                const dataKey = dataKeys[i];
-                // @ts-ignore
-                let value = data[dataKey];
-                const targetFieldSchemaArray = tableSchema
-                    ? (_b = tableSchema === null || tableSchema === void 0 ? void 0 : tableSchema.fields) === null || _b === void 0 ? void 0 : _b.filter((field) => field.fieldName === dataKey)
-                    : null;
-                const targetFieldSchema = targetFieldSchemaArray && targetFieldSchemaArray[0]
-                    ? targetFieldSchemaArray[0]
-                    : null;
-                if (value == null || value == undefined)
-                    continue;
-                const htmlRegex = /<[^>]+>/g;
-                if ((targetFieldSchema === null || targetFieldSchema === void 0 ? void 0 : targetFieldSchema.richText) || String(value).match(htmlRegex)) {
-                    value = (0, sanitize_html_1.default)(value, sanitizeHtmlOptions_1.default);
-                }
-                if (targetFieldSchema === null || targetFieldSchema === void 0 ? void 0 : targetFieldSchema.encrypted) {
-                    value = (0, encrypt_1.default)({
-                        data: value,
-                        encryptionKey,
-                        encryptionSalt,
-                    });
-                }
-                if (typeof value === "object") {
-                    value = JSON.stringify(value);
-                }
-                if (targetFieldSchema === null || targetFieldSchema === void 0 ? void 0 : targetFieldSchema.pattern) {
-                    const pattern = new RegExp(targetFieldSchema.pattern, targetFieldSchema.patternFlags || "");
-                    if (!pattern.test(value)) {
-                        console.log("DSQL: Pattern not matched =>", value);
-                        value = "";
-                    }
-                }
-                if (typeof value === "string" && value.match(/^null$/i)) {
-                    value = {
-                        toSqlString: function () {
-                            return "NULL";
-                        },
-                    };
-                }
-                if (typeof value === "string" && !value.match(/./i)) {
-                    value = {
-                        toSqlString: function () {
-                            return "NULL";
-                        },
-                    };
-                }
-                updateKeyValueArray.push(`\`${dataKey}\`=?`);
-                if (typeof value == "number") {
-                    updateValues.push(String(value));
-                }
-                else {
-                    updateValues.push(value);
-                }
-                ////////////////////////////////////////
-                ////////////////////////////////////////
-            }
-            catch ( /** @type {any} */error) {
-                ////////////////////////////////////////
-                ////////////////////////////////////////
-                console.log("DSQL: Error in parsing data keys in update function =>", error.message);
+export default async function updateDbEntry({ dbContext, dbFullName, tableName, data, tableSchema, identifierColumnName, identifierValue, encryptionKey, encryptionSalt, forceLocal, }) {
+    var _a;
+    /**
+     * Check if data is valid
+     */
+    if (!data || !Object.keys(data).length) {
+        return {
+            success: false,
+            payload: undefined,
+            msg: "No data provided",
+        };
+    }
+    const isMaster = forceLocal
+        ? true
+        : checkIfIsMaster({ dbContext, dbFullName });
+    const DB_CONN = isMaster
+        ? global.DSQL_DB_CONN
+        : global.DSQL_FULL_ACCESS_DB_CONN || global.DSQL_DB_CONN;
+    ////////////////////////////////////////
+    ////////////////////////////////////////
+    ////////////////////////////////////////
+    let newData = _.cloneDeep(data);
+    newData = purgeDefaultFields(newData);
+    /**
+     * Declare variables
+     *
+     * @description Declare "results" variable
+     */
+    const dataKeys = Object.keys(newData);
+    let updateKeyValueArray = [];
+    let updateValues = [];
+    for (let i = 0; i < dataKeys.length; i++) {
+        try {
+            const dataKey = dataKeys[i];
+            let value = newData[dataKey];
+            const targetFieldSchemaArray = tableSchema
+                ? (_a = tableSchema === null || tableSchema === void 0 ? void 0 : tableSchema.fields) === null || _a === void 0 ? void 0 : _a.filter((field) => field.fieldName === dataKey)
+                : null;
+            const targetFieldSchema = targetFieldSchemaArray && targetFieldSchemaArray[0]
+                ? targetFieldSchemaArray[0]
+                : null;
+            if (value == null || value == undefined)
                 continue;
+            const htmlRegex = /<[^>]+>/g;
+            if ((targetFieldSchema === null || targetFieldSchema === void 0 ? void 0 : targetFieldSchema.richText) || String(value).match(htmlRegex)) {
+                value = sanitizeHtml(value, sanitizeHtmlOptions);
             }
+            if (targetFieldSchema === null || targetFieldSchema === void 0 ? void 0 : targetFieldSchema.encrypted) {
+                value = encrypt({
+                    data: value,
+                    encryptionKey,
+                    encryptionSalt,
+                });
+            }
+            if (typeof value === "object") {
+                value = JSON.stringify(value);
+            }
+            if (targetFieldSchema === null || targetFieldSchema === void 0 ? void 0 : targetFieldSchema.pattern) {
+                const pattern = new RegExp(targetFieldSchema.pattern, targetFieldSchema.patternFlags || "");
+                if (!pattern.test(value)) {
+                    console.log("DSQL: Pattern not matched =>", value);
+                    value = "";
+                }
+            }
+            if (typeof value === "string" && value.match(/^null$/i)) {
+                value = {
+                    toSqlString: function () {
+                        return "NULL";
+                    },
+                };
+            }
+            if (typeof value === "string" && !value.match(/./i)) {
+                value = {
+                    toSqlString: function () {
+                        return "NULL";
+                    },
+                };
+            }
+            updateKeyValueArray.push(`\`${dataKey}\`=?`);
+            if (typeof value == "number") {
+                updateValues.push(String(value));
+            }
+            else {
+                updateValues.push(value);
+            }
+            ////////////////////////////////////////
+            ////////////////////////////////////////
         }
-        ////////////////////////////////////////
-        ////////////////////////////////////////
-        updateKeyValueArray.push(`date_updated='${Date()}'`);
-        updateKeyValueArray.push(`date_updated_code='${Date.now()}'`);
-        ////////////////////////////////////////
-        ////////////////////////////////////////
-        const query = `UPDATE ${isMaster ? "" : `\`${dbFullName}\`.`}\`${tableName}\` SET ${updateKeyValueArray.join(",")} WHERE \`${identifierColumnName}\`=?`;
-        updateValues.push(identifierValue);
-        const updatedEntry = yield (0, conn_db_handler_1.default)(DB_CONN, query, updateValues);
-        /**
-         * Return statement
-         */
-        return updatedEntry;
-    });
+        catch ( /** @type {any} */error) {
+            ////////////////////////////////////////
+            ////////////////////////////////////////
+            console.log("DSQL: Error in parsing data keys in update function =>", error.message);
+            continue;
+        }
+    }
+    ////////////////////////////////////////
+    ////////////////////////////////////////
+    updateKeyValueArray.push(`date_updated='${Date()}'`);
+    updateKeyValueArray.push(`date_updated_code='${Date.now()}'`);
+    ////////////////////////////////////////
+    ////////////////////////////////////////
+    const query = `UPDATE ${isMaster && !dbFullName ? "" : `\`${dbFullName}\`.`}\`${tableName}\` SET ${updateKeyValueArray.join(",")} WHERE \`${identifierColumnName}\`=?`;
+    updateValues.push(identifierValue);
+    const updatedEntry = await connDbHandler(DB_CONN, query, updateValues);
+    /**
+     * Return statement
+     */
+    return {
+        success: Boolean(updatedEntry === null || updatedEntry === void 0 ? void 0 : updatedEntry.affectedRows),
+        payload: updatedEntry,
+        queryObject: {
+            sql: query,
+            params: updateValues,
+        },
+    };
 }

dist/package-shared/functions/backend/dbHandler.d.ts

@@ -1,4 +1,11 @@
+type Param = {
+    query: string;
+    values?: string[] | object;
+    noErrorLogs?: boolean;
+};
 /**
  * # Main DB Handler Function
+ * @requires DSQL_DB_CONN - Gobal Variable for Datasquirel Database
  */
-export default function dbHandler(...args: any[]): Promise<any>;
+export default function dbHandler({ query, values, noErrorLogs, }: Param): Promise<any[] | object | null>;
+export {};

dist/package-shared/functions/backend/dbHandler.js

@@ -1,74 +1,47 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = dbHandler;
-const fs_1 = __importDefault(require("fs"));
-const serverError_1 = __importDefault(require("./serverError"));
-const grab_dsql_connection_1 = __importDefault(require("../../utils/grab-dsql-connection"));
-const path_1 = __importDefault(require("path"));
+import fs from "fs";
+import path from "path";
+import grabDSQLConnection from "../../utils/grab-dsql-connection";
 /**
  * # Main DB Handler Function
+ * @requires DSQL_DB_CONN - Gobal Variable for Datasquirel Database
  */
-function dbHandler(...args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        ((_a = process.env.NODE_ENV) === null || _a === void 0 ? void 0 : _a.match(/dev/)) &&
-            fs_1.default.appendFileSync("./.tmp/sqlQuery.sql", args[0] + "\n" + Date() + "\n\n\n", "utf8");
-        const CONNECTION = (0, grab_dsql_connection_1.default)();
-        let results;
-        /**
-         * Fetch from db
-         *
-         * @description Fetch data from db if no cache
-         */
-        try {
-            results = yield new Promise((resolve, reject) => {
-                CONNECTION.query(...args, (error, result, fields) => {
-                    if (error) {
-                        resolve({ error: error.message });
-                    }
-                    else {
-                        resolve(result);
-                    }
-                });
-            });
-        }
-        catch (error) {
-            const tmpFolder = path_1.default.resolve(process.cwd(), "./.tmp");
-            if (!fs_1.default.existsSync(tmpFolder))
-                fs_1.default.mkdirSync(tmpFolder, { recursive: true });
-            fs_1.default.appendFileSync(path_1.default.resolve(tmpFolder, "./dbErrorLogs.txt"), JSON.stringify(error, null, 4) + "\n" + Date() + "\n\n\n", "utf8");
-            results = null;
-            (_b = global.ERROR_CALLBACK) === null || _b === void 0 ? void 0 : _b.call(global, `DB Handler Error`, error);
-            (0, serverError_1.default)({
-                component: "dbHandler",
-                message: error.message,
-            });
-        }
-        finally {
-            yield (CONNECTION === null || CONNECTION === void 0 ? void 0 : CONNECTION.end());
-        }
-        /**
-         * Return results
-         *
-         * @description Return results add to cache if "req" param is passed
-         */
-        if (results) {
-            return JSON.parse(JSON.stringify(results));
+export default async function dbHandler({ query, values, noErrorLogs, }) {
+    var _a;
+    const CONNECTION = grabDSQLConnection();
+    let results;
+    try {
+        if (query && values) {
+            results = await CONNECTION.query(query, values);
         }
         else {
+            results = await CONNECTION.query(query);
+        }
+    }
+    catch (error) {
+        if (!noErrorLogs) {
+            (_a = global.ERROR_CALLBACK) === null || _a === void 0 ? void 0 : _a.call(global, `DB Handler Error...`, error);
+        }
+        if (process.env.FIRST_RUN) {
             return null;
         }
-    });
+        if (!noErrorLogs) {
+            console.log("ERROR in dbHandler =>", error.message);
+            console.log(error);
+            console.log(CONNECTION.config());
+            const tmpFolder = path.resolve(process.cwd(), "./.tmp");
+            if (!fs.existsSync(tmpFolder))
+                fs.mkdirSync(tmpFolder, { recursive: true });
+            fs.appendFileSync(path.resolve(tmpFolder, "./dbErrorLogs.txt"), JSON.stringify(error, null, 4) + "\n" + Date() + "\n\n\n", "utf8");
+        }
+        results = null;
+    }
+    finally {
+        await (CONNECTION === null || CONNECTION === void 0 ? void 0 : CONNECTION.end());
+    }
+    if (results) {
+        return JSON.parse(JSON.stringify(results));
+    }
+    else {
+        return null;
+    }
 }

dist/package-shared/functions/backend/defaultFieldsRegexp.d.ts

@@ -1,7 +0,0 @@
-/**
- * Regular expression to match default fields
- *
- * @description Regular expression to match default fields
- */
-declare const defaultFieldsRegexp: RegExp;
-export default defaultFieldsRegexp;

dist/package-shared/functions/backend/defaultFieldsRegexp.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * Regular expression to match default fields
- *
- * @description Regular expression to match default fields
- */
-const defaultFieldsRegexp = /^id$|^uuid$|^date_created$|^date_created_code$|^date_created_timestamp$|^date_updated$|^date_updated_code$|^date_updated_timestamp$/;
-exports.default = defaultFieldsRegexp;

dist/package-shared/functions/backend/fullAccessDbHandler.js

@@ -1,78 +1,61 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = fullAccessDbHandler;
-const conn_db_handler_1 = __importDefault(require("../../utils/db/conn-db-handler"));
-const parseDbResults_1 = __importDefault(require("./parseDbResults"));
-const serverError_1 = __importDefault(require("./serverError"));
+import connDbHandler from "../../utils/db/conn-db-handler";
+import parseDbResults from "./parseDbResults";
+import serverError from "./serverError";
 /**
  * # Full Access Db Handler
  */
-function fullAccessDbHandler(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ queryString, tableSchema, queryValuesArray, forceLocal, }) {
-        var _b;
+export default async function fullAccessDbHandler({ queryString, tableSchema, queryValuesArray, forceLocal, }) {
+    var _a;
+    /**
+     * Declare variables
+     *
+     * @description Declare "results" variable
+     */
+    let results;
+    const DB_CONN = forceLocal
+        ? global.DSQL_DB_CONN
+        : global.DSQL_FULL_ACCESS_DB_CONN || global.DSQL_DB_CONN;
+    /**
+     * Fetch from db
+     *
+     * @description Fetch data from db if no cache
+     */
+    try {
+        results = await connDbHandler(DB_CONN, queryString, queryValuesArray);
+        ////////////////////////////////////////
+    }
+    catch (error) {
+        ////////////////////////////////////////
+        (_a = global.ERROR_CALLBACK) === null || _a === void 0 ? void 0 : _a.call(global, `Full Access DB Handler Error`, error);
+        serverError({
+            component: "fullAccessDbHandler",
+            message: error.message,
+        });
         /**
-         * Declare variables
-         *
-         * @description Declare "results" variable
+         * Return error
          */
-        let results;
-        const DB_CONN = forceLocal
-            ? global.DSQL_DB_CONN
-            : global.DSQL_FULL_ACCESS_DB_CONN || global.DSQL_DB_CONN;
-        /**
-         * Fetch from db
-         *
-         * @description Fetch data from db if no cache
-         */
-        try {
-            results = yield (0, conn_db_handler_1.default)(DB_CONN, queryString, queryValuesArray);
-            ////////////////////////////////////////
-        }
-        catch (error) {
-            ////////////////////////////////////////
-            (_b = global.ERROR_CALLBACK) === null || _b === void 0 ? void 0 : _b.call(global, `Full Access DB Handler Error`, error);
-            (0, serverError_1.default)({
-                component: "fullAccessDbHandler",
-                message: error.message,
-            });
-            /**
-             * Return error
-             */
-            return error.message;
-        }
-        finally {
-            DB_CONN === null || DB_CONN === void 0 ? void 0 : DB_CONN.end();
-        }
-        /**
-         * Return results
-         *
-         * @description Return results add to cache if "req" param is passed
-         */
-        if (results && tableSchema) {
-            const unparsedResults = results;
-            const parsedResults = yield (0, parseDbResults_1.default)({
-                unparsedResults: unparsedResults,
-                tableSchema: tableSchema,
-            });
-            return parsedResults;
-        }
-        else if (results) {
-            return results;
-        }
-        else {
-            return null;
-        }
-    });
+        return error.message;
+    }
+    finally {
+        DB_CONN === null || DB_CONN === void 0 ? void 0 : DB_CONN.end();
+    }
+    /**
+     * Return results
+     *
+     * @description Return results add to cache if "req" param is passed
+     */
+    if (results && tableSchema) {
+        const unparsedResults = results;
+        const parsedResults = await parseDbResults({
+            unparsedResults: unparsedResults,
+            tableSchema: tableSchema,
+        });
+        return parsedResults;
+    }
+    else if (results) {
+        return results;
+    }
+    else {
+        return null;
+    }
 }

dist/package-shared/functions/backend/grab-mariadb-main-user-for-user.d.ts

@@ -0,0 +1,12 @@
+import { UserType } from "../../types";
+type Params = {
+    user: UserType;
+};
+type Return = {
+    fullName?: string;
+    host?: string;
+    username?: string;
+    password?: string;
+};
+export default function grabMariadbMainUserForUser({ user, }: Params): Promise<Return>;
+export {};

dist/package-shared/functions/backend/grab-mariadb-main-user-for-user.js

@@ -0,0 +1,41 @@
+import dbHandler from "./dbHandler";
+import dsqlCrud from "../../utils/data-fetching/crud";
+import decrypt from "../dsql/decrypt";
+import createUserSQLUser from "../../utils/create-user-sql-user";
+import grabUserMainSqlUserName from "../../utils/grab-user-main-sql-user-name";
+export default async function grabMariadbMainUserForUser({ user, }) {
+    var _a;
+    const { fullName, host, username: mariaDBUsername, webHost, } = grabUserMainSqlUserName({ user });
+    const existingWebAppUser = (await dbHandler({
+        query: `SELECT * FROM mysql.user WHERE user=? AND host=?`,
+        values: [mariaDBUsername, webHost],
+    }));
+    if (!(existingWebAppUser === null || existingWebAppUser === void 0 ? void 0 : existingWebAppUser[0])) {
+        return await createUserSQLUser(user);
+    }
+    else {
+        const existingUserRecord = await dsqlCrud({
+            action: "get",
+            table: "users",
+            query: {
+                query: {
+                    id: {
+                        value: String(user.id),
+                    },
+                },
+            },
+        });
+        const targetUser = (_a = existingUserRecord === null || existingUserRecord === void 0 ? void 0 : existingUserRecord.payload) === null || _a === void 0 ? void 0 : _a[0];
+        if (!(targetUser === null || targetUser === void 0 ? void 0 : targetUser.id)) {
+            return {};
+        }
+        return {
+            fullName,
+            host,
+            username: mariaDBUsername,
+            password: decrypt({
+                encryptedString: targetUser.mariadb_pass || "",
+            }),
+        };
+    }
+}

dist/package-shared/functions/backend/grabNewUsersTableSchema.js

@@ -1,20 +1,14 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = grabNewUsersTableSchema;
-const grabSchemaFieldsFromData_1 = __importDefault(require("./grabSchemaFieldsFromData"));
-const serverError_1 = __importDefault(require("./serverError"));
+import grabSchemaFieldsFromData from "./grabSchemaFieldsFromData";
+import serverError from "./serverError";
 /**
  * # Add User Table to Database
  */
-function grabNewUsersTableSchema(params) {
+export default function grabNewUsersTableSchema(params) {
     try {
         const userPreset = require("../../data/presets/users.json");
         const defaultFields = require("../../data/defaultFields.json");
         const supplementalFields = (params === null || params === void 0 ? void 0 : params.payload)
-            ? (0, grabSchemaFieldsFromData_1.default)({
+            ? grabSchemaFieldsFromData({
                 data: params === null || params === void 0 ? void 0 : params.payload,
                 excludeData: defaultFields,
                 excludeFields: userPreset.fields,
@@ -33,7 +27,7 @@ function grabNewUsersTableSchema(params) {
     }
     catch ( /** @type {any} */error) {
         console.log(`grabNewUsersTableSchema.ts ERROR: ${error.message}`);
-        (0, serverError_1.default)({
+        serverError({
             component: "grabNewUsersTableSchema",
             message: error.message,
         });

dist/package-shared/functions/backend/grabSchemaFieldsFromData.js

@@ -1,14 +1,8 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = grabSchemaFieldsFromData;
-const serverError_1 = __importDefault(require("./serverError"));
+import serverError from "./serverError";
 /**
  * # Add User Table to Database
  */
-function grabSchemaFieldsFromData({ data, fields, excludeData, excludeFields, }) {
+export default function grabSchemaFieldsFromData({ data, fields, excludeData, excludeFields, }) {
     var _a;
     try {
         /** @type {DSQL_FieldSchemaType[]} */
@@ -55,7 +49,7 @@ function grabSchemaFieldsFromData({ data, fields, excludeData, excludeFields, })
     }
     catch ( /** @type {any} */error) {
         console.log(`grabSchemaFieldsFromData.ts ERROR: ${error.message}`);
-        (0, serverError_1.default)({
+        serverError({
             component: "grabSchemaFieldsFromData.ts",
             message: error.message,
         });

dist/package-shared/functions/backend/grabUserSchemaData.d.ts

@@ -1,9 +0,0 @@
-import { DSQL_DatabaseSchemaType } from "../../types";
-type Params = {
-    userId?: string | number;
-};
-/**
- * # Grab User Schema Data
- */
-export default function grabUserSchemaData({ userId, }: Params): DSQL_DatabaseSchemaType[] | null;
-export {};

dist/package-shared/functions/backend/grabUserSchemaData.js

@@ -1,30 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = grabUserSchemaData;
-const serverError_1 = __importDefault(require("./serverError"));
-const fs_1 = __importDefault(require("fs"));
-const grab_dir_names_1 = __importDefault(require("../../utils/backend/names/grab-dir-names"));
-const ejson_1 = __importDefault(require("../../utils/ejson"));
-/**
- * # Grab User Schema Data
- */
-function grabUserSchemaData({ userId, }) {
-    var _a;
-    try {
-        const { userSchemaMainJSONFilePath } = (0, grab_dir_names_1.default)({ userId });
-        const schemaJSON = fs_1.default.readFileSync(userSchemaMainJSONFilePath || "", "utf-8");
-        const schemaObj = ejson_1.default.parse(schemaJSON);
-        return schemaObj;
-    }
-    catch (error) {
-        (0, serverError_1.default)({
-            component: "grabUserSchemaData",
-            message: error.message,
-        });
-        (_a = global.ERROR_CALLBACK) === null || _a === void 0 ? void 0 : _a.call(global, `Error Grabbing User Schema Data`, error);
-        return null;
-    }
-}

dist/package-shared/functions/backend/handleNodemailer.js

@@ -1,67 +1,50 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = handleNodemailer;
-const fs_1 = __importDefault(require("fs"));
-const lodash_1 = __importDefault(require("lodash"));
-const nodemailer_1 = __importDefault(require("nodemailer"));
+import fs from "fs";
+import _ from "lodash";
+import nodemailer from "nodemailer";
 /**
  * # Handle mails With Nodemailer
  */
-function handleNodemailer(params) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        if (!process.env.DSQL_MAIL_HOST ||
-            !process.env.DSQL_MAIL_EMAIL ||
-            !process.env.DSQL_MAIL_PASSWORD) {
-            return undefined;
-        }
-        let transporter = nodemailer_1.default.createTransport(Object.assign({ host: process.env.DSQL_MAIL_HOST, port: 465, secure: true, auth: {
-                user: process.env.DSQL_MAIL_EMAIL,
-                pass: process.env.DSQL_MAIL_PASSWORD,
-            } }, params.options));
-        const sender = (() => {
-            var _a;
-            if ((_a = params.alias) === null || _a === void 0 ? void 0 : _a.match(/support/i))
-                return process.env.DSQL_MAIL_EMAIL;
-            return process.env.DSQL_MAIL_EMAIL;
-        })();
-        const mailRootPath = process.env.DSQL_MAIL_ROOT || "./email/index.html";
-        let mailRoot = fs_1.default.existsSync(mailRootPath)
-            ? fs_1.default.readFileSync(mailRootPath, "utf8")
-            : undefined;
-        let finalHtml = mailRoot
-            ? mailRoot
-                .replace(/{{email_body}}/, ((_a = params.html) === null || _a === void 0 ? void 0 : _a.toString()) || "")
-                .replace(/{{issue_date}}/, Date().substring(0, 24))
-            : (_b = params.html) === null || _b === void 0 ? void 0 : _b.toString();
-        try {
-            let mailObject = {};
-            mailObject["from"] = `"${params.senderName || "Datasquirel"}" <${sender}>`;
-            mailObject["sender"] = sender;
-            if (params.alias)
-                mailObject["replyTo"] = sender;
-            mailObject["to"] = params.to;
-            mailObject["subject"] = params.subject;
-            mailObject["text"] = params.text;
-            mailObject["html"] = finalHtml;
-            let info = yield transporter.sendMail(Object.assign(Object.assign({}, lodash_1.default.omit(mailObject, ["alias", "senderName", "options"])), mailObject));
-            return info;
-        }
-        catch (error) {
-            console.log("ERROR in handleNodemailer Function =>", error.message);
-        }
+export default async function handleNodemailer(params) {
+    var _a, _b;
+    if (!process.env.DSQL_MAIL_HOST ||
+        !process.env.DSQL_MAIL_EMAIL ||
+        !process.env.DSQL_MAIL_PASSWORD) {
         return undefined;
-    });
+    }
+    let transporter = nodemailer.createTransport(Object.assign({ host: process.env.DSQL_MAIL_HOST, port: 465, secure: true, auth: {
+            user: process.env.DSQL_MAIL_EMAIL,
+            pass: process.env.DSQL_MAIL_PASSWORD,
+        } }, params.options));
+    const sender = (() => {
+        var _a;
+        if ((_a = params.alias) === null || _a === void 0 ? void 0 : _a.match(/support/i))
+            return process.env.DSQL_MAIL_EMAIL;
+        return process.env.DSQL_MAIL_EMAIL;
+    })();
+    const mailRootPath = process.env.DSQL_MAIL_ROOT || "./email/index.html";
+    let mailRoot = fs.existsSync(mailRootPath)
+        ? fs.readFileSync(mailRootPath, "utf8")
+        : undefined;
+    let finalHtml = mailRoot
+        ? mailRoot
+            .replace(/{{email_body}}/, ((_a = params.html) === null || _a === void 0 ? void 0 : _a.toString()) || "")
+            .replace(/{{issue_date}}/, Date().substring(0, 24))
+        : (_b = params.html) === null || _b === void 0 ? void 0 : _b.toString();
+    try {
+        let mailObject = {};
+        mailObject["from"] = `"${params.senderName || "Datasquirel"}" <${sender}>`;
+        mailObject["sender"] = sender;
+        if (params.alias)
+            mailObject["replyTo"] = sender;
+        mailObject["to"] = params.to;
+        mailObject["subject"] = params.subject;
+        mailObject["text"] = params.text;
+        mailObject["html"] = finalHtml;
+        let info = await transporter.sendMail(Object.assign(Object.assign({}, _.omit(mailObject, ["alias", "senderName", "options"])), mailObject));
+        return info;
+    }
+    catch (error) {
+        console.log("ERROR in handleNodemailer Function =>", error.message);
+    }
+    return undefined;
 }

dist/package-shared/functions/backend/html/sanitizeHtmlOptions.js

@@ -1,5 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
 const sanitizeHtmlOptions = {
     allowedTags: [
         "b",
@@ -31,4 +29,4 @@ const sanitizeHtmlOptions = {
         "*": ["style", "class", "title"],
     },
 };
-exports.default = sanitizeHtmlOptions;
+export default sanitizeHtmlOptions;

dist/package-shared/functions/backend/httpsRequest.js

@@ -1,19 +1,13 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = httpsRequest;
-const https_1 = __importDefault(require("https"));
-const http_1 = __importDefault(require("http"));
-const url_1 = require("url");
+import https from "https";
+import http from "http";
+import { URL } from "url";
 /**
  * # Make Https Request
  */
-function httpsRequest({ url, method, hostname, path, headers, body, port, scheme, }) {
+export default function httpsRequest({ url, method, hostname, path, headers, body, port, scheme, }) {
     var _a;
     const reqPayloadString = body ? JSON.stringify(body) : null;
-    const PARSED_URL = url ? new url_1.URL(url) : null;
+    const PARSED_URL = url ? new URL(url) : null;
     ////////////////////////////////////////////////
     ////////////////////////////////////////////////
     ////////////////////////////////////////////////
@@ -49,10 +43,10 @@ function httpsRequest({ url, method, hostname, path, headers, body, port, scheme
     return new Promise((res, rej) => {
         var _a;
         const httpsRequest = ((scheme === null || scheme === void 0 ? void 0 : scheme.match(/https/i))
-            ? https_1.default
+            ? https
             : ((_a = PARSED_URL === null || PARSED_URL === void 0 ? void 0 : PARSED_URL.protocol) === null || _a === void 0 ? void 0 : _a.match(/https/i))
-                ? https_1.default
-                : http_1.default).request(
+                ? https
+                : http).request(
         /* ====== Request Options object ====== */
         requestOptions, 
         ////////////////////////////////////////////////

dist/package-shared/functions/backend/noDatabaseDbHandler.js

@@ -1,64 +1,47 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = noDatabaseDbHandler;
-const fs_1 = __importDefault(require("fs"));
-const serverError_1 = __importDefault(require("./serverError"));
-const NO_DB_HANDLER_1 = __importDefault(require("../../utils/backend/global-db/NO_DB_HANDLER"));
+import fs from "fs";
+import serverError from "./serverError";
+import NO_DB_HANDLER from "../../utils/backend/global-db/NO_DB_HANDLER";
 /**
  * # No Database DB Handler
  */
-function noDatabaseDbHandler(queryString) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        ((_a = process.env.NODE_ENV) === null || _a === void 0 ? void 0 : _a.match(/dev/)) &&
-            fs_1.default.appendFileSync("./.tmp/sqlQuery.sql", queryString + "\n" + Date() + "\n\n\n", "utf8");
-        /**
-         * Declare variables
-         *
-         * @description Declare "results" variable
-         */
-        let results;
-        /**
-         * Fetch from db
-         *
-         * @description Fetch data from db if no cache
-         */
-        try {
-            /** ********************* Run Query */
-            results = yield (0, NO_DB_HANDLER_1.default)(queryString);
-            ////////////////////////////////////////
-            ////////////////////////////////////////
-            ////////////////////////////////////////
-        }
-        catch ( /** @type {any} */error) {
-            (0, serverError_1.default)({
-                component: "noDatabaseDbHandler",
-                message: error.message,
-            });
-            console.log("ERROR in noDatabaseDbHandler =>", error.message);
-        }
-        /**
-         * Return results
-         *
-         * @description Return results add to cache if "req" param is passed
-         */
-        if (results) {
-            return results;
-        }
-        else {
-            return null;
-        }
-    });
+export default async function noDatabaseDbHandler(queryString) {
+    var _a;
+    ((_a = process.env.NODE_ENV) === null || _a === void 0 ? void 0 : _a.match(/dev/)) &&
+        fs.appendFileSync("./.tmp/sqlQuery.sql", queryString + "\n" + Date() + "\n\n\n", "utf8");
+    /**
+     * Declare variables
+     *
+     * @description Declare "results" variable
+     */
+    let results;
+    /**
+     * Fetch from db
+     *
+     * @description Fetch data from db if no cache
+     */
+    try {
+        /** ********************* Run Query */
+        results = await NO_DB_HANDLER(queryString);
+        ////////////////////////////////////////
+        ////////////////////////////////////////
+        ////////////////////////////////////////
+    }
+    catch ( /** @type {any} */error) {
+        serverError({
+            component: "noDatabaseDbHandler",
+            message: error.message,
+        });
+        console.log("ERROR in noDatabaseDbHandler =>", error.message);
+    }
+    /**
+     * Return results
+     *
+     * @description Return results add to cache if "req" param is passed
+     */
+    if (results) {
+        return results;
+    }
+    else {
+        return null;
+    }
 }

dist/package-shared/functions/backend/parseDbResults.js

@@ -1,21 +1,6 @@
-"use strict";
 // @ts-check
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = parseDbResults;
-const decrypt_1 = __importDefault(require("../dsql/decrypt"));
-const defaultFieldsRegexp_1 = __importDefault(require("./defaultFieldsRegexp"));
+import decrypt from "../dsql/decrypt";
+import defaultFieldsRegexp from "../dsql/default-fields-regexp";
 /**
  * Parse Database results
  * ==============================================================================
@@ -23,54 +8,52 @@ const defaultFieldsRegexp_1 = __importDefault(require("./defaultFieldsRegexp"));
  * function, decrypts encrypted fields, and returns an updated array with no encrypted
  * fields
  */
-function parseDbResults(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ unparsedResults, tableSchema, }) {
+export default async function parseDbResults({ unparsedResults, tableSchema, }) {
+    /**
+     * Declare variables
+     *
+     * @description Declare "results" variable
+     */
+    let parsedResults = [];
+    try {
         /**
          * Declare variables
          *
          * @description Declare "results" variable
          */
-        let parsedResults = [];
-        try {
-            /**
-             * Declare variables
-             *
-             * @description Declare "results" variable
-             */
-            for (let pr = 0; pr < unparsedResults.length; pr++) {
-                let result = unparsedResults[pr];
-                let resultFieldNames = Object.keys(result);
-                for (let i = 0; i < resultFieldNames.length; i++) {
-                    const resultFieldName = resultFieldNames[i];
-                    let resultFieldSchema = tableSchema === null || tableSchema === void 0 ? void 0 : tableSchema.fields[i];
-                    if (resultFieldName === null || resultFieldName === void 0 ? void 0 : resultFieldName.match(defaultFieldsRegexp_1.default)) {
-                        continue;
-                    }
-                    let value = result[resultFieldName];
-                    if (typeof value !== "number" && !value) {
-                        // parsedResults.push(result);
-                        continue;
-                    }
-                    if (resultFieldSchema === null || resultFieldSchema === void 0 ? void 0 : resultFieldSchema.encrypted) {
-                        if (value === null || value === void 0 ? void 0 : value.match(/./)) {
-                            result[resultFieldName] = (0, decrypt_1.default)({
-                                encryptedString: value,
-                            });
-                        }
+        for (let pr = 0; pr < unparsedResults.length; pr++) {
+            let result = unparsedResults[pr];
+            let resultFieldNames = Object.keys(result);
+            for (let i = 0; i < resultFieldNames.length; i++) {
+                const resultFieldName = resultFieldNames[i];
+                let resultFieldSchema = tableSchema === null || tableSchema === void 0 ? void 0 : tableSchema.fields[i];
+                if (resultFieldName === null || resultFieldName === void 0 ? void 0 : resultFieldName.match(defaultFieldsRegexp)) {
+                    continue;
+                }
+                let value = result[resultFieldName];
+                if (typeof value !== "number" && !value) {
+                    // parsedResults.push(result);
+                    continue;
+                }
+                if (resultFieldSchema === null || resultFieldSchema === void 0 ? void 0 : resultFieldSchema.encrypted) {
+                    if (value === null || value === void 0 ? void 0 : value.match(/./)) {
+                        result[resultFieldName] = decrypt({
+                            encryptedString: value,
+                        });
                     }
                 }
-                parsedResults.push(result);
             }
-            /**
-             * Declare variables
-             *
-             * @description Declare "results" variable
-             */
-            return parsedResults;
+            parsedResults.push(result);
         }
-        catch ( /** @type {any} */error) {
-            console.log("ERROR in parseDbResults Function =>", error.message);
-            return unparsedResults;
-        }
-    });
+        /**
+         * Declare variables
+         *
+         * @description Declare "results" variable
+         */
+        return parsedResults;
+    }
+    catch ( /** @type {any} */error) {
+        console.log("ERROR in parseDbResults Function =>", error.message);
+        return unparsedResults;
+    }
 }

dist/package-shared/functions/backend/queues/add-queue.d.ts

@@ -4,5 +4,5 @@ type Param = {
     userId: string | number;
     dummy?: boolean;
 };
-export default function addQueue({ queue, userId, dummy }: Param): Promise<import("../../../utils/data-fetching/crud").DsqlCrudReturn | undefined>;
+export default function addQueue({ queue, userId, dummy }: Param): Promise<import("../../../types").APIResponseObject | undefined>;
 export {};

dist/package-shared/functions/backend/queues/add-queue.js

@@ -1,46 +1,29 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = addQueue;
-const get_queue_1 = __importDefault(require("./get-queue"));
-const crud_1 = __importDefault(require("../../../utils/data-fetching/crud"));
-const numberfy_1 = __importDefault(require("../../../utils/numberfy"));
-function addQueue(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ queue, userId, dummy }) {
-        const tableName = "process_queue";
-        const existingQueueRes = dummy
-            ? undefined
-            : (yield (0, get_queue_1.default)({
+import getQueue from "./get-queue";
+import dsqlCrud from "../../../utils/data-fetching/crud";
+import numberfy from "../../../utils/numberfy";
+export default async function addQueue({ queue, userId, dummy }) {
+    const tableName = "process_queue";
+    const existingQueueRes = dummy
+        ? undefined
+        : (await getQueue({
+            query: {
                 query: {
-                    query: {
-                        user_id: {
-                            value: String(userId),
-                        },
-                        job_type: {
-                            value: String(queue.job_type),
-                        },
+                    user_id: {
+                        value: String(userId),
+                    },
+                    job_type: {
+                        value: String(queue.job_type),
                     },
                 },
-            }));
-        const existingQueue = existingQueueRes === null || existingQueueRes === void 0 ? void 0 : existingQueueRes[0];
-        if ((existingQueue === null || existingQueue === void 0 ? void 0 : existingQueue.id) && !dummy)
-            return undefined;
-        const addQueueRes = yield (0, crud_1.default)({
-            action: "insert",
-            table: tableName,
-            data: Object.assign(Object.assign({}, queue), { user_id: (0, numberfy_1.default)(userId) }),
-        });
-        return addQueueRes;
+            },
+        }));
+    const existingQueue = existingQueueRes === null || existingQueueRes === void 0 ? void 0 : existingQueueRes[0];
+    if ((existingQueue === null || existingQueue === void 0 ? void 0 : existingQueue.id) && !dummy)
+        return undefined;
+    const addQueueRes = await dsqlCrud({
+        action: "insert",
+        table: tableName,
+        data: Object.assign(Object.assign({}, queue), { user_id: numberfy(userId) }),
     });
+    return addQueueRes;
 }

dist/package-shared/functions/backend/queues/delete-queue.js

@@ -1,31 +1,14 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = deleteQueue;
-const crud_1 = __importDefault(require("../../../utils/data-fetching/crud"));
-const get_queue_1 = __importDefault(require("./get-queue"));
-function deleteQueue(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ queueId, userId }) {
-        const tableName = "process_queue";
-        const existingQueue = (yield (0, get_queue_1.default)({ userId, queueId }));
-        if (!(existingQueue === null || existingQueue === void 0 ? void 0 : existingQueue.id))
-            return false;
-        const deleteQueueRes = yield (0, crud_1.default)({
-            action: "delete",
-            table: tableName,
-            targetId: existingQueue.id,
-        });
-        return Boolean(deleteQueueRes === null || deleteQueueRes === void 0 ? void 0 : deleteQueueRes.success);
+import dsqlCrud from "../../../utils/data-fetching/crud";
+import getQueue from "./get-queue";
+export default async function deleteQueue({ queueId, userId }) {
+    const tableName = "process_queue";
+    const existingQueue = (await getQueue({ userId, queueId }));
+    if (!(existingQueue === null || existingQueue === void 0 ? void 0 : existingQueue.id))
+        return false;
+    const deleteQueueRes = await dsqlCrud({
+        action: "delete",
+        table: tableName,
+        targetId: existingQueue.id,
     });
+    return Boolean(deleteQueueRes === null || deleteQueueRes === void 0 ? void 0 : deleteQueueRes.success);
 }

dist/package-shared/functions/backend/queues/get-queue.js

@@ -1,35 +1,18 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = getQueue;
-const crud_1 = __importDefault(require("../../../utils/data-fetching/crud"));
-function getQueue(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ queueId, userId, query, single, }) {
-        const tableName = "process_queue";
-        let queryQuery = {};
-        if (queueId) {
-            queryQuery = Object.assign(Object.assign({}, queryQuery), { id: { value: String(queueId) } });
-        }
-        if (userId) {
-            queryQuery = Object.assign(Object.assign({}, queryQuery), { user_id: { value: String(userId) } });
-        }
-        const getQueue = yield (0, crud_1.default)({
-            action: "get",
-            table: tableName,
-            query: Object.assign(Object.assign({}, query), { query: Object.assign(Object.assign({}, query === null || query === void 0 ? void 0 : query.query), queryQuery) }),
-        });
-        const queuePayload = getQueue === null || getQueue === void 0 ? void 0 : getQueue.payload;
-        return queueId || single ? queuePayload === null || queuePayload === void 0 ? void 0 : queuePayload[0] : queuePayload;
+import dsqlCrud from "../../../utils/data-fetching/crud";
+export default async function getQueue({ queueId, userId, query, single, }) {
+    const tableName = "process_queue";
+    let queryQuery = {};
+    if (queueId) {
+        queryQuery = Object.assign(Object.assign({}, queryQuery), { id: { value: String(queueId) } });
+    }
+    if (userId) {
+        queryQuery = Object.assign(Object.assign({}, queryQuery), { user_id: { value: String(userId) } });
+    }
+    const getQueue = await dsqlCrud({
+        action: "get",
+        table: tableName,
+        query: Object.assign(Object.assign({}, query), { query: Object.assign(Object.assign({}, query === null || query === void 0 ? void 0 : query.query), queryQuery) }),
     });
+    const queuePayload = getQueue === null || getQueue === void 0 ? void 0 : getQueue.payload;
+    return queueId || single ? queuePayload === null || queuePayload === void 0 ? void 0 : queuePayload[0] : queuePayload;
 }

dist/package-shared/functions/backend/queues/update-queue.js

@@ -1,28 +1,11 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = updateQueue;
-const crud_1 = __importDefault(require("../../../utils/data-fetching/crud"));
-function updateQueue(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ queueId, queue }) {
-        const tableName = "process_queue";
-        const updateQueueRes = yield (0, crud_1.default)({
-            action: "update",
-            table: tableName,
-            targetId: queueId,
-            data: queue,
-        });
-        return Boolean(updateQueueRes === null || updateQueueRes === void 0 ? void 0 : updateQueueRes.success);
+import dsqlCrud from "../../../utils/data-fetching/crud";
+export default async function updateQueue({ queueId, queue }) {
+    const tableName = "process_queue";
+    const updateQueueRes = await dsqlCrud({
+        action: "update",
+        table: tableName,
+        targetId: queueId,
+        data: queue,
     });
+    return Boolean(updateQueueRes === null || updateQueueRes === void 0 ? void 0 : updateQueueRes.success);
 }

dist/package-shared/functions/backend/serverError.js

@@ -1,76 +1,59 @@
-"use strict";
 // @ts-check
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = serverError;
-const fs_1 = __importDefault(require("fs"));
+import fs from "fs";
 /**
  * # Server Error
  */
-function serverError(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ user, message, component, noMail, req, }) {
-        const date = new Date();
-        const reqIp = (() => {
-            if (!req)
-                return null;
-            try {
-                const forwarded = req.headers["x-forwarded-for"];
-                const realIp = req.headers["x-real-ip"];
-                const cloudflareIp = req.headers["cf-connecting-ip"];
-                // Convert forwarded IPs to string and get the first IP if multiple exist
-                const forwardedIp = Array.isArray(forwarded)
-                    ? forwarded[0]
-                    : forwarded === null || forwarded === void 0 ? void 0 : forwarded.split(",")[0];
-                const clientIp = cloudflareIp ||
-                    forwardedIp ||
-                    realIp ||
-                    req.socket.remoteAddress;
-                if (!clientIp)
-                    return null;
-                return String(clientIp);
-            }
-            catch (error) {
-                return null;
-            }
-        })();
+export default async function serverError({ user, message, component, noMail, req, }) {
+    const date = new Date();
+    const reqIp = (() => {
+        if (!req)
+            return null;
         try {
-            let log = `🚀 SERVER ERROR ===========================\nError Message: ${message}\nComponent: ${component}`;
-            if ((user === null || user === void 0 ? void 0 : user.id) && (user === null || user === void 0 ? void 0 : user.first_name) && (user === null || user === void 0 ? void 0 : user.last_name) && (user === null || user === void 0 ? void 0 : user.email)) {
-                log += `\nUser Id: ${user === null || user === void 0 ? void 0 : user.id}\nUser Name: ${user === null || user === void 0 ? void 0 : user.first_name} ${user === null || user === void 0 ? void 0 : user.last_name}\nUser Email: ${user === null || user === void 0 ? void 0 : user.email}`;
-            }
-            if (req === null || req === void 0 ? void 0 : req.url) {
-                log += `\nURL: ${req.url}`;
-            }
-            if (req === null || req === void 0 ? void 0 : req.body) {
-                log += `\nRequest Body: ${JSON.stringify(req.body, null, 4)}`;
-            }
-            if (reqIp) {
-                log += `\nIP: ${reqIp}`;
-            }
-            log += `\nDate: ${date.toDateString()}`;
-            log += "\n========================================";
-            if (!fs_1.default.existsSync(`./.tmp/error.log`)) {
-                fs_1.default.writeFileSync(`./.tmp/error.log`, "", "utf-8");
-            }
-            const initialText = fs_1.default.readFileSync(`./.tmp/error.log`, "utf-8");
-            fs_1.default.writeFileSync(`./.tmp/error.log`, log);
-            fs_1.default.appendFileSync(`./.tmp/error.log`, `\n\n\n\n\n${initialText}`);
+            const forwarded = req.headers["x-forwarded-for"];
+            const realIp = req.headers["x-real-ip"];
+            const cloudflareIp = req.headers["cf-connecting-ip"];
+            // Convert forwarded IPs to string and get the first IP if multiple exist
+            const forwardedIp = Array.isArray(forwarded)
+                ? forwarded[0]
+                : forwarded === null || forwarded === void 0 ? void 0 : forwarded.split(",")[0];
+            const clientIp = cloudflareIp ||
+                forwardedIp ||
+                realIp ||
+                req.socket.remoteAddress;
+            if (!clientIp)
+                return null;
+            return String(clientIp);
         }
-        catch ( /** @type {any} */error) {
-            console.log("Server Error Reporting Error:", error.message);
+        catch (error) {
+            return null;
         }
-    });
+    })();
+    try {
+        let log = `🚀 SERVER ERROR ===========================\nError Message: ${message}\nComponent: ${component}`;
+        if ((user === null || user === void 0 ? void 0 : user.id) && (user === null || user === void 0 ? void 0 : user.first_name) && (user === null || user === void 0 ? void 0 : user.last_name) && (user === null || user === void 0 ? void 0 : user.email)) {
+            log += `\nUser Id: ${user === null || user === void 0 ? void 0 : user.id}\nUser Name: ${user === null || user === void 0 ? void 0 : user.first_name} ${user === null || user === void 0 ? void 0 : user.last_name}\nUser Email: ${user === null || user === void 0 ? void 0 : user.email}`;
+        }
+        if (req === null || req === void 0 ? void 0 : req.url) {
+            log += `\nURL: ${req.url}`;
+        }
+        if (req === null || req === void 0 ? void 0 : req.body) {
+            log += `\nRequest Body: ${JSON.stringify(req.body, null, 4)}`;
+        }
+        if (reqIp) {
+            log += `\nIP: ${reqIp}`;
+        }
+        log += `\nDate: ${date.toDateString()}`;
+        log += "\n========================================";
+        if (!fs.existsSync(`./.tmp/error.log`)) {
+            fs.writeFileSync(`./.tmp/error.log`, "", "utf-8");
+        }
+        const initialText = fs.readFileSync(`./.tmp/error.log`, "utf-8");
+        fs.writeFileSync(`./.tmp/error.log`, log);
+        fs.appendFileSync(`./.tmp/error.log`, `\n\n\n\n\n${initialText}`);
+    }
+    catch ( /** @type {any} */error) {
+        console.log("Server Error Reporting Error:", error.message);
+    }
 }
 ////////////////////////////////////////
 ////////////////////////////////////////

dist/package-shared/functions/backend/setUserSchemaData.d.ts

@@ -1,10 +0,0 @@
-import { DSQL_DatabaseSchemaType } from "../../types";
-type Param = {
-    userId: string | number;
-    schemaData: DSQL_DatabaseSchemaType[];
-};
-/**
- * # Set User Schema Data
- */
-export default function setUserSchemaData({ userId, schemaData, }: Param): boolean;
-export {};

dist/package-shared/functions/backend/setUserSchemaData.js

@@ -1,31 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = setUserSchemaData;
-const serverError_1 = __importDefault(require("./serverError"));
-const fs_1 = __importDefault(require("fs"));
-const grab_dir_names_1 = __importDefault(require("../../utils/backend/names/grab-dir-names"));
-/**
- * # Set User Schema Data
- */
-function setUserSchemaData({ userId, schemaData, }) {
-    var _a;
-    try {
-        const { userSchemaMainJSONFilePath } = (0, grab_dir_names_1.default)({ userId });
-        if (!userSchemaMainJSONFilePath) {
-            throw new Error(`No User Schema JSON found!`);
-        }
-        fs_1.default.writeFileSync(userSchemaMainJSONFilePath, JSON.stringify(schemaData), "utf8");
-        return true;
-    }
-    catch (error) {
-        (0, serverError_1.default)({
-            component: "/functions/backend/setUserSchemaData",
-            message: error.message,
-        });
-        (_a = global.ERROR_CALLBACK) === null || _a === void 0 ? void 0 : _a.call(global, `Error Setting User Schema`, error);
-        return false;
-    }
-}

dist/package-shared/functions/backend/su-db-handler.d.ts

@@ -0,0 +1,9 @@
+import { UserType } from "../../types";
+type Params = {
+    query?: string;
+    values?: any[];
+    database?: string;
+    user: UserType;
+};
+export default function suDbHandler({ query, database, user, values, }: Params): Promise<any>;
+export {};

dist/package-shared/functions/backend/su-db-handler.js

@@ -0,0 +1,15 @@
+import mysql from "serverless-mysql";
+import connDbHandler from "../../utils/db/conn-db-handler";
+export default async function suDbHandler({ query, database, user, values, }) {
+    const connection = mysql({
+        config: {
+            host: process.env.DSQL_DB_HOST,
+            user: process.env.DSQL_DB_USERNAME,
+            password: process.env.DSQL_DB_PASSWORD,
+            database: database,
+            charset: "utf8mb4",
+        },
+    });
+    const results = await connDbHandler(connection, query);
+    return results;
+}

dist/package-shared/functions/backend/suSocketAuth.js

@@ -1,47 +1,30 @@
-"use strict";
 // @ts-check
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = default_1;
-const parseCookies_1 = __importDefault(require("../../utils/backend/parseCookies"));
-const decrypt_1 = __importDefault(require("../dsql/decrypt"));
-const get_auth_cookie_names_1 = __importDefault(require("./cookies/get-auth-cookie-names"));
-function default_1(req) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const { keyCookieName, csrfCookieName } = (0, get_auth_cookie_names_1.default)();
-        const suKeyName = `${keyCookieName}_su`;
-        const cookies = (0, parseCookies_1.default)({ request: req });
-        if (!(cookies === null || cookies === void 0 ? void 0 : cookies[suKeyName])) {
-            return null;
-        }
-        /** ********************* Grab the payload */
-        let userPayload = (0, decrypt_1.default)({
-            encryptedString: cookies[suKeyName],
-        });
-        /** ********************* Return if no payload */
-        if (!userPayload)
-            return null;
-        /** ********************* Parse the payload */
-        let userObject = JSON.parse(userPayload);
-        if (userObject.password !== process.env.DSQL_USER_KEY)
-            return null;
-        if (userObject.authKey !== process.env.DSQL_SPECIAL_KEY)
-            return null;
-        ////////////////////////////////////////
-        ////////////////////////////////////////
-        ////////////////////////////////////////
-        /** ********************* return user object */
-        return userObject;
+import parseCookies from "../../utils/backend/parseCookies";
+import decrypt from "../dsql/decrypt";
+import getAuthCookieNames from "./cookies/get-auth-cookie-names";
+export default async function (req) {
+    const { keyCookieName, csrfCookieName } = getAuthCookieNames();
+    const suKeyName = `${keyCookieName}_su`;
+    const cookies = parseCookies({ request: req });
+    if (!(cookies === null || cookies === void 0 ? void 0 : cookies[suKeyName])) {
+        return null;
+    }
+    /** ********************* Grab the payload */
+    let userPayload = decrypt({
+        encryptedString: cookies[suKeyName],
     });
+    /** ********************* Return if no payload */
+    if (!userPayload)
+        return null;
+    /** ********************* Parse the payload */
+    let userObject = JSON.parse(userPayload);
+    if (userObject.password !== process.env.DSQL_USER_KEY)
+        return null;
+    if (userObject.authKey !== process.env.DSQL_SPECIAL_KEY)
+        return null;
+    ////////////////////////////////////////
+    ////////////////////////////////////////
+    ////////////////////////////////////////
+    /** ********************* return user object */
+    return userObject;
 }

dist/package-shared/functions/backend/updateUsersTableSchema.d.ts

@@ -5,9 +5,10 @@ type Param = {
     newPayload?: {
         [s: string]: any;
     };
+    dbId: string | number;
 };
 /**
  * # Add User Table to Database
  */
-export default function updateUsersTableSchema({ userId, database, newFields, newPayload, }: Param): Promise<any>;
+export default function updateUsersTableSchema({ userId, database, newFields, newPayload, dbId, }: Param): Promise<any>;
 export {};

dist/package-shared/functions/backend/updateUsersTableSchema.js

@@ -1,64 +1,46 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = updateUsersTableSchema;
-const serverError_1 = __importDefault(require("./serverError"));
-const grabUserSchemaData_1 = __importDefault(require("./grabUserSchemaData"));
-const setUserSchemaData_1 = __importDefault(require("./setUserSchemaData"));
-const createDbFromSchema_1 = __importDefault(require("../../shell/createDbFromSchema"));
-const grabSchemaFieldsFromData_1 = __importDefault(require("./grabSchemaFieldsFromData"));
+import serverError from "./serverError";
+import createDbFromSchema from "../../shell/createDbFromSchema";
+import grabSchemaFieldsFromData from "./grabSchemaFieldsFromData";
+import { grabPrimaryRequiredDbSchema, writeUpdatedDbSchema, } from "../../shell/createDbFromSchema/grab-required-database-schemas";
 /**
  * # Add User Table to Database
  */
-function updateUsersTableSchema(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ userId, database, newFields, newPayload, }) {
-        var _b, _c, _d;
-        try {
-            const dbFullName = database;
-            const userSchemaData = (0, grabUserSchemaData_1.default)({ userId });
-            if (!userSchemaData)
-                throw new Error("User schema data not found!");
-            let targetDatabaseIndex = userSchemaData.findIndex((db) => db.dbFullName === database);
-            if (targetDatabaseIndex < 0) {
-                throw new Error("Couldn't Find Target Database!");
-            }
-            let existingTableIndex = (_b = userSchemaData[targetDatabaseIndex]) === null || _b === void 0 ? void 0 : _b.tables.findIndex((table) => table.tableName === "users");
-            const usersTable = userSchemaData[targetDatabaseIndex].tables[existingTableIndex];
-            if (!((_c = usersTable === null || usersTable === void 0 ? void 0 : usersTable.fields) === null || _c === void 0 ? void 0 : _c[0]))
-                throw new Error("Users Table Not Found!");
-            const additionalFields = (0, grabSchemaFieldsFromData_1.default)({
-                fields: newFields,
-                data: newPayload,
-            });
-            const spliceStartIndex = usersTable.fields.findIndex((field) => field.fieldName === "date_created");
-            const finalSpliceStartIndex = spliceStartIndex >= 0 ? spliceStartIndex : 0;
-            usersTable.fields.splice(finalSpliceStartIndex, 0, ...additionalFields);
-            (0, setUserSchemaData_1.default)({ schemaData: userSchemaData, userId });
-            const dbShellUpdate = yield (0, createDbFromSchema_1.default)({
-                userId,
-                targetDatabase: dbFullName,
-            });
-            return `Done!`;
+export default async function updateUsersTableSchema({ userId, database, newFields, newPayload, dbId, }) {
+    var _a, _b;
+    try {
+        const dbFullName = database;
+        let targetDatabase = grabPrimaryRequiredDbSchema({
+            dbId,
+            userId,
+        });
+        if (!targetDatabase) {
+            throw new Error("Couldn't Find Target Database!");
         }
-        catch (error) {
-            (_d = global.ERROR_CALLBACK) === null || _d === void 0 ? void 0 : _d.call(global, `Error Updating User Table Schema`, error);
-            (0, serverError_1.default)({
-                component: "addUsersTableToDb",
-                message: error.message,
-                user: { id: userId },
-            });
-            return error.message;
-        }
-    });
+        let existingTableIndex = targetDatabase === null || targetDatabase === void 0 ? void 0 : targetDatabase.tables.findIndex((table) => table.tableName === "users");
+        const usersTable = targetDatabase.tables[existingTableIndex];
+        if (!((_a = usersTable === null || usersTable === void 0 ? void 0 : usersTable.fields) === null || _a === void 0 ? void 0 : _a[0]))
+            throw new Error("Users Table Not Found!");
+        const additionalFields = grabSchemaFieldsFromData({
+            fields: newFields,
+            data: newPayload,
+        });
+        const spliceStartIndex = usersTable.fields.findIndex((field) => field.fieldName === "date_created");
+        const finalSpliceStartIndex = spliceStartIndex >= 0 ? spliceStartIndex : 0;
+        usersTable.fields.splice(finalSpliceStartIndex, 0, ...additionalFields);
+        writeUpdatedDbSchema({ dbSchema: targetDatabase, userId });
+        const dbShellUpdate = await createDbFromSchema({
+            userId,
+            targetDatabase: dbFullName,
+        });
+        return `Done!`;
+    }
+    catch (error) {
+        (_b = global.ERROR_CALLBACK) === null || _b === void 0 ? void 0 : _b.call(global, `Error Updating User Table Schema`, error);
+        serverError({
+            component: "addUsersTableToDb",
+            message: error.message,
+            user: { id: userId },
+        });
+        return error.message;
+    }
 }

dist/package-shared/functions/backend/user-db-handler.d.ts

@@ -0,0 +1,11 @@
+import { DSQL_TableSchemaType, UserType } from "../../types";
+type Params = {
+    query?: string;
+    values?: any[];
+    database?: string;
+    tableSchema?: DSQL_TableSchemaType;
+    debug?: boolean;
+    user: UserType;
+};
+export default function userDbHandler({ query, user, database, debug, tableSchema, values, }: Params): Promise<any>;
+export {};

dist/package-shared/functions/backend/user-db-handler.js

@@ -0,0 +1,17 @@
+import mysql from "serverless-mysql";
+import grabMariadbMainUserForUser from "./grab-mariadb-main-user-for-user";
+import connDbHandler from "../../utils/db/conn-db-handler";
+export default async function userDbHandler({ query, user, database, debug, tableSchema, values, }) {
+    const { fullName, host, username, password } = await grabMariadbMainUserForUser({ user });
+    const connection = mysql({
+        config: {
+            host,
+            user: username,
+            password: password,
+            database: database,
+            charset: "utf8mb4",
+        },
+    });
+    const results = await connDbHandler(connection, query);
+    return results;
+}

dist/package-shared/functions/backend/varDatabaseDbHandler.d.ts

@@ -1,8 +1,9 @@
+import { DSQL_TableSchemaType } from "../../types";
 type Param = {
     queryString: string;
     queryValuesArray?: any[];
     database?: string;
-    tableSchema?: import("../../types").DSQL_TableSchemaType;
+    tableSchema?: DSQL_TableSchemaType;
     debug?: boolean;
 };
 /**

dist/package-shared/functions/backend/varDatabaseDbHandler.js

@@ -1,66 +1,49 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = varDatabaseDbHandler;
-const parseDbResults_1 = __importDefault(require("./parseDbResults"));
-const serverError_1 = __importDefault(require("./serverError"));
-const grab_dsql_connection_1 = __importDefault(require("../../utils/grab-dsql-connection"));
-const conn_db_handler_1 = __importDefault(require("../../utils/db/conn-db-handler"));
+import parseDbResults from "./parseDbResults";
+import serverError from "./serverError";
+import grabDSQLConnection from "../../utils/grab-dsql-connection";
+import connDbHandler from "../../utils/db/conn-db-handler";
 /**
  * # DB handler for specific database
  */
-function varDatabaseDbHandler(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ queryString, queryValuesArray, database, tableSchema, debug, }) {
-        var _b;
-        let CONNECTION = (0, grab_dsql_connection_1.default)({ fa: true });
-        if (global.DSQL_USE_LOCAL)
-            CONNECTION = (0, grab_dsql_connection_1.default)({ local: true });
-        if (database === null || database === void 0 ? void 0 : database.match(/^datasquirel$/))
-            CONNECTION = (0, grab_dsql_connection_1.default)();
-        if (debug) {
-            console.log(`varDatabaseDbHandler:query:`, queryString);
-            console.log(`varDatabaseDbHandler:values:`, queryValuesArray);
-            console.log(`varDatabaseDbHandler:CONNECTION:`, CONNECTION.getConfig());
+export default async function varDatabaseDbHandler({ queryString, queryValuesArray, database, tableSchema, debug, }) {
+    var _a;
+    let CONNECTION = grabDSQLConnection({ fa: true });
+    if (global.DSQL_USE_LOCAL)
+        CONNECTION = grabDSQLConnection({ local: true });
+    if (database === null || database === void 0 ? void 0 : database.match(/^datasquirel$/))
+        CONNECTION = grabDSQLConnection();
+    if (debug) {
+        console.log(`varDatabaseDbHandler:query:`, queryString);
+        console.log(`varDatabaseDbHandler:values:`, queryValuesArray);
+        console.log(`varDatabaseDbHandler:CONNECTION:`, CONNECTION.getConfig());
+    }
+    let results = await connDbHandler(CONNECTION, queryString, queryValuesArray);
+    if (debug) {
+        console.log(`varDatabaseDbHandler:results:`, results);
+    }
+    if (results && tableSchema) {
+        try {
+            const unparsedResults = results;
+            const parsedResults = await parseDbResults({
+                unparsedResults: unparsedResults,
+                tableSchema: tableSchema,
+            });
+            return parsedResults;
         }
-        let results = yield (0, conn_db_handler_1.default)(CONNECTION, queryString, queryValuesArray);
-        if (debug) {
-            console.log(`varDatabaseDbHandler:results:`, results);
-        }
-        if (results && tableSchema) {
-            try {
-                const unparsedResults = results;
-                const parsedResults = yield (0, parseDbResults_1.default)({
-                    unparsedResults: unparsedResults,
-                    tableSchema: tableSchema,
-                });
-                return parsedResults;
-            }
-            catch (error) {
-                console.log("\x1b[31mvarDatabaseDbHandler ERROR\x1b[0m =>", database, error);
-                (_b = global.ERROR_CALLBACK) === null || _b === void 0 ? void 0 : _b.call(global, `VarDb Handler Error`, error);
-                (0, serverError_1.default)({
-                    component: "varDatabaseDbHandler/lines-52-53",
-                    message: error.message,
-                });
-                return null;
-            }
-        }
-        else if (results) {
-            return results;
-        }
-        else {
+        catch (error) {
+            console.log("\x1b[31mvarDatabaseDbHandler ERROR\x1b[0m =>", database, error);
+            (_a = global.ERROR_CALLBACK) === null || _a === void 0 ? void 0 : _a.call(global, `VarDb Handler Error`, error);
+            serverError({
+                component: "varDatabaseDbHandler/lines-52-53",
+                message: error.message,
+            });
             return null;
         }
-    });
+    }
+    else if (results) {
+        return results;
+    }
+    else {
+        return null;
+    }
 }

dist/package-shared/functions/backend/varReadOnlyDatabaseDbHandler.js

@@ -1,57 +1,40 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = varReadOnlyDatabaseDbHandler;
-const serverError_1 = __importDefault(require("./serverError"));
-const parseDbResults_1 = __importDefault(require("./parseDbResults"));
-const conn_db_handler_1 = __importDefault(require("../../utils/db/conn-db-handler"));
+import serverError from "./serverError";
+import parseDbResults from "./parseDbResults";
+import connDbHandler from "../../utils/db/conn-db-handler";
 /**
  * # Read Only Db Handler with Varaibles
  * @returns
  */
-function varReadOnlyDatabaseDbHandler(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ queryString, queryValuesArray, tableSchema, forceLocal, }) {
-        var _b;
-        let results;
-        const DB_CONN = forceLocal
-            ? global.DSQL_DB_CONN
-            : global.DSQL_READ_ONLY_DB_CONN || global.DSQL_DB_CONN;
-        try {
-            results = yield (0, conn_db_handler_1.default)(DB_CONN, queryString, queryValuesArray);
-        }
-        catch (error) {
-            (0, serverError_1.default)({
-                component: "varReadOnlyDatabaseDbHandler",
-                message: error.message,
-                noMail: true,
-            });
-            (_b = global.ERROR_CALLBACK) === null || _b === void 0 ? void 0 : _b.call(global, `VarReadOnlyDB Handler Error`, error);
-            return error.message;
-        }
-        finally {
-            DB_CONN === null || DB_CONN === void 0 ? void 0 : DB_CONN.end();
-        }
-        if (results) {
-            const unparsedResults = results;
-            const parsedResults = yield (0, parseDbResults_1.default)({
-                unparsedResults: unparsedResults,
-                tableSchema: tableSchema,
-            });
-            return parsedResults;
-        }
-        else {
-            return null;
-        }
-    });
+export default async function varReadOnlyDatabaseDbHandler({ queryString, queryValuesArray, tableSchema, forceLocal, }) {
+    var _a;
+    let results;
+    const DB_CONN = forceLocal
+        ? global.DSQL_DB_CONN
+        : global.DSQL_READ_ONLY_DB_CONN || global.DSQL_DB_CONN;
+    try {
+        results = await connDbHandler(DB_CONN, queryString, queryValuesArray);
+    }
+    catch (error) {
+        serverError({
+            component: "varReadOnlyDatabaseDbHandler",
+            message: error.message,
+            noMail: true,
+        });
+        (_a = global.ERROR_CALLBACK) === null || _a === void 0 ? void 0 : _a.call(global, `VarReadOnlyDB Handler Error`, error);
+        return error.message;
+    }
+    finally {
+        DB_CONN === null || DB_CONN === void 0 ? void 0 : DB_CONN.end();
+    }
+    if (results) {
+        const unparsedResults = results;
+        const parsedResults = await parseDbResults({
+            unparsedResults: unparsedResults,
+            tableSchema: tableSchema,
+        });
+        return parsedResults;
+    }
+    else {
+        return null;
+    }
 }

dist/package-shared/functions/dsql/db-schema-to-type.js

@@ -1,25 +1,18 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = dbSchemaToType;
-const fs_1 = __importDefault(require("fs"));
-const grab_dir_names_1 = __importDefault(require("../../utils/backend/names/grab-dir-names"));
-const lodash_1 = __importDefault(require("lodash"));
-const ejson_1 = __importDefault(require("../../utils/ejson"));
-const generate_type_definitions_1 = __importDefault(require("./generate-type-definitions"));
-const path_1 = __importDefault(require("path"));
-function dbSchemaToType(params) {
+import fs from "fs";
+import grabDirNames from "../../utils/backend/names/grab-dir-names";
+import _ from "lodash";
+import EJSON from "../../utils/ejson";
+import generateTypeDefinition from "./generate-type-definitions";
+import { AppNames } from "../../dict/app-names";
+export default function dbSchemaToType(params) {
     var _a, _b;
     let datasquirelSchema;
-    const defaultTableFieldsJSONFilePath = path_1.default.resolve(__dirname, "../../data/defaultFields.json");
+    const { mainShemaJSONFilePath, defaultTableFieldsJSONFilePath } = grabDirNames();
     if (params === null || params === void 0 ? void 0 : params.dbSchema) {
         datasquirelSchema = params.dbSchema;
     }
     else {
-        const { mainShemaJSONFilePath } = (0, grab_dir_names_1.default)();
-        const mainSchema = ejson_1.default.parse(fs_1.default.readFileSync(mainShemaJSONFilePath, "utf-8"));
+        const mainSchema = EJSON.parse(fs.readFileSync(mainShemaJSONFilePath, "utf-8"));
         datasquirelSchema = mainSchema.find((sch) => sch.dbFullName == "datasquirel");
     }
     if (!datasquirelSchema)
@@ -27,10 +20,10 @@ function dbSchemaToType(params) {
     let tableNames = `export const DsqlTables = [\n${datasquirelSchema.tables
         .map((tbl) => `    "${tbl.tableName}",`)
         .join("\n")}\n] as const`;
-    const defaultFields = ejson_1.default.parse(fs_1.default.readFileSync(defaultTableFieldsJSONFilePath, "utf-8"));
+    const defaultFields = EJSON.parse(fs.readFileSync(defaultTableFieldsJSONFilePath, "utf-8"));
     const dbTablesSchemas = datasquirelSchema.tables.map((tblSchm) => {
-        let newDefaultFields = lodash_1.default.cloneDeep(defaultFields);
-        return Object.assign(Object.assign({}, tblSchm), { fields: (params === null || params === void 0 ? void 0 : params.dbSchema)
+        let newDefaultFields = _.cloneDeep(defaultFields);
+        return Object.assign(Object.assign({}, tblSchm), { fields: tblSchm.fields.find((fld) => fld.fieldName == "id")
                 ? tblSchm.fields
                 : [
                     newDefaultFields.shift(),
@@ -40,9 +33,9 @@ function dbSchemaToType(params) {
                 ] });
     });
     const defDbName = (_b = (datasquirelSchema.dbName ||
-        ((_a = datasquirelSchema.dbFullName) === null || _a === void 0 ? void 0 : _a.replace(/datasquirel_user_\d+_/, "")))) === null || _b === void 0 ? void 0 : _b.toUpperCase().replace(/ /g, "_");
+        ((_a = datasquirelSchema.dbFullName) === null || _a === void 0 ? void 0 : _a.replace(new RegExp(`${AppNames["DsqlDbPrefix"]}\\d+_`), "")))) === null || _b === void 0 ? void 0 : _b.toUpperCase().replace(/ /g, "_");
     const schemas = dbTablesSchemas
-        .map((table) => (0, generate_type_definitions_1.default)({
+        .map((table) => generateTypeDefinition({
         paradigm: "TypeScript",
         table,
         typeDefName: `DSQL_${defDbName}_${table.tableName.toUpperCase()}`,

dist/package-shared/functions/dsql/decrypt.js

@@ -1,23 +1,17 @@
-"use strict";
 // @ts-check
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = decrypt;
-const crypto_1 = require("crypto");
-const buffer_1 = require("buffer");
-const grab_keys_1 = __importDefault(require("../../utils/grab-keys"));
+import { scryptSync, createDecipheriv } from "crypto";
+import { Buffer } from "buffer";
+import grabKeys from "../../utils/grab-keys";
 /**
  * # Decrypt Function
  */
-function decrypt({ encryptedString, encryptionKey, encryptionSalt, }) {
+export default function decrypt({ encryptedString, encryptionKey, encryptionSalt, }) {
     var _a;
     if (!(encryptedString === null || encryptedString === void 0 ? void 0 : encryptedString.match(/./))) {
         console.log("Encrypted string is invalid");
         return encryptedString;
     }
-    const { key: encrptKey, salt, keyLen, algorithm, bufferAllocSize, } = (0, grab_keys_1.default)({ encryptionKey });
+    const { key: encrptKey, salt, keyLen, algorithm, bufferAllocSize, } = grabKeys({ encryptionKey });
     if (!(encrptKey === null || encrptKey === void 0 ? void 0 : encrptKey.match(/.{8,}/))) {
         console.log("Decrption key is invalid");
         return encryptedString;
@@ -26,9 +20,9 @@ function decrypt({ encryptedString, encryptionKey, encryptionSalt, }) {
         console.log("Decrption salt is invalid");
         return encryptedString;
     }
-    let key = (0, crypto_1.scryptSync)(encrptKey, salt, keyLen);
-    let iv = buffer_1.Buffer.alloc(bufferAllocSize, 0);
-    const decipher = (0, crypto_1.createDecipheriv)(algorithm, key, iv);
+    let key = scryptSync(encrptKey, salt, keyLen);
+    let iv = Buffer.alloc(bufferAllocSize, 0);
+    const decipher = createDecipheriv(algorithm, key, iv);
     try {
         let decrypted = decipher.update(encryptedString, "hex", "utf8");
         decrypted += decipher.final("utf8");
@@ -36,6 +30,7 @@ function decrypt({ encryptedString, encryptionKey, encryptionSalt, }) {
     }
     catch (error) {
         console.log("Error in decrypting =>", error.message);
+        console.log("encryptedString =>", encryptedString);
         (_a = global.ERROR_CALLBACK) === null || _a === void 0 ? void 0 : _a.call(global, `Error Decrypting data`, error);
         return encryptedString;
     }

dist/package-shared/functions/dsql/default-fields-regexp.d.ts

@@ -1,7 +1,7 @@
 /**
- * Check for user in local storage
+ * Regular expression to match default fields
  *
- * @description Preventdefault, declare variables
+ * @description Regular expression to match default fields
  */
 declare const defaultFieldsRegexp: RegExp;
 export default defaultFieldsRegexp;

dist/package-shared/functions/dsql/default-fields-regexp.js

@@ -1,13 +1,7 @@
-"use strict";
-// @ts-check
-Object.defineProperty(exports, "__esModule", { value: true });
 /**
- * Check for user in local storage
+ * Regular expression to match default fields
  *
- * @description Preventdefault, declare variables
+ * @description Regular expression to match default fields
  */
-const defaultFieldsRegexp = /^id$|^uuid$|^date_created$|^date_created_code$|^date_created_timestamp$|^date_updated$|^date_updated_code$|^date_updated_timestamp$/;
-////////////////////////////////////////
-////////////////////////////////////////
-////////////////////////////////////////
-exports.default = defaultFieldsRegexp;
+const defaultFieldsRegexp = /^id$|^uuid$|^uid$|^date_created$|^date_created_code$|^date_created_timestamp$|^date_updated$|^date_updated_code$|^date_updated_timestamp$/;
+export default defaultFieldsRegexp;

dist/package-shared/functions/dsql/encrypt.js

@@ -1,23 +1,17 @@
-"use strict";
 // @ts-check
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = encrypt;
-const crypto_1 = require("crypto");
-const buffer_1 = require("buffer");
-const grab_keys_1 = __importDefault(require("../../utils/grab-keys"));
+import { scryptSync, createCipheriv } from "crypto";
+import { Buffer } from "buffer";
+import grabKeys from "../../utils/grab-keys";
 /**
  * # Encrypt String
  */
-function encrypt({ data, encryptionKey, encryptionSalt, }) {
+export default function encrypt({ data, encryptionKey, encryptionSalt, }) {
     var _a;
     if (!(data === null || data === void 0 ? void 0 : data.match(/./))) {
         console.log("Encryption string is invalid");
         return data;
     }
-    const { key: encrptKey, salt, keyLen, algorithm, bufferAllocSize, } = (0, grab_keys_1.default)({ encryptionKey });
+    const { key: encrptKey, salt, keyLen, algorithm, bufferAllocSize, } = grabKeys({ encryptionKey });
     if (!(encrptKey === null || encrptKey === void 0 ? void 0 : encrptKey.match(/.{8,}/))) {
         console.log("Encryption key is invalid");
         return data;
@@ -27,9 +21,9 @@ function encrypt({ data, encryptionKey, encryptionSalt, }) {
         return data;
     }
     const password = encrptKey;
-    let key = (0, crypto_1.scryptSync)(password, salt, keyLen);
-    let iv = buffer_1.Buffer.alloc(bufferAllocSize, 0);
-    const cipher = (0, crypto_1.createCipheriv)(algorithm, key, iv);
+    let key = scryptSync(password, salt, keyLen);
+    let iv = Buffer.alloc(bufferAllocSize, 0);
+    const cipher = createCipheriv(algorithm, key, iv);
     try {
         let encrypted = cipher.update(data, "utf8", "hex");
         encrypted += cipher.final("hex");

dist/package-shared/functions/dsql/generate-type-definitions.d.ts

@@ -6,6 +6,7 @@ type Param = {
     typeDefName?: string;
     allValuesOptional?: boolean;
     addExport?: boolean;
+    dbName?: string;
 };
-export default function generateTypeDefinition({ paradigm, table, query, typeDefName, allValuesOptional, addExport, }: Param): string | null;
+export default function generateTypeDefinition({ paradigm, table, query, typeDefName, allValuesOptional, addExport, dbName, }: Param): string | null;
 export {};

dist/package-shared/functions/dsql/generate-type-definitions.js

@@ -1,21 +1,30 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = generateTypeDefinition;
-const default_fields_regexp_1 = __importDefault(require("./default-fields-regexp"));
-function generateTypeDefinition({ paradigm, table, query, typeDefName, allValuesOptional, addExport, }) {
+import defaultFieldsRegexp from "./default-fields-regexp";
+export default function generateTypeDefinition({ paradigm, table, query, typeDefName, allValuesOptional, addExport, dbName, }) {
     let typeDefinition = ``;
     try {
-        const tdName = typeDefName ||
-            `DSQL_${query.single}_${query.single_table}`.toUpperCase();
+        const tdName = typeDefName
+            ? typeDefName
+            : dbName
+                ? `DSQL_${dbName}_${table.tableName}`.toUpperCase()
+                : `DSQL_${query.single}_${query.single_table}`.toUpperCase();
         const fields = table.fields;
-        function typeMap(type) {
-            if (type === null || type === void 0 ? void 0 : type.match(/int/i)) {
+        function typeMap(schemaType) {
+            var _a, _b;
+            if (schemaType.options && schemaType.options.length > 0) {
+                return schemaType.options
+                    .map((opt) => {
+                    var _a;
+                    return ((_a = schemaType.dataType) === null || _a === void 0 ? void 0 : _a.match(/int/i)) ||
+                        typeof opt == "number"
+                        ? `${opt}`
+                        : `"${opt}"`;
+                })
+                    .join(" | ");
+            }
+            if ((_a = schemaType.dataType) === null || _a === void 0 ? void 0 : _a.match(/int/i)) {
                 return "number";
             }
-            if (type === null || type === void 0 ? void 0 : type.match(/text|varchar|timestamp/i)) {
+            if ((_b = schemaType.dataType) === null || _b === void 0 ? void 0 : _b.match(/text|varchar|timestamp/i)) {
                 return "string";
             }
             return "string";
@@ -28,13 +37,13 @@ function generateTypeDefinition({ paradigm, table, query, typeDefName, allValues
             var _a;
             const nullValue = allValuesOptional
                 ? "?"
-                : field.nullValue
+                : ((_a = field.fieldName) === null || _a === void 0 ? void 0 : _a.match(defaultFieldsRegexp))
                     ? "?"
-                    : ((_a = field.fieldName) === null || _a === void 0 ? void 0 : _a.match(default_fields_regexp_1.default))
-                        ? "?"
-                        : "";
-            typesArrayTypeScript.push(`    ${field.fieldName}${nullValue}: ${typeMap(field.dataType || "")};`);
-            typesArrayJavascript.push(` * @property {${typeMap(field.dataType || "")}${nullValue}} ${field.fieldName}`);
+                    : field.notNullValue
+                        ? ""
+                        : "?";
+            typesArrayTypeScript.push(`    ${field.fieldName}${nullValue}: ${typeMap(field)};`);
+            typesArrayJavascript.push(` * @property {${typeMap(field)}${nullValue}} ${field.fieldName}`);
         });
         typesArrayTypeScript.push(`}`);
         typesArrayJavascript.push(` */`);

dist/package-shared/functions/dsql/hashPassword.js

@@ -1,20 +1,14 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = hashPassword;
-const crypto_1 = require("crypto");
-const grab_keys_1 = __importDefault(require("../../utils/grab-keys"));
+import { createHmac } from "crypto";
+import grabKeys from "../../utils/grab-keys";
 /**
  * # Hash password Function
  */
-function hashPassword({ password, encryptionKey, }) {
-    const { key } = (0, grab_keys_1.default)({ encryptionKey });
+export default function hashPassword({ password, encryptionKey, }) {
+    const { key } = grabKeys({ encryptionKey });
     if (!(key === null || key === void 0 ? void 0 : key.match(/.{8,}/))) {
         throw new Error("Encryption key is invalid");
     }
-    const hmac = (0, crypto_1.createHmac)("sha512", key);
+    const hmac = createHmac("sha512", key);
     hmac.update(password);
     let hashed = hmac.digest("base64");
     return hashed;

dist/package-shared/functions/dsql/sql/sql-delete-generator.d.ts

@@ -1,3 +1,4 @@
+import { SQLDeleteGeneratorParams } from "../../../types";
 interface SQLDeleteGenReturn {
     query: string;
     values: string[];
@@ -5,9 +6,5 @@ interface SQLDeleteGenReturn {
 /**
  * # SQL Delete Generator
  */
-export default function sqlDeleteGenerator({ tableName, data, dbFullName, }: {
-    data: any;
-    tableName: string;
-    dbFullName?: string;
-}): SQLDeleteGenReturn | undefined;
+export default function sqlDeleteGenerator({ tableName, deleteKeyValues, dbFullName, data, }: SQLDeleteGeneratorParams): SQLDeleteGenReturn | undefined;
 export {};

dist/package-shared/functions/dsql/sql/sql-delete-generator.js

@@ -1,26 +1,47 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = sqlDeleteGenerator;
+import sqlEqualityParser from "../../../utils/sql-equality-parser";
 /**
  * # SQL Delete Generator
  */
-function sqlDeleteGenerator({ tableName, data, dbFullName, }) {
+export default function sqlDeleteGenerator({ tableName, deleteKeyValues, dbFullName, data, }) {
     const finalDbName = dbFullName ? `${dbFullName}.` : "";
     try {
         let queryStr = `DELETE FROM ${finalDbName}${tableName}`;
         let deleteBatch = [];
         let queryArr = [];
-        Object.keys(data).forEach((ky) => {
-            deleteBatch.push(`${ky}=?`);
-            queryArr.push(data[ky]);
-        });
+        if (data) {
+            Object.keys(data).forEach((ky) => {
+                let value = data[ky];
+                const parsedValue = typeof value == "number" ? String(value) : value;
+                if (!parsedValue)
+                    return;
+                if (parsedValue.match(/%/)) {
+                    deleteBatch.push(`${ky} LIKE ?`);
+                    queryArr.push(parsedValue);
+                }
+                else {
+                    deleteBatch.push(`${ky}=?`);
+                    queryArr.push(parsedValue);
+                }
+            });
+        }
+        else if (deleteKeyValues) {
+            deleteKeyValues.forEach((ky) => {
+                let value = ky.value;
+                const parsedValue = typeof value == "number" ? String(value) : value;
+                if (!parsedValue)
+                    return;
+                const operator = sqlEqualityParser(ky.operator || "EQUAL");
+                deleteBatch.push(`${ky.key} ${operator} ?`);
+                queryArr.push(parsedValue);
+            });
+        }
         queryStr += ` WHERE ${deleteBatch.join(" AND ")}`;
         return {
             query: queryStr,
             values: queryArr,
         };
     }
-    catch ( /** @type {any} */error) {
+    catch (error) {
         console.log(`SQL delete gen ERROR: ${error.message}`);
         return undefined;
     }

dist/package-shared/functions/dsql/sql/sql-gen-operator-gen.d.ts

@@ -0,0 +1,12 @@
+import { ServerQueryEqualities } from "../../../types";
+type Params = {
+    fieldName: string;
+    value?: string;
+    equality: (typeof ServerQueryEqualities)[number];
+};
+/**
+ * # SQL Gen Operator Gen
+ * @description Generates an SQL operator for node module `mysql` or `serverless-mysql`
+ */
+export default function sqlGenOperatorGen({ fieldName, value, equality, }: Params): string;
+export {};

dist/package-shared/functions/dsql/sql/sql-gen-operator-gen.js

@@ -0,0 +1,50 @@
+import sqlEqualityParser from "../../../utils/sql-equality-parser";
+/**
+ * # SQL Gen Operator Gen
+ * @description Generates an SQL operator for node module `mysql` or `serverless-mysql`
+ */
+export default function sqlGenOperatorGen({ fieldName, value, equality, }) {
+    if (value) {
+        if (equality == "LIKE") {
+            return `LOWER(${fieldName}) LIKE LOWER('%${value}%')`;
+        }
+        else if (equality == "LIKE_RAW") {
+            return `LOWER(${fieldName}) LIKE LOWER('${value}')`;
+        }
+        else if (equality == "NOT LIKE") {
+            return `LOWER(${fieldName}) NOT LIKE LOWER('%${value}%')`;
+        }
+        else if (equality == "NOT LIKE_RAW") {
+            return `LOWER(${fieldName}) NOT LIKE LOWER('${value}')`;
+        }
+        else if (equality == "REGEXP") {
+            return `LOWER(${fieldName}) REGEXP LOWER('${value}')`;
+        }
+        else if (equality == "FULLTEXT") {
+            return `MATCH(${fieldName}) AGAINST('${value}' IN BOOLEAN MODE)`;
+        }
+        else if (equality == "NOT EQUAL") {
+            return `${fieldName} != ${value}`;
+        }
+        else if (equality) {
+            return `${fieldName} ${sqlEqualityParser(equality)} ${value}`;
+        }
+        else {
+            return `${fieldName} = ${value}`;
+        }
+    }
+    else {
+        if (equality == "IS NULL") {
+            return `${fieldName} IS NULL`;
+        }
+        else if (equality == "IS NOT NULL") {
+            return `${fieldName} IS NOT NULL`;
+        }
+        else if (equality) {
+            return `${fieldName} ${sqlEqualityParser(equality)} ?`;
+        }
+        else {
+            return `${fieldName} = ?`;
+        }
+    }
+}

dist/package-shared/functions/dsql/sql/sql-generator.js

@@ -1,11 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = sqlGenerator;
+import sqlEqualityParser from "../../../utils/sql-equality-parser";
 /**
  * # SQL Query Generator
  * @description Generates an SQL Query for node module `mysql` or `serverless-mysql`
  */
-function sqlGenerator({ tableName, genObject, dbFullName, count }) {
+export default function sqlGenerator({ tableName, genObject, dbFullName, count }) {
+    var _a;
     const finalQuery = (genObject === null || genObject === void 0 ? void 0 : genObject.query) ? genObject.query : undefined;
     const queryKeys = finalQuery ? Object.keys(finalQuery) : undefined;
     const sqlSearhValues = [];
@@ -33,19 +32,37 @@ function sqlGenerator({ tableName, genObject, dbFullName, count }) {
         else if (typeof queryObj.value == "string" ||
             typeof queryObj.value == "number") {
             const valueParsed = String(queryObj.value);
+            const operator = sqlEqualityParser(queryObj.equality || "EQUAL");
             if (queryObj.equality == "LIKE") {
                 str = `LOWER(${finalFieldName}) LIKE LOWER('%${valueParsed}%')`;
             }
+            else if (queryObj.equality == "LIKE_RAW") {
+                str = `LOWER(${finalFieldName}) LIKE LOWER(?)`;
+                sqlSearhValues.push(valueParsed);
+            }
+            else if (queryObj.equality == "NOT LIKE") {
+                str = `LOWER(${finalFieldName}) NOT LIKE LOWER('%${valueParsed}%')`;
+            }
+            else if (queryObj.equality == "NOT LIKE_RAW") {
+                str = `LOWER(${finalFieldName}) NOT LIKE LOWER(?)`;
+                sqlSearhValues.push(valueParsed);
+            }
             else if (queryObj.equality == "REGEXP") {
-                str = `${finalFieldName} REGEXP '${valueParsed}'`;
+                str = `LOWER(${finalFieldName}) REGEXP LOWER(?)`;
+                sqlSearhValues.push(valueParsed);
             }
             else if (queryObj.equality == "FULLTEXT") {
-                str = `MATCH(${finalFieldName}) AGAINST('${valueParsed}' IN BOOLEAN MODE)`;
+                str = `MATCH(${finalFieldName}) AGAINST(? IN BOOLEAN MODE)`;
+                sqlSearhValues.push(valueParsed);
             }
             else if (queryObj.equality == "NOT EQUAL") {
                 str = `${finalFieldName} != ?`;
                 sqlSearhValues.push(valueParsed);
             }
+            else if (queryObj.equality) {
+                str = `${finalFieldName} ${operator} ?`;
+                sqlSearhValues.push(valueParsed);
+            }
             else {
                 sqlSearhValues.push(valueParsed);
             }
@@ -120,7 +137,7 @@ function sqlGenerator({ tableName, genObject, dbFullName, count }) {
         }
         else if ((_a = genObject === null || genObject === void 0 ? void 0 : genObject.selectFields) === null || _a === void 0 ? void 0 : _a[0]) {
             if (genObject.join) {
-                str += ` ${(_b = genObject.selectFields) === null || _b === void 0 ? void 0 : _b.map((fld) => `${finalDbName}${tableName}.${fld}`).join(",")}`;
+                str += ` ${(_b = genObject.selectFields) === null || _b === void 0 ? void 0 : _b.map((fld) => `${finalDbName}${tableName}.${String(fld)}`).join(",")}`;
             }
             else {
                 str += ` ${(_c = genObject.selectFields) === null || _c === void 0 ? void 0 : _c.join(",")}`;
@@ -207,10 +224,16 @@ function sqlGenerator({ tableName, genObject, dbFullName, count }) {
         const stringOperator = (genObject === null || genObject === void 0 ? void 0 : genObject.searchOperator) || "AND";
         queryString += ` WHERE ${sqlSearhString.join(` ${stringOperator} `)}`;
     }
-    if ((genObject === null || genObject === void 0 ? void 0 : genObject.order) && !count)
+    if ((_a = genObject === null || genObject === void 0 ? void 0 : genObject.group) === null || _a === void 0 ? void 0 : _a[0]) {
+        queryString += ` GROUP BY ${genObject.group
+            .map((g) => `\`${g.toString()}\``)
+            .join(",")}`;
+    }
+    if ((genObject === null || genObject === void 0 ? void 0 : genObject.order) && !count) {
         queryString += ` ORDER BY ${genObject.join
             ? `${finalDbName}${tableName}.${String(genObject.order.field)}`
             : String(genObject.order.field)} ${genObject.order.strategy}`;
+    }
     if ((genObject === null || genObject === void 0 ? void 0 : genObject.limit) && !count)
         queryString += ` LIMIT ${genObject.limit}`;
     if ((genObject === null || genObject === void 0 ? void 0 : genObject.offset) && !count)

dist/package-shared/functions/dsql/sql/sql-insert-generator.js

@@ -1,11 +1,8 @@
-"use strict";
 // @ts-check
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = sqlInsertGenerator;
 /**
  * # SQL Insert Generator
  */
-function sqlInsertGenerator({ tableName, data, dbFullName, }) {
+export default function sqlInsertGenerator({ tableName, data, dbFullName, }) {
     const finalDbName = dbFullName ? `${dbFullName}.` : "";
     try {
         if (Array.isArray(data) && (data === null || data === void 0 ? void 0 : data[0])) {

dist/package-shared/functions/dsql/sync-databases/index.d.ts

@@ -0,0 +1 @@
+export {};

dist/package-shared/functions/dsql/sync-databases/index.js

@@ -0,0 +1,82 @@
+import mysql from "mysql";
+import { exec } from "child_process";
+import { promisify } from "util";
+function getConnection(config) {
+    return mysql.createConnection(config);
+}
+function getMasterStatus(config) {
+    return new Promise((resolve, reject) => {
+        const connection = getConnection(config);
+        connection.query("SHOW MASTER STATUS", (error, results) => {
+            connection.end();
+            if (error)
+                reject(error);
+            else
+                resolve(results[0]);
+        });
+    });
+}
+async function syncDatabases() {
+    const config = {
+        host: "localhost",
+        user: "root",
+        password: "your_password",
+    };
+    let lastPosition = null; // Track last synced position
+    while (true) {
+        try {
+            // Get current master status
+            const { File, Position } = await getMasterStatus(config);
+            // Determine start position (use lastPosition or 4 if first run)
+            const startPosition = lastPosition !== null ? lastPosition + 1 : 4;
+            if (startPosition >= Position) {
+                await new Promise((resolve) => setTimeout(resolve, 5000)); // Wait 5 seconds if no new changes
+                continue;
+            }
+            // Execute mysqlbinlog to get changes
+            const execPromise = promisify(exec);
+            const { stdout } = await execPromise(`mysqlbinlog --database=db_master ${File} --start-position=${startPosition} --stop-position=${Position}`);
+            if (stdout) {
+                const connection = getConnection(Object.assign(Object.assign({}, config), { database: "db_slave" }));
+                return new Promise((resolve, reject) => {
+                    connection.query(stdout, (error) => {
+                        connection.end();
+                        if (error)
+                            reject(error);
+                        else {
+                            lastPosition = Position;
+                            console.log(`Synced up to position ${Position} at ${new Date().toISOString()}`);
+                            resolve(null);
+                        }
+                    });
+                });
+            }
+        }
+        catch (error) {
+            console.error("Sync error:", error);
+        }
+        await new Promise((resolve) => setTimeout(resolve, 5000)); // Check every 5 seconds
+    }
+}
+// Initialize db_slave with db_master data
+async function initializeSlave() {
+    const config = {
+        host: "localhost",
+        user: "root",
+        password: "your_password",
+    };
+    try {
+        await promisify(exec)(`mysqldump -u ${config.user} -p${config.password} db_master > db_master_backup.sql`);
+        await promisify(exec)(`mysql -u ${config.user} -p${config.password} db_slave < db_master_backup.sql`);
+        console.log("Slave initialized with master data");
+    }
+    catch (error) {
+        console.error("Initialization error:", error);
+    }
+}
+// Run the sync process
+async function main() {
+    await initializeSlave();
+    await syncDatabases();
+}
+main().catch(console.error);

dist/package-shared/functions/dsql/triggers-and-stored-proceedures/create-duplicate-tables-triggers.d.ts

@@ -0,0 +1,2 @@
+type Params = {};
+declare function createDuplicateTablesTriggers({}: Params): void;

dist/package-shared/functions/dsql/triggers-and-stored-proceedures/create-duplicate-tables-triggers.js

@@ -0,0 +1,2 @@
+"use strict";
+function createDuplicateTablesTriggers({}) { }

dist/package-shared/functions/dsql/triggers-and-stored-proceedures/grab-trigger-name.d.ts

@@ -0,0 +1,9 @@
+export declare const TriggerParadigms: readonly ["sync_tables", "sync_dbs"];
+type Params = {
+    userId?: string | number;
+    paradigm: (typeof TriggerParadigms)[number];
+    dbId?: string | number;
+    tableName?: string;
+};
+export default function grabTriggerName({ userId, paradigm, dbId, tableName, }: Params): string;
+export {};

dist/package-shared/functions/dsql/triggers-and-stored-proceedures/grab-trigger-name.js

@@ -0,0 +1,11 @@
+export const TriggerParadigms = ["sync_tables", "sync_dbs"];
+export default function grabTriggerName({ userId, paradigm, dbId, tableName, }) {
+    let triggerName = `dsql_trig_${paradigm}`;
+    if (userId)
+        triggerName += `_${userId}`;
+    if (dbId)
+        triggerName += `_${dbId}`;
+    if (tableName)
+        triggerName += `_${tableName}`;
+    return triggerName;
+}

dist/package-shared/functions/dsql/triggers-and-stored-proceedures/stored-proceedure-sql-gen.d.ts

@@ -0,0 +1,20 @@
+import { DSQL_DatabaseSchemaType, DSQL_TableSchemaType } from "../../../types";
+declare const TriggerTypes: readonly [{
+    readonly name: "after_insert";
+    readonly value: "INSERT";
+}, {
+    readonly name: "after_update";
+    readonly value: "UPDATE";
+}, {
+    readonly name: "after_delete";
+    readonly value: "DELETE";
+}];
+export type TriggerSQLGenParams = {
+    type: (typeof TriggerTypes)[number];
+    srcDbSchema: DSQL_DatabaseSchemaType;
+    srcTableSchema: DSQL_TableSchemaType;
+    content: string;
+    proceedureName: string;
+};
+export default function triggerSQLGen({ type, srcDbSchema, srcTableSchema, content, proceedureName, }: TriggerSQLGenParams): string;
+export {};

dist/package-shared/functions/dsql/triggers-and-stored-proceedures/stored-proceedure-sql-gen.js

@@ -0,0 +1,23 @@
+const TriggerTypes = [
+    {
+        name: "after_insert",
+        value: "INSERT",
+    },
+    {
+        name: "after_update",
+        value: "UPDATE",
+    },
+    {
+        name: "after_delete",
+        value: "DELETE",
+    },
+];
+export default function triggerSQLGen({ type, srcDbSchema, srcTableSchema, content, proceedureName, }) {
+    let sql = `DELIMITER //\n`;
+    sql += `CREATE PROCEDURE ${proceedureName}`;
+    sql += `\nBEGIN`;
+    sql += ` ${content}`;
+    sql += `\nEND //`;
+    sql += `\nDELIMITER\n`;
+    return sql;
+}

dist/package-shared/functions/dsql/triggers-and-stored-proceedures/table-replication-trigger-sql-gen.d.ts

@@ -0,0 +1,8 @@
+import { DSQL_DatabaseSchemaType, DSQL_TableSchemaType } from "../../../types";
+import { TriggerSQLGenParams } from "./trigger-sql-gen";
+type Params = TriggerSQLGenParams & {
+    dstDbSchema: DSQL_DatabaseSchemaType;
+    dstTableSchema: DSQL_TableSchemaType;
+};
+export default function tableReplicationTriggerSQLGen({ type, dstDbSchema, dstTableSchema, srcDbSchema, srcTableSchema, userId, paradigm, }: Params): string;
+export {};

dist/package-shared/functions/dsql/triggers-and-stored-proceedures/table-replication-trigger-sql-gen.js

@@ -0,0 +1,32 @@
+import triggerSQLGen from "./trigger-sql-gen";
+export default function tableReplicationTriggerSQLGen({ type, dstDbSchema, dstTableSchema, srcDbSchema, srcTableSchema, userId, paradigm, }) {
+    let sql = `CREATE TRIGGER`;
+    const srcColumns = srcTableSchema.fields
+        .map((fld) => fld.fieldName)
+        .filter((fld) => typeof fld == "string");
+    const dstColumns = dstTableSchema.fields
+        .map((fld) => fld.fieldName)
+        .filter((fld) => typeof fld == "string");
+    if (type.name == "after_insert") {
+        sql += ` INSERT INTO ${dstDbSchema.dbFullName}.${dstTableSchema.tableName}`;
+        sql += ` (${dstColumns.join(",")})`;
+        sql += ` VALUES (${dstColumns.map((c) => `NEW.${c}`).join(",")})`;
+    }
+    else if (type.name == "after_update") {
+        sql += ` UPDATE ${dstDbSchema.dbFullName}.${dstTableSchema.tableName}`;
+        sql += ` SET ${dstColumns.map((c) => `${c}=NEW.${c}`).join(",")}`;
+        sql += ` WHERE id = NEW.id`;
+    }
+    else if (type.name == "after_delete") {
+        sql += ` DELETE FROM ${dstDbSchema.dbFullName}.${dstTableSchema.tableName}`;
+        sql += ` WHERE id = OLD.id`;
+    }
+    return triggerSQLGen({
+        content: sql,
+        srcDbSchema,
+        srcTableSchema,
+        type,
+        paradigm,
+        userId,
+    });
+}

dist/package-shared/functions/dsql/triggers-and-stored-proceedures/trigger-sql-gen.d.ts

@@ -0,0 +1,22 @@
+import { DSQL_DatabaseSchemaType, DSQL_TableSchemaType } from "../../../types";
+import { TriggerParadigms } from "./grab-trigger-name";
+declare const TriggerTypes: readonly [{
+    readonly name: "after_insert";
+    readonly value: "INSERT";
+}, {
+    readonly name: "after_update";
+    readonly value: "UPDATE";
+}, {
+    readonly name: "after_delete";
+    readonly value: "DELETE";
+}];
+export type TriggerSQLGenParams = {
+    type: (typeof TriggerTypes)[number];
+    srcDbSchema: DSQL_DatabaseSchemaType;
+    srcTableSchema: DSQL_TableSchemaType;
+    content: string;
+    userId?: string | number;
+    paradigm: (typeof TriggerParadigms)[number];
+};
+export default function triggerSQLGen({ type, srcDbSchema, srcTableSchema, content, userId, paradigm, }: TriggerSQLGenParams): string;
+export {};

dist/package-shared/functions/dsql/triggers-and-stored-proceedures/trigger-sql-gen.js

@@ -0,0 +1,30 @@
+import grabTriggerName from "./grab-trigger-name";
+const TriggerTypes = [
+    {
+        name: "after_insert",
+        value: "INSERT",
+    },
+    {
+        name: "after_update",
+        value: "UPDATE",
+    },
+    {
+        name: "after_delete",
+        value: "DELETE",
+    },
+];
+export default function triggerSQLGen({ type, srcDbSchema, srcTableSchema, content, userId, paradigm, }) {
+    let sql = `CREATE TRIGGER`;
+    let triggerName = grabTriggerName({
+        paradigm,
+        dbId: srcDbSchema.id,
+        tableName: srcTableSchema.tableName,
+        userId,
+    });
+    sql += ` ${triggerName}`;
+    sql += ` AFTER ${type.value} ON ${srcTableSchema.tableName}`;
+    sql += ` FOR EACH ROW BEGIN`;
+    sql += ` ${content}`;
+    sql += ` END`;
+    return sql;
+}