sequelize-transactional/dist/Transactional.js

A Transactional method decorator for Sequelize

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Transactional = void 0;
const init_sequelize_transactional_1 = require("./init-sequelize-transactional");
const DEFAULT_PROPAGATION = 'REQUIRED';
function Transactional(options) {
    return (target, propertyKey, descriptor) => {
        const originalMethod = descriptor.value;
        descriptor.value = async function (...args) {
            const sequelize = (0, init_sequelize_transactional_1.getSequelize)();
            if (!sequelize) {
                throw new Error('Error trying to get sequelize connection in @Transactional method. It is possible that your Sequelize connection uses custom name and you did not specify it in decorator "connectionName" option');
            }
            const callOriginalMethod = async () => originalMethod.call(this, ...args);
            const transactionOptions = {};
            if (options?.isolationLevel) {
                transactionOptions.isolationLevel =
                    options.isolationLevel;
            }
            const callInNewTransaction = async () => sequelize.transaction(transactionOptions, async () => {
                return await callOriginalMethod();
            });
            const transactionalNamespace = (0, init_sequelize_transactional_1.getTransactionalNamespace)();
            const currentTransaction = transactionalNamespace.get('transaction');
            const currentTransactionExists = currentTransaction?.sequelize === sequelize;
            const propagation = options?.propagation || DEFAULT_PROPAGATION;
            if (propagation === 'REQUIRED') {
                if (currentTransactionExists) {
                    return await callOriginalMethod();
                }
                return await callInNewTransaction();
            }
            if (propagation === 'SUPPORTS') {
                return await callOriginalMethod();
            }
            if (propagation === 'MANDATORY') {
                if (currentTransactionExists) {
                    return await callOriginalMethod();
                }
                throw new Error('For transaction with Propagation.MANDATORY active transaction is required but was not found');
            }
            if (propagation === 'NEVER') {
                if (currentTransactionExists) {
                    throw new Error('For transaction with Propagation.NEVER there must be no active transaction but one was not found');
                }
                return await callOriginalMethod();
            }
            if (propagation === 'NOT_SUPPORTED') {
                if (currentTransactionExists) {
                    transactionalNamespace.set('transaction', null);
                    try {
                        return await callOriginalMethod();
                    }
                    finally {
                        transactionalNamespace.set('transaction', currentTransaction);
                    }
                }
                else {
                    return await callOriginalMethod();
                }
            }
            if (propagation === 'REQUIRES_NEW') {
                return await callInNewTransaction();
            }
        };
    };
}
exports.Transactional = Transactional;