pg-mvc-service 2.0.43 → 2.0.45

package/src/models/MigrateDatabase.ts

@@ -0,0 +1,135 @@
+import { Pool } from "pg";
+
+export class MigrateDatabase {
+
+    private dbName: string;
+    get DbName(): string { return this.dbName; }
+    private userName: string;
+    get UserName(): string { return this.userName; }
+    private password: string | null = null;
+    get Password(): string | null {
+        return this.password;
+    }
+    private pool: Pool;
+
+    constructor (dbName: string, userName: string, pool: Pool) {
+        this.dbName = dbName;
+        this.userName = userName;
+        this.pool = pool;
+    }
+
+    public async IsExistUser(): Promise<boolean> {
+        const sql = `
+            SELECT count(*) > 0 as is_exist
+            FROM pg_roles
+            WHERE rolname = '${this.UserName}';
+        `;
+        const datas = await this.pool.query(sql);
+        return datas.rows[0].is_exist;
+    }
+
+    public async CreateUser(password: string = ''): Promise<void> {
+        if (password.trim() === '') {
+            password = '';
+
+            const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@$%^&*_+|;:.<>?';
+            for (let i = 0; i < 36; i++) {
+                const randomIndex = Math.floor(Math.random() * characters.length);
+                password += characters[randomIndex];
+            }
+        }
+        this.password = password;
+
+        const sql = `
+            DO $$
+            BEGIN
+                IF NOT EXISTS (
+                    SELECT FROM pg_catalog.pg_roles WHERE rolname = '${this.UserName}'
+                ) THEN
+                    CREATE USER ${this.UserName} WITH PASSWORD '${password}';
+                END IF;
+            END
+            $$;
+
+            GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA public TO ${this.UserName};
+
+            ALTER DEFAULT PRIVILEGES IN SCHEMA public
+            GRANT SELECT, INSERT, UPDATE, DELETE ON TABLES TO ${this.UserName};
+        `;
+        await this.pool.query(sql);
+    }
+
+    public async IsExistDb(): Promise<boolean> {
+        const sql = `
+            SELECT count(*) > 0 as is_exist
+            FROM pg_database
+            WHERE datname = '${this.DbName}';
+        `;
+        const datas = await this.pool.query(sql);
+        return datas.rows[0].is_exist;
+    }
+
+    public async CreateDb(collateType: string = 'C'): Promise<void> {
+        const sql = `
+            CREATE DATABASE ${this.DbName}
+                WITH OWNER = ${this.UserName}
+                ENCODING = 'UTF8'
+                LC_COLLATE = '${collateType}'
+                LC_CTYPE = '${collateType}'
+                CONNECTION LIMIT = -1;
+        `;
+        await this.pool.query(sql);
+    }
+
+    public RollbackDbSql(): string {
+        const sql = `
+            -- ${this.DbName}データベースに接続しているすべてのセッションを強制終了
+            SELECT pg_terminate_backend(pid)
+            FROM pg_stat_activity
+            WHERE datname = '${this.DbName}';
+
+            -- DB削除
+            DROP DATABASE IF EXISTS ${this.DbName};`;
+        return this.trimSpaceLineSql(sql);
+    }
+
+    public RollbackUserSql(otherUserName: string): string {
+        const sql = `
+            -- 1. すべてのセッションを強制終了
+            SELECT pg_terminate_backend(pg_stat_activity.pid)
+            FROM pg_stat_activity
+            WHERE usename = '${this.UserName}';
+
+            -- 2. 所有オブジェクトを ${otherUserName} に移行
+            REASSIGN OWNED BY ${this.UserName} TO ${otherUserName};
+
+            -- 2. すべての権限を削除
+            DROP OWNED BY ${this.UserName} CASCADE;
+
+            -- 3. ロールを削除
+            DROP ROLE IF EXISTS ${this.UserName};`;
+        return this.trimSpaceLineSql(sql);
+    }
+
+    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/MigrateRollback.ts

@@ -0,0 +1,151 @@
+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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,97 @@
+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の文字列。
+     */
+    static createDateTime(column: string | TColumnInfo, to: 'date' | 'time' | 'datetime') {
+        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')`;
+        }
+    }
+}

package/src/models/SqlUtils/UpdateExpression.ts

@@ -0,0 +1,29 @@
+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
+        }
+    }
+
+}