@rsdk/db.typeorm 2.5.1

package/dist/internal/initializer.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Initializer = void 0;
+const db_1 = require("@rsdk/db");
+const typeorm_1 = require("typeorm");
+const exceptions_1 = require("./exceptions");
+const originalCreateQueryRunner = typeorm_1.DataSource.prototype.createQueryRunner;
+class Initializer {
+    static storage = new db_1.ContextStorage();
+    /**
+     * Патчинг всех необходимых методов из typeorm
+     */
+    static initialize() {
+        Object.defineProperty(typeorm_1.DataSource.prototype, 'createQueryRunner', {
+            value: Initializer.wrappedCreateQueryRunner,
+        });
+    }
+    static wrappedCreateQueryRunner(...args) {
+        const originalQueryRunner = originalCreateQueryRunner.call(this, ...args);
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const dataSource = this;
+        const proxiesQueryRunner = new Proxy(originalQueryRunner, {
+            get(target, propertyKey) {
+                const originalQueryRunnerProp = target[propertyKey];
+                /**
+                 * Мы сами контролируем то когда будет освобожден queryRunner
+                 * Даже сейчас есть проблема с тем что в пул может попасть соединение в котором не была завершена транзакция
+                 */
+                if (propertyKey === 'release') {
+                    return Initializer.getWrappedRelease(target);
+                }
+                /**
+                 * ATTENTION: Очень важна последовательность, потому что ряд драйверов (postgres например) делает так
+                 * @see https://github.com/typeorm/typeorm/blob/f5b93c14b5efa1a55aed0211a4757af1b3d6e66b/src/driver/postgres/PostgresQueryRunner.ts#L148
+                 * Ничего сверх критичного не происходит, или по крайней мере я не нашёл этого
+                 * Единственное, уходит в бесконечную проверку коннекты к бд не висят, но `DataSource.destroy` уходит в бесконечный цикл
+                 * @see https://github.com/typeorm/typeorm/blob/f5b93c14b5efa1a55aed0211a4757af1b3d6e66b/src/driver/postgres/PostgresDriver.ts#L1532
+                 */
+                /**
+                 * Защита от дурака
+                 */
+                /**
+                 * class A {
+                 *   queryRunner: QueryRunner
+                 *
+                 *   constructor(private dataSource: DataSource) {
+                 *     this.queryRunner = this.dataSource.createQueryRunner()
+                 *   }
+                 *
+                 *   @Transactional()
+                 *   transactionDo() {
+                 *     // wtf -_-
+                 *     this.queryRunner.query('drop database')
+                 *   }
+                 * }
+                 */
+                if (typeof originalQueryRunnerProp === 'function') {
+                    return Initializer.getProxiesMethod(dataSource, originalQueryRunnerProp, target);
+                }
+                const context = Initializer.storage.getContext();
+                if (!context) {
+                    return originalQueryRunnerProp;
+                }
+                if (context.isReleased) {
+                    throw new exceptions_1.ContextIsReleased();
+                }
+                /**
+                 * Если кто-то обратился к любому queryRunner во время исполнения функции контекста, а в контексте ещё нет queryRunner
+                 * Этот queryRunner добавляем в контекст
+                 */
+                if (!context.queryRunner &&
+                    /**
+                     * Дополнительно проверяем не является ли этот queryRunner релизнутым/с активной транзакцией
+                     */
+                    target.isTransactionActive &&
+                    !target.isReleased) {
+                    context.attach(originalQueryRunner);
+                }
+                if (propertyKey === 'manager') {
+                    /**
+                     * Из-за того что у manager должен быть линк на queryRunner
+                     */
+                    return dataSource.createEntityManager(proxiesQueryRunner);
+                }
+                return originalQueryRunnerProp;
+            },
+        });
+        return proxiesQueryRunner;
+    }
+    static getValidQueryRunner(dataSource, originalQueryRunner) {
+        /**
+         * Теоретически может быть ситуация в которой оригинальный
+         * queryRunner уже кто-то использует в транзакции или его уже релизнули
+         */
+        if (originalQueryRunner.isTransactionActive ||
+            originalQueryRunner.isReleased) {
+            /**
+             * Так как это нежелательное поведение показываем варнинг
+             */
+            Initializer.warnOnBusyQueryRunner(originalQueryRunner);
+            return originalCreateQueryRunner.call(dataSource, originalQueryRunner.getReplicationMode());
+        }
+        return originalQueryRunner;
+    }
+    static getWrappedRelease(originalQueryRunner) {
+        return async function () {
+            const ctx = Initializer.storage.getContext();
+            const contextQueryRunner = ctx?.queryRunner;
+            if (ctx && contextQueryRunner === originalQueryRunner) {
+                return;
+            }
+            return originalQueryRunner.release.call(originalQueryRunner);
+        };
+    }
+    static getProxiesMethod(dataSource, originalQueryRunnerProp, originalQueryRunner) {
+        // Чтобы ts не нервничал
+        if (typeof originalQueryRunnerProp !== 'function') {
+            throw new exceptions_1.ProxiedMethodIsNotFunction();
+        }
+        const originalQueryRunnerFunc = originalQueryRunnerProp;
+        return async function (...args) {
+            const context = Initializer.storage.getContext();
+            if (!context) {
+                /**
+                 * Если мы не в контексте просто даём делать свою работу
+                 */
+                return originalQueryRunnerFunc.call(originalQueryRunner, ...args);
+            }
+            /**
+             * Если у нас уже есть проинициализированный queryRunner делегируем работу ему
+             */
+            if (context.isInitialized()) {
+                return originalQueryRunnerFunc.call(context.queryRunner, ...args);
+            }
+            /**
+             * Если в контексте нет queryRunner его надо установить перед тем как инициализировать транзакцию
+             */
+            if (!context.queryRunner) {
+                const resultedQueryRunner = Initializer.getValidQueryRunner(dataSource, originalQueryRunner);
+                context.attach(resultedQueryRunner);
+            }
+            await context.initialize();
+            return await originalQueryRunnerFunc.call(context.queryRunner, ...args);
+        };
+    }
+    static warnOnBusyQueryRunner(potentialQueryRunner) {
+        const warnMessage = Initializer.getWarnMessage(potentialQueryRunner);
+        console.warn(warnMessage);
+    }
+    static getWarnMessage(potentialQueryRunner) {
+        return `[Initializer -> getProxiesMethod] originalQueryRunner already - ${[
+            potentialQueryRunner.isTransactionActive && 'used in transaction',
+            potentialQueryRunner.isReleased && 'released',
+        ].join(' and ')}`;
+    }
+}
+exports.Initializer = Initializer;
+//# sourceMappingURL=initializer.js.map

package/dist/internal/initializer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"initializer.js","sourceRoot":"","sources":["../../src/internal/initializer.ts"],"names":[],"mappings":"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"}

package/dist/internal/strategy.d.ts

@@ -0,0 +1,55 @@
+import type { CallBack, TransactionalStrategy } from '@rsdk/db';
+import type { IsolationLevel } from '../types';
+import { TypeOrmContext } from './context';
+export declare class TypeormTransactionalStrategy implements TransactionalStrategy<IsolationLevel, TypeOrmContext> {
+    /**
+     * Возвращает текущий контекст если вызвано внутри него
+     */
+    getContext(): TypeOrmContext | undefined;
+    /**
+     * Возвращает обернутую в контекст функцию
+     * @param fn
+     * @param propagationLevel
+     * @param options
+     */
+    bindContext<TResult, TArgs extends any[]>(fn: CallBack<TArgs, TResult>, options?: IsolationLevel): CallBack<TArgs, Promise<TResult>>;
+    /**
+     * Находимся ли мы в контексте и не является ли он suspend
+     */
+    isRunning(): boolean;
+    /**
+     * Вызывает функцию, обернутую внутри контекста с заданными параметрами и корректной обработкой транзакции
+     * @param isolation
+     * @param fn
+     * @param args
+     */
+    runInContext<TResult, TArgs extends any[]>(isolation: IsolationLevel, fn: CallBack<TArgs, TResult>, ...args: TArgs): Promise<TResult>;
+    /**
+     * Вызывает функцию в новом контексте, игнорируя внешний если он существует
+     * @param isolationLevel
+     * @param fn
+     * @param args
+     */
+    runFromNewContext<TResult, TArgs extends any[]>(isolationLevel: IsolationLevel, fn: CallBack<TArgs, TResult>, ...args: TArgs): Promise<TResult>;
+    /**
+     * Создаёт новый контекст внутри которого не будет создаваться/использоваться транзакция и игнорироваться внешняя
+     * @param fn
+     * @param args
+     */
+    runOutTransactionalContext<TResult, TArgs extends any[]>(fn: CallBack<TArgs, TResult>, ...args: TArgs): Promise<TResult>;
+    /**
+     * Вызывает функцию во вложенном уровне контекста
+     * @param context
+     * @param isolationLevel
+     * @param fn
+     * @param args
+     */
+    nestedExecute<TResult, TArgs extends any[]>(context: TypeOrmContext, isolationLevel: IsolationLevel, fn: CallBack<TArgs, TResult>, ...args: TArgs): Promise<TResult>;
+    /**
+     * Оборачивает функцию для корректного завершения транзакции, если она была проинициализирована внутри функции
+     * Важно - не оборачивает в вызов с контекстом
+     * @param mustReleased
+     * @param fn
+     */
+    private wrapInTransactionContext;
+}

package/dist/internal/strategy.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeormTransactionalStrategy = void 0;
+const types_1 = require("../types");
+const context_1 = require("./context");
+const exceptions_1 = require("./exceptions");
+const initializer_1 = require("./initializer");
+class TypeormTransactionalStrategy {
+    /**
+     * Возвращает текущий контекст если вызвано внутри него
+     */
+    getContext() {
+        return initializer_1.Initializer.storage.getContext();
+    }
+    /**
+     * Возвращает обернутую в контекст функцию
+     * @param fn
+     * @param propagationLevel
+     * @param options
+     */
+    bindContext(fn, options = types_1.DEFAULT_ISOLATION_LEVEL) {
+        return (...args) => this.runInContext(options, fn, ...args);
+    }
+    /**
+     * Находимся ли мы в контексте и не является ли он suspend
+     */
+    isRunning() {
+        const context = initializer_1.Initializer.storage.getContext();
+        if (!context) {
+            return false;
+        }
+        return Boolean(context.suspended);
+    }
+    /**
+     * Вызывает функцию, обернутую внутри контекста с заданными параметрами и корректной обработкой транзакции
+     * @param isolation
+     * @param fn
+     * @param args
+     */
+    async runInContext(isolation, fn, ...args) {
+        const currentContext = initializer_1.Initializer.storage.getContext();
+        if (!currentContext) {
+            return await this.runFromNewContext(isolation, fn, ...args);
+        }
+        return await this.nestedExecute(currentContext, isolation, fn, ...args);
+    }
+    /**
+     * Вызывает функцию в новом контексте, игнорируя внешний если он существует
+     * @param isolationLevel
+     * @param fn
+     * @param args
+     */
+    async runFromNewContext(isolationLevel, fn, ...args) {
+        const typeormContext = context_1.TypeOrmContext.create(isolationLevel);
+        const wrapped = this.wrapInTransactionContext(true, fn);
+        return initializer_1.Initializer.storage.run(typeormContext, wrapped, ...args);
+    }
+    /**
+     * Создаёт новый контекст внутри которого не будет создаваться/использоваться транзакция и игнорироваться внешняя
+     * @param fn
+     * @param args
+     */
+    async runOutTransactionalContext(fn, ...args) {
+        const typeormContext = context_1.TypeOrmContext.createSuspended();
+        const wrapped = this.wrapInTransactionContext(true, fn);
+        return initializer_1.Initializer.storage.run(typeormContext, wrapped, ...args);
+    }
+    /**
+     * Вызывает функцию во вложенном уровне контекста
+     * @param context
+     * @param isolationLevel
+     * @param fn
+     * @param args
+     */
+    async nestedExecute(context, isolationLevel, fn, ...args) {
+        context.assertIsolationCompatibility(isolationLevel);
+        const wrapped = this.wrapInTransactionContext(false, fn);
+        context.addNestLayer();
+        return initializer_1.Initializer.storage.run(context, wrapped, ...args);
+    }
+    /**
+     * Оборачивает функцию для корректного завершения транзакции, если она была проинициализирована внутри функции
+     * Важно - не оборачивает в вызов с контекстом
+     * @param mustReleased
+     * @param fn
+     */
+    wrapInTransactionContext(mustReleased, fn) {
+        return async (...args) => {
+            const context = initializer_1.Initializer.storage.getContext();
+            if (!context) {
+                throw new exceptions_1.ContextMustBeProvided();
+            }
+            try {
+                const result = await fn(...args);
+                await context.commitTransaction();
+                return result;
+            }
+            catch (error) {
+                await context.rollbackTransaction();
+                throw error;
+            }
+            finally {
+                await context.finalize(mustReleased);
+            }
+        };
+    }
+}
+exports.TypeormTransactionalStrategy = TypeormTransactionalStrategy;
+//# sourceMappingURL=strategy.js.map

package/dist/internal/strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategy.js","sourceRoot":"","sources":["../../src/internal/strategy.ts"],"names":[],"mappings":"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"}

package/dist/internal/test/strategy.test.e2e.d.ts

@@ -0,0 +1,5 @@
+import { Cat } from './util';
+export declare const fetchCats: () => Promise<Cat[]>;
+export declare const createCat: () => Promise<Cat>;
+export declare const createSecondCat: () => Promise<Cat>;
+export declare const pingDatabase: () => Promise<void>;