pg-mvc-service 2.1.0 → 2.1.1

package/src/models/MigrateRollback.ts

@@ -1,151 +0,0 @@
-import { Pool } from "pg";
-import { MigrateTable } from "./MigrateTable";
-
-export const migrate = async (migrates: Array<MigrateTable>, poolParam: {
-    host: string, user: string, dbName: string, password: string, port?: number, isSsl?: boolean
-}): Promise<void> => {
-
-    const pool = new Pool({
-        user: poolParam.user,
-        password: poolParam.password,
-        host: poolParam.host,
-        database: poolParam.dbName,
-        port: poolParam.port ?? 5432,
-        ssl: poolParam.isSsl === true ? {
-            rejectUnauthorized: false
-        } : false
-    });
-
-    // create migration table
-    try {
-        if (await isExistMigrationTable(pool) == false) {
-            const sql = `
-                CREATE TABLE migrations (
-                    migration_number int,
-                    script_file VARCHAR(50),
-                    rollback_script VARCHAR(5000),
-                    create_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
-                );`;
-            await pool.query(sql);
-        }
-    } catch (ex) {
-        console.error('An error occurred related to the Migrate table:', ex);
-        await pool.end();
-        throw ex;
-    }
-
-    const client = await pool.connect();
-    try {
-        client.query('BEGIN');
-
-        const datas = await getMigrations(pool);
-        let maxNumber = datas.maxNumber;
-        for (const migrate of migrates) {
-            const className = migrate.constructor.name;
-            if (datas.datas.filter(data => data.script_file === className).length > 0) {
-                console.log(`Already executed: ${className}`);
-                continue;
-            }
-
-            await client.query(migrate.MigrateSql);
-
-            const grantSql = migrate.AddGrantSql;
-            if (grantSql !== null) {
-                await client.query(grantSql);
-            }
-    
-            const migrateInsertSql = `
-                INSERT INTO migrations
-                (migration_number, script_file, rollback_script)
-                VALUES (${maxNumber + 1}, '${className}', '${migrate.RollbackSql}');
-            `;
-            maxNumber++;
-    
-            await client.query(migrateInsertSql);
-    
-            console.log(`Execution completed: ${className}`);
-        }
-        
-        await client.query('COMMIT');
-        
-        console.log('Migration completed');
-    } catch (ex) {
-        await client.query('ROLLBACK');
-        console.log('Migration failed.', ex);
-    } finally {
-        client.release();
-        await pool.end();
-    }
-}
-
-export const rollback = async (toNumber: number, poolParam: {
-    host: string, user: string, dbName: string, password: string, port?: number, isSsl?: boolean
-}): Promise<void> => {
-
-    const pool = new Pool({
-        user: poolParam.user,
-        password: poolParam.password,
-        host: poolParam.host,
-        database: poolParam.dbName,
-        port: poolParam.port ?? 5432,
-        ssl: poolParam.isSsl === true ? {
-            rejectUnauthorized: false
-        } : false
-    });
-
-    try {
-        // If the migration table does not exist, there is no target for rollback, so do not perform it
-        if (await isExistMigrationTable(pool) == false) {
-          return;
-        }
-    } catch (ex) {
-        console.error('An error occurred related to the Migrate table:', ex);
-        await pool.end();
-        return;
-    }
-
-    const client = await pool.connect();
-    try {
-        await client.query('BEGIN');
-
-        const datas = await getMigrations(pool);
-        for (const data of datas.datas) {
-            if (data.migration_number < toNumber) {
-                break;
-            }
-            await client.query(data.rollback_script);
-            await client.query(`DELETE FROM migrations WHERE migration_number = ${data.migration_number}`);
-  
-            console.log(`Execution completed: ${data.script_file}`);
-        }
-  
-        await client.query('COMMIT');
-
-        console.log('Rollback completed');
-    } catch (ex) {
-        await client.query('ROLLBACK');
-        console.error('Rollback failed', ex);
-    } finally {
-        client.release();
-        await pool.end();
-    }
-}
-
-const isExistMigrationTable = async (pool: Pool) => {
-    const existMigrationTableSql = `
-        SELECT EXISTS (
-            SELECT FROM information_schema.tables 
-            WHERE table_name = 'migrations'
-        );
-    `;
-    const res = await pool.query(existMigrationTableSql);
-    return res.rows[0].exists;
-}
-
-const getMigrations = async (pool: Pool): Promise<{datas: Array<{migration_number: number, script_file: string, rollback_script: string}>, maxNumber: number}> => {
-    const datas = await pool.query("SELECT * FROM migrations ORDER BY migration_number DESC;");
-    return {
-        maxNumber: datas.rows.reduce((max, data) => data.migration_number > max ? data.migration_number : max, 0),
-        datas: datas.rows
-    }
-}

package/src/models/MigrateTable.ts

@@ -1,56 +0,0 @@
-export class MigrateTable {
-
-    protected readonly migrateSql: string = '';
-    protected readonly rollbackSql: string = '';
-    protected readonly addGrantTables: Array<string> = [];
-    protected readonly user: string = '';
-
-    get MigrateSql(): string { return this.trimSpaceLineSql(this.migrateSql); }
-    get RollbackSql(): string { return this.trimSpaceLineSql(this.rollbackSql); }
-    get AddGrantSql(): string | null {
-        if ((this.user ?? "").trim() === "") {
-            return null;
-        }
-
-        const tables = this.addGrantTables.filter(table => table.trim() !== '');
-        if (tables.length === 0) {
-            return null;
-        }
-
-        let sql = "";
-        for (const table of tables) {
-            sql += `GRANT SELECT, INSERT, UPDATE, DELETE ON TABLE public.${table} TO ${this.user};`;
-        }
-        return sql;
-    }
-
-    constructor();
-    constructor(user: string);
-    constructor(user?: string) {
-        if (user !== undefined) {
-            this.user = user;
-        }
-    }
-
-    private trimSpaceLineSql(str: string) {
-        const splitLines = str.split('\n');
-        let sql = '';
-        for (let line of splitLines) {
-            line = line.replace(/\s+/g, ' ').trim(); // 複数のスペースを一つに置き換え
-
-            if (line.startsWith('--') && sql[sql.length - 1] != '\n') {
-                line = '\n' + line;
-            }
-
-            if (line.length > 0) {
-                if (line.includes('--') === false) {
-                    sql += line + ' ';
-                } else {
-                    sql += line + '\n';
-                }
-            }
-        }
-
-        return sql;
-    }
-}

package/src/models/SqlUtils/SelectExpression.ts

@@ -1,102 +0,0 @@
-import { TableModel } from "../TableModel";
-import { TAggregateFuncType, TColumnInfo, TKeyFormat } from "../Type";
-import StringUtil from "../../Utils/StringUtil";
-
-export default class SelectExpression {
-
-    /**
-     * 指定されたカラム情報と関数を使用して、SQLのSELECT文を作成します。
-     * @param columnInfoType カラム情報を含むオブジェクト。
-     * @param func カラムに適用する関数名。nullの場合は関数を適用しません。
-     * @returns SQLのSELECT文の文字列。
-     */
-    static create(columnInfo: TColumnInfo, func: TAggregateFuncType | null = null, alias: string | null = null, keyFormat: TKeyFormat = 'snake') : string {
-
-        const column = columnInfo.model.getColumn(columnInfo.name);
-        let select = ''
-        switch (column.type) {
-            case 'date':
-                select = this.createDateTime(columnInfo, 'date');
-                break;
-            case 'time':
-                select = this.createDateTime(columnInfo, 'time');
-                break;
-            case 'timestamp':
-                select = this.createDateTime(columnInfo, 'datetime');
-                break;
-            default:
-                select = column.expression;
-                break;
-        }
-
-        let aliasName = alias ?? '';
-        if (func !== null) {
-            if (aliasName.trim() === '') {
-                const snakeAlias = func + '_' + columnInfo.name;
-                aliasName = keyFormat === 'snake' ? snakeAlias : StringUtil.formatFromSnakeToCamel(snakeAlias);
-            }
-            select = `${func}(${select})`;
-            switch (func) {
-                case 'sum':
-                case 'max':
-                case 'min':
-                case 'avg':
-                case 'count':
-                    // なぜかStringで返却されるため、INTでキャスト
-                    select = `CAST(${select} as INTEGER)`;
-                    break;
-                default:
-                    break;
-            }
-        }
-
-        if (aliasName.trim() === '') {
-            aliasName = keyFormat === 'snake' ? columnInfo.name : StringUtil.formatFromSnakeToCamel(columnInfo.name);
-        }
-
-        return `${select} as "${aliasName}"`;
-    }
-
-    /**
-     * BaseModelからSELECTクエリを作成します。
-     * @param baseModel クエリを作成するためのBaseModelオブジェクト。
-     * @param isExcludeId trueの場合、idカラムを除外します。
-     * @param isExcludeSystemTime trueの場合、システム時間のカラムを除外します。
-     * @returns 作成されたSELECTクエリの文字列。
-     */
-    static createFromModel(model: TableModel) {
-        const queries: Array<string> = [];
-        for (const key of Object.keys(model.Columns)) {
-            queries.push(this.create({model: model, name: key}));
-        }
-
-        return queries.join(',');
-    }
-
-    /**
-     * Converts the specified column to a SQL string format.
-     * 指定されたカラムをSQLの文字列形式に変換します。
-     * @param column - The column information or a string containing the column name.
-     *                 変換するカラム情報またはカラム名を含む文字列。
-     * @param to - Specifies the target format. Either 'date', 'time', or 'datetime'.
-     *             変換先の形式を指定します。'date'、'time'、または'datetime'のいずれか。
-     * @returns The SQL string converted to the specified format.
-     *          指定された形式に変換されたSQLの文字列。
-     */
-    public static createDateTime(column: TColumnInfo, to: 'date' | 'time' | 'datetime') {
-        const columnInfo = column.model.getColumn(column.name);
-
-        if (['date', 'time', 'timestamp'].includes(columnInfo.type) === false) {
-            return '';
-        }
-
-        switch (to) {
-            case 'date':
-                return `to_char(${columnInfo.expression}, 'YYYY-MM-DD')`;
-            case 'datetime':
-                return `to_char(${columnInfo.expression}, 'YYYY-MM-DD HH24:mi:ss')`;
-            case 'time':
-                return `to_char(${columnInfo.expression}, 'HH24:mi:ss')`;
-        }
-    }
-}

package/src/models/SqlUtils/UpdateExpression.ts

@@ -1,29 +0,0 @@
-import { TableModel } from "../TableModel";
-import { TQuery } from "../Type";
-
-export default class UpdateExpression {
-
-    static createUpdateSet(model: TableModel, options: {[key: string]: any}): TQuery {
-        const expressions = [];
-        const vars = [];
-        for (const [key, value] of Object.entries(options)) {
-            if (value === undefined) {
-                throw new Error(`The update option ${key} is undefined.`);
-            }
-
-            const column = model.getColumn(key);
-            if (column.attribute === 'primary') {
-                throw new Error(`The primary key ${model.TableName}.${key} cannot be changed.`);
-            }
-
-            vars.push(value);
-            expressions.push(`${key} = $${vars.length}`);
-        }
-
-        return {
-            expression: `UPDATE ${model.TableName} SET ${expressions.join(',')}`,
-            vars: vars
-        }
-    }
-
-}

package/src/models/SqlUtils/ValidateValueUtil.ts

@@ -1,354 +0,0 @@
-import { TColumn, TColumnArrayType, TColumnType } from "../Type";
-import DateTimeUtil from "../../Utils/DateTimeUtil";
-import StringUtil from "../../Utils/StringUtil";
-
-export default class ValidateValueUtil {
-    
-    static validateId(columns: {[key: string]: TColumn}, id: any) {
-        if ('id' in columns === false) {
-            throw new Error("The 'id' is not set in Columns.");
-        }
-
-        const pkColumnsArray = Object.entries(columns).filter(([key, column]) => column.attribute === 'primary');
-        const pkColumns = Object.fromEntries(pkColumnsArray);
-        if ('id' in pkColumns === false) {
-            throw new Error("The 'id' is not set as a Primary Key.");
-        }
-
-        if (Object.keys(pkColumns).length > 1) {
-            throw new Error("This method cannot be used because there are other Primary Keys set besides 'id'.");
-        }
-        
-
-        ValidateValueUtil.validateValue(pkColumns['id'], id);
-    }
-
-    static validateValue(column: TColumn, value: any) {
-        if (value === undefined) {
-            throw new Error(`The value is undefined.`);
-        }
-
-        if (value === null) {
-            if (column.attribute === 'nullable') {
-                return null;
-            }
-
-            throw new Error(`The specified column does not allow null values. (${column.attribute})`);
-        }
-
-        // // 配列のチェック
-        // if (column.type.endsWith("[]")) {
-        //     if (Array.isArray(value) === false) {
-        //         throw new Error('The value must be an array.');
-        //     }
-
-        //     for (const v of value) {
-        //         switch (column.type) {
-        //             case "string[]":
-        //                 if (this.isErrorString(v)) {
-        //                     throw new Error('Please enter a value of type string.');
-        //                 }
-        //                 break;
-        //             case "uuid[]":
-        //                 if (this.isErrorUUID(v)) {
-        //                     throw new Error('Please enter a value in UUID string format.');
-        //                 }
-        //                 break;
-        //             case "date[]":
-        //                 if (this.isErrorDate(v)) {
-        //                     throw new Error('Please enter a valid date in "YYYY-MM-DD" or "YYYY-MM-DD hh:mi:ss" format or as a Date type.');
-        //                 }
-        //                 break;
-        //             case "time[]":
-        //                 if (this.isErrorTime(v)) {
-        //                     throw new Error('Please enter a valid time in "hh:mi" or "hh:mi:ss" format.');
-        //                 }
-        //                 break;
-        //             case "timestamp[]":
-        //                 if (this.isErrorTimestamp(v)) {
-        //                     throw new Error('Please enter a valid timestamp in "YYYY-MM-DD", "YYYY-MM-DD hh:mi:ss", or "YYYY-MM-DDThh:mi:ss" format or as a Date type.');
-        //                 }
-        //                 break;
-        //             case "number[]":
-        //                 if (this.isErrorNumber(v)) {
-        //                     throw new Error('Please enter a value of type number or a string of half-width digits.');
-        //                 }
-        //                 break;
-        //             case "bool[]":
-        //                 if (this.isErrorBool(v)) {
-        //                     throw new Error('Please enter a value of type bool, or a string "true" or "false", or a number 0 or 1.');
-        //                 }
-        //                 break;
-        //             default:
-        //                 throw new Error(`The specified ColumnTypeEnum does not exist. (${column.type})`);
-        //         }
-
-        //         if (v === true) {
-        //             return true;
-        //         }
-        //     }
-
-        //     return false;
-        // }
-
-        switch (column.type) {
-            case "string":
-                if (this.isErrorString(value)) {
-                    throw new Error('Please enter a value of type string or number.');
-                }
-                break;
-            case "uuid":
-                if (this.isErrorUUID(value)) {
-                    throw new Error('Please enter a value in UUID string format.');
-                }
-                break;
-            case "date":
-                if (this.isErrorDate(value)) {
-                    throw new Error('Please enter a valid date in "YYYY-MM-DD" or "YYYY-MM-DD hh:mi:ss" format or as a Date type.');
-                }
-                break;
-            case "time":
-                if (this.isErrorTime(value)) {
-                    throw new Error('Please enter a valid time in "hh:mi" or "hh:mi:ss" format.');
-                }
-                break;
-            case "timestamp":
-                if (this.isErrorTimestamp(value)) {
-                    throw new Error('Please enter a valid timestamp in "YYYY-MM-DD", "YYYY-MM-DD hh:mi:ss", or "YYYY-MM-DDThh:mi:ss" format or as a Date type.');
-                }
-                break;
-            case "integer":
-                if (this.isErrorNumber(value)) {
-                    throw new Error('Please enter a value of type number or a string of half-width digits.');
-                }
-                break;
-            case "bool":
-                if (this.isErrorBool(value)) {
-                    throw new Error('Please enter a value of type bool, or a string "true" or "false", or a number 0 or 1.');
-                }
-                break;
-            case "json":
-            case "jsonb":
-                if (this.isErrorJson(value)) {
-                    throw new Error('Please enter a value as an Object or JSON string.');
-                }
-                break;
-        }
-    }
-
-    static isErrorValue(columnType: TColumnType | TColumnArrayType, value: any) {
-
-        // 配列のチェック
-        if (columnType.endsWith("[]")) {
-            if (Array.isArray(value) === false) {
-                return true;
-            }
-
-            for (const v of value) {
-                let isError = false;
-                switch (columnType) {
-                    case "string[]":
-                        isError = this.isErrorString(v);
-                        break;
-                    case "uuid[]":
-                        isError = this.isErrorUUID(v);
-                        break;
-                    case "date[]":
-                        isError = this.isErrorDate(v);
-                        break;
-                    case "time[]":
-                        isError = this.isErrorTime(v);
-                        break;
-                    case "timestamp[]":
-                        isError = this.isErrorTimestamp(v);
-                        break;
-                    case "integer[]": // TODO: ここ最大最小のチェックもしないと
-                    case "real[]": // TODO: ここ最大最小 + 桁数のチェックもしないと
-                        isError = this.isErrorNumber(v);
-                        break;
-                    case "bool[]":
-                        isError = this.isErrorBool(v);
-                        break;
-                    case "json[]":
-                    case "jsonb[]":
-                        isError = this.isErrorJson(v);
-                        break;
-                    default:
-                        throw new Error(`The specified ColumnTypeEnum does not exist. (${columnType})`);
-                }
-
-                if (isError) {
-                    return true;
-                }
-            }
-
-            return false;
-        }
-
-        switch (columnType) {
-            case "string":
-                return this.isErrorString(value);
-            case "uuid":
-                return this.isErrorUUID(value);
-            case "date":
-                return this.isErrorDate(value);
-            case "time":
-                return this.isErrorTime(value);
-            case "timestamp":
-                return this.isErrorTimestamp(value);
-            case "integer": // TODO: ここ最大最小のチェックもしないと
-            case "real": // TODO: ここ最大最小 + 桁数のチェックもしないと
-                return this.isErrorNumber(value);
-            case "bool":
-                return this.isErrorBool(value);
-            case "json":
-            case "jsonb":
-                return this.isErrorJson(value);
-            default:
-                throw new Error(`The specified ColumnTypeEnum does not exist. (${columnType})`);
-        }
-    }
-
-    static isErrorString(value: any): boolean {
-        if (typeof(value) == 'string' || typeof(value) == 'number') {
-            return false;
-        }
-        return true;
-    }
-
-    static isErrorInteger(value: any): boolean {
-        let numberValue: number;
-        if (typeof value === 'string') {
-            if (value.trim() === "" || isNaN(Number(value))) {
-                return true;
-            }
-
-            numberValue = Number(value);
-        } else if (typeof value === 'number') {
-            numberValue = value;
-        } else {
-            return true;
-        }
-
-        if (Number.isInteger(numberValue) === false) {
-            return true;
-        }
-
-        if (numberValue < -2147483648 || numberValue > 2147483647) {
-            return true;
-        }
-
-        return false;
-    }
-
-    static isErrorReal(value: any): boolean {
-        let numberValue: number;
-        if (typeof value === 'string') {
-            if (value.trim() === "" || isNaN(Number(value))) {
-                return true;
-            }
-
-            numberValue = Number(value);
-        } else if (typeof value === 'number') {
-            numberValue = value;
-        } else {
-            return true;
-        }
-
-        // 特殊値チェック
-        if (isFinite(numberValue) === false) {
-            return true;
-        }
-
-        // 範囲チェック（real型の範囲）
-        if (numberValue < -3.4e38 || numberValue > 3.4e38) {
-            return true;
-        }
-
-        return false;
-    }
-
-    static isErrorNumber(value: any): boolean {
-        if (typeof value === 'string') {
-            if (value.trim() === "" || isNaN(Number(value))) {
-                return true;
-            }
-            return false;
-        } else if (typeof value === 'number') {
-            return false;
-        }
-
-        return true;
-    }
-
-    static isErrorBool(value: any): boolean {
-        switch (typeof(value)) {
-            case 'string':
-                return value !== 'true' && value !== 'false';
-            case 'number':
-                return value !== 0 && value !== 1;
-            case 'boolean':
-                return false;
-            default:
-                return true;
-        }
-    }
-
-    static isErrorUUID(value: any) {
-        return StringUtil.isUUID(value) === false;
-    }
-
-    static isErrorDate(value: any): boolean {
-        if (value instanceof Date) {
-            return false;
-        } else if (DateTimeUtil.isYYYYMMDD(value)) {
-            return false;
-        } else if (DateTimeUtil.isYYYYMMDDhhmiss(value)) {
-            return false;
-        }
-
-        return true;
-    }
-
-    static isErrorTimestamp(value: any): boolean {
-        if (value instanceof Date) {
-            return false
-        } else if (DateTimeUtil.isYYYYMMDD(`${value}`)) {
-            return false;
-        } else if (DateTimeUtil.isYYYYMMDDhhmiss(value)) {
-            return false;
-        }
-
-        return true;
-    }
-
-    static isErrorTime(value: any): boolean {
-        if (value instanceof Date) {
-            return false
-        }
-        if (DateTimeUtil.isHHMMSS(value)) {
-            return false;
-        } else if (DateTimeUtil.isHHMM(value)) {
-            return false;
-        }
-
-        return true;
-    }
-
-    static isErrorJson(value: any): boolean {
-        if (typeof value === 'object' && value !== null && Array.isArray(value) === false) {
-            return false;
-        }
-
-        if (typeof value === 'string') {
-            try {
-                JSON.parse(value);
-                return false;
-            } catch {
-                return true;
-            }
-        }
-
-        return true;
-    }
-}