datasquirel/package-shared/functions/backend/createDbSchemaFromDb.ts

import varDatabaseDbHandler from "../../functions/backend/varDatabaseDbHandler";
import { default as grabUserSchemaData } from "../../functions/backend/grabUserSchemaData";
import { default as setUserSchemaData } from "../../functions/backend/setUserSchemaData";
import addDbEntry from "../../functions/backend/db/addDbEntry";
import slugToCamelTitle from "../../shell/utils/slugToCamelTitle";
import { DSQL_DATASQUIREL_USER_DATABASES } from "@/package-shared/types/dsql";
import {
    DSQL_FieldSchemaType,
    DSQL_MYSQL_SHOW_COLUMNS_Type,
    DSQL_TableSchemaType,
} from "@/package-shared/types";

type Params = {
    userId: number | string;
    database: DSQL_DATASQUIREL_USER_DATABASES;
};

export default async function createDbSchemaFromDb({
    userId,
    database,
}: Params) {
    try {
        if (!userId) {
            console.log("No user Id provided");
            return;
        }

        const userSchemaData = grabUserSchemaData({ userId });
        if (!userSchemaData) throw new Error("User schema data not found!");

        const targetDb: { tables: object[] } = userSchemaData.filter(
            (dbObject) => dbObject.dbFullName === database.db_full_name
        )[0];

        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] as string;

            const tableInsert = await addDbEntry({
                dbFullName: "datasquirel",
                tableName: "user_database_tables",
                data: {
                    user_id: userId,
                    db_id: database.id,
                    db_slug: database.db_slug,
                    table_name: slugToCamelTitle(tableName),
                    table_slug: tableName,
                },
            });

            const tableObject: DSQL_TableSchemaType = {
                tableName: tableName,
                tableFullName: slugToCamelTitle(tableName) || "",
                fields: [],
                indexes: [],
            };

            const tableColumns: DSQL_MYSQL_SHOW_COLUMNS_Type[] =
                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 fieldObject: DSQL_FieldSchemaType = {
                        fieldName: Field,
                        dataType: Type.toUpperCase(),
                    };

                    if (Null?.match(/^no$/i)) fieldObject.notNullValue = true;
                    if (Key?.match(/^pri$/i)) fieldObject.primaryKey = true;
                    if (Default?.toString()?.match(/./))
                        fieldObject.defaultValue = Default;
                    if (Default?.toString()?.match(/timestamp/i)) {
                        delete fieldObject.defaultValue;
                        fieldObject.defaultValueLiteral = Default;
                    }
                    if (Extra?.toString()?.match(/auto_increment/i))
                        fieldObject.autoIncrement = true;

                    tableObject.fields.push(fieldObject);
                }
            }

            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?.match(/^schema_index$/)) continue;

                    const indexNewObject: import("@/package-shared/types").DSQL_IndexSchemaType =
                        {
                            indexType: Index_type?.match(/fulltext/i)
                                ? "fullText"
                                : "regular",
                            indexName: Key_name,
                            indexTableFields: [],
                        };

                    const targetTableFieldObject = tableColumns?.filter(
                        (col) => col.Field === Column_name
                    )[0];

                    const existingIndexField = tableObject.indexes?.filter(
                        (indx) => indx.indexName == Key_name
                    );

                    if (existingIndexField && existingIndexField[0]) {
                        existingIndexField[0].indexTableFields?.push({
                            value: Column_name,
                            dataType: targetTableFieldObject.Type.toUpperCase(),
                        });
                    } else {
                        indexNewObject.indexTableFields = [
                            {
                                value: Column_name,
                                dataType:
                                    targetTableFieldObject.Type.toUpperCase(),
                            },
                        ];

                        tableObject.indexes?.push(indexNewObject);
                    }
                }
            }

            targetDb.tables.push(tableObject);
        }

        setUserSchemaData({ schemaData: userSchemaData, userId });

        return true;
    } catch (error) {
        console.log(error);

        return false;
    }
}