gg-mysql-connector 1.0.30 → 1.0.32

package/dist/GGMySQLConnector.d.ts

@@ -66,7 +66,7 @@ export default class GGMySQLConnector<Main> implements ClassDBInterface<Main> {
     loadColumnListToCache(): Promise<void>;
     getColumnList(tableName: string): Promise<string[]>;
     getColumnFullList(tableName: string): Promise<mysql.RowDataPacket[]>;
-    waitUntilInitSuccess(interval: number): Promise<unknown>;
+    waitUntilInitSuccess(interval: number): true | Promise<unknown>;
     query<T>(statment: string, parameter?: any[], isPrint?: boolean): Promise<T | QueryResult>;
     private printResultLength;
 }

package/dist/GGMySQLConnector.js

@@ -245,6 +245,8 @@ class GGMySQLConnector {
         return result;
     }
     waitUntilInitSuccess(interval) {
+        if (this.isConnected === true)
+            return true;
         return new Promise((resolve, reject) => {
             setTimeout(() => {
                 if (this.isConnected === false) {
@@ -252,7 +254,6 @@ class GGMySQLConnector {
                     this.waitUntilInitSuccess(interval);
                 }
                 else {
-                    console.log(`${this.DBInfo.database} > database connectd`);
                     return resolve(true);
                 }
             }, interval);

package/dist/ModelGenerator.d.ts

@@ -27,4 +27,9 @@ export default class ModelGenerator {
         model: MyModel[];
         outputDirectory: string[];
     }): Promise<string>;
+    generateModelConstStructure(params: {
+        appName: string;
+        model: MyModel[];
+        outputDirectory: string[];
+    }): Promise<string>;
 }

package/dist/ModelGenerator.js

@@ -56,7 +56,6 @@ class ModelGenerator {
                     this.waitUntilInitSuccess(interval);
                 }
                 else {
-                    // console.log(`${this.dbInfo.database} > database connectd`)
                     return resolve(true);
                 }
             }, interval);
@@ -182,6 +181,81 @@ class ModelGenerator {
         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) => `"${row}"`)
+                                .join(" , ")}],`;
+                        }
+                        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}_const = { ${array.join(",")} }`;
+        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) {

package/package.json

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

package/src/GGMySQLConnector.ts

@@ -405,6 +405,7 @@ export default class GGMySQLConnector<Main> implements ClassDBInterface<Main> {
     return result
   }
   waitUntilInitSuccess(interval: number) {
+    if (this.isConnected === true) return true
     return new Promise((resolve, reject) => {
       setTimeout(() => {
         if (this.isConnected === false) {
@@ -413,13 +414,11 @@ export default class GGMySQLConnector<Main> implements ClassDBInterface<Main> {
           )
           this.waitUntilInitSuccess(interval)
         } else {
-          console.log(`${this.DBInfo.database} > database connectd`)
           return resolve(true)
         }
       }, interval)
     })
   }
-
   async query<T>(
     statment: string,
     parameter?: any[],

package/src/ModelGenerator.ts

@@ -56,7 +56,6 @@ export default class ModelGenerator {
           )
           this.waitUntilInitSuccess(interval)
         } else {
-          // console.log(`${this.dbInfo.database} > database connectd`)
           return resolve(true)
         }
       }, interval)
@@ -152,12 +151,10 @@ export default class ModelGenerator {
       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(
@@ -239,6 +236,99 @@ export default class ModelGenerator {
 
     return code
   }
+
+  async generateModelConstStructure(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 = []
+    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) => `"${row}"`)
+                .join(" , ")}],`
+            } 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}_const = { ${array.join(",")} }`
+
+    for (let row of params.outputDirectory) {
+      const serverFilePath = path.join(row, fileName)
+      await fs.writeFileSync(serverFilePath, code)
+      console.log("save to ", serverFilePath)
+    }
+
+    console.log(
+      `generate interface ${params.appName} ${chalk.bgGreen(" SUCCESS ")}`
+    )
+
+    return code
+  }
 }
 
 function convertDataType(inputDataType: string): "string" | "number" {