gg-mysql-connector 1.0.37 → 1.0.39

package/dist/src/ModelGenerator/ModelGenerator.js

@@ -0,0 +1,317 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+const crypto_1 = require("crypto");
+const fs_1 = __importDefault(require("fs"));
+const promise_1 = __importDefault(require("mysql2/promise"));
+const path_1 = __importDefault(require("path"));
+const MyDBMigrator_1 = __importDefault(require("../MyDBMigrator/MyDBMigrator"));
+class ModelGenerator {
+    constructor(dbInfo, model) {
+        this.printResultLength = (results, executionTime, queryResult) => {
+            if (results.length) {
+                const executionTimeMessage = executionTime > 1000
+                    ? chalk_1.default.bgRed(`${executionTime} ` + " ms")
+                    : chalk_1.default.yellow(`${executionTime} ` + " ms");
+                console.log(`${chalk_1.default.green(queryResult.sql)} ${chalk_1.default.cyan(`found ${results.length} rows.`)} ${executionTimeMessage}`);
+            }
+        };
+        this.model = model;
+        this.dbInfo = dbInfo;
+        this.isConnected = false;
+    }
+    async init() {
+        console.log("init");
+        this.connection = await promise_1.default.createConnection({
+            host: this.dbInfo.host,
+            user: this.dbInfo.user,
+            password: this.dbInfo.password,
+        });
+        this.isConnected = true;
+        await this.createDatabaseIfNotExist();
+    }
+    async createDatabaseIfNotExist() {
+        const databaseName = this.dbInfo.database;
+        await this.connection.query(`CREATE DATABASE IF NOT EXISTS ${databaseName}`);
+        await this.connection.query(`USE ${databaseName}`);
+    }
+    async pushModelToDB() {
+        const migrator = new MyDBMigrator_1.default(this);
+        await migrator.migrateTable(this.model);
+    }
+    async pushViewToDB(viewDirectory) {
+        const migrator = new MyDBMigrator_1.default(this);
+        await migrator.migrateView(viewDirectory);
+    }
+    async pushViewToDB_v2(viewModel) {
+        const migrator = new MyDBMigrator_1.default(this);
+        await migrator.migrateView_v2(viewModel);
+    }
+    waitUntilInitSuccess(interval) {
+        if (this.isConnected === true)
+            return true;
+        return new Promise((resolve, reject) => {
+            setTimeout(() => {
+                if (this.isConnected === false) {
+                    console.log(`${this.dbInfo.database} > wait for database connection . . .`);
+                    this.waitUntilInitSuccess(interval);
+                }
+                else {
+                    return resolve(true);
+                }
+            }, interval);
+        });
+    }
+    async query(statment, parameter, isPrint) {
+        await this.waitUntilInitSuccess(1000);
+        return new Promise((resolve, reject) => {
+            const uniqueTime = `${(0, crypto_1.randomUUID)()} ${statment}`;
+            console.time(uniqueTime);
+            const startTime = new Date();
+            const queryResult = this.connection
+                .query(statment, parameter)
+                .then((result) => {
+                const endTime = new Date();
+                const executionTime = endTime.getTime() - startTime.getTime();
+                if (isPrint === true)
+                    this.printResultLength(result, executionTime, queryResult);
+                resolve(result[0]);
+            })
+                .catch((error) => {
+                // _getCallerFile()
+                console.log(chalk_1.default.bgRed("Query Error"));
+                console.log(chalk_1.default.bgRed(error));
+                console.log(chalk_1.default.bgRed("Statement : "));
+                console.log(statment);
+                console.log(chalk_1.default.bgRed("Parameter : "));
+                console.log(parameter);
+                console.log("------------------------------------------------");
+                console.log(chalk_1.default.bgRed(queryResult.sql));
+                reject(error);
+            });
+        });
+    }
+    async getTableNameList() {
+        let data = [];
+        let result = (await this.query("SELECT * FROM information_schema.tables WHERE table_schema = ? AND TABLE_TYPE = 'BASE TABLE'", [this.dbInfo.database], false));
+        for (let row of result)
+            data.push(row.TABLE_NAME || row.row.table_name);
+        return data;
+    }
+    async getViewNameList() {
+        let data = [];
+        let result = (await this.query("SELECT * FROM information_schema.tables WHERE table_schema = ? AND TABLE_TYPE = 'VIEW'", [this.dbInfo.database], false));
+        for (let row of result)
+            data.push(row.TABLE_NAME || row.row.table_name);
+        return data;
+    }
+    async getColumnFullList(tableName) {
+        const result = (await this.query(`SELECT * FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = '${this.dbInfo.database}' AND TABLE_NAME = '${tableName}'`, undefined, false));
+        return result;
+    }
+    isTableNameExistInModel(model, tableName) {
+        if (tableName === "sessions")
+            return true;
+        const table = model.find((row) => row.tableName === tableName);
+        return table ? true : false;
+    }
+    isColumnExistInModel(model, tableName, columnName) {
+        if (tableName === "sessions")
+            return true;
+        const table = model.find((row) => row.tableName === tableName);
+        if (table) {
+            const column = table.columns.find((row) => row.COLUMN_NAME === columnName);
+            if (column)
+                return true;
+        }
+        return false;
+    }
+    getPossibleColumnValue(model, tableName, columnName, columnType) {
+        const foundTable = model.find((row) => row.tableName === tableName);
+        // search in table model
+        if (foundTable) {
+            const foundColumn = foundTable["columns"].find((row) => row.COLUMN_NAME === columnName);
+            // find in possible value in table model first
+            if (foundColumn && foundColumn.POSSIBLE_VALUE) {
+                return foundColumn.POSSIBLE_VALUE;
+            }
+            else {
+                return false;
+            }
+        }
+        else {
+            // search in database view data structure
+            // if not found. search in view stucture in db engine structure
+            if (columnType.search("enum") >= 0) {
+                let temp = columnType.replace("enum(", "");
+                temp = temp.slice(0, -1);
+                temp = temp.replace(/"/g, "");
+                temp = temp.replace(/'/g, "");
+                let word = temp.split(",");
+                return word;
+            }
+        }
+    }
+    async generateModelInterface(params) {
+        const tableList = [
+            ...(await this.getTableNameList()),
+            ...(await this.getViewNameList()),
+        ];
+        const arrayOfColumnKeyValue = [];
+        const arrayOfSeedColumnKeyValue = [];
+        for (let i = 0; i < tableList.length; i++) {
+            const tableName = tableList[i];
+            if (this.isTableNameExistInModel(params.model, tableName) ||
+                tableName.search("_view") >= 0) {
+                const columnList = await this.getColumnFullList(tableName);
+                let stringOfRawColumnKeyAndValue = "";
+                for (const cRow of columnList) {
+                    // console.log("cRow", cRow.COLUMN_TYPE)
+                    const isColumnExistInModel = this.isColumnExistInModel(params.model, tableName, cRow.COLUMN_NAME);
+                    if (isColumnExistInModel || tableName.search("_view") >= 0) {
+                        const possibleValue = this.getPossibleColumnValue(params.model, cRow.TABLE_NAME, cRow.COLUMN_NAME, cRow.COLUMN_TYPE);
+                        if (possibleValue) {
+                            stringOfRawColumnKeyAndValue = `${stringOfRawColumnKeyAndValue} \n ${cRow.COLUMN_NAME}: ${possibleValue.map((row) => `"${row}"`).join(" | ")};`;
+                        }
+                        else {
+                            stringOfRawColumnKeyAndValue = `${stringOfRawColumnKeyAndValue} \n ${cRow.COLUMN_NAME}: ${convertDataType(cRow.DATA_TYPE)};`;
+                        }
+                    }
+                    else {
+                        console.log(`${tableName}-${cRow.COLUMN_NAME} not exist in model `);
+                    }
+                }
+                // normal app model code
+                const str = ` ${tableName} : { ${stringOfRawColumnKeyAndValue} }`;
+                arrayOfColumnKeyValue.push(str);
+                // only seed model code
+                const tempSeedModel = params.model.find((row) => row.tableName === tableName && row.isSeed);
+                if (tempSeedModel)
+                    arrayOfSeedColumnKeyValue.push(str);
+            }
+        }
+        // normal app model code
+        const fileName = `${params.appName}_INF.ts`;
+        const seedFileName = `seed_INF.ts`;
+        const code = `export default interface ${params.appName}_INF  { ${arrayOfColumnKeyValue.join("\n")} }`;
+        const seedCode = `export default interface seed_INF  { ${arrayOfSeedColumnKeyValue.join("\n")} }`;
+        for (let row of params.outputDirectory) {
+            // normal app model code
+            const serverFilePath = path_1.default.join(row, fileName);
+            await fs_1.default.writeFileSync(serverFilePath, code);
+            console.log("save app model to ", serverFilePath);
+            // only seed model code
+            const seedServerFilePath = path_1.default.join(row, seedFileName);
+            await fs_1.default.writeFileSync(seedServerFilePath, seedCode);
+            console.log("save seed model to ", seedServerFilePath);
+        }
+        console.log(`generate interface ${params.appName} ${chalk_1.default.bgGreen(" SUCCESS ")}`);
+        return code;
+    }
+    async generateModelConstStructure(params) {
+        const isTableNameExistInModel = (tableName) => {
+            if (tableName === "sessions")
+                return true;
+            const table = params.model.find((row) => row.tableName === tableName);
+            if (table)
+                return true;
+            return false;
+        };
+        const isColumnExistInModel = (tableName, columnName) => {
+            if (tableName === "sessions")
+                return true;
+            const table = params.model.find((row) => row.tableName === tableName);
+            if (table) {
+                const column = table.columns.find((row) => row.COLUMN_NAME === columnName);
+                if (column)
+                    return true;
+            }
+            return false;
+        };
+        // const getPossibleColumnValue = (tableName: string, columnName: string) => {
+        //   const foundTable = params.model.find((row) => row.tableName === tableName)
+        //   if (foundTable) {
+        //     const foundColumn = foundTable["columns"].find(
+        //       (row) => row.COLUMN_NAME === columnName
+        //     )
+        //     if (foundColumn) {
+        //       if (foundColumn.POSSIBLE_VALUE) return foundColumn.POSSIBLE_VALUE
+        //     } else return false
+        //   }
+        // }
+        const tableList = [
+            ...(await this.getTableNameList()),
+            ...(await this.getViewNameList()),
+        ];
+        const array = [];
+        for (let i = 0; i < tableList.length; i++) {
+            const tableName = tableList[i];
+            if (isTableNameExistInModel(tableName) ||
+                tableName.search("_view") >= 0) {
+                const columnList = await this.getColumnFullList(tableName);
+                let value = "";
+                for (const cRow of columnList) {
+                    const columnChecker = isColumnExistInModel(tableName, cRow.COLUMN_NAME);
+                    if (columnChecker || tableName.search("_view") >= 0) {
+                        const possibleValue = this.getPossibleColumnValue(params.model, cRow.TABLE_NAME, cRow.COLUMN_NAME, cRow.COLUMN_TYPE);
+                        if (possibleValue) {
+                            value = `${value} \n ${cRow.COLUMN_NAME}: [${possibleValue
+                                .map((row) => {
+                                if (typeof row === "string")
+                                    return `"${row}"`;
+                                else if (typeof row === "number")
+                                    return `${row}`;
+                            })
+                                .join(" , ")}]  as  ${typeof possibleValue[0]}[],`;
+                        }
+                        else {
+                            value = `${value} \n ${cRow.COLUMN_NAME}: "${convertDataType(cRow.DATA_TYPE)}",`;
+                        }
+                    }
+                    else {
+                        console.log(`${tableName}-${cRow.COLUMN_NAME} not exist in model `);
+                    }
+                }
+                const str = ` ${tableName}  : { ${value} }`;
+                array.push(str);
+                // console.log(`generate interface from ${tableName}`)
+            }
+        }
+        const fileName = `${params.appName}_model_const.ts`;
+        const code = `
+    export const ${params.appName}_model_const = { ${array.join(",")} } as const`;
+        for (let row of params.outputDirectory) {
+            const serverFilePath = path_1.default.join(row, fileName);
+            await fs_1.default.writeFileSync(serverFilePath, code);
+            console.log("save to ", serverFilePath);
+        }
+        console.log(`generate interface ${params.appName} ${chalk_1.default.bgGreen(" SUCCESS ")}`);
+        return code;
+    }
+}
+exports.default = ModelGenerator;
+function convertDataType(inputDataType) {
+    let result = "string";
+    if (inputDataType === "int") {
+        result = "number";
+    }
+    else if (inputDataType === "tinyint") {
+        result = "number";
+    }
+    else if (inputDataType === "bigint") {
+        result = "number";
+    }
+    else if (inputDataType === "date") {
+        result = "string";
+    }
+    else if (inputDataType === "float") {
+        result = "number";
+    }
+    else if (inputDataType === "double") {
+        result = "number";
+    }
+    return result;
+}

package/dist/src/ModelGenerator/SeedGenerator.js

@@ -0,0 +1,30 @@
+"use strict";
+// import { MyModel } from "../myModel"
+// function generateSeedInterfaceNoDBConnection(models: MyModel[]) {
+//   for (const tableModel of models) {
+//     const arrayOfColumnKeyValue = []
+//     const arrayOfSeedColumnKeyValue = []
+//     const columnList = tableModel.columns
+//     let stringOfRawColumnKeyAndValue = ""
+//     for (const cRow of columnList) {
+//       const possibleValue = cRow.POSSIBLE_VALUE
+//       if (possibleValue) {
+//         stringOfRawColumnKeyAndValue = `${stringOfRawColumnKeyAndValue} \n ${
+//           cRow.COLUMN_NAME
+//         }: ${possibleValue.map((row) => `"${row}"`).join(" | ")};`
+//       } else {
+//         stringOfRawColumnKeyAndValue = `${stringOfRawColumnKeyAndValue} \n ${
+//           cRow.COLUMN_NAME
+//         }: ${convertDataType(cRow.DATA_TYPE)};`
+//       }
+//     }
+//     // normal app model code
+//     const str = ` ${tableName} : { ${stringOfRawColumnKeyAndValue} }`
+//     arrayOfColumnKeyValue.push(str)
+//     // only seed model code
+//     const tempSeedModel = params.model.find(
+//       (row) => row.tableName === tableName && row.isSeed
+//     )
+//     if (tempSeedModel) arrayOfSeedColumnKeyValue.push(str)
+//   }
+// }

package/dist/src/MyDBMigrator/MyDBMigrator.d.ts

@@ -0,0 +1,24 @@
+import ModelGenerator from "../ModelGenerator/ModelGenerator";
+import { columnType, MyModel, MyViewModel } from "../myModel";
+export default class MyDBMigrator {
+    MyDB: ModelGenerator;
+    onetimeLoadColumnContent: {
+        COLUMN_NAME: string;
+        DATA_TYPE: columnType;
+        TABLE_NAME: string;
+        COLUMN_DEFAULT: string;
+        COLUMN_KEY: string;
+    }[];
+    constructor(connection: ModelGenerator);
+    migrateTable(model: MyModel[]): Promise<void>;
+    private createTableIfNotExist;
+    private columnInTableExist;
+    private loadColumnContentIfEmpty;
+    private checkIsColumnDataTypeChange;
+    alterUniqueKey(tableName: string, columnName: string, IS_UNIQUE: boolean | undefined): Promise<void>;
+    alterIndex(tableName: string, columnName: string, IS_INDEX: boolean | undefined): Promise<void>;
+    alterPossibleEnum(tableName: string, columnName: string, possibleValue?: string[]): Promise<null | undefined>;
+    migrateView(viewDirectory: string): Promise<0 | undefined>;
+    migrateView_v2(viewModel: MyViewModel[]): Promise<void>;
+    checkIsPrimaryKey(databaseName: string, tableName: string, columnName: string): Promise<boolean>;
+}

package/dist/src/MyDBMigrator/MyDBMigrator.js

@@ -0,0 +1,196 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+class MyDBMigrator {
+    constructor(connection) {
+        this.MyDB = connection;
+        this.onetimeLoadColumnContent = [];
+    }
+    async migrateTable(model) {
+        let data = model.filter((row) => row.tableName !== "sessions" && row.tableName.search("prisma") < 0);
+        let index = 1;
+        for (let row of data) {
+            console.log(chalk_1.default.bgBlue(`${index}/${data.length}  ${row.tableName}`));
+            await this.createTableIfNotExist(row.tableName);
+            this.onetimeLoadColumnContent = [];
+            await this.loadColumnContentIfEmpty();
+            index++;
+            for (let col of row.columns) {
+                console.log(`${row.tableName} (${col.DATA_TYPE}) - ${col.COLUMN_NAME} `);
+                if (col.COLUMN_NAME === "id" && col.AUTO_INCREMENT === true) {
+                    const isPrimaryKey = await this.checkIsPrimaryKey(this.MyDB.dbInfo.database, row.tableName, col.COLUMN_NAME);
+                    if (isPrimaryKey === false)
+                        await this.MyDB.query(`ALTER TABLE ${row.tableName} ADD PRIMARY KEY(id);`);
+                }
+                const AutoIncrement = col.AUTO_INCREMENT ? "AUTO_INCREMENT" : "";
+                const columnDefault = col.COLUMN_DEFAULT
+                    ? `DEFAULT ${col.COLUMN_DEFAULT}`
+                    : "";
+                const isColumnChange = await this.checkIsColumnDataTypeChange(row.tableName, col.COLUMN_NAME, col.DATA_TYPE, col.COLUMN_DEFAULT);
+                if (isColumnChange) {
+                    const isColumnExist = await this.columnInTableExist(row.tableName, col.COLUMN_NAME);
+                    if (!isColumnExist) {
+                        await this.MyDB.query(`ALTER TABLE ${row.tableName} ADD COLUMN ${col.COLUMN_NAME} ${col.DATA_TYPE} ${AutoIncrement} ${columnDefault}`);
+                    }
+                    else {
+                        await this.MyDB.query(`ALTER TABLE ${row.tableName} MODIFY COLUMN ${col.COLUMN_NAME} ${col.DATA_TYPE} ${AutoIncrement} ${columnDefault}`);
+                    }
+                }
+                await this.alterUniqueKey(row.tableName, col.COLUMN_NAME, col.IS_UNIQUE);
+                await this.alterIndex(row.tableName, col.COLUMN_NAME, col.IS_INDEX);
+                await this.alterPossibleEnum(row.tableName, col.COLUMN_NAME, col.POSSIBLE_VALUE);
+            }
+        }
+        console.log("migrate table done");
+    }
+    async createTableIfNotExist(tableName) {
+        await this.MyDB.query(`CREATE TABLE IF NOT EXISTS ${tableName} (id INT(11) AUTO_INCREMENT PRIMARY KEY)`);
+    }
+    async columnInTableExist(tableName, columnName) {
+        await this.loadColumnContentIfEmpty();
+        let result = this.onetimeLoadColumnContent.filter((row) => row.COLUMN_NAME === columnName && row.TABLE_NAME === tableName);
+        if (result.length)
+            return true;
+        else
+            return false;
+    }
+    async loadColumnContentIfEmpty() {
+        if (this.onetimeLoadColumnContent.length === 0) {
+            this.onetimeLoadColumnContent = (await this.MyDB.query(`SELECT * FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = '${this.MyDB.dbInfo.database}'`, undefined, false));
+        }
+    }
+    async checkIsColumnDataTypeChange(tableName, columnName, dataType, columnDefault) {
+        await this.loadColumnContentIfEmpty();
+        let temp = this.onetimeLoadColumnContent.filter((row) => row.TABLE_NAME === tableName && row.COLUMN_NAME === columnName);
+        if (columnDefault === undefined)
+            columnDefault = "NULL";
+        if (columnDefault === null)
+            columnDefault = "NULL";
+        if (temp.length > 0) {
+            if (temp[0].DATA_TYPE !== dataType) {
+                console.log(chalk_1.default.green `${temp[0].DATA_TYPE} change to ${dataType}`);
+                return true;
+            }
+            if (temp[0].COLUMN_DEFAULT !== columnDefault) {
+                console.log(chalk_1.default.green `${temp[0].COLUMN_DEFAULT} change to ${columnDefault}`);
+                return true;
+            }
+            return false;
+        }
+        else {
+            console.log(chalk_1.default.red `${columnName} not found`);
+            return true;
+        }
+    }
+    async alterUniqueKey(tableName, columnName, IS_UNIQUE) {
+        const data = this.onetimeLoadColumnContent.find((row) => row.COLUMN_NAME === columnName && row.TABLE_NAME === tableName);
+        if (data) {
+            if ((data.COLUMN_KEY === "UNI" && !IS_UNIQUE) ||
+                (data.COLUMN_KEY !== "UNI" && IS_UNIQUE === true))
+                if (IS_UNIQUE === true) {
+                    await this.MyDB.query(`ALTER TABLE ${tableName} ADD UNIQUE (${columnName});`);
+                }
+                else {
+                    await this.MyDB.query(`ALTER TABLE ${tableName} DROP INDEX ${columnName};`);
+                }
+        }
+    }
+    async alterIndex(tableName, columnName, IS_INDEX) {
+        const data = this.onetimeLoadColumnContent.find((row) => row.COLUMN_NAME === columnName && row.TABLE_NAME === tableName);
+        if (data) {
+            if ((data.COLUMN_KEY === "MUL" && !IS_INDEX) ||
+                (data.COLUMN_KEY !== "MUL" && IS_INDEX === true))
+                if (IS_INDEX === true) {
+                    await this.MyDB.query(`ALTER TABLE ${tableName} ADD INDEX (${columnName});`);
+                }
+                else {
+                    await this.MyDB.query(`DROP INDEX ${columnName} ON ${tableName};`);
+                }
+        }
+    }
+    async alterPossibleEnum(tableName, columnName, possibleValue) {
+        if (!possibleValue)
+            return null;
+        const data = this.onetimeLoadColumnContent.find((row) => row.COLUMN_NAME === columnName && row.TABLE_NAME === tableName);
+        if (data) {
+            const possibleValueString = possibleValue
+                .map((row) => `"${row}"`)
+                .join(", ");
+            await this.MyDB.query(`ALTER TABLE ${tableName} MODIFY COLUMN ${columnName} ENUM(${possibleValueString}) NOT NULL;`);
+        }
+    }
+    async migrateView(viewDirectory) {
+        if (!fs_1.default.existsSync(viewDirectory)) {
+            return 0;
+        }
+        let fileList = (await fs_1.default.readdirSync(path_1.default.join(viewDirectory)));
+        let unSuccessUpdateViewList = fileList;
+        let loopCount = 0;
+        while (unSuccessUpdateViewList.length > 0) {
+            for (const viewFileName of unSuccessUpdateViewList) {
+                const filePath = path_1.default.join(viewDirectory, viewFileName);
+                const content = fs_1.default.readFileSync(filePath, "utf8");
+                process.stdout.write(`loop : ${loopCount} unUpdate : ${unSuccessUpdateViewList.length} update view ${viewFileName}`);
+                await this.MyDB.query(content)
+                    .then((result) => {
+                    process.stdout.write(" " + chalk_1.default.bgGreen(`success`));
+                    unSuccessUpdateViewList = unSuccessUpdateViewList.filter((row) => row !== viewFileName);
+                })
+                    .catch((_error) => {
+                    process.stdout.write(" " + chalk_1.default.bgRed(`fail`));
+                })
+                    .finally(() => {
+                    console.log("");
+                });
+            }
+        }
+    }
+    async migrateView_v2(viewModel) {
+        let unSuccessUpdateViewList = viewModel;
+        let loopCount = 0;
+        while (unSuccessUpdateViewList.length > 0) {
+            for (const viewRow of unSuccessUpdateViewList) {
+                const content = viewRow.sqlStatement;
+                process.stdout.write(`loop : ${loopCount} unUpdate : ${unSuccessUpdateViewList.length} update view ${viewRow.viewName}`);
+                await this.MyDB.query(content)
+                    .then((result) => {
+                    process.stdout.write(" " + chalk_1.default.bgGreen(`success`));
+                    unSuccessUpdateViewList = unSuccessUpdateViewList.filter((row) => row.viewName !== viewRow.viewName);
+                })
+                    .catch((_error) => {
+                    process.stdout.write(" " + chalk_1.default.bgRed(`fail`));
+                })
+                    .finally(() => {
+                    console.log("");
+                });
+                loopCount++;
+                if (loopCount > viewModel.length * 5) {
+                    console.log("error while updating view, reason is loop update counter is over 5 time fail");
+                    process.exit(1);
+                }
+            }
+        }
+    }
+    async checkIsPrimaryKey(databaseName, tableName, columnName) {
+        let result = await this.MyDB.query(`SELECT * 
+    FROM INFORMATION_SCHEMA.COLUMNS 
+    WHERE TABLE_SCHEMA='${databaseName}'  
+        AND TABLE_NAME='${tableName}' 
+        AND COLUMN_NAME='${columnName}'`);
+        console.log("result", result);
+        if (result.length) {
+            if (result[0].COLUMN_KEY === "PRI")
+                return true;
+            else
+                return false;
+        }
+        else
+            return false;
+    }
+}
+exports.default = MyDBMigrator;

package/dist/src/app_INF.d.ts

@@ -0,0 +1,17 @@
+export default interface app_INF {
+    item: {
+        id: number;
+        name: "pen" | "ruler";
+        price: number;
+        description: string;
+    };
+    user: {
+        id: number;
+        name: string;
+    };
+    test_view: {
+        id: number;
+        name: string;
+        itemName: string;
+    };
+}

package/dist/src/app_INF.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/index.d.ts

@@ -0,0 +1,4 @@
+export { MyModel, columnContent, columnType } from "./myModel";
+export { DatabaseConfigInterface } from "./ModelGenerator/ModelGenerator";
+export { default as ModelGenerator } from "./ModelGenerator/ModelGenerator";
+export { default as GGMySQLConnector } from "./GGMySQLConnector/GGMySQLConnector";

package/dist/src/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GGMySQLConnector = exports.ModelGenerator = void 0;
+var ModelGenerator_1 = require("./ModelGenerator/ModelGenerator");
+Object.defineProperty(exports, "ModelGenerator", { enumerable: true, get: function () { return __importDefault(ModelGenerator_1).default; } });
+var GGMySQLConnector_1 = require("./GGMySQLConnector/GGMySQLConnector");
+Object.defineProperty(exports, "GGMySQLConnector", { enumerable: true, get: function () { return __importDefault(GGMySQLConnector_1).default; } });

package/dist/src/myModel.d.ts

@@ -0,0 +1,21 @@
+import { SQLStatement } from "sql-template-strings";
+export type columnType = "int" | "tinyint" | "float" | "double" | "text" | "varchar(8)" | "varchar(16)" | "varchar(32)" | "varchar(64)" | "varchar(128)" | "varchar(256)" | "varchar(512)" | "longtext" | "date" | "time" | "datetime";
+export interface columnContent {
+    COLUMN_NAME: string;
+    DATA_TYPE: columnType;
+    COLUMN_DEFAULT?: string | number | null;
+    AUTO_INCREMENT?: boolean;
+    POSSIBLE_VALUE?: string[];
+    IS_UNIQUE?: boolean;
+    IS_INDEX?: boolean;
+}
+export interface MyModel {
+    isSeed: boolean;
+    tableName: string;
+    columns: [...columnContent[]];
+    meaning?: string;
+}
+export interface MyViewModel {
+    viewName: string;
+    sqlStatement: string | SQLStatement;
+}

package/dist/src/myModel.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gg-mysql-connector",
-  "version": "1.0.37",
+  "version": "1.0.39",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -14,10 +14,11 @@
     "chalk": "^4.1.2",
     "fs": "^0.0.1-security",
     "mysql2": "^3.11.3",
-    "path": "^0.12.7"
+    "path": "^0.12.7",
+    "sql-template-strings": "^2.2.2"
   },
   "devDependencies": {
     "@types/node": "^22.7.5",
-    "typescript": "^5.6.3"
+    "typescript": "^5.8.2"
   }
 }

package/seed_INF.ts

@@ -0,0 +1,3 @@
+export default interface seed_INF  {  user : {  
+ id: number; 
+ name: string; } }