[Reimplementation] Improving the inject-ability with config providers

[bashleigh]

The idea

I've been debating for a while if the method of storing application configurations in an injectable class is the best approach. Since the AsyncProvider was added to nestjs it would be possible to await the loading of the config module to create providers for each file found from the glob.

The reason

This method would make the config providers easier to import into the constructors of injectables and would clear up implementation issues and the need for injecting the entire configuration class #30, #12.

Possible drawback

However it does mean that some functionality could be lost. Specifically the ConfigService would be rendered redundant unless we're able to inject all config providers as one provider into the ConfigService class.

If you like the idea give this comment a ❤️. If you don't, add a 👎.

TLDR;

Remove ConfigService injection and instead create a provider for each config file

ConfigModule async provider build

class ConfigModule {
  public static async asyncLoad(glob: string, options: ConfigOptions): Promise<DynamicModule> {
    const configs = await ConfigService.findByGlob(glob);
    configs.map(config => ({
      provide: configToken(config.fileName),
      useValue: config.value,
    }));
 
    return {
      module: ConfigModule,
      providers: configs,
      exports: configs,
    };
  }
}

@Controller()
export class ExampleController {
  constructor(@InjectConfig('filename') config) {}
}

@Injectable()
export class ExampleProvider {
  constructor(@InjectConfig('database') database, @InjectConfig('another') Another) {}
}

@Module({
  imports: [
    TypeOrmModule.forRootAsync((
      useFactory: (config) => config,
      inject: [configToken('database')],
    }),
  ],
})

Further possibilities

Types

Using types in the config could be very beneficial for validation and obviously typing in the project.

configs/app.config.ts

export default class AppConfig {
  port: number = process.env.PORT;
  development: boolean = process.env.NODE_ENV === 'development';
}

@Module({
  imports: [
    SomeModule.forRootAsync({
        useFactory: (config: AppConfig) => config,
        injects: [AppConfig],
    }),
  ],
})

or

@Injectable()
export class SomeClass {
  constructor(private readonly myConfig: AppConfig) {}
}

Without types

export default {
  '__provide': 'SOME_TOKEN',
  '__name': 'name_of_config',
  port: process.env.PORT,
}

This could then be injected with

@Module({
  providers: [
    {
        provide: SomeProvider,
        useFactory: (config) => config,
        inject: ['SOME_TOKEN'],
    },
  ],
})

@Injectable()
export class SomeClass {
  constructor(@Inject('SOME_TOKEN') private readonly config) {}
}

Or selected with ConfigService.get('name_of_config.port').

[bashleigh]

If anyone is interested, I started an experimental repo for these v2 features/implementation changes https://github.com/bashleigh/nestjs-config-v2-prototype