Async Local Storage

1@Module({
2  providers: [
3    {
4      provide: AsyncLocalStorage,
5      useValue: new AsyncLocalStorage(),
6    },
7  ],
8  exports: [AsyncLocalStorage],
9})
10export class AlsModule {}

1@Module({
2  imports: [AlsModule],
3  providers: [CatsService],
4  controllers: [CatsController],
5})
6export class AppModule implements NestModule {
7  constructor(
8    // inject the AsyncLocalStorage in the module constructor,
9    private readonly als: AsyncLocalStorage
10  ) {}
11
12  configure(consumer: MiddlewareConsumer) {
13    // bind the middleware,
14    consumer
15      .apply((req, res, next) => {
16        // populate the store with some default values
17        // based on the request,
18        const store = {
19          userId: req.headers['x-user-id'],
20        };
21        // and pass the "next" function as callback
22        // to the "als.run" method together with the store.
23        this.als.run(store, () => next());
24      })
25      .forRoutes('*path');
26  }
27}

1@Injectable()
2export class CatsService {
3  constructor(
4    // We can inject the provided ALS instance.
5    private readonly als: AsyncLocalStorage,
6    private readonly catsRepository: CatsRepository,
7  ) {}
8
9  getCatForUser() {
10    // The "getStore" method will always return the
11    // store instance associated with the given request.
12    const userId = this.als.getStore()["userId"] as number;
13    return this.catsRepository.getForUser(userId);
14  }
15}

1npm i nestjs-cls

1@Module({
2  imports: [
3    // Register the ClsModule,
4    ClsModule.forRoot({
5      middleware: {
6        // automatically mount the
7        // ClsMiddleware for all routes
8        mount: true,
9        // and use the setup method to
10        // provide default store values.
11        setup: (cls, req) => {
12          cls.set('userId', req.headers['x-user-id']);
13        },
14      },
15    }),
16  ],
17  providers: [CatsService],
18  controllers: [CatsController],
19})
20export class AppModule {}

1@Injectable()
2export class CatsService {
3  constructor(
4    // We can inject the provided ClsService instance,
5    private readonly cls: ClsService,
6    private readonly catsRepository: CatsRepository,
7  ) {}
8
9  getCatForUser() {
10    // and use the "get" method to retrieve any stored value.
11    const userId = this.cls.get('userId');
12    return this.catsRepository.getForUser(userId);
13  }
14}

1export interface MyClsStore extends ClsStore {
2  userId: number;
3}

1describe('CatsService', () => {
2  let service: CatsService
3  let cls: ClsService
4  const mockCatsRepository = createMock<CatsRepository>()
5
6  beforeEach(async () => {
7    const module = await Test.createTestingModule({
8      // Set up most of the testing module as we normally would.
9      providers: [
10        CatsService,
11        {
12          provide: CatsRepository
13          useValue: mockCatsRepository
14        }
15      ],
16      imports: [
17        // Import the static version of ClsModule which only provides
18        // the ClsService, but does not set up the store in any way.
19        ClsModule
20      ],
21    }).compile()
22
23    service = module.get(CatsService)
24
25    // Also retrieve the ClsService for later use.
26    cls = module.get(ClsService)
27  })
28
29  describe('getCatForUser', () => {
30    it('retrieves cat based on user id', async () => {
31      const expectedUserId = 42
32      mocksCatsRepository.getForUser.mockImplementationOnce(
33        (id) => ({ userId: id })
34      )
35
36      // Wrap the test call in the `runWith` method
37      // in which we can pass hand-crafted store values.
38      const cat = await cls.runWith(
39        { userId: expectedUserId },
40        () => service.getCatForUser()
41      )
42
43      expect(cat.userId).toEqual(expectedUserId)
44    })
45  })
46})