feat(): durable providers #1 - multi-tenancy

Author: egocentryk

src/app.module.ts

@@ -9,7 +9,13 @@ import { FibonacciModule } from './fibonacci/fibonacci.module'
 import { HttpClientModule } from './http-client/http-client.module'
 import { TagsModule } from './tags/tags.module'
 import { EventEmitterModule } from '@nestjs/event-emitter'
-import { PaymentsModule } from './payments/payments.module';
+import { PaymentsModule } from './payments/payments.module'
+import { DataSourceModule } from './data-source/data-source.module'
+import { UsersModule } from './users/users.module'
+import { ContextIdFactory } from '@nestjs/core'
+import { AggregateByTenantContextIdStrategy } from './core/aggregate-by-tenant.strategy'
+
+ContextIdFactory.apply(new AggregateByTenantContextIdStrategy())
 
 @Module({
   imports: [
@@ -29,6 +35,8 @@ import { PaymentsModule } from './payments/payments.module';
     }),
     TagsModule,
     PaymentsModule,
+    DataSourceModule,
+    UsersModule,
     // Alternatively, we can use the `forRootAsync` method to register the module with dynamic options
     // HttpClientModule.forRootAsync({
     //   useFactory: () => ({ baseUrl: 'https://nestjs.com' }),

src/core/aggregate-by-tenant.strategy.ts

@@ -0,0 +1,46 @@
+import {
+  ContextId,
+  ContextIdFactory,
+  ContextIdResolver,
+  ContextIdResolverFn,
+  ContextIdStrategy,
+  HostComponentInfo,
+} from '@nestjs/core'
+import { Request } from 'express'
+
+export class AggregateByTenantContextIdStrategy implements ContextIdStrategy {
+  // A collection of context identifiers representing separate DI sub-trees per tenant
+  private readonly tenants = new Map<string, ContextId>()
+
+  attach(
+    contextId: ContextId,
+    request: Request,
+  ): ContextIdResolverFn | ContextIdResolver {
+    const tenantId = request.headers['x-tenant-id'] as string
+
+    if (!tenantId) {
+      // OR log error depending on what we want to accomplish
+      return () => contextId
+    }
+
+    let tenantSubTreeId: ContextId
+
+    if (this.tenants.has(tenantId)) {
+      tenantSubTreeId = this.tenants.get(tenantId)!
+    } else {
+      // Construct a new context id
+      tenantSubTreeId = ContextIdFactory.create()
+      this.tenants.set(tenantId, tenantSubTreeId)
+
+      // we can remove the tenant context id after a certain period of time
+      // if not UserService instance is created once per tenant
+      setTimeout(() => this.tenants.delete(tenantId), 3000)
+    }
+
+    return {
+      payload: { tenantId },
+      resolve: (info: HostComponentInfo) =>
+        info.isTreeDurable ? tenantSubTreeId : contextId,
+    }
+  }
+}

src/data-source/data-source.module.ts

@@ -0,0 +1,16 @@
+import { Module } from '@nestjs/common'
+import { DataSourceService } from './data-source.service'
+
+@Module({
+  providers: [
+    DataSourceService,
+    // {
+    //   provide: 'DATA_SOURCE',
+    //   useFactory: (payload) => new DataSource(...),
+    //   scope: Scope.REQUEST,
+    //   durable: true,
+    // },
+  ],
+  exports: [DataSourceService],
+})
+export class DataSourceModule {}

src/data-source/data-source.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { DataSourceService } from './data-source.service';
+
+describe('DataSourceService', () => {
+  let service: DataSourceService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [DataSourceService],
+    }).compile();
+
+    service = module.get<DataSourceService>(DataSourceService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

src/data-source/data-source.service.ts

@@ -0,0 +1,7 @@
+import { Inject, Injectable, Scope } from '@nestjs/common'
+import { REQUEST } from '@nestjs/core'
+
+@Injectable({ scope: Scope.REQUEST, durable: true })
+export class DataSourceService {
+  constructor(@Inject(REQUEST) private readonly requestContext: unknown) {}
+}

src/users/dto/create-user.dto.ts

@@ -0,0 +1 @@
+export class CreateUserDto {}

src/users/dto/update-user.dto.ts

@@ -0,0 +1,4 @@
+import { PartialType } from '@nestjs/mapped-types';
+import { CreateUserDto } from './create-user.dto';
+
+export class UpdateUserDto extends PartialType(CreateUserDto) {}

src/users/entities/user.entity.ts

@@ -0,0 +1 @@
+export class User {}

src/users/users.controller.spec.ts

@@ -0,0 +1,20 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { UsersController } from './users.controller';
+import { UsersService } from './users.service';
+
+describe('UsersController', () => {
+  let controller: UsersController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [UsersController],
+      providers: [UsersService],
+    }).compile();
+
+    controller = module.get<UsersController>(UsersController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});

src/users/users.controller.ts

@@ -0,0 +1,34 @@
+import { Controller, Get, Post, Body, Patch, Param, Delete } from '@nestjs/common';
+import { UsersService } from './users.service';
+import { CreateUserDto } from './dto/create-user.dto';
+import { UpdateUserDto } from './dto/update-user.dto';
+
+@Controller('users')
+export class UsersController {
+  constructor(private readonly usersService: UsersService) {}
+
+  @Post()
+  create(@Body() createUserDto: CreateUserDto) {
+    return this.usersService.create(createUserDto);
+  }
+
+  @Get()
+  findAll() {
+    return this.usersService.findAll();
+  }
+
+  @Get(':id')
+  findOne(@Param('id') id: string) {
+    return this.usersService.findOne(+id);
+  }
+
+  @Patch(':id')
+  update(@Param('id') id: string, @Body() updateUserDto: UpdateUserDto) {
+    return this.usersService.update(+id, updateUserDto);
+  }
+
+  @Delete(':id')
+  remove(@Param('id') id: string) {
+    return this.usersService.remove(+id);
+  }
+}