Nestjs environment variable configuration to solve the problem of how to inject services into interceptors

In fact, this is also a NestJS Process record of environment variable configuration .

During the development process, I have generated such a requirement , I need to start different environments with different script commands .mock Environment , I want to provide virtual data for the front end ;staging Environment , I want to be BFF Provide the front end with data transmitted from the background .

Before returning data , I need to format the data uniformly . So I made an interceptor RespTransformInterceptor.

import {
    
  CallHandler,
  ExecutionContext,
  NestInterceptor,
} from '@nestjs/common';
import {
     Observable } from 'rxjs';
import {
     map } from 'rxjs/operators';

@Injectable()
export class RespTransformInterceptor implements NestInterceptor {
    
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    
    return next.handle().pipe(
      map((data) => {
    
        return {
    
          code: 0,
          result: data,
        };
      }),
    );
  }
}

Now I want to process the data in the interceptor , Make sure that no matter what the environment , The data structures I return are unified . Then I have to distinguish the current operating environment .

First , According to official website To configure Custom configuration files .

// configuration.ts
//  All with ':mock' At the end of the package.json command , The environment is mock; For the other staging
export type ENV_TYPE = 'mock' | 'staging';

export default () => {
    
  const commandSlices = process.env.npm_lifecycle_event.split(':');
  const envType = commandSlices[commandSlices.length - 1] as ENV_TYPE;
  return {
    
    node_env: envType === 'mock' ? 'mock' : 'staging',
  };
};

then , We import it into AppModule in .

// app.module.ts
import {
     Module } from '@nestjs/common';
import {
     AppController } from './app.controller';
import {
     AppService } from './app.service';
import {
     LayoutModule } from './common/layout/layout.module';
import {
     ConfigModule, ConfigService } from '@nestjs/config';
import {
     APP_INTERCEPTOR } from '@nestjs/core';
import {
     RespTransformInterceptor } from './common/interceptor/resp-transform.interceptor';
import configuration from './config/configuration';

@Module({
    
  imports: [
    LayoutModule,
    ConfigModule.forRoot({
    
      load: [configuration], //  The configuration file 
      isGlobal: true, //  Provide to the global 
    }),
  ],
  controllers: [AppController],
  providers: [
    AppService,
    {
    
      provide: APP_INTERCEPTOR,
      useClass: RespTransformInterceptor,
    },
    //  Another way to provide to the global 
    // ConfigService
  ],
})
export class AppModule {
    }

Last , We need to inject services into interceptors ：

// resp-transform.interceptor.ts
constructor(private readonly configService: ConfigService) {
    }

We can provide services through get API Get the current environment .

// resp-transform.interceptor.ts
this.configService.get<string>('node_env') // log:mock | staging

summary , We can inject the services that need to be injected provide Into the module , At the same time, we should also inject the services that need to be injected 、 Interceptor 、 Guard, etc provide Into the module . In this way, we can obtain various services through injection .