@rsdk/db.typeorm 2.5.1

package/src/internal/context.ts

@@ -0,0 +1,164 @@
+import { BaseContext } from '@rsdk/db';
+import type { QueryRunner } from 'typeorm';
+
+import type { IsolationLevel } from '../types';
+import { DEFAULT_ISOLATION_LEVEL, isolationLevels } from '../types';
+
+import {
+  AlreadyAttached,
+  MustReleased,
+  QueryRunnerIsReleased,
+  QueryRunnerIsTransactionActive,
+  QueryRunnerMustBeAttached,
+  UnexpectedRelease,
+} from './exceptions';
+
+export class TypeOrmContext extends BaseContext<IsolationLevel> {
+  readonly isolationLevels = isolationLevels;
+
+  /**
+   * TypeOrm queryRunner который будет использоваться для выполнения запросов и инициализации транзакции
+   * @private
+   */
+  private _queryRunner?: QueryRunner;
+
+  /**
+   * Текущая глубина на которую должна быть проинициализирована транзакция
+   * @private
+   */
+  private transactionInitializedDepth = 0;
+  /**
+   * Глубина вложенности
+   * Не путать с индексом вложенности
+   * По сути является необходимым количеством проинициализированных слоев
+   * @private
+   */
+  private nestDepth = 1;
+
+  /**
+   * Завершена ли работа с этим контекстом
+   * Необходимо для контроля за тем чтобы не было переиспользований этого контекста
+   * @private
+   */
+  private _isReleased = false;
+
+  private constructor(isolationLevel?: IsolationLevel);
+
+  private constructor(suspended: true);
+
+  private constructor(arg?: true | IsolationLevel) {
+    super(arg ?? DEFAULT_ISOLATION_LEVEL);
+  }
+
+  get isReleased(): boolean {
+    return this._isReleased;
+  }
+
+  get queryRunner(): QueryRunner | undefined {
+    return this._queryRunner;
+  }
+
+  static create(isolationLevel: IsolationLevel): TypeOrmContext {
+    return new TypeOrmContext(isolationLevel);
+  }
+
+  static createSuspended(): TypeOrmContext {
+    return new TypeOrmContext(true);
+  }
+
+  /**
+   * Устанавливаем queryRunner который будет использоваться для инициализации транзакции
+   * @param queryRunner
+   */
+  attach(queryRunner: QueryRunner): void {
+    if (this._queryRunner) {
+      throw new AlreadyAttached();
+    }
+
+    if (queryRunner.isTransactionActive) {
+      throw new QueryRunnerIsTransactionActive();
+    }
+
+    if (queryRunner.isReleased) {
+      throw new QueryRunnerIsReleased();
+    }
+
+    this._queryRunner = queryRunner;
+  }
+
+  async initialize(): Promise<void> {
+    if (this.suspended) {
+      return;
+    }
+
+    if (!this._queryRunner) {
+      throw new QueryRunnerMustBeAttached();
+    }
+
+    /**
+     * Инициализируем нужное количество `savepoint`
+     */
+    for (
+      this.transactionInitializedDepth;
+      this.transactionInitializedDepth < this.nestDepth;
+      this.transactionInitializedDepth++
+    ) {
+      await this._queryRunner.startTransaction();
+    }
+  }
+
+  isInitialized(): boolean {
+    return this.nestDepth === this.transactionInitializedDepth;
+  }
+
+  addNestLayer(): void {
+    if (this.suspended) {
+      throw new Error('unsupported nesting muted ');
+    }
+
+    this.nestDepth += 1;
+  }
+
+  async rollbackTransaction(): Promise<void> {
+    if (!this._queryRunner) {
+      return;
+    }
+
+    if (this.isInitialized()) {
+      await this._queryRunner.rollbackTransaction();
+    }
+  }
+
+  async commitTransaction(): Promise<void> {
+    if (!this._queryRunner) {
+      return;
+    }
+
+    if (this.isInitialized()) {
+      await this._queryRunner.commitTransaction();
+    }
+  }
+
+  async finalize(mustRelease: boolean): Promise<void> {
+    this.nestDepth -= 1;
+    this.transactionInitializedDepth = this.nestDepth;
+
+    const isReleased = this.nestDepth === 0;
+    /**
+     * В обоих случаях в идеале завершать работу приложения так как часть операция может быть не выполнена, хотя должна была и наоборот
+     * И в качестве бонуса получим висящее соединение к СУБД которое нельзя использовать
+     */
+    if (!isReleased && mustRelease) {
+      throw new MustReleased();
+    }
+
+    if (isReleased && !mustRelease) {
+      throw new UnexpectedRelease();
+    }
+
+    if (isReleased) {
+      this._isReleased = true;
+      await this._queryRunner?.release();
+    }
+  }
+}

package/src/internal/exceptions.ts

@@ -0,0 +1,96 @@
+import { InternalException } from '@rsdk/core';
+
+export class TypeormdbException extends InternalException {}
+
+export class ProxiedMethodIsNotFunction extends TypeormdbException {
+  constructor() {
+    super('Proxied method non function value');
+  }
+}
+
+export class AlreadyAttached extends TypeormdbException {
+  constructor() {
+    super('Already attached');
+  }
+}
+
+export class QueryRunnerMustBeAttached extends TypeormdbException {
+  constructor() {
+    super('QueryRunner must be attached');
+  }
+}
+
+export class ContextMustBeProvided extends TypeormdbException {
+  constructor() {
+    super('Incorrect call, context must be provided');
+  }
+}
+
+/**
+ * Неожиданный релиз (закрытие/возвращение в пул) соединения
+ */
+export class UnexpectedRelease extends TypeormdbException {
+  constructor() {
+    super('Unexpected release connection');
+  }
+}
+
+/**
+ * Ожидалось завершение работы с транзакцией, но не удовлетворены условия завершения (например транзакция не может быть закрыта из-за наличия незакрытых `savepoint`)
+ */
+export class MustReleased extends TypeormdbException {
+  constructor() {
+    super('Must released but conditions not satisfied');
+  }
+}
+
+/**
+ * Попытка использовать контекст когда работа с ним была завершена
+ * Например если не дождались завершения промиса использующего соединение
+ * @example
+ * runInContext(()=> {
+ *     Promise.resolve().then(() => manager.query('SELECT 1'))
+ * })
+ *
+ * @example
+ * class UserController {
+ *   constructor(
+ *     private registerAttemptService: { registerAttemptToDb(): Promise<void> },
+ *     private userService: { fetchUser(userId: UserId): Promise<User | null> }
+ *   ) {}
+ *
+ *   // @Get('/user')
+ *   // @Transactional()
+ *   async sum(@Query() query: { userId: UserId }): Promise<void> {
+ *     this.registerAttemptService.registerAttemptToDb();
+ *     return this.userService.fetchUser(query.userId);
+ *   }
+ * }
+ */
+export class ContextIsReleased extends InternalException {
+  constructor() {
+    super(
+      "Trying to use a context when it's already released (the function started in the context has been ended)",
+    );
+  }
+}
+
+/**
+ * QueryRunner переданный для аттача уже в состоянии isReleased
+ * Такой queryRunner не может быть использован для работы контекста
+ */
+export class QueryRunnerIsReleased extends InternalException {
+  constructor() {
+    super('queryRunner.isReleased must be false for attach');
+  }
+}
+
+/**
+ * QueryRunner переданный для аттача уже внутри транзакции
+ * Такой queryRunner не может быть использован для работы контекста
+ */
+export class QueryRunnerIsTransactionActive extends InternalException {
+  constructor() {
+    super('queryRunner.isTransactionActive must be false for attach');
+  }
+}

package/src/internal/initializer.ts

@@ -0,0 +1,213 @@
+import { ContextStorage } from '@rsdk/db';
+import type { QueryRunner } from 'typeorm';
+import { DataSource } from 'typeorm';
+
+import type { TypeOrmContext } from './context';
+import { ContextIsReleased, ProxiedMethodIsNotFunction } from './exceptions';
+
+const originalCreateQueryRunner = DataSource.prototype.createQueryRunner;
+
+export class Initializer {
+  static readonly storage = new ContextStorage<TypeOrmContext>();
+
+  /**
+   * Патчинг всех необходимых методов из typeorm
+   */
+  static initialize(): void {
+    Object.defineProperty(DataSource.prototype, 'createQueryRunner', {
+      value: Initializer.wrappedCreateQueryRunner,
+    });
+  }
+
+  private static wrappedCreateQueryRunner(
+    this: DataSource,
+    ...args: any[]
+  ): QueryRunner {
+    const originalQueryRunner: QueryRunner = originalCreateQueryRunner.call(
+      this,
+      ...args,
+    );
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const dataSource = this;
+    const proxiesQueryRunner = new Proxy(originalQueryRunner, {
+      get(target: QueryRunner, propertyKey: keyof QueryRunner): any {
+        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 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;
+  }
+
+  private static getValidQueryRunner(
+    dataSource: DataSource,
+    originalQueryRunner: QueryRunner,
+  ): QueryRunner {
+    /**
+     * Теоретически может быть ситуация в которой оригинальный
+     * queryRunner уже кто-то использует в транзакции или его уже релизнули
+     */
+    if (
+      originalQueryRunner.isTransactionActive ||
+      originalQueryRunner.isReleased
+    ) {
+      /**
+       * Так как это нежелательное поведение показываем варнинг
+       */
+      Initializer.warnOnBusyQueryRunner(originalQueryRunner);
+
+      return originalCreateQueryRunner.call(
+        dataSource,
+        originalQueryRunner.getReplicationMode(),
+      );
+    }
+
+    return originalQueryRunner;
+  }
+
+  private static getWrappedRelease(originalQueryRunner: QueryRunner) {
+    return async function (this: QueryRunner): Promise<void> {
+      const ctx = Initializer.storage.getContext();
+      const contextQueryRunner = ctx?.queryRunner;
+
+      if (ctx && contextQueryRunner === originalQueryRunner) {
+        return;
+      }
+
+      return originalQueryRunner.release.call(originalQueryRunner);
+    };
+  }
+
+  private static getProxiesMethod<K extends keyof QueryRunner>(
+    dataSource: DataSource,
+    originalQueryRunnerProp: QueryRunner[K],
+    originalQueryRunner: QueryRunner,
+  ): QueryRunner[K] {
+    // Чтобы ts не нервничал
+    if (typeof originalQueryRunnerProp !== 'function') {
+      throw new ProxiedMethodIsNotFunction();
+    }
+
+    const originalQueryRunnerFunc = originalQueryRunnerProp as (
+      ...args: any
+    ) => any;
+
+    return async function (this: QueryRunner, ...args: any[]): Promise<any> {
+      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);
+    } as QueryRunner[K];
+  }
+
+  private static warnOnBusyQueryRunner(
+    potentialQueryRunner: QueryRunner,
+  ): void {
+    const warnMessage = Initializer.getWarnMessage(potentialQueryRunner);
+
+    console.warn(warnMessage);
+  }
+
+  private static getWarnMessage(potentialQueryRunner: QueryRunner): string {
+    return `[Initializer -> getProxiesMethod] originalQueryRunner already - ${[
+      potentialQueryRunner.isTransactionActive && 'used in transaction',
+      potentialQueryRunner.isReleased && 'released',
+    ].join(' and ')}`;
+  }
+}

package/src/internal/strategy.ts

@@ -0,0 +1,149 @@
+import type { CallBack, TransactionalStrategy } from '@rsdk/db';
+
+import type { IsolationLevel } from '../types';
+import { DEFAULT_ISOLATION_LEVEL } from '../types';
+
+import { TypeOrmContext } from './context';
+import { ContextMustBeProvided } from './exceptions';
+import { Initializer } from './initializer';
+
+export class TypeormTransactionalStrategy
+  implements TransactionalStrategy<IsolationLevel, TypeOrmContext>
+{
+  /**
+   * Возвращает текущий контекст если вызвано внутри него
+   */
+  getContext(): TypeOrmContext | undefined {
+    return Initializer.storage.getContext();
+  }
+
+  /**
+   * Возвращает обернутую в контекст функцию
+   * @param fn
+   * @param propagationLevel
+   * @param options
+   */
+  bindContext<TResult, TArgs extends any[]>(
+    fn: CallBack<TArgs, TResult>,
+    options: IsolationLevel = DEFAULT_ISOLATION_LEVEL,
+  ): CallBack<TArgs, Promise<TResult>> {
+    return (...args: TArgs) => this.runInContext(options, fn, ...args);
+  }
+
+  /**
+   * Находимся ли мы в контексте и не является ли он suspend
+   */
+  isRunning(): boolean {
+    const context = Initializer.storage.getContext();
+    if (!context) {
+      return false;
+    }
+
+    return Boolean(context.suspended);
+  }
+
+  /**
+   * Вызывает функцию, обернутую внутри контекста с заданными параметрами и корректной обработкой транзакции
+   * @param isolation
+   * @param fn
+   * @param args
+   */
+  async runInContext<TResult, TArgs extends any[]>(
+    isolation: IsolationLevel,
+    fn: CallBack<TArgs, TResult>,
+    ...args: TArgs
+  ): Promise<TResult> {
+    const currentContext = 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<TResult, TArgs extends any[]>(
+    isolationLevel: IsolationLevel,
+    fn: CallBack<TArgs, TResult>,
+    ...args: TArgs
+  ): Promise<TResult> {
+    const typeormContext = TypeOrmContext.create(isolationLevel);
+    const wrapped = this.wrapInTransactionContext(true, fn);
+
+    return Initializer.storage.run(typeormContext, wrapped, ...args);
+  }
+
+  /**
+   * Создаёт новый контекст внутри которого не будет создаваться/использоваться транзакция и игнорироваться внешняя
+   * @param fn
+   * @param args
+   */
+  async runOutTransactionalContext<TResult, TArgs extends any[]>(
+    fn: CallBack<TArgs, TResult>,
+    ...args: TArgs
+  ): Promise<TResult> {
+    const typeormContext = TypeOrmContext.createSuspended();
+    const wrapped = this.wrapInTransactionContext(true, fn);
+
+    return Initializer.storage.run(typeormContext, wrapped, ...args);
+  }
+
+  /**
+   * Вызывает функцию во вложенном уровне контекста
+   * @param context
+   * @param isolationLevel
+   * @param fn
+   * @param args
+   */
+  async nestedExecute<TResult, TArgs extends any[]>(
+    context: TypeOrmContext,
+    isolationLevel: IsolationLevel,
+    fn: CallBack<TArgs, TResult>,
+    ...args: TArgs
+  ): Promise<TResult> {
+    context.assertIsolationCompatibility(isolationLevel);
+
+    const wrapped = this.wrapInTransactionContext(false, fn);
+
+    context.addNestLayer();
+
+    return Initializer.storage.run(context, wrapped, ...args);
+  }
+
+  /**
+   * Оборачивает функцию для корректного завершения транзакции, если она была проинициализирована внутри функции
+   * Важно - не оборачивает в вызов с контекстом
+   * @param mustReleased
+   * @param fn
+   */
+  private wrapInTransactionContext<TResult, TArgs extends any[]>(
+    mustReleased: boolean,
+    fn: CallBack<TArgs, TResult>,
+  ): CallBack<TArgs, Promise<TResult>> {
+    return async (...args) => {
+      const context = Initializer.storage.getContext();
+      if (!context) {
+        throw new ContextMustBeProvided();
+      }
+
+      try {
+        const result = await fn(...args);
+
+        await context.commitTransaction();
+
+        return result;
+      } catch (error) {
+        await context.rollbackTransaction();
+
+        throw error;
+      } finally {
+        await context.finalize(mustReleased);
+      }
+    };
+  }
+}