gg-mysql-connector 1.0.36 → 1.0.39

package/dist/src/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/src/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/src/ModelGenerator/ModelGenerator.d.ts

@@ -0,0 +1,39 @@
+import mysql from "mysql2/promise";
+import { MyModel, MyViewModel } 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>;
+    pushViewToDB_v2(viewModel: MyViewModel[]): 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, columnType: string): false | string[] | undefined;
+    generateModelInterface(params: {
+        appName: string;
+        model: MyModel[];
+        outputDirectory: string[];
+    }): Promise<string>;
+    generateModelConstStructure(params: {
+        appName: string;
+        model: MyModel[];
+        outputDirectory: string[];
+    }): Promise<string>;
+}