DEV Community: Murilo Gervasio

Building a Unit of Work like pattern in NestJS and Sequelize.

Murilo Gervasio — Sat, 21 Sep 2024 22:14:45 +0000

Introduction

Have you ever get that problem when working with the repo managing transaction across multiple repositories across
different aggregates or entities and one of them fails and you need to rollback all the changes? Well, I have and it's
a pain in the ass to manage all that transactions across different providers and have to manually rollback them or make a
compensation operation through them.

One of the most used techniques to solve this problem is the Unit of Work pattern which aims to centralize the database transaction
in one dependency which will which will orchestrate the queries through the repositories and whenever one of the repositories receives an error
we can then rollback all the changes in our database.

Unit of Work

Scenario

In the scenario below we have some models which is the Product and Purchase model. The service will create a purchase
but before the purchase is created we will need to check the stock of the product used in the purchase, if there is stock
for the requested product we will create the purchase and subtract from the stock amount.

@Injectable()
export class ProductRepository {
  constructor(private readonly productModel: typeof ProductModel) {}

  async create(product: ProductModel): Promise<ProductModel> {
    return this.productModel.create({ product });
  }

  async findAll(): Promise<ProductModel[]> {
    return this.productModel.findAll();
  }

  async findOne(id: number): Promise<ProductModel> {
    return this.productModel.findByPk(id);
  }

  async update(id: number, product: ProductModel) {
    return this.productModel.update(product, { where: { id } });
  }

  async remove(id: number): Promise<number> {
    return this.productModel.destroy({ where: { id } });
  }
}


@Injectable()
export class PurchaseRepository {
  constructor(private readonly purchaseModel: typeof PurchaseModel) {}

  async create(purchase: PurchaseModel): Promise<PurchaseModel> {
    return this.purchaseModel.create({ purchase });
  }

  async findAll(): Promise<PurchaseModel[]> {
    return this.purchaseModel.findAll();
  }

  async findOne(id: number): Promise<PurchaseModel> {
    return this.purchaseModel.findByPk(id);
  }

  async update(id: number, purchase: PurchaseModel) {
    return this.purchaseModel.update(purchase, { where: { id } });
  }

  async remove(id: number): Promise<number> {
    return this.purchaseModel.destroy({ where: { id } });
  }
}

@Injectable()
export class PurchaseService {
  constructor(
    private readonly purchaseRepository: PurchaseRepository,
    private readonly productRepository: ProductRepository,
  ) {}

  async create(createPurchaseDto: CreatePurchaseDto) {
    const product = await this.productRepository.findOne(
      createPurchaseDto.productId,
    );
    if (product.stock < createPurchaseDto.quantity) {
      throw new Error('Insufficient stock');
    }
    product.stock -= createPurchaseDto.quantity;
    await this.productRepository.update(product.id, product);

    const purchase = new PurchaseModel();

    purchase.date = new Date();
    purchase.productId = product.id;
    purchase.quantity = createPurchaseDto.quantity;

    return this.purchaseRepository.create(purchase);
  }
}

So what is the problem with this code? Well, if the purchase creation fails we will have a stock inconsistency in our database
and we will need to rollback the changes made in the product repository. This is where the Unit of Work pattern comes in.

The unit of work pattern will be responsible for managing the transaction across the repositories and will rollback the changes
if one of the repositories fails.

Implementing the Unit of Work pattern

So let's implement the Unit of Work pattern in our code.

@Injectable({ scope: Scope.REQUEST })
export class UnitOfWork {
  transaction?: Transaction;

  constructor(
    @Inject(forwardRef(() => ProductRepository))
    public readonly productRepository: ProductRepository,
    @Inject(forwardRef(() => PurchaseRepository))
    public readonly purchaseRepository: PurchaseRepository,
    @Inject('SEQUELIZE')
    private readonly sequelize: Sequelize,
  ) {}

  async startTransaction() {
    this.transaction = await this.sequelize.transaction();
  }

  async commit() {
    await this.transaction.commit();
  }

  async rollback() {
    await this.transaction.rollback();
  }
}

This implementation is an adaptation to Martin Fowler's Unit of Work pattern. The UnitOfWork class will be responsible for managing the transaction.

After that we can update our implementation of the repositories just like the below code.


@Injectable()
export class PurchaseRepository {
  constructor(
    @Inject(forwardRef(() => UnitOfWork))
    private readonly unitOfWork: UnitOfWork,
    private readonly purchaseModel: typeof PurchaseModel,
  ) {}

  async create(purchase: PurchaseModel): Promise<PurchaseModel> {
    return this.purchaseModel.create(
      { purchase },
      { transaction: this.unitOfWork.transaction },
    );
  }

  async findAll(): Promise<PurchaseModel[]> {
    return this.purchaseModel.findAll({
      transaction: this.unitOfWork.transaction,
    });
  }

  async findOne(id: number): Promise<PurchaseModel> {
    return this.purchaseModel.findByPk(id, {
      transaction: this.unitOfWork.transaction,
    });
  }

  async update(id: number, purchase: PurchaseModel) {
    return this.purchaseModel.update(purchase, {
      where: { id },
      transaction: this.unitOfWork.transaction,
    });
  }

  async remove(id: number): Promise<number> {
    return this.purchaseModel.destroy({
      where: { id },
      transaction: this.unitOfWork.transaction,
    });
  }
}

With that we can start the transaction in the Unit of Work provider and share it through all the repositories since
they expect it's transaction in the options object. By that we can improve our service code and finally have a transaction.

@Injectable()
export class PurchaseService {
  constructor(private readonly uom: UnitOfWork) {}

  async create(createPurchaseDto: CreatePurchaseDto) {
    await this.uom.startTransaction();

    try {
      const product = await this.uom.productRepository.findOne(
        createPurchaseDto.productId,
      );
      if (product.stock < createPurchaseDto.quantity) {
        throw new Error('Insufficient stock');
      }
      product.stock -= createPurchaseDto.quantity;
      await this.uom.productRepository.update(product.id, product);

      const purchase = new PurchaseModel();

      purchase.productId = product.id;
      purchase.quantity = createPurchaseDto.quantity;

      return this.uom.purchaseRepository.create(purchase);
    } catch (error) {
      await this.uom.rollback();
      throw error;
    }
  }
}

The Unit of Work must have all the repositories and act as a middleware between the repositories and the service layer.
By that if anything goes wrong in the service layer we can rollback all the changes made in the repositories.

Thats all for today folks. I hope you enjoyed this article and learned something new. If you have any questions or suggestions
please let me know in the comments below.

You can se the code in the following repository: nestjs-unit-of-work.

Building a Unit of Work like pattern in NestJS and Sequelize.

Murilo Gervasio — Sat, 21 Sep 2024 21:51:01 +0000

Introduction

Have you ever get that problem when working with the repo managing transaction across multiple repositories across
different aggregates or entities and one of them fails and you need to rollback all the changes? Well, I have and it`s
a pain in the ass to manage all that transactions across different providers and have to manually rollback them or make a
compensation operation through them.

Unit of Work

Scenario

`typescript
@Injectable()
export class ProductRepository {
constructor(private readonly productModel: typeof ProductModel) {}

async create(product: ProductModel): Promise {
return this.productModel.create({ product });
}

async findAll(): Promise {
return this.productModel.findAll();
}

async findOne(id: number): Promise {
return this.productModel.findByPk(id);
}

async update(id: number, product: ProductModel) {
return this.productModel.update(product, { where: { id } });
}

async remove(id: number): Promise {
return this.productModel.destroy({ where: { id } });
}
}
`

`typescript

@Injectable()
export class PurchaseRepository {
constructor(private readonly purchaseModel: typeof PurchaseModel) {}

async create(purchase: PurchaseModel): Promise {
return this.purchaseModel.create({ purchase });
}

async findAll(): Promise {
return this.purchaseModel.findAll();
}

async findOne(id: number): Promise {
return this.purchaseModel.findByPk(id);
}

async update(id: number, purchase: PurchaseModel) {
return this.purchaseModel.update(purchase, { where: { id } });
}

async remove(id: number): Promise {
return this.purchaseModel.destroy({ where: { id } });
}
}
`

`typescript
@Injectable()
export class PurchaseService {
constructor(
private readonly purchaseRepository: PurchaseRepository,
private readonly productRepository: ProductRepository,
) {}

async create(createPurchaseDto: CreatePurchaseDto) {
const product = await this.productRepository.findOne(
createPurchaseDto.productId,
);
if (product.stock < createPurchaseDto.quantity) {
throw new Error('Insufficient stock');
}
product.stock -= createPurchaseDto.quantity;
await this.productRepository.update(product.id, product);

const purchase = new PurchaseModel();

purchase.date = new Date();
purchase.productId = product.id;
purchase.quantity = createPurchaseDto.quantity;

return this.purchaseRepository.create(purchase);

}
}
`

The unit of work pattern will be responsible for managing the transaction across the repositories and will rollback the changes
if one of the repositories fails.

Implementing the Unit of Work pattern

So let's implement the Unit of Work pattern in our code.

`typescript
@Injectable({ scope: Scope.REQUEST })
export class UnitOfWork {
transaction?: Transaction;

constructor(
@Inject(forwardRef(() => ProductRepository))
public readonly productRepository: ProductRepository,
@Inject(forwardRef(() => PurchaseRepository))
public readonly purchaseRepository: PurchaseRepository,
@Inject('SEQUELIZE')
private readonly sequelize: Sequelize,
) {}

async startTransaction() {
this.transaction = await this.sequelize.transaction();
}

async commit() {
await this.transaction.commit();
}

async rollback() {
await this.transaction.rollback();
}
}
`

This implementation is an adaptation to Martin Fowler's Unit of Work pattern. The UnitOfWork class will be responsible for managing the transaction.

After that we can update our implementation of the repositories just like the below code.

`typescript

@Injectable()
export class PurchaseRepository {
constructor(
@Inject(forwardRef(() => UnitOfWork))
private readonly unitOfWork: UnitOfWork,
private readonly purchaseModel: typeof PurchaseModel,
) {}

async create(purchase: PurchaseModel): Promise {
return this.purchaseModel.create(
{ purchase },
{ transaction: this.unitOfWork.transaction },
);
}

async findAll(): Promise {
return this.purchaseModel.findAll({
transaction: this.unitOfWork.transaction,
});
}

async findOne(id: number): Promise {
return this.purchaseModel.findByPk(id, {
transaction: this.unitOfWork.transaction,
});
}

async update(id: number, purchase: PurchaseModel) {
return this.purchaseModel.update(purchase, {
where: { id },
transaction: this.unitOfWork.transaction,
});
}

async remove(id: number): Promise {
return this.purchaseModel.destroy({
where: { id },
transaction: this.unitOfWork.transaction,
});
}
}
`

With that we can start the transaction in the Unit of Work provider and share it through all the repositories since
they expect it`s transaction in the options object. By that we can improve our service code and finally have a transaction.


@Injectable()
export class PurchaseService {
  constructor(private readonly uom: UnitOfWork) {}

  async create(createPurchaseDto: CreatePurchaseDto) {
    await this.uom.startTransaction();

    try {
      const product = await this.uom.productRepository.findOne(
        createPurchaseDto.productId,
      );
      if (product.stock < createPurchaseDto.quantity) {
        throw new Error('Insufficient stock');
      }
      product.stock -= createPurchaseDto.quantity;
      await this.uom.productRepository.update(product.id, product);

      const purchase = new PurchaseModel();

      purchase.productId = product.id;
      purchase.quantity = createPurchaseDto.quantity;

      return this.uom.purchaseRepository.create(purchase);
    } catch (error) {
      await this.uom.rollback();
      throw error;
    }
  }
}

Thats all for today folks. I hope you enjoyed this article and learned something new. If you have any questions or suggestions
please let me know in the comments below.

You can se the code in the following repository: nestjs-unit-of-work.

How to make Multi-tenant applications with NestJS and Prisma 🚀.

Murilo Gervasio — Mon, 09 Sep 2024 00:08:20 +0000

In this article we are going to build a multi tenant application using NestJS and Prisma.
We will be using PostgreSQL as our database and we will be using Prisma to interact with the database.
At the end our Prisma service will be going to automatic make the filters based on tenant access level.

There are several ways to implement multi-tenancy in an application. The most common ways are:

Database per tenant: Each tenant has its own database. This is the most isolated approach, but it can be expensive and hard to maintain.
Schema per tenant: Each tenant has its own schema in the database. This is a good balance between isolation and cost.
Shared database, shared schema: All tenants share the same database and schema. This is the most cost-effective approach, but it requires more complex logic to separate the data of different tenants.

The way we are going to implement multi-tenancy in this article is by using the Shared database, shared schema approach. We will add a tenant_id column to each table in the database to associate each record with a tenant. We will then use this column to filter the data based on the tenant that is making the request. the column is called discriminator.

First things first!

before we start lets start a new NestJS project and install the required dependencies.

$ npm i @nestjs/cli
$ nest new multi-tenant-app
$ cd multi-tenant-app
$ npm i -g prisma
$ prisma init

Setting up Prisma

Now were are going to define some models to exemplify our Application. The following models will be used posts and tenants.

model Post {
  id        Int     @id @default(autoincrement())
  title     String
  content   String?
  tenant_id Int
  tenant    Tenant  @relation(fields: [tenant_id], references: [id])

  @@map("posts")
}

model Tenant {
  id   Int    @id @default(autoincrement())
  name String
  Post Post[]

  @@map("tenants")
}

At the end you can just run the following command to generate the Prisma client.

$ prisma generate

Now you can just define a simple prisma service and a prisma module and import it at your AppModule just as NestJS documentation.

import { Global, Injectable, Module, OnModuleInit } from '@nestjs/common';
import { PrismaClient } from '@prisma/client';

@Injectable()
export class PrismaService extends PrismaClient implements OnModuleInit {
  constructor() {
    super();
  }

  async onModuleInit(): Promise<void> {
    await this.$connect();
  }
}

@Global()
@Module({
  providers: [PrismaService],
  exports: [PrismaService],
})
export class PrismaModule {}

Defining our post module

Now you can just define a simple post module with a get all posts endpoint.

import { Controller, Get } from '@nestjs/common';
import { PostService } from './post.service';

@Controller('posts')
export class PostController {
  constructor(private readonly postService: PostService) {}

  @Get()
  findAll() {
    return this.postService.findAll();
  }
}

import { Injectable } from '@nestjs/common';
import { PrismaService } from '../infrastructure/prisma.service';

@Injectable()
export class PostService {
  constructor(private readonly prisma: PrismaService) {}

  findAll() {
    return this.prisma.post.findMany();
  }
}

NestJS CLS module

Now we are going to use the NestJS CLS module to handle the tenant_id at our requests. The CLS module is a middleware that allows you to store data in a context that is shared across all the functions that are executed in the same request. This is useful for storing data that is specific to a request, such as the tenant_id.

$ npm i nestjs-cls

After that you can just set up the CLS module at your AppModule.

@Module({
  imports: [
    PrismaModule,
    PostModule,
    ClsModule.forRoot({
      middleware: {
        mount: true,
        setup: (cls, req) => {
          cls.set('tenantId', req.headers['x-tenant-id']);
        },
      },
    }),
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

By doing this we are going to set the tenant_id in the CLS context for each request. Now we can just use this tenantId to filter the data based on the tenant that is making the request.

Now we can just prevent the user from making a request without the tenant_id or to access data he does not have access by creating a guard.

@Injectable()
export class TenantGuard implements CanActivate {
  async canActivate(context: ExecutionContext): Promise<boolean> {
    const tenantId = context.switchToHttp().getRequest().headers['x-tenant-id'];

    if (!tenantId) {
      throw new ForbiddenException('Tenant ID is required');
    }

    const userHasAccess = true; // Check if the user has access to the tenant

    return userHasAccess;
  }
}

Prisma automatic filters by request tenant.

Now we are defining a new prisma service that is going to filter the data based on the tenant_id that is in the CLS context.

To do this we are going to use the prisma.$extends method to add a middleware that is going to filter the data based on the tenant_id.

export function prismaTenantFactory(
  prisma: PrismaService,
  tenant_id: number | null,
): PrismaService {
  return prisma.$extends({
    query: {
      $allModels: {
        findMany: function ({ query, args }) {
          args.where = {
            ...args.where,
            tenant_id,
          } as unknown;

          return query(args);
        },
        findFirst({ query, args }) {
          args.where = {
            ...args.where,
            tenant_id,
          } as unknown;

          return query(args);
        },
        findUnique({ query, args }) {
          args.where = {
            ...args.where,
            tenant_id,
          } as any;

          return query(args);
        },
        findUniqueOrThrow({ query, args }) {
          args.where = {
            ...args.where,
            tenant_id,
          } as any;

          return query(args);
        },
        findFirstOrThrow({ query, args }) {
          args.where = {
            ...args.where,
            tenant_id,
          } as unknown;

          return query(args);
        },
        updateMany({ args, query }) {
          args.where = {
            ...args.where,
            tenant_id,
          } as unknown;

          return query(args);
        },

        deleteMany({ args, query }) {
          args.where = {
            ...args.where,
            tenant_id,
          } as unknown;

          return query(args);
        },

        create({ query, args }) {
          args.data = {
            ...args.data,
            tenant_id: tenant_id,
          } as any;

          return query(args);
        },
        upsert({ args, query }) {
          args.where = {
            ...args.where,
            tenant_id: tenant_id,
          } as any;

          args.create = {
            ...args.create,
            tenant_id: tenant_id,
          } as any;

          return query(args);
        },

        createMany({ query, args }) {
          if (Array.isArray(args.data)) {
            args.data = args.data.map(
              (d) =>
                ({
                  ...d,
                  tenant_id: tenant_id,
                }) as any,
            );
          } else {
            args.data = {
              ...args.data,
              tenant_id: tenant_id,
            } as any;
          }

          return query(args);
        },
      },
    },
  }) as PrismaService;
}

By doing this we define a factory that will extend our prisma client, adding a middleware that will filter the data based on the tenant_id that is in the CLS context. Not only that it will automatically insert the tenant_id from the user request to new rows.

This will be our updated prisma service calling the factory.

@Injectable()
export class PrismaService extends PrismaClient implements OnModuleInit {
  constructor(private readonly cls: ClsService) {
    super({
      log: ['query'],
    });
  }

  async onModuleInit(): Promise<void> {
    await this.$connect();
  }

  get instance(): PrismaService {
    const tenantId = this.cls.get('tenantId');
    return prismaTenantFactory(this, tenantId);
  }
}

Now we can just use the instance property of the prisma service to get a new prisma client that will filter the using the current tenant_id ind the request.

@Injectable()
export class PostService {
  constructor(private readonly prisma: PrismaService) {}

  findAll() {
    return this.prisma.instance.post.findMany();
  }
}

Now when we send a Get request to the /posts endpoint, the data will be filtered based on the tenantId that is in the CLS context.

Now we will send the bellow request to the NestJS application.

$ curl -X GET http://localhost:3000/posts -H "x-tenant-id: 3"

The prisma provider will create a proxy of the prisma instance and will generate the query bellow to the database.

SELECT "public"."posts"."id", "public"."posts"."title",
"public"."posts"."content", "public"."posts"."tenant_id" FROM 
"public"."posts" WHERE "public"."posts"."tenant_id" = $1 OFFSET $2

You can find the full code in the GitHub repository.
Now Happy coding! 🚀