Support Transaction Decorator like Java Spring

[yeongjet]

  @Transactional
  public void update(CategoryUpdateParam param){
    
    if(! Strings.isNullOrEmpty(param.getName())) {
      changeName(param.getShopId(), param.getId(), param.getName());
    }else if(param.getParentId()!=null) {
      changeParent(param.getShopId(), param.getId(), param.getParentId());
    }
  }
  
  @Transactional
  public void changeName(Long shopId, Long categoryId, String name){
    Category category = findById(shopId,categoryId);
    category.changeName(name);
    categoryRepo.save(category);
  }

  @Transactional
  public void changeParent(Long shopId, Long categoryId, Long parentId){
    
    Category category = findById(shopId,categoryId)
        .loadParent()
        .loadDescendants();
    
    Category parent = findById(shopId,parentId);
    
    category.changeParent(parent);
    
    categoryRepo.save(category);
}

That will be convenient if support this feature

[RobinBuschmann]

Thanks for this suggestion. I will try to find a solution for that. But any PRs are welcome as wel!

[bvandenbon]

I created a package for this, which is called zb-sequelize.
https://www.npmjs.com/package/zb-sequelize

It's all explained in the README file. But it's pretty much:

import { Transactional, Tx } from 'zb-sequelize';

@Transactional
function foo(@Tx transaction) {
}

It works the same as a @Transactional(propagation=Propagation.REQUIRED) would in Java Spring.

[happnz]

I created a simple package for this - https://www.npmjs.com/package/sequelize-transactional-decorator
No need to pass transaction between method calls.
Easy setup and usage with NestJS or without it.
Supports different propagation methods (by default Propagation.REQUIRED).

[gabriel-logan]

Thanks for this suggestion. I will try to find a solution for that. But any PRs are welcome as wel!

What do you think of something like this? If this were done inside the SequelizeModule.forRoot it would be better and more beautiful and organized, but look at my functional example.

First: I create a class to set and get the instance globally.

import { Sequelize } from "sequelize-typescript";

export class SequelizeProvider {
  private static sequelizeInstance: Sequelize;

  static setSequelizeInstance(sequelize: Sequelize) {
    SequelizeProvider.sequelizeInstance = sequelize;
  }

  static getSequelizeInstance(): Sequelize {
    if (!SequelizeProvider.sequelizeInstance) {
      throw new Error(
        "Sequelize instance has not been set in the SequelizeProvider.",
      );
    }

    return SequelizeProvider.sequelizeInstance;
  }
}

In App.Module

import { Module, OnModuleInit } from "@nestjs/common";
import { AppController } from "./app.controller";
import { StudentsModule } from "./students/students.module";
import { SequelizeModule } from "@nestjs/sequelize";
import { CoursesModule } from "./courses/courses.module";
import { TempModule } from "./temp/temp.module";
import { Sequelize } from "sequelize-typescript";
import { SequelizeProvider } from "./config/decorators/SequelizeProvider";

@Module({
  imports: [
    SequelizeModule.forRoot({
      dialect: "sqlite",
      autoLoadModels: true,
    }),
    StudentsModule,
    CoursesModule,
    TempModule,
  ],
  controllers: [AppController],
})
export class AppModule implements OnModuleInit {
  constructor(private readonly sequelize: Sequelize) {}

  onModuleInit() {
    SequelizeProvider.setSequelizeInstance(this.sequelize);
  }
}

Then I Create the decorator:

import { Transaction } from "sequelize";
import { SequelizeProvider } from "../../database/SequelizeProvider";

interface TransactionalOptions {
  isolationLevel?: Transaction.ISOLATION_LEVELS;
  type?: Transaction.TYPES;
  readOnly?: boolean;
}

export function Transactional({
  isolationLevel,
  type = Transaction.TYPES.DEFERRED,
  readOnly = false,
}: TransactionalOptions = {}) {
  return (target: any, methodName: string, descriptor: PropertyDescriptor) => {
    const originalMethod: (...args: any[]) => Promise<any> = descriptor.value;

    descriptor.value = async function (...args: any[]) {
      const sequelizeInstance = SequelizeProvider.getSequelizeInstance();

      if (!sequelizeInstance) {
        throw new Error(
          `Sequelize instance not found in the transactional context of the method ${methodName}. Make sure that the SequelizeProvider is properly configured.`,
        );
      }

      const transaction = await sequelizeInstance.transaction({
        ...(isolationLevel && { isolationLevel }),
        type,
        readOnly,
      });

      try {
        const result = await originalMethod.apply(this, [...args, transaction]);

        await transaction.commit();

        return result;
      } catch (error) {
        await transaction.rollback();
        throw error;
      }
    };
  };
}

and can be used normally:

import { Injectable } from "@nestjs/common";
import { InjectModel } from "@nestjs/sequelize";
import { Transaction } from "sequelize";
import { Transactional } from "src/config/decorators/Transactional";
import { Course } from "src/courses/models/course.model";
import { Student } from "src/students/models/user.model";

@Injectable()
export class TempService {
  constructor(
    @InjectModel(Student)
    private readonly studentModel: typeof Student,

    @InjectModel(Course)
    private readonly courseModel: typeof Course,
  ) {}

  @Transactional()
  async postTemp(body: any, transaction?: Transaction) {
    const { courseName, studentName } = body;

    const newCourse = await this.courseModel.create(
      { name: courseName },
      { transaction },
    );

    const newStudent = await this.studentModel.create(
      { name: studentName },
      { transaction },
    );

    return { newCourse, newStudent };
  }
}