gg-mysql-connector 1.0.37 → 1.0.39

package/src/ModelGenerator/ModelGenerator.ts

@@ -4,7 +4,7 @@ import fs from "fs"
 import mysql from "mysql2/promise"
 import path from "path"
 import MyDBMigrator from "../MyDBMigrator/MyDBMigrator"
-import { MyModel } from "../myModel"
+import { MyModel, MyViewModel } from "../myModel"
 export interface DatabaseConfigInterface {
   host: string
   user: string
@@ -46,6 +46,11 @@ export default class ModelGenerator {
     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) => {
@@ -164,16 +169,32 @@ export default class ModelGenerator {
   getPossibleColumnValue(
     model: MyModel[],
     tableName: string,
-    columnName: 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
       )
-      if (foundColumn) {
-        if (foundColumn.POSSIBLE_VALUE) return foundColumn.POSSIBLE_VALUE
-      } else return false
+      // 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: {
@@ -198,6 +219,7 @@ export default class ModelGenerator {
 
         let stringOfRawColumnKeyAndValue = ""
         for (const cRow of columnList) {
+          // console.log("cRow", cRow.COLUMN_TYPE)
           const isColumnExistInModel = this.isColumnExistInModel(
             params.model,
             tableName,
@@ -207,7 +229,8 @@ export default class ModelGenerator {
             const possibleValue = this.getPossibleColumnValue(
               params.model,
               cRow.TABLE_NAME,
-              cRow.COLUMN_NAME
+              cRow.COLUMN_NAME,
+              cRow.COLUMN_TYPE
             )
             if (possibleValue) {
               stringOfRawColumnKeyAndValue = `${stringOfRawColumnKeyAndValue} \n ${
@@ -283,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()),
@@ -315,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

package/src/ModelGenerator/SeedGenerator.ts

@@ -1,3 +1,33 @@
-import { MyModel } from "../myModel"
+// import { MyModel } from "../myModel"
 
-function generateSeedInterface(model: 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/MyDBMigrator/MyDBMigrator.ts

@@ -2,7 +2,7 @@ import chalk from "chalk"
 import fs from "fs"
 import path from "path"
 import ModelGenerator from "../ModelGenerator/ModelGenerator"
-import { columnType, MyModel } from "../myModel"
+import { columnType, MyModel, MyViewModel } from "../myModel"
 
 export default class MyDBMigrator {
   MyDB: ModelGenerator
@@ -35,13 +35,12 @@ export default class MyDBMigrator {
         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 MyDBMigrator {
         }
         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 MyDBMigrator {
     }
   }
 
+  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 MyDBMigrator {
       }
     }
   }
+
+  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/myModel.ts

@@ -1,3 +1,5 @@
+import { SQLStatement } from "sql-template-strings"
+
 export type columnType =
   | "int"
   | "tinyint"
@@ -20,7 +22,7 @@ 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
 }
@@ -30,7 +32,7 @@ export interface MyModel {
   columns: [...columnContent[]]
   meaning?: string
 }
-// export interface MyModelView {
-//   viewName: string
-//   relatedTableName: (keyof hotel_INF)[]
-// }
+export interface MyViewModel {
+  viewName: string
+  sqlStatement: string | SQLStatement
+}