Setting Up a Multi-Tenant Application with NestJS and MongoDB

In today's digital landscape, businesses often require applications that can serve multiple clients or tenants. This is where multi-tenant architecture comes into play. By isolating data and resources for each tenant within a single application, developers can optimize resource usage, reduce costs, and simplify maintenance. In this article, we will walk through setting up a multi-tenant application using NestJS and MongoDB. We will cover definitions, use cases, and actionable insights, along with clear code examples and step-by-step instructions.

What is a Multi-Tenant Application?

A multi-tenant application is a software architecture where a single instance of the application serves multiple tenants. Each tenant is logically isolated but shares the application and its resources. This approach is common in SaaS (Software as a Service) offerings, allowing for efficient resource management while maintaining tenant data separation.

Benefits of Multi-Tenant Architecture

• Cost Efficiency: Shared resources lead to lower costs for both the provider and the tenants.
• Simplified Maintenance: Upgrades and bug fixes are easier to manage with a single application instance.
• Scalability: Accommodating new tenants often requires minimal changes.

Use Cases for Multi-Tenant Applications

• SaaS Products: Software that caters to various businesses, such as CRM systems, project management tools, and e-commerce platforms.
• Educational Platforms: Learning management systems that serve multiple institutions.
• Healthcare Systems: Applications that manage patient data for different clinics and hospitals.

Getting Started with NestJS and MongoDB

Prerequisites

To follow along, ensure you have the following installed:

• Node.js (version 14 or above)
• MongoDB (local or cloud instance)
• NestJS CLI

Install the NestJS CLI globally if you haven't already:

npm install -g @nestjs/cli

Step 1: Create a New NestJS Project

First, create a new NestJS application:

nest new multi-tenant-app
cd multi-tenant-app

Step 2: Install Required Packages

Install the necessary packages for MongoDB:

npm install @nestjs/mongoose mongoose

Step 3: Set Up MongoDB Connection

Open app.module.ts and configure the MongoDB connection using Mongoose. Replace the connection string with your MongoDB URI.

import { Module } from '@nestjs/common';
import { MongooseModule } from '@nestjs/mongoose';

@Module({
  imports: [
    MongooseModule.forRoot('mongodb://localhost/multi-tenant-db'),
  ],
})
export class AppModule {}

Step 4: Create the Tenant Schema

Create a tenant.schema.ts file in a new schemas directory to define the tenant schema.

import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
import { Document } from 'mongoose';

export type TenantDocument = Tenant & Document;

@Schema()
export class Tenant {
  @Prop({ required: true })
  name: string;

  @Prop({ required: true, unique: true })
  databaseUri: string;
}

export const TenantSchema = SchemaFactory.createForClass(Tenant);

Step 5: Create a Tenant Service and Controller

Generate a new service and controller for tenants:

nest g service tenants
nest g controller tenants

Step 6: Implement Tenant Service Logic

In tenants.service.ts, implement methods to handle tenant CRUD operations.

import { Injectable } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Model } from 'mongoose';
import { Tenant, TenantDocument } from './schemas/tenant.schema';

@Injectable()
export class TenantsService {
  constructor(@InjectModel(Tenant.name) private tenantModel: Model<TenantDocument>) {}

  async createTenant(name: string, databaseUri: string): Promise<Tenant> {
    const newTenant = new this.tenantModel({ name, databaseUri });
    return newTenant.save();
  }

  async getTenants(): Promise<Tenant[]> {
    return this.tenantModel.find().exec();
  }
}

Step 7: Implement Tenant Controller

In tenants.controller.ts, set up routes for the tenant service.

import { Body, Controller, Get, Post } from '@nestjs/common';
import { TenantsService } from './tenants.service';
import { Tenant } from './schemas/tenant.schema';

@Controller('tenants')
export class TenantsController {
  constructor(private readonly tenantsService: TenantsService) {}

  @Post()
  async create(@Body() body: { name: string; databaseUri: string }): Promise<Tenant> {
    return this.tenantsService.createTenant(body.name, body.databaseUri);
  }

  @Get()
  async findAll(): Promise<Tenant[]> {
    return this.tenantsService.getTenants();
  }
}

Step 8: Run the Application

Now that we have set up the basic structure, run your application:

npm run start

You can test your endpoints using tools like Postman or Insomnia. Create a tenant by sending a POST request to http://localhost:3000/tenants with a JSON body:

{
  "name": "Tenant A",
  "databaseUri": "mongodb://localhost/tenantA-db"
}

Troubleshooting Common Issues

• Connection Errors: Ensure your MongoDB service is running and the connection string is correct.
• Schema Validation Errors: Check your schema definitions to ensure that all required fields are provided.
• CORS Issues: If you are making requests from a different origin, configure CORS in your application.

Conclusion

Setting up a multi-tenant application with NestJS and MongoDB is a powerful way to serve multiple customers with a single code base. This architecture not only saves resources but also simplifies the development and maintenance processes. By following the steps outlined in this article, you can create a scalable and efficient multi-tenant application that meets the needs of your business.

As you grow your application, consider implementing advanced features like tenant-specific configurations, data partitioning strategies, and robust authentication mechanisms to enhance security and performance. Happy coding!