typeorm-aop-transaction

import { MiddlewareConsumer, Module } from '@nestjs/common';
import {
  TransactionMiddleware,
  TransactionModule,
} from 'typeorm-aop-transaction';

@Module({
  imports: [TransactionModule.regist()],
  controllers: [],
  providers: [],
})
export class AppModule {}

import { CustomTransactionRepository } from 'typeorm-aop-transaction';
import { BaseRepository } from 'typeorm-aop-transaction';

@CustomTransactionRepository(User) // <-- add this Decorator
@Injectable()
export class UserRepository extends BaseRepository<User> {}

@CustomTransactionRepository(User, USER_REPOSITORY_TOKEN) // <-- add this Decorator
@Injectable()
export class UserRepository extends BaseRepository<User> {}

@Module({
  imports: [TransactionModule.setRepository([UserRepository])], // <-- register a CustomRepository
  controllers: [UserController],
  providers: [UserService],
  exports: [UserService],
})
export class UserModule {}

@Module({
  imports: [TransactionModule.setRepository([User])], // <-- regist a Entity Class
  controllers: [UserController],
  providers: [UserService],
  exports: [UserService],
})
export class UserModule {}

@Injectable()
export class UserService {
  constructor(
    @InjectTransactionRepository(User) // <-- add this decorator
    private readonly userRepository: UserRepository,
  ) {}
  ...

@Injectable()
export class UserService {
  constructor(
    @InjectTransactionRepository(User)
    private readonly userRepository: Repository<User>,
  ) {}

  @Transactional()
  async create(dto: CreateUserDto): Promise<void> {
    const user = this.userMapper.to(User, dto);

    await this.userRepository.insert(user);
  }

  @Transactional({
    propagation: PROPAGATION.SUPPORTS
  })
  async findAll(): Promise<User[]> {
    const user = await this.userRepository.find({
      order: {
        created_at: 'DESC',
      },
    });

    return user;
  }

[Nest] 15178  - 2023. 07. 02. 오후 5:35:17   DEBUG [Transactional] 1688286917592|POSTGRES_CONNECTION|create|READ COMMITTED|REQUIRED - New Transaction
query: START TRANSACTION
query: SET TRANSACTION ISOLATION LEVEL READ COMMITTED
query: INSERT INTO "user"("created_at", "updated_at", "deleted_at", "id", "user_id", "password", "email", "phone_number") VALUES (DEFAULT, DEFAULT, DEFAULT, DEFAULT, $1, $2, $3, $4) RETURNING "created_at", "updated_at", "deleted_at", "id" -- PARAMETERS: ["c2d-5b8df90d6607","wjdrms15!","qjqdn1568@naver.comxx","+82-10-3252-2568"]
query: ROLLBACK
**[Nest] 15178  - 2023. 07. 02. 오후 5:35:17   ERROR [ExceptionsHandler] Attempting to join a transaction in progress. Methods with NEVER properties cannot run within a transaction boundary**
Error: Attempting to join a transaction in progress. Methods with NEVER properties cannot run within a transaction boundary
    at AlsTransactionDecorator.<anonymous> (/Users/beobwoo/dev/beebee/server/node_modules/typeorm-aop-transaction/src/providers/als-transaction.decorator.ts:305:15)
    at Generator.throw (<anonymous>)
    at rejected (/Users/beobwoo/dev/beebee/server/node_modules/typeorm-aop-transaction/dist/providers/als-transaction.decorator.js:18:65)
    at processTicksAndRejections (node:internal/process/task_queues:95:5)

[Nest] 15328  - 2023. 07. 02. 오후 5:36:42   DEBUG [Transactional] 1688287002875|POSTGRES_CONNECTION|findAll|READ COMMITTED|NEVER - No Transaction
query: SELECT "*" FROM "user" "User" WHERE "User"."deleted_at" IS NULL ORDER BY "User"."created_at" DESC

[Nest] 15328  - 2023. 07. 02. 오후 5:36:42   DEBUG [Transactional] 1688287002875|POSTGRES_CONNECTION|findAll|READ COMMITTED|NEVER - No Transaction
query: SELECT "*" FROM "user" "User" WHERE "User"."deleted_at" IS NULL ORDER BY "User"."created_at" DESC

[Nest] 15831  - 2023. 07. 02. 오후 5:41:09   DEBUG [Transactional] 1688287269077|POSTGRES_CONNECTION|create|READ COMMITTED|NESTED - New Transaction
query: START TRANSACTION
query: SET TRANSACTION ISOLATION LEVEL READ COMMITTED
query: INSERT INTO "user"("created_at", "updated_at", "deleted_at", "id", "user_id", "password", "email", "phone_number") VALUES (DEFAULT, DEFAULT, DEFAULT, DEFAULT, $1, $2, $3, $4) RETURNING "created_at", "updated_at", "deleted_at", "id" -- PARAMETERS: ["b0f-a42a40a6ba7f","wjdrms15!","qjqdn1568@naver.comxx","+82-10-3252-2568"]
[Nest] 15831  - 2023. 07. 02. 오후 5:41:09   DEBUG [Transactional] 1688287269077|POSTGRES_CONNECTION|create2|READ COMMITTED|**SUPPORTS - Join Transaction // <-- join**
query: INSERT INTO "user"("created_at", "updated_at", "deleted_at", "id", "user_id", "password", "email", "phone_number") VALUES (DEFAULT, DEFAULT, DEFAULT, DEFAULT, $1, $2, $3, $4) RETURNING "created_at", "updated_at", "deleted_at", "id" -- PARAMETERS: ["42b-d4bbdccc8c9a","wjdrms15!","2222 qjqdn1568@naver.comxx","+82-10-3252-2568"]
query: COMMIT

@Module({
  imports: [
    TransactionModule.regist({
      logging: 'debug', // logging level
    }),
  ],
  controllers: [],
  providers: [],
})
export class AppModule {
  configure(consumer: MiddlewareConsumer) {
    consumer.apply(TransactionMiddleware).forRoutes('*');
  }
}

// (example) console logging
[Nest] 20212  - 2023. 07. 24. 오후 11:29:57   DEBUG [Transactional] 1690208997228|POSTGRES_CONNECTION|findAll|READ COMMITTED|REQUIRED - New Transaction
[Nest] 20212  - 2023. 07. 24. 오후 11:46:05   DEBUG [Transactional] 1690209965305|POSTGRES_CONNECTION|create|READ COMMITTED|REQUIRED - New Transaction

// basic-queue.processor.ts
@Processor(QueueName.BASIC_QUEUE)
export class BasicQueueProcessor {
  constructor(
    @Inject(EmploymentOpportunityInjector.EMPLOYMENT_OPPORTUNITY_SERVICE)
    private readonly eopService: EmploymentOpportunityService,
  ) {}

  @Process(AutoDeleteEmploymentOpportunityJobName)
  async deleteEmploymentOpportunity(
    job: Job<AutoDeleteEmploymentOpportunityJob>,
  ) {
    // call REQUIRED delete method
    // has no parent transaction, so start new transaction
    await this.eopService.delete(job.data.eopId);
  }
}

// eop.service.ts
@Transactional()
delete(eopId: string) {
  return this.eopRepository.delete(eopId);
}

// user.service.ts
@Injectable()
export class UserService {
  constructor(
    @InjectTransactionRepository(User)
    private readonly userRepository: Repository<User>,
    @InjectTransactionRepository(SocialAccount)
    private readonly socialAccountRepository: Repository<SocialAccount>,
  ) {}
  ...

// user.service.spec.ts
import { Test, TestingModule } from '@nestjs/testing';
import { getRepositoryToken } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { CreateUserDto } from '../dtos/create-user.dto';
import { UserService } from '../service/user.service';

describe('UserService', () => {
  let service: UserService;
  let userRepository: Repository<User>;
  let socialAccountRepository: Repository<SocialAccount>;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [
        UserService,
        {
          provide: getRepositoryToken(User),
          useValue: {
            create: jest.fn(),
            save: jest.fn(),
            ...
          },
        },
        {
          provide: getRepositoryToken(SocialAccount),
          useValue: {
            create: jest.fn(),
            save: jest.fn(),
            ...
          },
        },
      ],
    }).compile();

    service = module.get<UserService>(UserService);
    userRepository = module.get<Repository<User>>(getRepositoryToken(User));
    socialAccountRepository = module.get<Repository<SocialAccount>>(
      getRepositoryToken(SocialAccount),
    );
  });
 ...

it('should save User Entity and related Entities', async () => {
  const create = jest.spyOn(userRepository, 'create').mockReturnValue(user);
  const save = jest.spyOn(userRepository, 'save').mockResolvedValue({
    ...user,
    _id: 'test uuid',
  });

  await service.create(createUserDto);

  expect(create).toBeCalledTimes(1);
  expect(save).toBeCalledTimes(1);
  ...
});

@Module({
  imports: [
    AopModule,
    TransactionModule.regist({
      defaultConnectionName: <<Optional>>,
    }),
    DatabaseModule,
    ...
  ],
  controllers: [AppController],
})
export class AppModule {
  configure(consumer: MiddlewareConsumer) {
    consumer.apply(TransactionMiddleware).forRoutes('*');
  }
}

describe('UserController (e2e)', () => {
  let app: INestApplication;
  let dataSource: DataSource;

  beforeAll(async () => {
    const module = await Test.createTestingModule({
      imports: [AppModule],
      providers: [],
    }).compile();

    app = module.createNestApplication();
    await app.init();
  });

  beforeEach(async () => {
    jest.restoreAllMocks();

    dataSource = app.get<DataSource>(getDataSourceToken());
    const queryRunner = dataSource.createQueryRunner();
    try {
      await queryRunner.query('TRUNCATE "user" CASCADE');
    } finally {
      await queryRunner.release();
    }
  });

  afterAll(async () => {
    await app.close();
  });

  it('GET /user/list', () => {
    return request(app.getHttpServer()).get('/user/list').expect(<<expedted_value>>);
  });

  ...
});