@uql/core 3.1.1 → 3.1.2

package/src/querier/abstractSqlQuerier-test.ts

@@ -1,21 +0,0 @@
-import { createTables, dropTables } from '../test/index.js';
-import type { QuerierPool } from '../type/index.js';
-import { AbstractQuerierIt } from './abstractQuerier-test.js';
-import type { AbstractSqlQuerier } from './abstractSqlQuerier.js';
-
-export abstract class AbstractSqlQuerierIt extends AbstractQuerierIt<AbstractSqlQuerier> {
-  constructor(
-    pool: QuerierPool<AbstractSqlQuerier>,
-    readonly idType: string,
-  ) {
-    super(pool);
-  }
-
-  override createTables() {
-    return createTables(this.querier, this.idType);
-  }
-
-  override dropTables() {
-    return dropTables(this.querier);
-  }
-}

package/src/querier/abstractSqlQuerier.ts

@@ -1,138 +0,0 @@
-import type { AbstractSqlDialect } from '../dialect/index.js';
-import { getMeta } from '../entity/index.js';
-import type {
-  Query,
-  QueryConflictPaths,
-  QueryOptions,
-  QuerySearch,
-  QueryUpdateResult,
-  SqlQuerier,
-  Type,
-} from '../type/index.js';
-import { clone, unflatObjects } from '../util/index.js';
-import { AbstractQuerier } from './abstractQuerier.js';
-import { Serialized } from './decorator/index.js';
-
-export abstract class AbstractSqlQuerier extends AbstractQuerier implements SqlQuerier {
-  private hasPendingTransaction?: boolean;
-
-  constructor(readonly dialect: AbstractSqlDialect) {
-    super();
-  }
-
-  /**
-   * internal read query.
-   */
-  protected abstract internalAll<T>(query: string, values?: unknown[]): Promise<T[]>;
-
-  /**
-   * internal insert/update/delete/ddl query.
-   */
-  protected abstract internalRun(query: string, values?: unknown[]): Promise<QueryUpdateResult>;
-
-  @Serialized()
-  async all<T>(query: string, values?: unknown[]): Promise<T[]> {
-    return this.internalAll<T>(query, values);
-  }
-
-  @Serialized()
-  async run(query: string, values?: unknown[]): Promise<QueryUpdateResult> {
-    return this.internalRun(query, values);
-  }
-
-  override async findMany<E>(entity: Type<E>, q: Query<E>) {
-    const ctx = this.dialect.createContext();
-    this.dialect.find(ctx, entity, q);
-    const res = await this.all<E>(ctx.sql, ctx.values);
-    const founds = unflatObjects(res);
-    await this.fillToManyRelations(entity, founds, q.$select);
-    return founds;
-  }
-
-  override async count<E>(entity: Type<E>, q: QuerySearch<E> = {}) {
-    const ctx = this.dialect.createContext();
-    this.dialect.count(ctx, entity, q);
-    const res = await this.all<{ count: number }>(ctx.sql, ctx.values);
-    return Number(res[0].count);
-  }
-
-  override async insertMany<E>(entity: Type<E>, payload: E[]) {
-    if (!payload?.length) {
-      return [];
-    }
-    payload = clone(payload);
-    const ctx = this.dialect.createContext();
-    this.dialect.insert(ctx, entity, payload);
-    const { ids } = await this.run(ctx.sql, ctx.values);
-    const meta = getMeta(entity);
-    const payloadIds = payload.map((it, index) => {
-      it[meta.id as string] ??= ids[index];
-      return it[meta.id];
-    });
-    await this.insertRelations(entity, payload);
-    return payloadIds;
-  }
-
-  override async updateMany<E>(entity: Type<E>, q: QuerySearch<E>, payload: E) {
-    payload = clone(payload);
-    const ctx = this.dialect.createContext();
-    this.dialect.update(ctx, entity, q, payload);
-    const { changes } = await this.run(ctx.sql, ctx.values);
-    await this.updateRelations(entity, q, payload);
-    return changes;
-  }
-
-  override async upsertOne<E>(entity: Type<E>, conflictPaths: QueryConflictPaths<E>, payload: E) {
-    payload = clone(payload);
-    const ctx = this.dialect.createContext();
-    this.dialect.upsert(ctx, entity, conflictPaths, payload);
-    return this.run(ctx.sql, ctx.values);
-  }
-
-  override async deleteMany<E>(entity: Type<E>, q: QuerySearch<E>, opts?: QueryOptions) {
-    const meta = getMeta(entity);
-    const findCtx = this.dialect.createContext();
-    this.dialect.find(findCtx, entity, { ...q, $select: [meta.id] });
-    const founds = await this.all<E>(findCtx.sql, findCtx.values);
-    if (!founds.length) {
-      return 0;
-    }
-    const ids = founds.map((it) => it[meta.id]);
-    const deleteCtx = this.dialect.createContext();
-    this.dialect.delete(deleteCtx, entity, { $where: ids }, opts);
-    const { changes } = await this.run(deleteCtx.sql, deleteCtx.values);
-    await this.deleteRelations(entity, ids, opts);
-    return changes;
-  }
-
-  override get hasOpenTransaction() {
-    return this.hasPendingTransaction;
-  }
-
-  @Serialized()
-  override async beginTransaction() {
-    if (this.hasPendingTransaction) {
-      throw TypeError('pending transaction');
-    }
-    await this.internalRun(this.dialect.beginTransactionCommand);
-    this.hasPendingTransaction = true;
-  }
-
-  @Serialized()
-  override async commitTransaction() {
-    if (!this.hasPendingTransaction) {
-      throw TypeError('not a pending transaction');
-    }
-    await this.internalRun(this.dialect.commitTransactionCommand);
-    this.hasPendingTransaction = false;
-  }
-
-  @Serialized()
-  override async rollbackTransaction() {
-    if (!this.hasPendingTransaction) {
-      throw TypeError('not a pending transaction');
-    }
-    await this.internalRun(this.dialect.rollbackTransactionCommand);
-    this.hasPendingTransaction = false;
-  }
-}

package/src/querier/decorator/index.ts

@@ -1,3 +0,0 @@
-export * from './injectQuerier.js';
-export * from './serialized.js';
-export * from './transactional.js';

package/src/querier/decorator/injectQuerier.spec.ts

@@ -1,74 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import type { Querier } from '../../type/index.js';
-import { getInjectedQuerierIndex, InjectQuerier } from './injectQuerier.js';
-
-describe('injectQuerier', () => {
-  it('no inject', () => {
-    class ServiceA {
-      save() {}
-
-      hello(param1: string, someQuerier?: Querier) {}
-    }
-
-    expect(getInjectedQuerierIndex(ServiceA, 'save')).toBe(undefined);
-    expect(getInjectedQuerierIndex(ServiceA, 'hello')).toBe(undefined);
-  });
-
-  it('one', () => {
-    class ServiceA {
-      save(@InjectQuerier() someQuerier?: Querier) {}
-
-      update(param1: string, @InjectQuerier() someQuerier?: Querier) {}
-    }
-
-    expect(getInjectedQuerierIndex(ServiceA, 'save')).toBe(0);
-    expect(getInjectedQuerierIndex(ServiceA, 'update')).toBe(1);
-  });
-
-  it('inheritance', () => {
-    class ServiceA {
-      save(@InjectQuerier() someQuerier?: Querier) {}
-    }
-    class ServiceB extends ServiceA {}
-    class ServiceC extends ServiceB {
-      hello(@InjectQuerier() someQuerier?: Querier) {}
-    }
-
-    class ServiceD extends ServiceC {}
-
-    class ServiceE extends ServiceB {}
-
-    expect(getInjectedQuerierIndex(ServiceA, 'save')).toBe(0);
-    expect(getInjectedQuerierIndex(ServiceB, 'save')).toBe(0);
-    expect(getInjectedQuerierIndex(ServiceC, 'save')).toBe(0);
-    expect(getInjectedQuerierIndex(ServiceC, 'hello')).toBe(0);
-    expect(getInjectedQuerierIndex(ServiceD, 'save')).toBe(0);
-    expect(getInjectedQuerierIndex(ServiceC, 'hello')).toBe(0);
-    expect(getInjectedQuerierIndex(ServiceE, 'save')).toBe(0);
-  });
-
-  it('inheritance - overridden', () => {
-    class ServiceA {
-      save(@InjectQuerier() someQuerier?: Querier) {}
-    }
-    class ServiceB extends ServiceA {
-      override save(someQuerier?: Querier) {}
-    }
-
-    class ServiceC extends ServiceA {
-      override save(@InjectQuerier() someQuerier?: Querier) {}
-    }
-
-    expect(getInjectedQuerierIndex(ServiceA, 'save')).toBe(0);
-    expect(getInjectedQuerierIndex(ServiceB, 'save')).toBe(undefined);
-    expect(getInjectedQuerierIndex(ServiceC, 'save')).toBe(0);
-  });
-
-  it('prevent duplicated injection', () => {
-    expect(() => {
-      class ServiceA {
-        save(@InjectQuerier() someQuerier?: Querier, @InjectQuerier() anotherQuerier?: Querier) {}
-      }
-    }).toThrow("@InjectQuerier() can only appears once in 'ServiceA.save'");
-  });
-});

package/src/querier/decorator/injectQuerier.ts

@@ -1,45 +0,0 @@
-import type { Key, Primitive, Type } from '../../type/index.js';
-
-const metadataKey = Symbol('InjectQuerier');
-
-export function InjectQuerier() {
-  return (proto: Record<Primitive, any>, key: string, index: number) => {
-    if (!proto[metadataKey]) {
-      proto[metadataKey] = new WeakMap();
-    }
-
-    if (!proto[metadataKey].has(proto.constructor)) {
-      proto[metadataKey].set(proto.constructor, {});
-    }
-
-    const meta = proto[metadataKey].get(proto.constructor);
-    const isAlreadyInjected = key in meta;
-
-    if (isAlreadyInjected) {
-      throw new TypeError(`@InjectQuerier() can only appears once in '${proto.constructor.name}.${key}'}`);
-    }
-
-    meta[key] = index;
-  };
-}
-
-export function getInjectedQuerierIndex<S>(service: Type<S>, key: Key<S>) {
-  let proto = service.prototype;
-
-  while (proto.constructor !== Object) {
-    const meta = proto[metadataKey]?.get(proto.constructor);
-
-    if (meta && key in meta) {
-      return meta[key];
-    }
-
-    const keys = Object.getOwnPropertyNames(proto) as Key<S>[];
-    const isOwnKey = keys.includes(key);
-
-    if (isOwnKey) {
-      return;
-    }
-
-    proto = Object.getPrototypeOf(proto);
-  }
-}

package/src/querier/decorator/serialized.spec.ts

@@ -1,98 +0,0 @@
-import { expect, test } from 'bun:test';
-import { AbstractQuerier } from '../abstractQuerier.js';
-import { Serialized } from './serialized.js';
-
-class MockQuerier extends AbstractQuerier {
-  activeCount = 0;
-  maxConcurrency = 0;
-  executionOrder: number[] = [];
-
-  @Serialized()
-  async slowMethod(id: number, delay: number) {
-    this.activeCount++;
-    this.maxConcurrency = Math.max(this.maxConcurrency, this.activeCount);
-    await new Promise((resolve) => setTimeout(resolve, delay));
-    this.executionOrder.push(id);
-    this.activeCount--;
-    return id;
-  }
-
-  // Abstract methods required by AbstractQuerier
-  findMany(): any {}
-  count(): any {}
-  insertMany(): any {}
-  updateMany(): any {}
-  upsertOne(): any {}
-  deleteMany(): any {}
-  beginTransaction(): any {}
-  commitTransaction(): any {}
-  rollbackTransaction(): any {}
-  protected internalRelease(): any {}
-  hasOpenTransaction = false;
-}
-
-test('Serialized decorator executes tasks sequentially', async () => {
-  const querier = new MockQuerier();
-  // Fire 3 "parallel" calls
-  const results = await Promise.all([querier.slowMethod(1, 100), querier.slowMethod(2, 50), querier.slowMethod(3, 10)]);
-  // Even though 3 finished faster, it should be last because it was queued last
-  expect(results).toEqual([1, 2, 3]);
-  expect(querier.executionOrder).toEqual([1, 2, 3]);
-  // CRITICAL: Max concurrency must be 1
-  expect(querier.maxConcurrency).toBe(1);
-});
-
-test('Serialized decorator advances queue even on failure', async () => {
-  class FailingQuerier extends MockQuerier {
-    @Serialized()
-    async failingMethod() {
-      throw new Error('boom');
-    }
-  }
-
-  const querier = new FailingQuerier();
-  const promise1 = querier.failingMethod();
-  const promise2 = querier.slowMethod(2, 10);
-  await expect(promise1).rejects.toThrow('boom');
-  const result2 = await promise2;
-  expect(result2).toBe(2);
-  expect(querier.executionOrder).toEqual([2]);
-});
-
-test('Demonstrate deadlock when a @Serialized method calls another @Serialized method', async () => {
-  class DeadlockQuerier extends MockQuerier {
-    @Serialized()
-    async outer() {
-      return this.inner();
-    }
-
-    @Serialized()
-    async inner() {
-      return 'done';
-    }
-  }
-
-  const querier = new DeadlockQuerier();
-
-  // We expect this to deadlock/timeout because 'outer' holds the queue and waits for 'inner',
-  // but 'inner' is waiting for the queue to be free.
-  const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('DEADLOCK')), 500));
-
-  await expect(Promise.race([querier.outer(), timeoutPromise])).rejects.toThrow('DEADLOCK');
-});
-
-test('Proper solution: @Serialized method calls a non-decorated internal method', async () => {
-  class SafeQuerier extends MockQuerier {
-    @Serialized()
-    async publicMethod() {
-      return this.internalMethod();
-    }
-
-    async internalMethod() {
-      return 'safe';
-    }
-  }
-
-  const querier = new SafeQuerier();
-  await expect(querier.publicMethod()).resolves.toBe('safe');
-});

package/src/querier/decorator/serialized.ts

@@ -1,13 +0,0 @@
-/**
- * Decorator that ensures the decorated method is executed serially within the Querier instance.
- * It uses a private promise queue to prevent race conditions on the database connection.
- * Note: The decorated class must extend AbstractQuerier or implement a compatible serialize method.
- */
-export function Serialized() {
-  return (_target: object, _key: string, propDescriptor: PropertyDescriptor): void => {
-    const originalMethod = propDescriptor.value;
-    propDescriptor.value = function (this: any, ...args: any[]) {
-      return this.serialize(() => originalMethod.apply(this, args));
-    };
-  };
-}

package/src/querier/decorator/transactional.spec.ts

@@ -1,240 +0,0 @@
-import { beforeEach, describe, expect, it, jest } from 'bun:test';
-import { getQuerier, setQuerierPool } from '../../options.js';
-import type { Querier, QuerierPool, Writable } from '../../type/index.js';
-import { InjectQuerier } from './injectQuerier.js';
-import { Transactional } from './transactional.js';
-
-describe('transactional', () => {
-  let anotherQuerierPool: QuerierPool;
-
-  beforeEach(() => {
-    const querierSingleton = buildQuerierMock();
-    const anotherQuerierSingleton = buildQuerierMock();
-
-    setQuerierPool({
-      getQuerier: async () => querierSingleton,
-      end: async () => undefined,
-      dialect: 'postgres',
-    });
-
-    anotherQuerierPool = {
-      getQuerier: async () => anotherQuerierSingleton,
-      end: async () => undefined,
-      dialect: 'postgres',
-    };
-  });
-
-  it('injectQuerier', async () => {
-    class ServiceA {
-      @Transactional()
-      async save(@InjectQuerier() querier?: Querier) {}
-    }
-
-    const serviceA = new ServiceA();
-    await serviceA.save();
-
-    const querier = await getQuerier();
-
-    expect(querier.beginTransaction).toHaveBeenCalledTimes(1);
-    expect(querier.commitTransaction).toHaveBeenCalledTimes(1);
-    expect(querier.rollbackTransaction).toHaveBeenCalledTimes(0);
-    expect(querier.release).toHaveBeenCalledTimes(1);
-
-    const anotherQuerier = await anotherQuerierPool.getQuerier();
-
-    expect(anotherQuerier.beginTransaction).toHaveBeenCalledTimes(0);
-    expect(anotherQuerier.commitTransaction).toHaveBeenCalledTimes(0);
-    expect(anotherQuerier.rollbackTransaction).toHaveBeenCalledTimes(0);
-    expect(anotherQuerier.release).toHaveBeenCalledTimes(0);
-  });
-
-  it('injectQuerier - querier and repositories', async () => {
-    class ServiceA {
-      @Transactional()
-      async save(@InjectQuerier() querier?: Querier) {}
-    }
-
-    const serviceA = new ServiceA();
-    await serviceA.save();
-
-    const querier = await getQuerier();
-
-    expect(querier.beginTransaction).toHaveBeenCalledTimes(1);
-    expect(querier.commitTransaction).toHaveBeenCalledTimes(1);
-    expect(querier.rollbackTransaction).toHaveBeenCalledTimes(0);
-    expect(querier.release).toHaveBeenCalledTimes(1);
-
-    const anotherQuerier = await anotherQuerierPool.getQuerier();
-
-    expect(anotherQuerier.beginTransaction).toHaveBeenCalledTimes(0);
-    expect(anotherQuerier.commitTransaction).toHaveBeenCalledTimes(0);
-    expect(anotherQuerier.rollbackTransaction).toHaveBeenCalledTimes(0);
-    expect(anotherQuerier.release).toHaveBeenCalledTimes(0);
-  });
-
-  it('injectQuerier propagation: supported', async () => {
-    class ServiceA {
-      @Transactional({ propagation: 'supported' })
-      async find(@InjectQuerier() querier?: Querier) {}
-    }
-
-    const serviceA = new ServiceA();
-    await serviceA.find();
-
-    const querier = await getQuerier();
-
-    expect(querier.beginTransaction).toHaveBeenCalledTimes(0);
-    expect(querier.commitTransaction).toHaveBeenCalledTimes(0);
-    expect(querier.rollbackTransaction).toHaveBeenCalledTimes(0);
-    expect(querier.release).toHaveBeenCalledTimes(1);
-
-    const anotherQuerier = await anotherQuerierPool.getQuerier();
-
-    expect(anotherQuerier.beginTransaction).toHaveBeenCalledTimes(0);
-    expect(anotherQuerier.commitTransaction).toHaveBeenCalledTimes(0);
-    expect(anotherQuerier.rollbackTransaction).toHaveBeenCalledTimes(0);
-    expect(anotherQuerier.release).toHaveBeenCalledTimes(0);
-  });
-
-  it('injectQuerier another querierPool', async () => {
-    class ServiceA {
-      @Transactional({ querierPool: anotherQuerierPool })
-      async save(@InjectQuerier() querier?: Querier) {}
-    }
-
-    const serviceA = new ServiceA();
-    await serviceA.save();
-
-    const anotherQuerier = await anotherQuerierPool.getQuerier();
-
-    expect(anotherQuerier.beginTransaction).toHaveBeenCalledTimes(1);
-    expect(anotherQuerier.commitTransaction).toHaveBeenCalledTimes(1);
-    expect(anotherQuerier.rollbackTransaction).toHaveBeenCalledTimes(0);
-    expect(anotherQuerier.release).toHaveBeenCalledTimes(1);
-
-    const querier = await getQuerier();
-
-    expect(querier.beginTransaction).toHaveBeenCalledTimes(0);
-    expect(querier.commitTransaction).toHaveBeenCalledTimes(0);
-    expect(querier.rollbackTransaction).toHaveBeenCalledTimes(0);
-    expect(querier.release).toHaveBeenCalledTimes(0);
-  });
-
-  it('injectQuerier and call super', async () => {
-    const deleteStub = jest.fn((id: string, querier: Querier) => {});
-
-    class ServiceA {
-      @Transactional()
-      async delete(id: string, @InjectQuerier() querier?: Querier) {
-        deleteStub(id, querier);
-      }
-    }
-
-    class ServiceB extends ServiceA {
-      @Transactional({ querierPool: anotherQuerierPool })
-      override async delete(id: string, @InjectQuerier() querier?: Querier) {
-        return super.delete(id, querier);
-      }
-    }
-
-    const serviceB = new ServiceB();
-    await serviceB.delete('123');
-
-    const querier = await getQuerier();
-
-    expect(deleteStub).toHaveBeenCalledTimes(1);
-
-    const anotherQuerier = await anotherQuerierPool.getQuerier();
-
-    expect(deleteStub).toHaveBeenCalledWith('123', anotherQuerier);
-
-    expect(anotherQuerier.beginTransaction).toHaveBeenCalledTimes(1);
-    expect(anotherQuerier.commitTransaction).toHaveBeenCalledTimes(1);
-    expect(anotherQuerier.rollbackTransaction).toHaveBeenCalledTimes(0);
-    expect(anotherQuerier.release).toHaveBeenCalledTimes(1);
-
-    expect(querier.beginTransaction).toHaveBeenCalledTimes(0);
-    expect(querier.commitTransaction).toHaveBeenCalledTimes(0);
-    expect(querier.rollbackTransaction).toHaveBeenCalledTimes(0);
-    expect(querier.release).toHaveBeenCalledTimes(0);
-  });
-
-  it('throw', async () => {
-    class ServiceA {
-      @Transactional({ propagation: 'supported' })
-      async save(@InjectQuerier() querier?: Querier) {
-        throw new Error('Some Error');
-      }
-    }
-
-    const serviceA = new ServiceA();
-
-    await expect(serviceA.save()).rejects.toThrow('Some Error');
-
-    const querier = await getQuerier();
-
-    expect(querier.beginTransaction).toHaveBeenCalledTimes(0);
-    expect(querier.commitTransaction).toHaveBeenCalledTimes(0);
-    expect(querier.rollbackTransaction).toHaveBeenCalledTimes(0);
-    expect(querier.release).toHaveBeenCalledTimes(1);
-
-    const anotherQuerier = await anotherQuerierPool.getQuerier();
-
-    expect(anotherQuerier.beginTransaction).toHaveBeenCalledTimes(0);
-    expect(anotherQuerier.commitTransaction).toHaveBeenCalledTimes(0);
-    expect(anotherQuerier.rollbackTransaction).toHaveBeenCalledTimes(0);
-    expect(anotherQuerier.release).toHaveBeenCalledTimes(0);
-  });
-
-  it('throw inside transaction', async () => {
-    class ServiceA {
-      @Transactional()
-      async save(@InjectQuerier() querier?: Querier) {
-        throw new Error('Some Error');
-      }
-    }
-
-    const serviceA = new ServiceA();
-
-    await expect(serviceA.save()).rejects.toThrow('Some Error');
-
-    const querier = await getQuerier();
-
-    expect(querier.beginTransaction).toHaveBeenCalledTimes(1);
-    expect(querier.commitTransaction).toHaveBeenCalledTimes(0);
-    expect(querier.rollbackTransaction).toHaveBeenCalledTimes(1);
-    expect(querier.release).toHaveBeenCalledTimes(1);
-
-    const anotherQuerier = await anotherQuerierPool.getQuerier();
-
-    expect(anotherQuerier.beginTransaction).toHaveBeenCalledTimes(0);
-    expect(anotherQuerier.commitTransaction).toHaveBeenCalledTimes(0);
-    expect(anotherQuerier.rollbackTransaction).toHaveBeenCalledTimes(0);
-    expect(anotherQuerier.release).toHaveBeenCalledTimes(0);
-  });
-
-  it('missing injectQuerier', () => {
-    expect(() => {
-      class ServiceA {
-        @Transactional()
-        async find() {}
-      }
-    }).toThrow("missing decorator @InjectQuerier() in 'ServiceA.find'");
-  });
-});
-
-function buildQuerierMock(): Querier {
-  const querier = {
-    beginTransaction: jest.fn(async () => {
-      querier.hasOpenTransaction = true;
-    }),
-    commitTransaction: jest.fn(async () => {
-      querier.hasOpenTransaction = undefined;
-    }),
-    rollbackTransaction: jest.fn(async () => {
-      querier.hasOpenTransaction = undefined;
-    }),
-    release: jest.fn(async () => {}),
-  } as Partial<Querier> as Writable<Querier>;
-  return querier;
-}

package/src/querier/decorator/transactional.ts

@@ -1,56 +0,0 @@
-import { getQuerierPool } from '../../options.js';
-import type { Querier, QuerierPool, Type } from '../../type/index.js';
-import { getInjectedQuerierIndex } from './injectQuerier.js';
-
-export function Transactional({
-  propagation = 'required',
-  querierPool,
-}: {
-  readonly propagation?: 'supported' | 'required';
-  readonly querierPool?: QuerierPool;
-} = {}) {
-  return (target: object, key: string, propDescriptor: PropertyDescriptor): void => {
-    const theClass = target.constructor as Type<any>;
-    const originalMethod = propDescriptor.value;
-    const injectedQuerierIndex = getInjectedQuerierIndex(theClass, key);
-
-    if (injectedQuerierIndex === undefined) {
-      throw TypeError(`missing decorator @InjectQuerier() in '${target.constructor.name}.${key}'`);
-    }
-
-    propDescriptor.value = async function func(this: object, ...args: any[]) {
-      const params = [...args];
-      let isOwnTransaction: boolean;
-      let querier: Querier;
-
-      if (params[injectedQuerierIndex]) {
-        querier = params[injectedQuerierIndex];
-      } else {
-        isOwnTransaction = true;
-        const pool = querierPool ?? getQuerierPool();
-        querier = await pool.getQuerier();
-        params[injectedQuerierIndex] = querier;
-      }
-
-      try {
-        if (propagation === 'required' && !querier.hasOpenTransaction) {
-          await querier.beginTransaction();
-        }
-        const resp = await originalMethod.apply(this, params);
-        if (isOwnTransaction && querier.hasOpenTransaction) {
-          await querier.commitTransaction();
-        }
-        return resp;
-      } catch (err) {
-        if (isOwnTransaction && querier.hasOpenTransaction) {
-          await querier.rollbackTransaction();
-        }
-        throw err;
-      } finally {
-        if (isOwnTransaction) {
-          await querier.release();
-        }
-      }
-    };
-  };
-}