pg-mvc-service 1.0.0

package/dist/models/MigrateRollback.js

@@ -0,0 +1,146 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rollback = exports.migrate = void 0;
+const pg_1 = require("pg");
+const migrate = (migrates, poolParam) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const pool = new pg_1.Pool({
+        user: poolParam.user,
+        password: poolParam.password,
+        host: poolParam.host,
+        database: poolParam.dbName,
+        port: (_a = poolParam.port) !== null && _a !== void 0 ? _a : 5432,
+        ssl: poolParam.isSsl === true ? {
+            rejectUnauthorized: false
+        } : false
+    });
+    // create migration table
+    try {
+        if ((yield 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
+                );`;
+            yield pool.query(sql);
+        }
+    }
+    catch (ex) {
+        console.error('An error occurred related to the Migrate table:', ex);
+        yield pool.end();
+        throw ex;
+    }
+    const client = yield pool.connect();
+    try {
+        client.query('BEGIN');
+        const datas = yield 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;
+            }
+            yield client.query(migrate.MigrateSql);
+            const grantSql = migrate.AddGrantSql;
+            if (grantSql !== null) {
+                yield client.query(grantSql);
+            }
+            const migrateInsertSql = `
+                INSERT INTO migrations
+                (migration_number, script_file, rollback_script)
+                VALUES (${maxNumber + 1}, '${className}', '${migrate.RollbackSql}');
+            `;
+            maxNumber++;
+            yield client.query(migrateInsertSql);
+            console.log(`Execution completed: ${className}`);
+        }
+        yield client.query('COMMIT');
+        console.log('Migration completed');
+    }
+    catch (ex) {
+        yield client.query('ROLLBACK');
+        console.log('Migration failed.', ex);
+    }
+    finally {
+        client.release();
+        yield pool.end();
+    }
+});
+exports.migrate = migrate;
+const rollback = (toNumber, poolParam) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const pool = new pg_1.Pool({
+        user: poolParam.user,
+        password: poolParam.password,
+        host: poolParam.host,
+        database: poolParam.dbName,
+        port: (_a = poolParam.port) !== null && _a !== void 0 ? _a : 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 ((yield isExistMigrationTable(pool)) == false) {
+            return;
+        }
+    }
+    catch (ex) {
+        console.error('An error occurred related to the Migrate table:', ex);
+        yield pool.end();
+        return;
+    }
+    const client = yield pool.connect();
+    try {
+        yield client.query('BEGIN');
+        const datas = yield getMigrations(pool);
+        for (const data of datas.datas) {
+            if (data.migration_number < toNumber) {
+                break;
+            }
+            yield client.query(data.rollback_script);
+            yield client.query(`DELETE FROM migrations WHERE migration_number = ${data.migration_number}`);
+            console.log(`Execution completed: ${data.script_file}`);
+        }
+        yield client.query('COMMIT');
+        console.log('Rollback completed');
+    }
+    catch (ex) {
+        yield client.query('ROLLBACK');
+        console.error('Rollback failed', ex);
+    }
+    finally {
+        client.release();
+        yield pool.end();
+    }
+});
+exports.rollback = rollback;
+const isExistMigrationTable = (pool) => __awaiter(void 0, void 0, void 0, function* () {
+    const existMigrationTableSql = `
+        SELECT EXISTS (
+            SELECT FROM information_schema.tables 
+            WHERE table_name = 'migrations'
+        );
+    `;
+    const res = yield pool.query(existMigrationTableSql);
+    return res.rows[0].exists;
+});
+const getMigrations = (pool) => __awaiter(void 0, void 0, void 0, function* () {
+    const datas = yield 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/dist/models/MigrateTable.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MigrateTable = void 0;
+class MigrateTable {
+    get MigrateSql() { return this.trimSpaceLineSql(this.migrateSql); }
+    get RollbackSql() { return this.trimSpaceLineSql(this.rollbackSql); }
+    get AddGrantSql() {
+        var _a;
+        if (((_a = this.user) !== null && _a !== void 0 ? _a : "").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(user) {
+        this.migrateSql = '';
+        this.rollbackSql = '';
+        this.addGrantTables = [];
+        this.user = '';
+        if (user !== undefined) {
+            this.user = user;
+        }
+    }
+    trimSpaceLineSql(str) {
+        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;
+    }
+}
+exports.MigrateTable = MigrateTable;

package/dist/models/SqlUtils/SelectExpression.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const StringUtil_1 = __importDefault(require("../Utils/StringUtil"));
+class SelectExpression {
+    /**
+     * 指定されたカラム情報と関数を使用して、SQLのSELECT文を作成します。
+     * @param columnInfoType カラム情報を含むオブジェクト。
+     * @param func カラムに適用する関数名。nullの場合は関数を適用しません。
+     * @returns SQLのSELECT文の文字列。
+     */
+    static create(columnInfo, func = null, alias = null, keyFormat = 'snake') {
+        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 !== null && alias !== void 0 ? alias : '';
+        if (func !== null) {
+            if (aliasName.trim() === '') {
+                const snakeAlias = func + '_' + columnInfo.name;
+                aliasName = keyFormat === 'snake' ? snakeAlias : StringUtil_1.default.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_1.default.formatFromSnakeToCamel(columnInfo.name);
+        }
+        return `${select} as "${aliasName}"`;
+    }
+    /**
+     * BaseModelからSELECTクエリを作成します。
+     * @param baseModel クエリを作成するためのBaseModelオブジェクト。
+     * @param isExcludeId trueの場合、idカラムを除外します。
+     * @param isExcludeSystemTime trueの場合、システム時間のカラムを除外します。
+     * @returns 作成されたSELECTクエリの文字列。
+     */
+    static createFromModel(model) {
+        const queries = [];
+        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の文字列。
+     */
+    static createDateTime(column, to) {
+        const columnQuery = typeof column === 'string' ? column : column.model.getColumn(column.name).expression;
+        switch (to) {
+            case 'date':
+                return `to_char(${columnQuery}, 'YYYY-MM-DD')`;
+            case 'datetime':
+                return `to_char(${columnQuery}, 'YYYY-MM-DD HH24:mi:ss')`;
+            case 'time':
+                return `to_char(${columnQuery}, 'HH24:mi:ss')`;
+        }
+    }
+}
+exports.default = SelectExpression;

package/dist/models/SqlUtils/ValidateValueUtil.js

@@ -0,0 +1,250 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const DateTimeUtil_1 = __importDefault(require("../Utils/DateTimeUtil"));
+const StringUtil_1 = __importDefault(require("../Utils/StringUtil"));
+class ValidateValueUtil {
+    static validateId(columns, id) {
+        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, value) {
+        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 "number":
+                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;
+        }
+    }
+    static isErrorValue(columnType, value) {
+        // 配列のチェック
+        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 "number[]":
+                        isError = this.isErrorNumber(v);
+                        break;
+                    case "bool[]":
+                        isError = this.isErrorBool(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 "number":
+                return this.isErrorNumber(value);
+            case "bool":
+                return this.isErrorBool(value);
+            default:
+                throw new Error(`The specified ColumnTypeEnum does not exist. (${columnType})`);
+        }
+    }
+    static isErrorString(value) {
+        if (typeof (value) == 'string' || typeof (value) == 'number') {
+            return false;
+        }
+        return true;
+    }
+    static isErrorNumber(value) {
+        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) {
+        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) {
+        return StringUtil_1.default.isUUID(value) === false;
+    }
+    static isErrorDate(value) {
+        if (value instanceof Date) {
+            return false;
+        }
+        else if (DateTimeUtil_1.default.isYYYYMMDD(value)) {
+            return false;
+        }
+        else if (DateTimeUtil_1.default.isYYYYMMDDhhmiss(value)) {
+            return false;
+        }
+        return true;
+    }
+    static isErrorTimestamp(value) {
+        if (value instanceof Date) {
+            return false;
+        }
+        else if (DateTimeUtil_1.default.isYYYYMMDD(`${value}`)) {
+            return false;
+        }
+        else if (DateTimeUtil_1.default.isYYYYMMDDhhmiss(value)) {
+            return false;
+        }
+        return true;
+    }
+    static isErrorTime(value) {
+        if (value instanceof Date) {
+            return false;
+        }
+        if (DateTimeUtil_1.default.isHHMMSS(value)) {
+            return false;
+        }
+        else if (DateTimeUtil_1.default.isHHMM(value)) {
+            return false;
+        }
+        return true;
+    }
+}
+exports.default = ValidateValueUtil;