gg-mysql-connector 1.0.35 → 1.0.37

package/dist/GGMySQLConnector/GGMySQLConnector.d.ts

@@ -0,0 +1,72 @@
+import mysql, { QueryResult, RowDataPacket } from "mysql2";
+import { DatabaseConfigInterface } from "../ModelGenerator/ModelGenerator";
+export interface ClassDBInterface<Main> {
+    connection: mysql.Connection;
+    query<T>(statement: string, parameter?: object, isPrint?: boolean): Promise<T | QueryResult>;
+    getColumnList(tableName: string): Promise<string[]>;
+    select<T extends keyof Main>(tableName: T extends string ? T : string): Promise<Main[T][]>;
+    selectByID<T extends keyof Main>(tableName: T extends string ? T : string, id: number): Promise<Main[T][]>;
+    selectByMatchParams<T extends keyof Main>(tableName: T extends string ? T : string, params: object): Promise<Main[T][]>;
+    selectBySearchTextInRow(tableName: string, textToSearch: string): Promise<RowDataPacket[]>;
+    insert<T extends keyof Main>(tableName: T, params: any): Promise<mysql.OkPacket>;
+    update(tableName: string, parameter: object | object[]): Promise<mysql.OkPacket>;
+    updateOnlyID<T extends keyof Main extends string ? keyof Main : string>(tableName: T, params: {
+        oldID: number;
+        newID: number;
+    }): Promise<mysql.OkPacket | null>;
+    deleteByID(tableName: string, id: number): Promise<mysql.OkPacket>;
+    deleteByMatchParams(tableName: string, parameter: any): Promise<mysql.OkPacket | null>;
+    getTableNameList(): Promise<string[]>;
+    getViewNameList(): Promise<string[]>;
+    getViewNameIfExist(tableName: string): Promise<string>;
+    loadTableAndViewNameList(): Promise<string[]>;
+    createDatabaseIfNotExist(tempConnection: mysql.Connection): Promise<void>;
+}
+export type Unarray<T> = T extends Array<infer U> ? U : T;
+export default class GGMySQLConnector<Main> implements ClassDBInterface<Main> {
+    DBInfo: DatabaseConfigInterface;
+    connection: mysql.Connection;
+    isPrintStatement: boolean;
+    tableAndViewNameList: string[];
+    columnAndTableListCache: {
+        COLUMN_NAME: string;
+        TABLE_NAME: string;
+        DATA_TYPE: string;
+    }[] | null;
+    isConnected: boolean;
+    constructor(DBInfo: DatabaseConfigInterface);
+    createDatabaseIfNotExist(tempConnection: mysql.Connection): Promise<void>;
+    selectBySearchTextInRow(tableName: string, textToSearch: string): Promise<mysql.RowDataPacket[]>;
+    loadTableAndViewNameList(): Promise<string[]>;
+    getViewNameIfExist(tableName: string): Promise<string>;
+    selectByMatchParams<T extends keyof Main>(tableName: T extends string ? T : string, params: Partial<{
+        [K in keyof Main[T]]: string | number | undefined | null;
+    }>): Promise<Main[T][]>;
+    selectByID<T extends keyof Main>(tableName: T extends string ? T : string, id: number): Promise<Main[T][]>;
+    select<T extends keyof Main>(tableName: T extends string ? T : string): Promise<Main[T][]>;
+    getTableNameList(): Promise<string[]>;
+    getViewNameList(): Promise<string[]>;
+    deleteByMatchParams<T extends keyof Main>(tableName: T extends string ? T : string, params: Partial<{
+        [K in keyof Main[T]]: T | string | number | undefined | null;
+    }>): Promise<mysql.OkPacket | null>;
+    deleteByID<T extends keyof Main>(tableName: T extends string ? T : string, id: number): Promise<mysql.OkPacket>;
+    insert<T extends keyof Main>(tableName: T, parameter: Partial<{
+        [R in keyof Unarray<Main[T]>]: any;
+    }> | Partial<{
+        [R in keyof Unarray<Main[T]>]: any;
+    }>[]): Promise<mysql.OkPacket>;
+    updateOnlyID<T extends keyof Main extends string ? keyof Main : string>(tableName: T, params: {
+        oldID: number;
+        newID: number;
+    }): Promise<mysql.OkPacket | null>;
+    update<T extends keyof Main>(tableName: T extends string ? T : string, parameter: Partial<{
+        [K in keyof Main[T]]: Main[T][K];
+    }>): Promise<mysql.OkPacket>;
+    init(): Promise<void>;
+    loadColumnListToCache(): Promise<void>;
+    getColumnList(tableName: string): Promise<string[]>;
+    getColumnFullList(tableName: string): Promise<mysql.RowDataPacket[]>;
+    waitUntilInitSuccess(interval: number): true | Promise<unknown>;
+    query<T>(statment: string, parameter?: any[], isPrint?: boolean): Promise<T | QueryResult>;
+    private printResultLength;
+}

package/dist/GGMySQLConnector/GGMySQLConnector.js

@@ -0,0 +1,296 @@
+"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 mysql2_1 = __importDefault(require("mysql2"));
+class GGMySQLConnector {
+    constructor(DBInfo) {
+        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(`${this.DBInfo.database} > ${chalk_1.default.green(queryResult.sql)} ${chalk_1.default.cyan(`found ${results.length} rows.`)} ${executionTimeMessage}`);
+            }
+        };
+        this.isPrintStatement = false;
+        this.tableAndViewNameList = [];
+        this.columnAndTableListCache = null;
+        this.DBInfo = DBInfo;
+        this.isConnected = false;
+    }
+    async createDatabaseIfNotExist(tempConnection) {
+        const currentDatabaseName = this.DBInfo.database;
+        console.log("currentDatabaseName", currentDatabaseName);
+        return new Promise((resolve, reject) => {
+            tempConnection.query(`CREATE DATABASE IF NOT EXISTS ${currentDatabaseName}`, () => {
+                resolve();
+            });
+        });
+    }
+    async selectBySearchTextInRow(tableName, textToSearch) {
+        const result = (await this.query(`SELECT * FROM ${tableName}`));
+        const wordList = textToSearch.split(" ");
+        const temp = result.filter((row) => {
+            const rawText = Object.values(row).flat().join(" ");
+            const wordFilterResult = wordList.filter((wRow) => rawText.search(wRow) >= 0);
+            if (wordFilterResult.length === wordList.length)
+                return true;
+            return false;
+        });
+        return temp;
+    }
+    async loadTableAndViewNameList() {
+        let result = (await this.query("SELECT TABLE_NAME FROM information_schema.tables WHERE table_schema = ?", [this.DBInfo.database], false));
+        this.tableAndViewNameList = result.map((row) => row.TABLE_NAME);
+        return this.tableAndViewNameList;
+    }
+    async getViewNameIfExist(tableName) {
+        const tableList = this.tableAndViewNameList;
+        const viewPostFixArray = ["_view", "__view", "__view_list"];
+        for (let i = 0; i < viewPostFixArray.length; i++) {
+            const expectViewName = tableName + viewPostFixArray[i];
+            for (let j = 0; j < tableList.length; j++) {
+                const row = tableList[j];
+                if (row === expectViewName) {
+                    return expectViewName;
+                }
+                else if (i == viewPostFixArray.length - 1 &&
+                    j == tableList.length - 1) {
+                    return tableName;
+                }
+            }
+        }
+        return tableName;
+    }
+    async selectByMatchParams(tableName, params) {
+        const columnList = await this.getColumnList(tableName);
+        const keyList = Object.keys(params);
+        const keyToSearchList = [];
+        const valueToSearchList = [];
+        for (const key of keyList) {
+            const temp = columnList.find((fkey) => key === fkey);
+            if (temp) {
+                keyToSearchList.push(` ${key} = ? `);
+                valueToSearchList.push(params[key]);
+            }
+        }
+        if (keyToSearchList.length === 0) {
+            return [];
+        }
+        let result = (await this.query(`SELECT * FROM ${tableName} WHERE ${keyToSearchList.join(" AND ")}`, valueToSearchList));
+        return result;
+    }
+    async selectByID(tableName, id) {
+        let result = (await this.query(`SELECT * FROM ${tableName} WHERE id = ? LIMIT 1`, [id]));
+        return result;
+    }
+    async select(tableName) {
+        let result = (await this.query(`SELECT * FROM ${tableName}`));
+        return result;
+    }
+    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 deleteByMatchParams(tableName, params) {
+        const columnList = await this.getColumnList(tableName);
+        const keyList = Object.keys(params);
+        const keyToSearchList = [];
+        const valueToSearchList = [];
+        for (const key of keyList) {
+            const temp = columnList.find((fkey) => key === fkey);
+            if (temp) {
+                keyToSearchList.push(` ${key} = ? `);
+                valueToSearchList.push(params[key]);
+            }
+        }
+        if (keyToSearchList.length === 0)
+            return null;
+        let result = (await this.query(`DELETE  FROM ${tableName} WHERE ${keyToSearchList.join(" AND ")}`, valueToSearchList));
+        // this.webSocket.sendByURL("/websocket/watchTableChange", tableName)
+        return result;
+    }
+    async deleteByID(tableName, id) {
+        let result = (await this.query(`DELETE FROM ${tableName} WHERE id = ?`, [
+            id,
+        ]));
+        console.log("Delete Success");
+        // this.webSocket.sendByURL("/websocket/watchTableChange", tableName)
+        return result;
+    }
+    async insert(tableName, parameter) {
+        let params = [];
+        if (Array.isArray(parameter) === true) {
+            params = parameter;
+        }
+        else
+            params = [parameter];
+        const columnList = await this.getColumnList(tableName);
+        const exampleParams = params[0];
+        const keyList = Object.keys(exampleParams);
+        const keyListToInsert = [];
+        for (const row of keyList) {
+            const temp = columnList.find((fRow) => row === fRow);
+            if (temp)
+                keyListToInsert.push(row);
+        }
+        const valueArrayToInsertInQuery = [];
+        for (let i = 0; i < params.length; i++) {
+            const valueListToInsert = [];
+            for (const row of keyList) {
+                const temp = columnList.find((fRow) => row === fRow);
+                if (temp) {
+                    valueListToInsert.push(params[i][row]);
+                }
+            }
+            valueArrayToInsertInQuery.push(valueListToInsert);
+        }
+        console.log(valueArrayToInsertInQuery.slice(0, 5));
+        const result = (await this.query(`INSERT INTO ${tableName} (${keyListToInsert.join(",")}) VALUES ?`, [valueArrayToInsertInQuery]));
+        console.log("Insert Success");
+        // this.webSocket.sendByURL("/websocket/watchTableChange", String(tableName))
+        return result;
+    }
+    async updateOnlyID(tableName, params) {
+        const isNewIdExist = await this.query(`SELECT * FROM ${tableName} WHERE id = ? `, [params.newID]);
+        if (isNewIdExist.length >= 1) {
+            console.log(`error : newID (${params.newID}) is already exist`);
+            return null;
+        }
+        let result = (await this.query(`UPDATE ${tableName} SET id = ? WHERE id = ?`, [params.newID, params.oldID], false));
+        console.log("UpdateOnlyID Success");
+        // this.webSocket.sendByURL("/websocket/watchTableChange", String(tableName))
+        return result;
+    }
+    async update(tableName, parameter) {
+        const columnList = await this.getColumnList(tableName);
+        console.log(parameter);
+        const keyList = Object.keys(parameter);
+        const keyListToInsert = [];
+        const valueListToInsert = [];
+        for (const row of keyList) {
+            const temp = columnList.find((fRow) => row === fRow);
+            if (temp) {
+                keyListToInsert.push(row);
+                valueListToInsert.push(parameter[row]);
+            }
+        }
+        // build set sql
+        const temp = [];
+        let index = 0;
+        for (const row of keyListToInsert) {
+            if (valueListToInsert[index] === null) {
+                temp.push(`${row} = NULL`);
+            }
+            else {
+                let value = valueListToInsert[index];
+                if (typeof value === "string") {
+                    value = value.replace(/'/g, "");
+                }
+                temp.push(`${row} = '${value}'`);
+            }
+            index++;
+        }
+        let result = (await this.query(`UPDATE ${tableName} SET ${temp.join(",")} WHERE id = ${parameter.id}`, [], false));
+        console.log("Update Success");
+        // this.webSocket.sendByURL("/websocket/watchTableChange", String(tableName))
+        return result;
+    }
+    async init() {
+        const currentConnection = mysql2_1.default.createConnection({
+            host: this.DBInfo.host,
+            user: this.DBInfo.user,
+            password: this.DBInfo.password,
+        });
+        this.isConnected = true;
+        await this.createDatabaseIfNotExist(currentConnection);
+        // await currentConnection.end()
+        this.connection = mysql2_1.default.createConnection(Object.assign({}, this.DBInfo));
+        // await this.query("SET global sql_mode=''")
+        // await this.query("SET global query_cache_type='ON'")
+        // await this.query("SET global query_cache_size=16777216")
+        // await this.query("SET global query_cache_limit=16777216")
+        await this.loadTableAndViewNameList();
+        await this.loadColumnListToCache();
+    }
+    async loadColumnListToCache() {
+        const result = (await this.query(`SELECT COLUMN_NAME,TABLE_NAME,DATA_TYPE FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = '${this.DBInfo.database}'`, undefined, false));
+        this.columnAndTableListCache = result;
+    }
+    async getColumnList(tableName) {
+        if (this.columnAndTableListCache !== null) {
+            return this.columnAndTableListCache
+                .filter((row) => row.TABLE_NAME === tableName)
+                .map((row) => row.COLUMN_NAME);
+        }
+        const result = await this.query(`SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = '${this.DBInfo.database}' AND TABLE_NAME = '${tableName}'`, undefined, false);
+        return result.map((row) => row.COLUMN_NAME);
+    }
+    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;
+    }
+    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, (error, results, fields) => {
+                if (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);
+                }
+                else {
+                    const endTime = new Date();
+                    const executionTime = endTime.getTime() - startTime.getTime();
+                    if (isPrint === true) {
+                        this.printResultLength(results, executionTime, queryResult);
+                    }
+                    else if (this.isPrintStatement) {
+                        this.printResultLength(results, executionTime, queryResult);
+                    }
+                    resolve(results);
+                }
+            });
+        });
+    }
+}
+exports.default = GGMySQLConnector;

package/dist/ModelGenerator/ModelGenerator.d.ts

@@ -0,0 +1,38 @@
+import mysql from "mysql2/promise";
+import { MyModel } from "../myModel";
+export interface DatabaseConfigInterface {
+    host: string;
+    user: string;
+    password: string;
+    database: string;
+}
+export default class ModelGenerator {
+    model: MyModel[];
+    dbInfo: DatabaseConfigInterface;
+    connection: mysql.Connection;
+    isConnected: boolean;
+    constructor(dbInfo: DatabaseConfigInterface, model: MyModel[]);
+    init(): Promise<void>;
+    private createDatabaseIfNotExist;
+    pushModelToDB(): Promise<void>;
+    pushViewToDB(viewDirectory: string): Promise<void>;
+    waitUntilInitSuccess(interval: number): true | Promise<unknown>;
+    query<T>(statment: string, parameter?: any[], isPrint?: boolean): Promise<T>;
+    private printResultLength;
+    getTableNameList(): Promise<string[]>;
+    getViewNameList(): Promise<string[]>;
+    getColumnFullList(tableName: string): Promise<mysql.RowDataPacket[]>;
+    private isTableNameExistInModel;
+    private isColumnExistInModel;
+    getPossibleColumnValue(model: MyModel[], tableName: string, columnName: string): false | any[] | undefined;
+    generateModelInterface(params: {
+        appName: string;
+        model: MyModel[];
+        outputDirectory: string[];
+    }): Promise<string>;
+    generateModelConstStructure(params: {
+        appName: string;
+        model: MyModel[];
+        outputDirectory: string[];
+    }): Promise<string>;
+}

package/dist/ModelGenerator/ModelGenerator.js

@@ -0,0 +1,299 @@
+"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);
+    }
+    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) {
+        const foundTable = 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;
+        }
+    }
+    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) {
+                    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);
+                        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, columnName) => {
+            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 = getPossibleColumnValue(cRow.TABLE_NAME, cRow.COLUMN_NAME);
+                        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/ModelGenerator/SeedGenerator.d.ts

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

package/dist/ModelGenerator/SeedGenerator.js

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

package/dist/ModelGenerator.js

@@ -253,15 +253,7 @@ class ModelGenerator {
         }
         const fileName = `${params.appName}_model_const.ts`;
         const code = `
-    type paramType = "number" | "string" | "any" | string[] | number[]
-    interface constInterface {
-    [keytable: string]: {
-      [key: string]: paramType
-    }
-  } 
-
-
-    export const ${params.appName}_model_const : constInterface = { ${array.join(",")} } as const`;
+    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);

package/dist/MyDBMigrator/MyDBMigrator.d.ts

@@ -0,0 +1,22 @@
+import ModelGenerator from "../ModelGenerator/ModelGenerator";
+import { columnType, MyModel } 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>;
+    migrateView(viewDirectory: string): Promise<0 | undefined>;
+    checkIsPrimaryKey(databaseName: string, tableName: string, columnName: string): Promise<boolean>;
+}

package/dist/MyDBMigrator/MyDBMigrator.js

@@ -0,0 +1,157 @@
+"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) {
+                    if ((await this.checkIsPrimaryKey(this.MyDB.dbInfo.database, row.tableName, col.COLUMN_NAME)) === 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);
+            }
+        }
+        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 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 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/index.d.ts

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

package/dist/index.js

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

package/dist/myModel.d.ts

@@ -9,9 +9,8 @@ export interface columnContent {
     IS_INDEX?: boolean;
 }
 export interface MyModel {
+    isSeed: boolean;
     tableName: string;
-    columns: [
-        ...columnContent[]
-    ];
+    columns: [...columnContent[]];
     meaning?: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gg-mysql-connector",
-  "version": "1.0.35",
+  "version": "1.0.37",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/src/{GGMySQLConnector.ts → GGMySQLConnector/GGMySQLConnector.ts}

@@ -1,7 +1,7 @@
 import chalk from "chalk"
 import { randomUUID } from "crypto"
 import mysql, { QueryResult, RowDataPacket } from "mysql2"
-import { DatabaseConfigInterface } from "./ModelGenerator"
+import { DatabaseConfigInterface } from "../ModelGenerator/ModelGenerator"
 
 export interface ClassDBInterface<Main> {
   connection: mysql.Connection

package/src/{ModelGenerator.ts → ModelGenerator/ModelGenerator.ts}

@@ -3,8 +3,8 @@ import { randomUUID } from "crypto"
 import fs from "fs"
 import mysql from "mysql2/promise"
 import path from "path"
-import MyDBMigration from "./MyDBMigration"
-import { MyModel } from "./myModel"
+import MyDBMigrator from "../MyDBMigrator/MyDBMigrator"
+import { MyModel } from "../myModel"
 export interface DatabaseConfigInterface {
   host: string
   user: string
@@ -39,11 +39,11 @@ export default class ModelGenerator {
   }
 
   async pushModelToDB() {
-    const migrator = new MyDBMigration(this)
+    const migrator = new MyDBMigrator(this)
     await migrator.migrateTable(this.model)
   }
   async pushViewToDB(viewDirectory: string) {
-    const migrator = new MyDBMigration(this)
+    const migrator = new MyDBMigrator(this)
     await migrator.migrateView(viewDirectory)
   }
   waitUntilInitSuccess(interval: number) {
@@ -142,70 +142,79 @@ export default class ModelGenerator {
     )) as mysql.RowDataPacket[]
     return result
   }
+
+  private isTableNameExistInModel(model: MyModel[], tableName: string) {
+    if (tableName === "sessions") return true
+    const table = model.find((row) => row.tableName === tableName)
+    return table ? true : false
+  }
+  private isColumnExistInModel(
+    model: MyModel[],
+    tableName: string,
+    columnName: string
+  ) {
+    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: MyModel[],
+    tableName: string,
+    columnName: string
+  ) {
+    const foundTable = 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
+    }
+  }
   async generateModelInterface(params: {
     appName: string
     model: MyModel[]
     outputDirectory: string[]
   }) {
-    const isTableNameExistInModel = (tableName: string) => {
-      if (tableName === "sessions") return true
-      const table = params.model.find((row) => row.tableName === tableName)
-      if (table) return true
-      return false
-    }
-    const isColumnExistInModel = (tableName: string, columnName: string) => {
-      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 = []
+    const arrayOfColumnKeyValue = []
+    const arrayOfSeedColumnKeyValue = []
     for (let i = 0; i < tableList.length; i++) {
       const tableName = tableList[i]
       if (
-        isTableNameExistInModel(tableName) ||
+        this.isTableNameExistInModel(params.model, tableName) ||
         tableName.search("_view") >= 0
       ) {
         const columnList = await this.getColumnFullList(tableName)
 
-        let singleInterfaceContent = ""
+        let stringOfRawColumnKeyAndValue = ""
         for (const cRow of columnList) {
-          const columnChecker = isColumnExistInModel(
+          const isColumnExistInModel = this.isColumnExistInModel(
+            params.model,
             tableName,
             cRow.COLUMN_NAME
           )
-          if (columnChecker || tableName.search("_view") >= 0) {
-            const possibleValue = getPossibleColumnValue(
+          if (isColumnExistInModel || tableName.search("_view") >= 0) {
+            const possibleValue = this.getPossibleColumnValue(
+              params.model,
               cRow.TABLE_NAME,
               cRow.COLUMN_NAME
             )
             if (possibleValue) {
-              singleInterfaceContent = `${singleInterfaceContent} \n ${
+              stringOfRawColumnKeyAndValue = `${stringOfRawColumnKeyAndValue} \n ${
                 cRow.COLUMN_NAME
               }: ${possibleValue.map((row) => `"${row}"`).join(" | ")};`
             } else {
-              singleInterfaceContent = `${singleInterfaceContent} \n ${
+              stringOfRawColumnKeyAndValue = `${stringOfRawColumnKeyAndValue} \n ${
                 cRow.COLUMN_NAME
               }: ${convertDataType(cRow.DATA_TYPE)};`
             }
@@ -214,20 +223,35 @@ export default class ModelGenerator {
           }
         }
 
-        const str = ` ${tableName}  : { ${singleInterfaceContent} }`
-        array.push(str)
-        // console.log(`generate interface from ${tableName}`)
+        // 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  { ${array.join("\n")} }`
+    }_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.join(row, fileName)
       await fs.writeFileSync(serverFilePath, code)
-      console.log("save to ", serverFilePath)
+      console.log("save app model to ", serverFilePath)
+      // only seed model code
+      const seedServerFilePath = path.join(row, seedFileName)
+      await fs.writeFileSync(seedServerFilePath, seedCode)
+      console.log("save seed model to ", seedServerFilePath)
     }
 
     console.log(
@@ -319,17 +343,9 @@ export default class ModelGenerator {
     }
     const fileName = `${params.appName}_model_const.ts`
     const code = `
-    type paramType = "number" | "string" | "any" | string[] | number[]
-    interface constInterface {
-    [keytable: string]: {
-      [key: string]: paramType
-    }
-  } 
-
-
-    export const ${
-      params.appName
-    }_model_const : constInterface = { ${array.join(",")} } as const`
+    export const ${params.appName}_model_const = { ${array.join(
+      ","
+    )} } as const`
 
     for (let row of params.outputDirectory) {
       const serverFilePath = path.join(row, fileName)

package/src/ModelGenerator/SeedGenerator.ts

@@ -0,0 +1,3 @@
+import { MyModel } from "../myModel"
+
+function generateSeedInterface(model: MyModel[]) {}

package/src/{MyDBMigration.ts → MyDBMigrator/MyDBMigrator.ts}

@@ -1,10 +1,10 @@
 import chalk from "chalk"
 import fs from "fs"
 import path from "path"
-import ModelGenerator from "./ModelGenerator"
-import { columnType, MyModel } from "./myModel"
+import ModelGenerator from "../ModelGenerator/ModelGenerator"
+import { columnType, MyModel } from "../myModel"
 
-export default class MyDBMigration<Main> {
+export default class MyDBMigrator {
   MyDB: ModelGenerator
   onetimeLoadColumnContent: {
     COLUMN_NAME: string

package/src/index.ts

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

package/src/myModel.ts

@@ -1,4 +1,3 @@
-
 export type columnType =
   | "int"
   | "tinyint"
@@ -26,10 +25,9 @@ export interface columnContent {
   IS_INDEX?: boolean
 }
 export interface MyModel {
+  isSeed: boolean
   tableName: string
-  columns: [
-    ...columnContent[]
-  ]
+  columns: [...columnContent[]]
   meaning?: string
 }
 // export interface MyModelView {