gg-mysql-connector 1.0.36 → 1.0.39

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, MyViewModel } from "../myModel"
 export interface DatabaseConfigInterface {
   host: string
   user: string
@@ -39,13 +39,18 @@ 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)
   }
+  async pushViewToDB_v2(viewModel: MyViewModel[]) {
+    const migrator = new MyDBMigrator(this)
+    await migrator.migrateView_v2(viewModel)
+  }
+
   waitUntilInitSuccess(interval: number) {
     if (this.isConnected === true) return true
     return new Promise((resolve, reject) => {
@@ -142,70 +147,97 @@ 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,
+    columnType: string
+  ) {
+    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: string[] = temp.split(",")
+        return word
+      }
+    }
+  }
   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(
+          // console.log("cRow", cRow.COLUMN_TYPE)
+          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
+              cRow.COLUMN_NAME,
+              cRow.COLUMN_TYPE
             )
             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 +246,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(
@@ -259,17 +306,17 @@ export default class ModelGenerator {
       }
       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 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()),
@@ -291,9 +338,11 @@ export default class ModelGenerator {
             cRow.COLUMN_NAME
           )
           if (columnChecker || tableName.search("_view") >= 0) {
-            const possibleValue = getPossibleColumnValue(
+            const possibleValue = this.getPossibleColumnValue(
+              params.model,
               cRow.TABLE_NAME,
-              cRow.COLUMN_NAME
+              cRow.COLUMN_NAME,
+              cRow.COLUMN_TYPE
             )
             if (possibleValue) {
               value = `${value} \n ${cRow.COLUMN_NAME}: [${possibleValue
@@ -319,7 +368,7 @@ export default class ModelGenerator {
     }
     const fileName = `${params.appName}_model_const.ts`
     const code = `
-    export const ${params.appName}_model_const  = { ${array.join(
+    export const ${params.appName}_model_const = { ${array.join(
       ","
     )} } as const`
 

package/src/ModelGenerator/SeedGenerator.ts

@@ -0,0 +1,33 @@
+// 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/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, MyViewModel } from "../myModel"
 
-export default class MyDBMigration<Main> {
+export default class MyDBMigrator {
   MyDB: ModelGenerator
   onetimeLoadColumnContent: {
     COLUMN_NAME: string
@@ -35,13 +35,12 @@ export default class MyDBMigration<Main> {
         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
+          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);`
             )
@@ -74,6 +73,11 @@ export default class MyDBMigration<Main> {
         }
         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")
@@ -182,6 +186,25 @@ export default class MyDBMigration<Main> {
     }
   }
 
+  async alterPossibleEnum(
+    tableName: string,
+    columnName: string,
+    possibleValue?: string[]
+  ) {
+    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: string) {
     if (!fs.existsSync(viewDirectory)) {
       return 0
@@ -214,6 +237,41 @@ export default class MyDBMigration<Main> {
       }
     }
   }
+
+  async migrateView_v2(viewModel: MyViewModel[]) {
+    let unSuccessUpdateViewList: MyViewModel[] = 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 as string)
+          .then((result) => {
+            process.stdout.write(" " + chalk.bgGreen(`success`))
+            unSuccessUpdateViewList = unSuccessUpdateViewList.filter(
+              (row) => row.viewName !== viewRow.viewName
+            )
+          })
+          .catch((_error) => {
+            process.stdout.write(" " + chalk.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: string,
     tableName: 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,3 +1,4 @@
+import { SQLStatement } from "sql-template-strings"
 
 export type columnType =
   | "int"
@@ -21,18 +22,17 @@ export interface columnContent {
   DATA_TYPE: columnType
   COLUMN_DEFAULT?: string | number | null
   AUTO_INCREMENT?: boolean
-  POSSIBLE_VALUE?: any[]
+  POSSIBLE_VALUE?: string[]
   IS_UNIQUE?: boolean
   IS_INDEX?: boolean
 }
 export interface MyModel {
+  isSeed: boolean
   tableName: string
-  columns: [
-    ...columnContent[]
-  ]
+  columns: [...columnContent[]]
   meaning?: string
 }
-// export interface MyModelView {
-//   viewName: string
-//   relatedTableName: (keyof hotel_INF)[]
-// }
+export interface MyViewModel {
+  viewName: string
+  sqlStatement: string | SQLStatement
+}