vkondratiuk482 / propagated-transactions Goto Github PK

Package consumer has to be able to specify one of the following isolation levels:

• READ COMMITED
• READ UNCOMMITTED
• REPEATABLE READ
• SERIALIZABLE

Hi @mokuteki225

Thanks for this brilliant package. I was looking for something like this specifically.

I faced an issue recently when using it with Typescript -

The PropagatedTransaction class expects a type variable to be passed whenever using it in the code. The current Typescript example in the documentation suggests doing the following -

// Creation
export const ptx = new PropagatedTransaction(TypeormTransactionRunner);

// Usage
export class UserService {
  constructor(
    private readonly ptx: PropagatedTransaction, 
    private readonly userRepository: IUserRepository, 
    private readonly walletRepository: IWalletRepository, 
  ) {}

But according to this class definition -

export class PropagatedTransaction<T extends unknown> {
  connection: T;

  constructor(runner: ITransactionRunner<T>, als?: AsyncLocalStorage<T>);

  run<R>(callback: () => R, isolationLevel?: IsolationLevelValue): R;
}

Typescript would force to pass the type variable to the PropagatedTransaction class and it will look like this -

// Creation
export const ptx = new PropagatedTransaction<QueryRunner>(TypeormTransactionRunner);

// Usage
export class UserService {
  constructor(
    private readonly ptx: PropagatedTransaction<QueryRunner>, 
    private readonly userRepository: IUserRepository, 
    private readonly walletRepository: IWalletRepository, 
  ) {}

Should I fix this example?

Also, I like how the library promotes abstraction, I created an interface for PropagatedTransaction myself so that my UserService class doesn't have to rely upon the concrete type variable QueryRunner, which would expose the implementation details of the underlying database being used to the service. Here's the interface -

import { IsolationLevelValue } from '@mokuteki/propagated-transactions';

// Interface for import { PropagatedTransaction } from '@mokuteki/propagated-transactions';
export default interface IPropagatedTransaction {
  connection: unknown;
  run<R>(callback: () => R, isolationLevel?: IsolationLevelValue): R;
}

Then I wrote my UserService like the following -

// Usage
export class UserService {
  constructor(
    private readonly ptx: IPropagatedTransaction, 
    private readonly userRepository: IUserRepository, 
    private readonly walletRepository: IWalletRepository, 
  ) {}

Let me what you think of this. Also, I'm happy to create a PR for the following changes if you approve 😄

Add unit testing examples into README.md

As for now PropagatedTransaction implements Singleton Pattern, but in fact we don't really need it since CJS/ESM imports are singletons by default

As for now if we use Typescript we can't just do ptx.start('REPEATABLE READ') due to the problems with enum typings