innots/build/lib/db/oracle.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const oracledb = require("oracledb");
const base_1 = require("../error/base");
const db_service_1 = require("./db_service");
const db_1 = require("../error/db");
exports.DB_CONNECT_ERROR = 'DB_QUERY';
exports.DB_ORACLE_ERROR = 'DB_ORACLE_ERROR';
exports.DB_ORACLE_FETCH_ERROR = 'DB_ORACLE_FETCH_ERROR';
exports.DB_ORACLE_CLOSE_ERROR = 'DB_ORACLE_CLOSE_ERROR';
exports.DB_ORACLE_RELEASE_ERROR = 'DB_ORACLE_RELEASE_ERROR';
exports.DB_ORACLE_EXECUTE_ERROR = 'DB_ORACLE_EXECUTE_ERROR';
class OracleService {
    constructor(connectionParams, options) {
        this.poolMax = 100;
        this.maxQueryAttempts = 10;
        this._queryFailsCounter = {};
        this.options = options || {};
        this.connectionParams = connectionParams;
    }
    async run(query, params, options = {}) {
        return await this._run(query, params, options);
    }
    async getManyRows(query, params = []) {
        try {
            return await this._run(query, params, { resultSet: true, prefetchRows: 500 });
        }
        catch (error) {
            throw new db_1.DbError({
                code: exports.DB_ORACLE_ERROR,
                innerDetails: {
                    query,
                    message: error.message,
                    params
                }
            });
        }
    }
    async fetchRows(resultSet, numRows) {
        let rows;
        try {
            rows = await resultSet.getRows(numRows);
        }
        catch (error) {
            await this.closeResultSet(resultSet);
            throw new db_1.DbError({
                code: exports.DB_ORACLE_FETCH_ERROR,
                innerDetails: error.message
            });
        }
        if (rows.length === 0) {
            await this.closeResultSet(resultSet);
            return [];
        }
        return rows;
    }
    async closeResultSet(resultSet, connection) {
        try {
            await resultSet.close();
        }
        catch (error) {
            throw new db_1.DbError({
                code: exports.DB_ORACLE_FETCH_ERROR,
                innerDetails: error.message
            });
        }
        if (connection) {
            await this._disconnect(connection);
        }
    }
    async getRows(query, params = [], options = {}) {
        try {
            const result = await this._run(query, params, options);
            return result.rows;
        }
        catch (error) {
            throw new db_1.DbError({
                code: exports.DB_ORACLE_ERROR,
                innerDetails: {
                    query,
                    message: error.message,
                    params
                }
            });
        }
    }
    async getRow(query, params = [], options = {}) {
        const rows = await this.getRows(query, params, options);
        if (rows.length === 0) {
            return false;
        }
        if (rows.length > 1) {
            console.warn(db_service_1.ONE_ROW_WARNING, rows.length, query);
        }
        return rows[0];
    }
    async mustGetRow(errorCode, query, params = [], options = {}) {
        const row = await this.getRow(query, params, options);
        if (row === false) {
            throw new db_1.DbError({
                code: errorCode,
                status: base_1.BaseError.CODE_NOT_FOUND,
                innerDetails: {}
            });
        }
        return row;
    }
    async _connect() {
        try {
            if (!this.pool) {
                this.pool = await oracledb.createPool(Object.assign({}, this.connectionParams, { poolMax: this.poolMax }));
            }
            return await this.pool.getConnection();
        }
        catch (error) {
            throw new db_1.DbError({
                code: exports.DB_CONNECT_ERROR,
                innerDetails: error.message
            });
        }
    }
    async _disconnect(connection) {
        try {
            await connection.close();
        }
        catch (error) {
            throw new db_1.DbError({
                code: exports.DB_ORACLE_RELEASE_ERROR,
                innerDetails: error.message
            });
        }
    }
    async _run(query, params, options) {
        let connection;
        options = Object.assign({}, this.options, options);
        try {
            connection = await this._connect();
            const result = await connection.execute(query, params, options);
            await this._disconnect(connection);
            return result;
        }
        catch (error) {
            if (connection) {
                await this._disconnect(connection);
            }
            if (this._needRetry(arguments, error)) {
                await this.pool.close();
                this.pool = null;
                return this._run(query, params, options);
            }
            else {
                throw new db_1.DbError({
                    publicMessage: error.message,
                    innerDetails: error
                });
            }
        }
    }
    _needRetry(runArguments, error) {
        if (!error || !error.message) {
            return false;
        }
        const retryErrorsRegexp = /^(ORA-03113|ORA-04068|ORA-00028|ORA-02020)/ig;
        if (!retryErrorsRegexp.test(error.message)) {
            return false;
        }
        const failsCounterKey = JSON.stringify(runArguments);
        if (!this._queryFailsCounter[failsCounterKey]) {
            this._queryFailsCounter[failsCounterKey] = 0;
        }
        this._queryFailsCounter[failsCounterKey]++;
        return this._queryFailsCounter[failsCounterKey] < this.maxQueryAttempts;
    }
}
exports.OracleService = OracleService;