pg-mvc-service 1.0.0

package/dist/reqestResponse/ResponseType.js

@@ -0,0 +1,380 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseType = void 0;
+const ReqResType_1 = __importDefault(require("./ReqResType"));
+class ResponseType extends ReqResType_1.default {
+    constructor() {
+        super(...arguments);
+        /**
+         * Property to store response data
+         * レスポンスデータを格納するためのプロパティ
+         */
+        this.Data = {};
+    }
+    /**
+     * Convert and retrieve data according to the type definition
+     * 型定義に従ってデータを変換して取得
+     * @returns {Object.<string, any>} Converted data, 変換されたデータ
+     */
+    get ResponseData() {
+        let data = {};
+        for (const [key, property] of Object.entries(this.properties)) {
+            if (key in this.Data === false) {
+                continue;
+            }
+            if (this.Data[key] === undefined) {
+                continue;
+            }
+            if (this.Data[key] === null || (property.type.replace("?", "") !== "string" && this.Data[key] === "")) {
+                data[key] = property.type.endsWith('?') ? null : undefined;
+                continue;
+            }
+            switch (property.type) {
+                case 'object':
+                case 'object?':
+                    data[key] = this.getObject([key]);
+                    break;
+                case 'array':
+                case 'array?':
+                    data[key] = this.getArray([key]);
+                    break;
+                default:
+                    data[key] = this.getValue([key]);
+                    break;
+            }
+        }
+        return data;
+    }
+    /**
+     * Retrieve object type data
+     * オブジェクト型のデータを取得
+     * @param {Array.<string|number>} keys - Path to the property, プロパティへのパス
+     * @returns {Object.<string, any>} Retrieved object data, 取得されたオブジェクトデータ
+     */
+    getObject(keys) {
+        let resData = {};
+        const data = this.getData(keys);
+        const properties = this.getProperty(keys).properties;
+        for (const key of Object.keys(properties)) {
+            if (key in data === false || data[key] === undefined) {
+                continue;
+            }
+            const property = properties[key];
+            if (data[key] === null || (property.type.replace("?", "") !== "string" && data[key] === "")) {
+                resData[key] = property.type.endsWith('?') ? null : undefined;
+                continue;
+            }
+            switch (property.type) {
+                case 'object':
+                case 'object?':
+                    resData[key] = this.getObject([...keys, key]);
+                    break;
+                case 'array':
+                case 'array?':
+                    resData[key] = this.getArray([...keys, key]);
+                    break;
+                default:
+                    resData[key] = this.getValue([...keys, key]);
+                    break;
+            }
+        }
+        return resData;
+    }
+    /**
+     * Retrieve array type data
+     * 配列型のデータを取得
+     * @param {Array.<string|number>} keys - Path to the property, プロパティへのパス
+     * @returns {Array<any> | undefined} Retrieved array data, 取得された配列データ
+     */
+    getArray(keys) {
+        const data = this.getData(keys);
+        if (data === undefined || Array.isArray(data) === false) {
+            return undefined;
+        }
+        const properties = this.getProperty(keys).properties;
+        let resData = [];
+        for (let i = 0; i < data.length; i++) {
+            switch (properties.type) {
+                case 'object':
+                case 'object?':
+                    resData.push(this.getObject([...keys, i]));
+                    break;
+                case 'array':
+                case 'array?':
+                    resData.push(this.getArray([...keys, i]));
+                    break;
+                default:
+                    resData.push(this.getValue([...keys, i]));
+                    break;
+            }
+        }
+        return resData;
+    }
+    /**
+     * Retrieve property type data
+     * プロパティ型のデータを取得
+     * @param {Array.<string|number>} keys - Path to the property, プロパティへのパス
+     * @returns {any} Retrieved property data, 取得されたプロパティデータ
+     */
+    getProperty(keys) {
+        let property = this.properties;
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            if (typeof key === 'number') {
+                property = property.properties;
+                continue;
+            }
+            if (i === 0) {
+                property = property[key];
+            }
+            else {
+                property = property.properties[key];
+            }
+        }
+        return property;
+    }
+    /**
+     * Retrieve data based on the provided keys
+     * 指定されたキーに基づいてデータを取得
+     * @param {Array.<string|number>} keys - Path to the data, データへのパス
+     * @returns {any} Retrieved data, 取得されたデータ
+     */
+    getData(keys) {
+        let data = this.Data;
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            if (typeof key === 'number') {
+                data = data[key];
+                continue;
+            }
+            data = data[key];
+        }
+        return data;
+    }
+    /**
+     * Retrieve value based on the provided keys
+     * 指定されたキーに基づいて値を取得
+     * @param {Array.<string|number>} keys - Path to the value, 値へのパス
+     * @returns {string | number | boolean | null | undefined} Retrieved value, 取得された値
+     */
+    getValue(keys) {
+        const property = this.getProperty(keys);
+        const value = this.getData(keys);
+        if (value === null) {
+            return property.type.endsWith('?') ? null : undefined;
+        }
+        switch (property.type) {
+            case 'number':
+            case 'number?':
+                if (this.isNumber(value) === false) {
+                    return undefined;
+                }
+                return Number(value);
+            case 'boolean':
+            case 'boolean?':
+                switch (typeof value) {
+                    case 'boolean':
+                        return value;
+                    case 'number':
+                        if (value !== 0 && value !== 1) {
+                            return undefined;
+                        }
+                        return value === 1 ? true : false;
+                    case 'string':
+                        if (value !== 'true' && value !== 'false') {
+                            return undefined;
+                        }
+                        return value === 'true' ? true : false;
+                    default:
+                        return undefined;
+                }
+            case 'string':
+            case 'string?':
+                switch (typeof value) {
+                    case 'number':
+                        return value.toString();
+                    case 'string':
+                        return value;
+                    default:
+                        return undefined;
+                }
+            case 'uuid':
+            case 'uuid?':
+                if (this.isUUID(value)) {
+                    return value;
+                }
+                return undefined;
+            case 'mail':
+            case 'mail?':
+                if (this.isMail(value)) {
+                    return value;
+                }
+                return undefined;
+            case 'date':
+            case 'date?':
+                if (value instanceof Date) {
+                    const year = value.getFullYear();
+                    const month = String(value.getMonth() + 1).padStart(2, '0');
+                    const day = String(value.getDate()).padStart(2, '0');
+                    return `${year}-${month}-${day}`;
+                }
+                if (this.isYYYYMMDD(value) && this.isErrorDateTime(value) === false) {
+                    return value;
+                }
+                return undefined;
+            case 'time':
+            case 'time?':
+                if (this.isHHMM(value)) {
+                    return `${value}`;
+                }
+                if (this.isHHMMSS(value)) {
+                    return value.slice(0, 5);
+                }
+                return undefined;
+            case 'datetime':
+            case 'datetime?':
+                if (value instanceof Date) {
+                    const year = value.getFullYear();
+                    const month = String(value.getMonth() + 1).padStart(2, '0');
+                    const day = String(value.getDate()).padStart(2, '0');
+                    const hours = String(value.getHours()).padStart(2, '0');
+                    const minutes = String(value.getMinutes()).padStart(2, '0');
+                    const seconds = String(value.getSeconds()).padStart(2, '0');
+                    return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
+                }
+                if (this.isYYYYMMDDhhmiss(value) && this.isErrorDateTime(value) === false) {
+                    return value.replace('T', ' ');
+                }
+                return undefined;
+            case 'https':
+            case 'https?':
+                if (this.isHttps(value)) {
+                    return value;
+                }
+                return undefined;
+            case 'base64':
+            case 'base64?':
+                if (this.isBase64(value)) {
+                    return value;
+                }
+                return undefined;
+            case 'enum':
+            case 'enum?':
+                if (Object.keys(property.enums).includes(value)) {
+                    return value;
+                }
+                return undefined;
+            default:
+                return undefined;
+        }
+    }
+    // ****************************************************************************
+    // for create swagger
+    // ****************************************************************************
+    /**
+     * Generates Swagger response definition
+     * Swaggerのレスポンス定義を生成します
+     * @returns {string} Swagger format response definition
+     * Swagger形式のレスポンス定義
+     */
+    createSwagger() {
+        let ymlString = `      responses:
+        '200':
+          description: 成功事レスポンス
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:`;
+        if (Object.keys(this.properties).length === 0) {
+            ymlString += ' {}\n';
+            return ymlString;
+        }
+        ymlString += `\n`;
+        let tabCount = 9;
+        const space = '  '.repeat(tabCount);
+        for (const [key, property] of Object.entries(this.properties)) {
+            ymlString += `${space}${key}:\n`;
+            ymlString += `${space}  type: ${this.replaceFromPropertyTypeToSwagger(property)}\n`;
+            if (property.description !== undefined) {
+                const joinSpace = `\n${space}    `;
+                ymlString += `${space}  description: |${joinSpace}${property.description.replaceAll("\n", joinSpace)}\n`;
+            }
+            switch (property.type) {
+                case 'object':
+                case 'object?':
+                    ymlString += this.makeSwaggerProperyFromObject([key], tabCount + 1);
+                    break;
+                case 'array':
+                case 'array?':
+                    ymlString += this.makeSwaggerPropertyFromArray([key], tabCount + 1);
+                    break;
+            }
+        }
+        return ymlString;
+    }
+    /**
+     * Generates Swagger properties from object type properties
+     * オブジェクト型のプロパティからSwaggerのプロパティを生成
+     * @param {Array.<string|number>} keys - Path to the properties
+     * プロパティへのパス
+     * @returns {string} Swagger format property definition
+     * Swagger形式のプロパティ定義
+     */
+    makeSwaggerProperyFromObject(keys, tabCount) {
+        const space = '  '.repeat(tabCount);
+        let ymlString = `${space}properties:\n`;
+        const properties = this.getProperty(keys).properties;
+        for (const key of Object.keys(properties)) {
+            const property = properties[key];
+            ymlString += `${space}  ${key}:\n`;
+            ymlString += `${space}    type: ${this.replaceFromPropertyTypeToSwagger(property)}\n`;
+            if (property.description !== undefined) {
+                const joinSpace = `\n${space}      `;
+                ymlString += `${space}    description: |${joinSpace}${property.description.replaceAll("\n", joinSpace)}\n`;
+            }
+            switch (property.type) {
+                case 'object':
+                case 'object?':
+                    ymlString += this.makeSwaggerProperyFromObject([...keys, key], tabCount + 2);
+                    break;
+                case 'array':
+                case 'array?':
+                    ymlString += this.makeSwaggerPropertyFromArray([...keys, key], tabCount + 2);
+                    break;
+            }
+        }
+        return ymlString;
+    }
+    /**
+     * Generates Swagger properties from array type properties
+     * 配列型のプロパティからSwaggerのプロパティを生成
+     * @param {Array.<string|number>} keys - Path to the properties, プロパティへのパス
+     * @returns {string} Swagger format property definition, Swagger形式のプロパティ定義
+     */
+    makeSwaggerPropertyFromArray(keys, tabCount) {
+        const property = this.getProperty(keys).properties;
+        const space = '  '.repeat(tabCount);
+        let ymlString = `${space}items:\n`;
+        ymlString += `${space}  type: ${this.replaceFromPropertyTypeToSwagger(property)}\n`;
+        if (property.description !== undefined) {
+            const joinSpace = `\n${space}    `;
+            ymlString += `${space}  description: |${joinSpace}${property.description.replaceAll("\n", joinSpace)}\n`;
+        }
+        switch (property.type) {
+            case 'object':
+            case 'object?':
+                ymlString += this.makeSwaggerProperyFromObject([...keys, 0], tabCount + 1);
+                break;
+            case 'array':
+            case 'array?':
+                ymlString += this.makeSwaggerPropertyFromArray([...keys, 0], tabCount + 1);
+                break;
+        }
+        return ymlString;
+    }
+}
+exports.ResponseType = ResponseType;

package/index.d.ts

@@ -0,0 +1,306 @@
+import { AxiosResponse } from "axios";
+import { Request, Response } from 'express';
+import { Pool, PoolClient } from 'pg';
+import { IncomingHttpHeaders } from './src/reqestResponse/RequestType';
+import { ArrayType, EnumType, ObjectType, PrimitiveType } from './src/reqestResponse/ReqResType';
+import S3Client from './src/clients/AwsS3Client';
+import Base64Client from './src/clients/Base64Client';
+import StringClient from './src/clients/StringClient';
+import EncryptClient from './src/clients/EncryptClient';
+
+// models class
+import ValidateClient from './src/models/ValidateClient';
+
+declare module 'pg-mvc-service' {
+    export type MethodType = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+
+    export class Service {
+        protected readonly method: MethodType;
+        get Method(): MethodType;
+        protected readonly endpoint: string;
+        get Endpoint(): string;
+        protected readonly apiCode: string;
+        get ApiCode(): string;
+        protected readonly summary: string;
+        get Summary(): string;
+        protected readonly apiUserAvailable: string;
+        get ApiUserAvailable(): string;
+        protected readonly request: RequestType;
+        get AuthToken(): string;
+        protected readonly response: ResponseType;
+        protected readonly isTest: boolean;
+        protected readonly tags: Array<string>;
+        get Tags(): Array<string>;
+
+        protected readonly req: Request;
+        protected readonly res: Response;
+        constructor(request: Request, response: Response);
+
+        public inintialize(): void;
+
+        protected dbUser?: string;
+        protected dbHost?: string;
+        protected dbName?: string;
+        protected dbPassword?: string;
+        protected dbPort?: number;
+        protected dbIsSslConnect?: boolean;
+        protected checkMaintenance(): Promise<void>;
+        protected middleware(): Promise<void>;
+
+        public resSuccess(): void;
+        public handleException(ex: any): void;
+        protected outputErrorLog(ex: any): Promise<void>;
+
+        protected get Pool(): Pool;
+        protected get Client(): PoolClient;
+
+        public startConnect(): Promise<void>;
+        public commit(): Promise<void>;
+        public rollback(): Promise<void>;
+        public release(): Promise<void>;
+
+        get S3Client(): S3Client;
+        get Base64Client(): Base64Client;
+        get StringClient(): StringClient;
+        get EncryptClient(): EncryptClient;
+
+        public requestApi<TRequest=Record<string, any>, TResponse={[key: string]: any}>(
+            method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE', url: string, params: TRequest, header: {[key: string]: any}): Promise<AxiosResponse<TResponse>>;
+    }
+
+    export interface IParams {
+        in: 'header' | 'path',
+        name: string,
+        require?: boolean,
+        description?: string,
+        example?: string
+    }
+    export function createSwagger(services: Service[], name: string, url: string, params: Array<IParams>): string;
+
+    export type PropertyType =  PrimitiveType | ObjectType | ArrayType | EnumType;
+
+    export class RequestType {
+        constructor();
+
+        protected properties: { [key: string]: PropertyType; };
+
+        public readonly INVALID_PATH_PARAM_UUID_ERROR_MESSAGE: string;
+        public readonly REQUIRED_ERROR_MESSAGE: string;
+        public readonly UNNECESSARY_INPUT_ERROR_MESSAGE: string;
+        public readonly INVALID_OBJECT_ERROR_MESSAGE: string;
+        public readonly INVALID_ARRAY_ERROR_MESSAGE: string;
+        public readonly INVALID_NUMBER_ERROR_MESSAGE: string;
+        public readonly INVALID_BOOL_ERROR_MESSAGE: string;
+        public readonly INVALID_STRING_ERROR_MESSAGE: string;
+        public readonly INVALID_UUID_ERROR_MESSAGE: string;
+        public readonly INVALID_MAIL_ERROR_MESSAGE: string;
+        public readonly INVALID_DATE_ERROR_MESSAGE: string;
+        public readonly INVALID_TIME_ERROR_MESSAGE: string;
+        public readonly INVALID_DATETIME_ERROR_MESSAGE: string;
+        public readonly INVALID_BASE64_ERROR_MESSAGE: string;
+        public readonly INVALID_ENUM_ERROR_MESSAGE: string;
+
+        protected throwException(code: string, message: string): never;
+
+        public setRequest(request: Request): void;
+        get Data(): { [key: string]: any };
+        get Headers(): IncomingHttpHeaders;
+        get Params(): { [key: string]: any };
+        get RemoteAddress(): string | undefined;
+        get Authorization(): string | null;
+    }
+
+    export class ResponseType {
+        public Data: { [key: string]: any };
+
+        protected properties: { [key: string]: PropertyType; };
+        get ResponseData(): { [key: string]: any };
+    }
+
+    export class AuthException extends Error {
+        private id: string;
+        get Id(): string;
+        constructor(id: string, message?: string);
+    }
+
+    export class ForbiddenException extends Error {
+    }
+
+    export class InputErrorException extends Error {
+        private errorId: string;
+        get ErrorId(): string;
+        private errorLog: string;
+        get ErrorLog(): string;
+        constructor(errorId: string, message?: string, errorLog?: string);
+    }
+
+    export class MaintenanceException extends Error {
+        constructor(message?: string);
+    }
+
+    export type TSqlValue = string | number | boolean | Date | null | Array<string | null> | Array<number | null> | Array<Date | null> | Array<Boolean | null>;
+
+    // column type
+    export type TColumnAttribute = "primary" | "nullable" | "hasDefault" | "noDefault";
+    export type TColumnType = "number" | "string" | "uuid" |  "date" | "time" | "timestamp" | "bool";
+    export type TColumnArrayType = "number[]" | "string[]" | "uuid[]" |  "date[]" | "time[]" | "timestamp[]" | "bool[]";
+    type TColumnBase = {
+        alias?: string,
+        type: TColumnType | TColumnArrayType,
+        attribute: TColumnAttribute,
+        default?: string,
+        comment?: string
+    };
+    
+    type TStringColumn = TColumnBase & {
+        type: "string",
+        length: number
+    };
+    
+    type TNonStringColumn = TColumnBase & {
+        type: Exclude<TColumnType, "string">,
+        length?: undefined
+    };
+    
+    type TStringArrayColumn = TColumnBase & {
+        type: "string[]",
+        length: number,
+        attribute: Exclude<TColumnAttribute, "primary">
+    };
+    
+    type TArrayColumn = TColumnBase & {
+        type:  Exclude<TColumnArrayType, "string[]">,
+        length?: undefined,
+        attribute: Exclude<TColumnAttribute, "primary">
+    };
+    
+    export type TColumn = TStringColumn | TNonStringColumn | TStringArrayColumn | TArrayColumn;
+    
+    export type TOperator = "=" | "!=" | ">" | ">=" | "<" | "<=" | "like" | "ilike" | "h2f_like" | "h2f_ilike" | "in" | "not in";
+    export type TColumnInfo = { model: TableModel, name: string }
+    export type TQuery = {sql: string, vars?: Array<any>};
+    export type TSelectExpression = { expression: string, alias: string }
+    export type TAggregateFuncType = 'sum' | 'avg' | 'max' | 'min' | 'count';
+    export type TCondition = string | {
+        l: string | TColumnInfo, 
+        o: TOperator, 
+        r: TSqlValue | Array<TSqlValue> | TColumnInfo
+    };
+    export type TNestedCondition = TCondition | ['AND' | 'OR', ...TNestedCondition[]] | TNestedCondition[];
+    export type TSortKeyword = 'desc' | 'asc';
+    export type TKeyFormat = 'snake' | 'lowerCamel';
+    export type TOption = {[key: string]: TSqlValue};
+
+    export class TableModel {
+        protected readonly dbName: string;
+        get DbName(): string;
+        protected readonly tableName: string;
+        get TableName(): string;
+        protected readonly tableDescription: string;
+        get TableDescription(): string;
+        protected readonly comment: string;
+        get Comment(): string;
+        protected readonly columns: { [key: string]: TColumn };
+        get Columns(): { [key: string]: TColumn };
+        protected readonly references: Array<{table: string, columns: Array<{target: string, ref: string}>}>;
+        get References(): Array<{table: string, columns: Array<{target: string, ref: string}>}>;
+        public GetReferences(columnName: string): Array<{table: string, columns: Array<{target: string, ref: string}>}>;
+        get TableAlias(): string;
+        public IsOutputLog: boolean;
+        public SortKeyword: TSortKeyword;
+        public Offset: number;
+        public Limit: number;
+        public PageCount: number;
+        set OffsetPage(value: number);
+
+        constructor(client: Pool);
+        constructor(client: Pool, tableAlias: string);
+        constructor(client: PoolClient);
+        constructor(client: PoolClient, tableAlias: string);
+
+        public select(): void;
+        public select(columls: Array<string | {name: string, alias?: string, func?: TAggregateFuncType}> | '*'): void;
+        public select(columls: Array<string | {name: string, alias?: string, func?: TAggregateFuncType}> | '*', model: TableModel): void;
+        public select(columls: Array<string | {name: string, alias?: string, func?: TAggregateFuncType}> | '*', keyFormat: TKeyFormat): void;
+        public select(columls: Array<string | {name: string, alias?: string, func?: TAggregateFuncType}> | '*', model: TableModel, keyFormat: TKeyFormat): void;
+        public select(expression: string, alias: string): void;
+
+        public join(joinType: 'left' | 'inner', joinModel: TableModel, conditions: Array<TNestedCondition>): void;
+
+        public where(expression: string): void;
+        public where(conditions: Array<TNestedCondition>): void;
+        public where(left: string, operator: TOperator, right: TSqlValue | Array<TSqlValue> | TColumnInfo | null): void;
+        public where(left: TColumnInfo, operator: TOperator, right: TSqlValue | Array<TSqlValue> | TColumnInfo | null): void;
+
+        public find<T = {[key: string]: any}>(pk: {[key: string]: any}, selectColumns: Array<string> | "*" | null, selectExpressions: Array<TSelectExpression> | null, keyFormat: TKeyFormat): Promise<T | null>;
+        public find<T = {[key: string]: any}>(pk: {[key: string]: any}, selectColumns: Array<string> | "*" | null, selectExpressions: Array<TSelectExpression> | null): Promise<T | null>;
+        public find<T = {[key: string]: any}>(pk: {[key: string]: any}, selectColumns: Array<string> | "*" | null): Promise<T | null>;
+        public find<T = {[key: string]: any}>(pk: {[key: string]: any}): Promise<T | null>;
+
+        public findId<T = {[key: string]: any}>(id: any, selectColumns: Array<string> | "*" | null, selectExpressions: Array<TSelectExpression> | null, keyFormat: TKeyFormat): Promise<T | null>;
+        public findId<T = {[key: string]: any}>(id: any, selectColumns: Array<string> | "*" | null, selectExpressions: Array<TSelectExpression> | null): Promise<T | null>;
+        public findId<T = {[key: string]: any}>(id: any, selectColumns: Array<string> | "*" | null): Promise<T | null>;
+        public findId<T = {[key: string]: any}>(id: any): Promise<T | null>;
+
+        protected readonly errorMessages: Record<TColumnType | 'length' | 'null' | 'notInput', string>
+        protected throwValidationError(code: string, message: string): never;
+        protected validateOptions(options: TOption, isInsert: boolean) : Promise<void>;
+        protected validateInsert(options: TOption) : Promise<void>;
+        protected validateUpdate(options: TOption) : Promise<void>;
+        protected validateUpdateId(id: any, options: TOption) : Promise<void>;
+        protected validateDelete() : Promise<void>;
+        protected validateDeleteId(id: any) : Promise<void>;
+
+        public executeInsert(options: TOption) : Promise<void>;
+        public executeUpdate(options: TOption) : Promise<number>;
+        public executeUpdateId(id: any, options: TOption) : Promise<void>;
+        public executeDelete() : Promise<number>;
+        public executeDeleteId(id: any) : Promise<void>;
+
+        public executeSelect<T = {[key: string]: any}>(): Promise<Array<T>>;
+        public executeSelectWithCount<T = any>(): Promise<{ datas: Array<T>, count: number, lastPage: number}>;
+
+        protected executeQuery(param1: string, vars?: Array<any>) : Promise<any>;
+        protected executeQuery(param1: TQuery) : Promise<any>;
+
+        public orderBy(column: string | TColumnInfo, sortKeyword: TSortKeyword): void;
+        public orderByList(column: string | TColumnInfo, list: Array<string | number | boolean | null>, sortKeyword: TSortKeyword): void;
+        public orderBySentence(query: string, sortKeyword: TSortKeyword): void;
+
+        public groupBy(column: string | TColumnInfo): void;
+
+        get ValidateClient(): ValidateClient;
+    }
+
+    export function createTableDoc(models: Array<TableModel>, serviceName?: string): string;
+    export function migrate(migrates: Array<MigrateTable>, poolParam: {
+        host: string, user: string, dbName: string, password: string, port?: number, isSsl?: boolean
+    }): Promise<void>;
+    export function rollback(toNumber: number, poolParam: {
+        host: string, user: string, dbName: string, password: string, port?: number, isSsl?: boolean
+    }): Promise<void>;
+    export class MigrateTable {
+        protected readonly migrateSql: string;
+        protected readonly rollbackSql: string;
+        protected readonly addGrantTables: Array<string>;
+        protected readonly user: string;
+
+        constructor();
+        constructor(user: string);
+    }
+
+    export class MigrateDatabase {
+        constructor(dbName: string, userName: string, pool: Pool);
+    
+        get DbName(): string;
+        get UserName(): string;
+        get Password(): string | null;
+    
+        public IsExistUser(): Promise<boolean>;
+        public CreateUser(password?: string): Promise<void>;
+        public IsExistDb(): Promise<boolean>;
+        public CreateDb(collateType?: string): Promise<void>;
+        public RollbackDbSql(): string;
+        public RollbackUserSql(otherUserName: string): string;
+    }
+}