如何将NestJS AuthModule的forRoot转换为forRootAsync，通过useFactory注入ConfigService以支持环境变量使用？

Got it, let's fix your AuthModule to support environment variables using forRootAsync instead of forRoot. Here's the complete modified implementation, followed by a breakdown of the changes:

Modified AuthModule Code #

import { Module, DynamicModule, MiddlewareConsumer, NestModule, Provider } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import { AuthController } from './auth.controller';
import { AuthService } from './auth.service';
import { SupertokensService } from './supertokens.service';
import { AuthMiddleware } from './auth.middleware';
import { ConfigInjectionToken } from './auth.constants'; // Your existing injection token
import { AuthModuleConfig } from './auth.module.config'; // Your existing config interface

@Module({
  controllers: [AuthController],
})
export class AuthModule implements NestModule {
  // Keep middleware configuration as-is
  configure(consumer: MiddlewareConsumer) {
    consumer.apply(AuthMiddleware).forRoutes('*');
  }

  // Optional: Keep forRoot for backward compatibility (if needed)
  static forRoot(config: AuthModuleConfig): DynamicModule {
    return {
      module: AuthModule,
      providers: [
        { provide: ConfigInjectionToken, useValue: config },
        SupertokensService,
        AuthService,
      ],
      exports: [],
    };
  }

  // New forRootAsync method to support environment variables
  static forRootAsync(options: {
    imports?: any[];
    useFactory: (configService: ConfigService) => AuthModuleConfig;
    inject?: any[];
  }): DynamicModule {
    // Define the config provider using the factory function
    const configProvider: Provider = {
      provide: ConfigInjectionToken,
      useFactory: options.useFactory,
      inject: options.inject || [ConfigService],
    };

    return {
      module: AuthModule,
      imports: options.imports,
      providers: [configProvider, SupertokensService, AuthService],
      exports: [],
    };
  }
}

How to Use It in Your AppModule #

import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import { AuthModule } from './auth/auth.module';

@Module({
  imports: [
    // Load environment variables globally
    ConfigModule.forRoot({ isGlobal: true }),
    // Initialize AuthModule with async config
    AuthModule.forRootAsync({
      useFactory: (configService: ConfigService) => ({
        connectionURI: configService.get<string>('SUPERTOKENS_CONNECTION_URI'),
        apiKey: configService.get<string>('SUPERTOKENS_API_KEY'),
        appInfo: {
          appName: configService.get<string>('APP_NAME'),
          apiDomain: configService.get<string>('API_DOMAIN'),
          websiteDomain: configService.get<string>('WEBSITE_DOMAIN'),
        },
      }),
      inject: [ConfigService],
    }),
  ],
})
export class AppModule {}

Key Changes Explained #

1. Async Configuration Support:

   • We added a forRootAsync static method that accepts a factory function instead of a direct config object. This factory uses ConfigService to pull values from environment variables (e.g., from your .env file).

2. Dependency Injection:

   • The inject array tells Nest to pass ConfigService into the factory function. This lets you access environment variables using configService.get().

3. Dynamic Module Structure:

   • The configProvider uses useFactory instead of useValue, which means the config is generated at runtime (when the module initializes) rather than being hardcoded.
   • We included SupertokensService and AuthService in the dynamic module's providers to ensure they have access to the injected config token.

4. Flexibility:

   • If ConfigModule isn't global, you can pass it in the imports option of forRootAsync (e.g., imports: [ConfigModule]).
   • You can customize the factory function to validate config values or handle complex logic before returning the final AuthModuleConfig.

Important Notes #

• Make sure your services (like SupertokensService) inject the ConfigInjectionToken to access the config:

  constructor(@Inject(ConfigInjectionToken) private readonly authConfig: AuthModuleConfig) {}
  

• Your .env file should include the variables referenced, e.g.:

  SUPERTOKENS_CONNECTION_URI=https://your-supertokens-instance.com
  SUPERTOKENS_API_KEY=your-api-key
  APP_NAME=YourAppName
  API_DOMAIN=http://localhost:3000
  WEBSITE_DOMAIN=http://localhost:3001
  

This setup makes your AuthModule environment-agnostic, so you don't have to hardcode config values for different environments.

内容的提问来源于stack exchange，提问作者Eivydas Vickus