dsql-admin/dsql-app/package-shared/shell/createDbFromSchema.js

// @ts-check

const path = require("path");
const fs = require("fs");

require("dotenv").config({ path: "./../.env" });

const noDatabaseDbHandler = require("./utils/noDatabaseDbHandler");
const varDatabaseDbHandler = require("./utils/varDatabaseDbHandler");
const createTable = require("./utils/createTable");
const updateTable = require("./utils/updateTable");
const dbHandler = require("./utils/dbHandler");
const EJSON = require("../utils/ejson");

const execFlag = process.argv.find((arg) => arg === "--exec");

/**
 * Create database from Schema Function
 * =============================================
 * @param {object} params - Single object params
 * @param {number|string|null} [params.userId] - User ID or null
 * @param {string} [params.targetDatabase] - User Database full name
 * @param {import("../types").DSQL_DatabaseSchemaType[]} [params.dbSchemaData]
 */
async function createDbFromSchema({ userId, targetDatabase, dbSchemaData }) {
    const schemaPath = userId
        ? path.join(
              String(process.env.DSQL_USER_DB_SCHEMA_PATH),
              `/user-${userId}/main.json`
          )
        : path.resolve(__dirname, "../../jsonData/dbSchemas/main.json");

    /** @type {import("../types").DSQL_DatabaseSchemaType[] | undefined} */
    const dbSchema =
        dbSchemaData ||
        /** @type {import("../types").DSQL_DatabaseSchemaType[] | undefined} */ (
            EJSON.parse(fs.readFileSync(schemaPath, "utf8"))
        );

    if (!dbSchema) {
        console.log("Schema Not Found!");
        return;
    }

    // await createDatabasesFromSchema(dbSchema);

    for (let i = 0; i < dbSchema.length; i++) {
        /** @type {import("../types").DSQL_DatabaseSchemaType} */
        const database = dbSchema[i];
        const { dbFullName, tables, dbName, dbSlug, childrenDatabases } =
            database;

        if (targetDatabase && dbFullName != targetDatabase) {
            continue;
        }

        /** @type {any} */
        const dbCheck = await noDatabaseDbHandler(
            `SELECT SCHEMA_NAME AS dbFullName FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = '${dbFullName}'`
        );

        if (dbCheck && dbCheck[0]?.dbFullName) {
            // Database Exists
        } else {
            const newDatabase = await noDatabaseDbHandler(
                `CREATE DATABASE IF NOT EXISTS \`${dbFullName}\` CHARACTER SET utf8mb4 COLLATE utf8mb4_bin`
            );
        }

        /**
         * Select all tables
         * @type {any}
         * @description Select All tables in target database
         */
        const allTables = await noDatabaseDbHandler(
            `SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA='${dbFullName}'`
        );

        // let tableDropped;

        for (let tb = 0; tb < allTables.length; tb++) {
            const { TABLE_NAME } = allTables[tb];

            /**
             * @description Check if TABLE_NAME is part of the tables contained
             * in the user schema JSON. If it's not, the table is either deleted
             * or the table name has been recently changed
             */
            if (
                !tables.filter((_table) => _table.tableName === TABLE_NAME)[0]
            ) {
                const oldTableFilteredArray = tables.filter(
                    (_table) =>
                        _table.tableNameOld &&
                        _table.tableNameOld === TABLE_NAME
                );

                /**
                 * @description Check if this table has been recently renamed. Rename
                 * table id true. Drop table if false
                 */
                if (oldTableFilteredArray && oldTableFilteredArray[0]) {
                    console.log("Renaming Table");
                    await varDatabaseDbHandler({
                        queryString: `RENAME TABLE \`${oldTableFilteredArray[0].tableNameOld}\` TO \`${oldTableFilteredArray[0].tableName}\``,
                        database: dbFullName,
                    });
                } else {
                    console.log(`Dropping Table from ${dbFullName}`);
                    await varDatabaseDbHandler({
                        queryString: `DROP TABLE \`${TABLE_NAME}\``,
                        database: dbFullName,
                    });

                    const deleteTableEntry = await dbHandler({
                        query: `DELETE FROM user_database_tables WHERE user_id = ? AND db_slug = ? AND table_slug = ?`,
                        values: [userId, dbSlug, TABLE_NAME],
                        database: "datasquirel",
                    });
                }
            }
        }

        const recordedDbEntryArray = userId
            ? await varDatabaseDbHandler({
                  database: "datasquirel",
                  queryString: `SELECT * FROM user_databases WHERE db_full_name = ?`,
                  queryValuesArray: [dbFullName],
              })
            : undefined;

        const recordedDbEntry = recordedDbEntryArray?.[0];

        /**
         * @description Iterate through each table and perform table actions
         */
        for (let t = 0; t < tables.length; t++) {
            const table = tables[t];

            const { tableName, fields, indexes } = table;

            /**
             * @description Check if table exists
             * @type {any}
             */
            const tableCheck = await varDatabaseDbHandler({
                queryString: `
                    SELECT EXISTS (
                        SELECT
                        TABLE_NAME
                        FROM
                        information_schema.TABLES
                        WHERE
                        TABLE_SCHEMA = ? AND
                        TABLE_NAME = ?
                        ) AS tableExists`,
                queryValuesArray: [dbFullName, table.tableName],
                database: dbFullName,
            });

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

            if (tableCheck && tableCheck[0]?.tableExists > 0) {
                /**
                 * @description Update table if table exists
                 */
                const updateExistingTable = await updateTable({
                    dbFullName: dbFullName,
                    tableName: tableName,
                    tableNameFull: table.tableFullName,
                    tableInfoArray: fields,
                    userId,
                    dbSchema,
                    tableIndexes: indexes,
                    tableIndex: t,
                    childDb: database.childDatabase || undefined,
                    recordedDbEntry,
                    tableSchema: table,
                });

                if (table.childrenTables && table.childrenTables[0]) {
                    for (let ch = 0; ch < table.childrenTables.length; ch++) {
                        const childTable = table.childrenTables[ch];

                        const updateExistingChildTable = await updateTable({
                            dbFullName: childTable.dbNameFull,
                            tableName: childTable.tableName,
                            tableNameFull: childTable.tableNameFull,
                            tableInfoArray: fields,
                            userId,
                            dbSchema,
                            tableIndexes: indexes,
                            clone: true,
                            childDb: database.childDatabase || undefined,
                            recordedDbEntry,
                            tableSchema: table,
                        });
                    }
                }

                ////////////////////////////////////////
            } else {
                ////////////////////////////////////////

                /**
                 * @description Create new Table if table doesnt exist
                 */
                const createNewTable = await createTable({
                    tableName: tableName,
                    tableInfoArray: fields,
                    dbFullName: dbFullName,
                    dbSchema,
                    tableSchema: table,
                    recordedDbEntry,
                });

                if (indexes && indexes[0]) {
                    /**
                     * Handle DATASQUIREL Table Indexes
                     * ===================================================
                     * @description Iterate through each datasquirel schema
                     * table index(if available), and perform operations
                     */
                    if (indexes && indexes[0]) {
                        for (let g = 0; g < indexes.length; g++) {
                            const {
                                indexType,
                                indexName,
                                indexTableFields,
                                alias,
                            } = indexes[g];

                            if (!alias?.match(/./)) continue;

                            /**
                             * @description Check for existing Index in MYSQL db
                             */
                            try {
                                /**
                                 * @type {import("../types").DSQL_MYSQL_SHOW_INDEXES_Type[]}
                                 * @description All indexes from MYSQL db
                                 */ // @ts-ignore
                                const allExistingIndexes =
                                    await varDatabaseDbHandler({
                                        queryString: `SHOW INDEXES FROM \`${tableName}\``,
                                        database: dbFullName,
                                    });

                                const existingKeyInDb =
                                    allExistingIndexes.filter(
                                        (indexObject) =>
                                            indexObject.Key_name === alias
                                    );
                                if (!existingKeyInDb[0])
                                    throw new Error(
                                        "This Index Does not Exist"
                                    );
                            } catch (error) {
                                /**
                                 * @description Create new index if determined that it
                                 * doesn't exist in MYSQL db
                                 */
                                await varDatabaseDbHandler({
                                    queryString: `CREATE${
                                        indexType?.match(/fullText/i)
                                            ? " FULLTEXT"
                                            : ""
                                    } INDEX \`${alias}\` ON ${tableName}(${indexTableFields
                                        ?.map((nm) => nm.value)
                                        .map((nm) => `\`${nm}\``)
                                        .join(",")}) COMMENT 'schema_index'`,
                                    database: dbFullName,
                                });
                            }
                        }
                    }
                }
            }
        }

        /**
         * @description Check all children databases
         */
        if (childrenDatabases?.[0]) {
            for (let ch = 0; ch < childrenDatabases.length; ch++) {
                const childDb = childrenDatabases[ch];
                const { dbFullName } = childDb;

                await createDbFromSchema({
                    userId,
                    targetDatabase: dbFullName,
                });
            }
        }
    }
}

module.exports = createDbFromSchema;

if (execFlag) {
    createDbFromSchema({});
}