gg-mysql-connector 1.0.5

package/src/GGMySQLConnector.ts

@@ -0,0 +1,457 @@
+import chalk from "chalk"
+import { randomUUID } from "crypto"
+import mysql, { QueryResult, RowDataPacket } from "mysql2"
+import { DatabaseConfigInterface } from "./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
+
+  constructor(DBInfo: DatabaseConfigInterface) {
+    this.isPrintStatement = false
+    this.tableAndViewNameList = []
+    this.columnAndTableListCache = null
+    this.DBInfo = DBInfo
+  }
+  async createDatabaseIfNotExist(
+    tempConnection: mysql.Connection
+  ): Promise<void> {
+    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: string,
+    textToSearch: string
+  ): Promise<mysql.RowDataPacket[]> {
+    const result = (await this.query(`SELECT * FROM ${tableName}`)) as any
+    const wordList = textToSearch.split(" ")
+    const temp = result.filter((row: any) => {
+      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(): Promise<string[]> {
+    let result = (await this.query(
+      "SELECT TABLE_NAME FROM information_schema.tables WHERE table_schema = ?",
+      [this.DBInfo.database],
+      false
+    )) as { TABLE_NAME: string }[]
+    this.tableAndViewNameList = result.map((row) => row.TABLE_NAME)
+    return this.tableAndViewNameList
+  }
+  async getViewNameIfExist(tableName: string): Promise<string> {
+    const tableList: string[] = this.tableAndViewNameList
+    const viewPostFixArray = ["_view", "__view", "__view_list"]
+
+    for (let i = 0; i < viewPostFixArray.length; i++) {
+      const expectViewName: string = 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<T extends keyof Main>(
+    tableName: T extends string ? T : string,
+    params: Partial<{
+      [K in keyof Main[T]]: string | number | undefined | null
+    }>
+  ): Promise<Main[T][]> {
+    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 as keyof Unarray<T>])
+      }
+    }
+    if (keyToSearchList.length === 0) {
+      return [] as any
+    }
+    let result = (await this.query(
+      `SELECT * FROM ${tableName} WHERE ${keyToSearchList.join(" AND ")}`,
+      valueToSearchList
+    )) as any
+    return result
+  }
+
+  async selectByID<T extends keyof Main>(
+    tableName: T extends string ? T : string,
+    id: number
+  ): Promise<Main[T][]> {
+    let result = (await this.query(
+      `SELECT * FROM ${tableName} WHERE id = ? LIMIT 1`,
+      [id]
+    )) as any
+
+    return result
+  }
+
+  async select<T extends keyof Main>(
+    tableName: T extends string ? T : string
+  ): Promise<Main[T][]> {
+    let result = (await this.query(`SELECT * FROM ${tableName}`)) as any
+    return result
+  }
+
+  async getTableNameList(): Promise<string[]> {
+    let data: string[] = []
+    let result = (await this.query(
+      "SELECT * FROM information_schema.tables WHERE table_schema = ? AND TABLE_TYPE = 'BASE TABLE'",
+      [this.DBInfo.database],
+      false
+    )) as mysql.RowDataPacket[]
+    for (let row of result) data.push(row.TABLE_NAME || row.row.table_name)
+    return data
+  }
+  async getViewNameList(): Promise<string[]> {
+    let data: string[] = []
+    let result = (await this.query(
+      "SELECT * FROM information_schema.tables WHERE table_schema = ? AND TABLE_TYPE = 'VIEW'",
+      [this.DBInfo.database],
+      false
+    )) as mysql.RowDataPacket[]
+    for (let row of result) data.push(row.TABLE_NAME || row.row.table_name)
+    return data
+  }
+
+  async deleteByMatchParams<T>(
+    tableName: string,
+    params: Partial<{
+      [K in keyof Unarray<T>]: string | number | undefined | null
+    }>
+  ) {
+    const columnList = await this.getColumnList(tableName)
+    const keyList = Object.keys(params)
+    const keyToSearchList = [] as string[]
+    const valueToSearchList = []
+    for (const key of keyList) {
+      const temp = columnList.find((fkey: any) => key === fkey)
+      if (temp) {
+        keyToSearchList.push(` ${key} = ? `)
+        valueToSearchList.push(params[key as keyof Unarray<T>])
+      }
+    }
+    if (keyToSearchList.length === 0) return null
+    let result = (await this.query(
+      `DELETE  FROM ${tableName} WHERE ${keyToSearchList.join(" AND ")}`,
+      valueToSearchList
+    )) as mysql.OkPacket
+    // this.webSocket.sendByURL("/websocket/watchTableChange", tableName)
+    return result
+  }
+
+  async deleteByID(tableName: string, id: number): Promise<mysql.OkPacket> {
+    let result = (await this.query(`DELETE FROM ${tableName} WHERE id = ?`, [
+      id,
+    ])) as mysql.OkPacket
+    console.log("Delete Success")
+    // this.webSocket.sendByURL("/websocket/watchTableChange", tableName)
+    return result
+  }
+
+  async insert<T extends keyof Main>(
+    tableName: T,
+    parameter:
+      | Partial<{
+          [R in keyof Unarray<Main[T]>]: any
+        }>
+      | Partial<{
+          [R in keyof Unarray<Main[T]>]: any
+        }>[]
+  ) {
+    let params = [] as any
+    if (Array.isArray(parameter) === true) {
+      params = parameter
+    } else params = [parameter]
+
+    const columnList = await this.getColumnList(tableName as string)
+    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: any) => 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 as string} (${keyListToInsert.join(
+        ","
+      )}) VALUES ?`,
+      [valueArrayToInsertInQuery]
+    )) as mysql.OkPacket
+    console.log("Insert Success")
+    // this.webSocket.sendByURL("/websocket/watchTableChange", String(tableName))
+    return result
+  }
+
+  async updateOnlyID<T extends keyof Main extends string ? keyof Main : string>(
+    tableName: T,
+    params: { oldID: number; newID: number }
+  ) {
+    const isNewIdExist: any = 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
+    )) as mysql.OkPacket
+
+    console.log("UpdateOnlyID Success")
+    // this.webSocket.sendByURL("/websocket/watchTableChange", String(tableName))
+    return result
+  }
+
+  async update<T extends keyof Main>(
+    tableName: T extends string ? T : string,
+    parameter: Partial<{
+      [K in keyof Main[T]]: Main[T][K]
+    }>
+  ) {
+    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: any) => row === fRow)
+      if (temp) {
+        keyListToInsert.push(row)
+        valueListToInsert.push((parameter as any)[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 as any).id
+      }`,
+      [],
+      false
+    )) as mysql.OkPacket
+
+    console.log("Update Success")
+    // this.webSocket.sendByURL("/websocket/watchTableChange", String(tableName))
+    return result
+  }
+
+  async init() {
+    const currentConnection = mysql.createConnection({
+      host: this.DBInfo.host,
+      user: this.DBInfo.user,
+      password: this.DBInfo.password,
+    })
+    await this.createDatabaseIfNotExist(currentConnection)
+    // await currentConnection.end()
+
+    this.connection = mysql.createConnection({ ...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: {
+      COLUMN_NAME: string
+      TABLE_NAME: string
+      DATA_TYPE: string
+    }[] = (await this.query(
+      `SELECT COLUMN_NAME,TABLE_NAME,DATA_TYPE FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = '${this.DBInfo.database}'`,
+      undefined,
+      false
+    )) as { COLUMN_NAME: string; TABLE_NAME: string; DATA_TYPE: string }[]
+
+    this.columnAndTableListCache = result
+  }
+
+  async getColumnList(tableName: string) {
+    if (this.columnAndTableListCache !== null) {
+      return this.columnAndTableListCache
+        .filter((row) => row.TABLE_NAME === tableName)
+        .map((row) => row.COLUMN_NAME)
+    }
+    const result: any = 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: any) => row.COLUMN_NAME) as string[]
+  }
+  async getColumnFullList(tableName: string) {
+    const result = (await this.query(
+      `SELECT * FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = '${this.DBInfo.database}' AND TABLE_NAME = '${tableName}'`,
+      undefined,
+      false
+    )) as mysql.RowDataPacket[]
+    return result
+  }
+
+  async query<T>(
+    statment: string,
+    parameter?: any[],
+    isPrint?: boolean
+  ): Promise<T | QueryResult> {
+    return new Promise((resolve, reject) => {
+      const uniqueTime = `${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.bgRed("Query Error"))
+            console.log(chalk.bgRed(error))
+            console.log(chalk.bgRed("Statement : "))
+            console.log(statment)
+            console.log(chalk.bgRed("Parameter : "))
+            console.log(parameter)
+            console.log("------------------------------------------------")
+            console.log(chalk.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)
+          }
+        }
+      )
+    })
+  }
+  private printResultLength = (
+    results: any,
+    executionTime: number,
+    queryResult: any
+  ) => {
+    if (results.length) {
+      const executionTimeMessage =
+        executionTime > 1000
+          ? chalk.bgRed(`${executionTime} ` + " ms")
+          : chalk.yellow(`${executionTime} ` + " ms")
+      console.log(
+        `${this.DBInfo.database} > ${chalk.green(queryResult.sql)} ${chalk.cyan(
+          `found ${results.length} rows.`
+        )} ${executionTimeMessage}`
+      )
+    }
+  }
+}

package/src/ModelGenerator.ts

@@ -0,0 +1,238 @@
+import chalk from "chalk"
+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"
+export interface DatabaseConfigInterface {
+  host: string
+  user: string
+  password: string
+  database: string
+}
+
+export default class ModelGenerator {
+  model: MyModel[]
+  dbInfo: DatabaseConfigInterface
+  connection!: mysql.Connection
+  constructor(dbInfo: DatabaseConfigInterface, model: MyModel[]) {
+    this.model = model
+    this.dbInfo = dbInfo
+  }
+  async init() {
+    console.log("init")
+    this.connection = await mysql.createConnection({
+      host: this.dbInfo.host,
+      user: this.dbInfo.user,
+      password: this.dbInfo.password,
+    })
+    await this.createDatabaseIfNotExist()
+  }
+  private 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 MyDBMigration(this)
+    await migrator.migrateTable(this.model)
+  }
+  async pushViewToDB(viewDirectory: string) {
+    const migrator = new MyDBMigration(this)
+    await migrator.migrateView(viewDirectory)
+  }
+
+  async query<T>(
+    statment: string,
+    parameter?: any[],
+    isPrint?: boolean
+  ): Promise<T> {
+    return new Promise((resolve, reject) => {
+      const uniqueTime = `${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] as any)
+        })
+        .catch((error) => {
+          // _getCallerFile()
+          console.log(chalk.bgRed("Query Error"))
+          console.log(chalk.bgRed(error))
+          console.log(chalk.bgRed("Statement : "))
+          console.log(statment)
+          console.log(chalk.bgRed("Parameter : "))
+          console.log(parameter)
+          console.log("------------------------------------------------")
+          console.log(chalk.bgRed((queryResult as any).sql))
+
+          reject(error)
+        })
+    })
+  }
+  private printResultLength = (
+    results: any,
+    executionTime: number,
+    queryResult: any
+  ) => {
+    if (results.length) {
+      const executionTimeMessage =
+        executionTime > 1000
+          ? chalk.bgRed(`${executionTime} ` + " ms")
+          : chalk.yellow(`${executionTime} ` + " ms")
+      console.log(
+        `${chalk.green(queryResult.sql)} ${chalk.cyan(
+          `found ${results.length} rows.`
+        )} ${executionTimeMessage}`
+      )
+    }
+  }
+  async getTableNameList(): Promise<string[]> {
+    let data: string[] = []
+    let result = (await this.query(
+      "SELECT * FROM information_schema.tables WHERE table_schema = ? AND TABLE_TYPE = 'BASE TABLE'",
+      [this.dbInfo.database],
+      false
+    )) as mysql.RowDataPacket[]
+    for (let row of result) data.push(row.TABLE_NAME || row.row.table_name)
+    return data
+  }
+  async getViewNameList(): Promise<string[]> {
+    let data: string[] = []
+    let result = (await this.query(
+      "SELECT * FROM information_schema.tables WHERE table_schema = ? AND TABLE_TYPE = 'VIEW'",
+      [this.dbInfo.database],
+      false
+    )) as mysql.RowDataPacket[]
+    for (let row of result) data.push(row.TABLE_NAME || row.row.table_name)
+    return data
+  }
+  async getColumnFullList(tableName: string) {
+    const result = (await this.query(
+      `SELECT * FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = '${this.dbInfo.database}' AND TABLE_NAME = '${tableName}'`,
+      undefined,
+      false
+    )) as mysql.RowDataPacket[]
+    return result
+  }
+  async generateModelInterface(
+    DBType: string,
+    model: MyModel[],
+    ouputDirectory: string[]
+  ) {
+    const isTableNameExistInModel = (tableName: string) => {
+      if (tableName === "sessions") return true
+      const table = 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 = 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 = 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 singleInterfaceContent = ""
+        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) {
+              singleInterfaceContent = `${singleInterfaceContent} \n ${
+                cRow.COLUMN_NAME
+              }: ${possibleValue.map((row) => `"${row}"`).join(" | ")};`
+            } else {
+              singleInterfaceContent = `${singleInterfaceContent} \n ${
+                cRow.COLUMN_NAME
+              }: ${convertDataType(cRow.DATA_TYPE)};`
+            }
+          } else {
+            console.log(`${tableName}-${cRow.COLUMN_NAME} not exist in model `)
+          }
+        }
+
+        const str = ` ${tableName}  : { ${singleInterfaceContent} }`
+        array.push(str)
+        // console.log(`generate interface from ${tableName}`)
+      }
+    }
+    const fileName = `${DBType}_INF.ts`
+    const code = `export default interface ${DBType}_INF  { ${array.join(
+      "\n"
+    )} }`
+
+    ouputDirectory.forEach(async (tempPath) => {
+      const serverFilePath = path.join(tempPath, fileName)
+      await fs.writeFileSync(serverFilePath, code)
+      console.log("save to ", serverFilePath)
+    })
+
+    console.log(`generate interface ${DBType} ${chalk.bgGreen(" SUCCESS ")}`)
+
+    return code
+  }
+}
+
+function convertDataType(inputDataType: string): "string" | "number" {
+  let result: "string" | "number" = "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
+}