Is NestJS the best choice for enforcing strong typing with TypeScript configurations?

Question

Is NestJS the best choice for enforcing strong typing with TypeScript configurations?

My app has a main configuration expressed through environment variables (process.env). How can I expose it as one object using Next.js? In the code example below, I am able to retrieve values by keys. However, since I am passing a string, TypeScript is not utilized here.

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { ConfigModule } from '@nestjs/config';
import { envVarsValidator } from "../interfaces/Config";

@Module({
  imports: [
    ConfigModule.forRoot({
      isGlobal: true,
      validationSchema: envVarsValidator,
    })
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

import { Injectable } from '@nestjs/common';
import { ConfigService } from "@nestjs/config";

@Injectable()
export class AppService {
  constructor(private configService: ConfigService) {}

  getHello(): string {
    return this.configService.get<string>('hello'); // not what I need;
  }

}

Pseudocode for what I need:


export class SomeService {
  constructor(private configService: ConfigService) {}

  someLogic(): any {
    const port = this.configService.config.port;
// What I need is one main config object with highlighted properties available on this object via TypeScript
  }

}

javascript typescript nestjs

Answer 1

Answer №1

When constructing your class, be sure to inject ConfigService and parameterize it with the interface that defines your configuration structure.

interface MyConfig {
  port: number;
  dbConnectionString: string;
}

class AppService {
  constructor(private configService: ConfigService<MyConfig>) {}
}

This will update the type of configService.get to

ConfigService<MyConfig, false>.get<any>(propertyPath: keyof MyConfig): any

. Even though you continue to pass in strings, TypeScript will now verify if the string matches a key in MyConfig.

For instance, calling

configService.get('nonexistentConfigProp')

will result in

TS2345: Argument of type '"nonexistentConfigProp"' is not assignable to parameter of type 'keyof MyConfig'

, which is the desired behavior.

Additionally, you can further customize the get method, such as using get<T> to return T | undefined instead of any. If you have already validated the config object and want get<T> to only return T, you can introduce another boolean parameter named WasValidated when parameterizing ConfigService like this:

ConfigService<MyConfig, true>

.

Answer 2

When constructing your class, be sure to inject ConfigService and parameterize it with the interface that defines your configuration structure.

interface MyConfig {
  port: number;
  dbConnectionString: string;
}

class AppService {
  constructor(private configService: ConfigService<MyConfig>) {}
}

This will update the type of configService.get to

ConfigService<MyConfig, false>.get<any>(propertyPath: keyof MyConfig): any

. Even though you continue to pass in strings, TypeScript will now verify if the string matches a key in MyConfig.

For instance, calling

configService.get('nonexistentConfigProp')

will result in

TS2345: Argument of type '"nonexistentConfigProp"' is not assignable to parameter of type 'keyof MyConfig'

, which is the desired behavior.

Additionally, you can further customize the get method, such as using get<T> to return T | undefined instead of any. If you have already validated the config object and want get<T> to only return T, you can introduce another boolean parameter named WasValidated when parameterizing ConfigService like this:

ConfigService<MyConfig, true>

.

Answer 3

Answer №2

check out the link for more information on configuration namespaces: https://docs.nestjs.com/techniques/configuration#configuration-namespaces

for example:

config/database.config.ts (JavaScript)

export default registerAs('database', () => ({
  host: process.env.DATABASE_HOST,
  port: process.env.DATABASE_PORT || 5432
}));

then you can inject a typed object like this:

constructor(
  @Inject(databaseConfig.KEY)
  private dbConfig: ConfigType<typeof databaseConfig>,
) {}

Answer 4

check out the link for more information on configuration namespaces: https://docs.nestjs.com/techniques/configuration#configuration-namespaces

for example:

config/database.config.ts (JavaScript)

export default registerAs('database', () => ({
  host: process.env.DATABASE_HOST,
  port: process.env.DATABASE_PORT || 5432
}));

then you can inject a typed object like this:

constructor(
  @Inject(databaseConfig.KEY)
  private dbConfig: ConfigType<typeof databaseConfig>,
) {}

Answer 5

Answer №3

You have the ability to define a TypeScript type object at the class level.

import { Injectable } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';

// Define a custom type with specified values
type MyType = {
  greeting: string;
  anotherValue: string;
};

@Injectable()
export class AppService {
  constructor(private configService: ConfigService<MyType>) {} // Specify the type here

  getGreeting(): string {
    return this.configService.get<string>('hello1'); // This will now trigger a TypeScript error
  }
}

Answer 6

You have the ability to define a TypeScript type object at the class level.

import { Injectable } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';

// Define a custom type with specified values
type MyType = {
  greeting: string;
  anotherValue: string;
};

@Injectable()
export class AppService {
  constructor(private configService: ConfigService<MyType>) {} // Specify the type here

  getGreeting(): string {
    return this.configService.get<string>('hello1'); // This will now trigger a TypeScript error
  }
}

Answer 7

Answer №4

For my project, I decided to take a more boilerplate approach by creating a custom wrapper for Nest's ConfigService. This wrapper is then exported as part of a module that includes other commonly used services in my application. Here's how I set it up:

import { Injectable } from '@nestjs/common'
import { ConfigService } from '@nestjs/config'

@Injectable()
export class CustomConfigurationService {
  constructor(private configService: ConfigService) {}

  get MY_CONFIG_STRING() {
    // Retrieve value from .env file
    return this.configService.get<string>('MY_CONFIG_STRING')!
  }

  get MY_CONFIG_Number() {
    // Retrieve value from .env file
    return this.configService.get<number>('MY_CONFIG_NUMBER')!
  }
}

Using the custom configuration service on the user side is quite straightforward:

export class DoSomethingService {
  constructor(private customConfigService: CustomConfigurationService) {}

  doSomething() {
    console.log(this.customConfigService.MY_CONFIG_VALUE)
  }

}

To ensure everything works smoothly, don't forget to include Nest's config service in your ConfigurationService module like this:

import { Module } from '@nestjs/common'
import { ConfigModule, ConfigService } from '@nestjs/config'
import { CustomConfigurationService } from './custom-configuration.service'

@Module({
  imports: [ConfigModule.forRoot()],
  providers: [
    ConfigService,
    CustomConfigurationService,
  ],
  exports: [CustomConfigurationService],
})
export class SharedModule {}

Answer 8

For my project, I decided to take a more boilerplate approach by creating a custom wrapper for Nest's ConfigService. This wrapper is then exported as part of a module that includes other commonly used services in my application. Here's how I set it up:

import { Injectable } from '@nestjs/common'
import { ConfigService } from '@nestjs/config'

@Injectable()
export class CustomConfigurationService {
  constructor(private configService: ConfigService) {}

  get MY_CONFIG_STRING() {
    // Retrieve value from .env file
    return this.configService.get<string>('MY_CONFIG_STRING')!
  }

  get MY_CONFIG_Number() {
    // Retrieve value from .env file
    return this.configService.get<number>('MY_CONFIG_NUMBER')!
  }
}

Using the custom configuration service on the user side is quite straightforward:

export class DoSomethingService {
  constructor(private customConfigService: CustomConfigurationService) {}

  doSomething() {
    console.log(this.customConfigService.MY_CONFIG_VALUE)
  }

}

To ensure everything works smoothly, don't forget to include Nest's config service in your ConfigurationService module like this:

import { Module } from '@nestjs/common'
import { ConfigModule, ConfigService } from '@nestjs/config'
import { CustomConfigurationService } from './custom-configuration.service'

@Module({
  imports: [ConfigModule.forRoot()],
  providers: [
    ConfigService,
    CustomConfigurationService,
  ],
  exports: [CustomConfigurationService],
})
export class SharedModule {}

Answer 9

Answer №5

We have come up with the solution by introducing the nest-typed-config module.

To begin, you will need to define your configuration model:

// config.ts
export class Configuration {
    @IsString()
    public readonly host!: string;

    @IsNumber()
    public readonly port!: number;
}

Include the TypedConfigModule in your AppModule:

// app.module.ts
import { Module } from '@nestjs/common';
import { TypedConfigModule, fileLoader } from 'nest-typed-config';
import { AppService } from './app.service';
import { Configuration } from './config';

@Module({
    imports: [
        TypedConfigModule.forRoot({
            schema: Configuration,
            load: fileLoader(),
            isGlobal: true,
        }),
    ],
    providers: [AppService],
})
export class AppModule {}

That's all! You can now inject Configuration into any service:

// app.service.ts
import { Configuration } from './config';

@Injectable()
export class AppService {
    constructor(private readonly config: Configuration) {}

    display() {
        // Enjoy full TypeScript support
        console.log(`http://${this.config.host}:${this.config.port}`)
    }
}

Answer 10

We have come up with the solution by introducing the nest-typed-config module.

To begin, you will need to define your configuration model:

// config.ts
export class Configuration {
    @IsString()
    public readonly host!: string;

    @IsNumber()
    public readonly port!: number;
}

Include the TypedConfigModule in your AppModule:

// app.module.ts
import { Module } from '@nestjs/common';
import { TypedConfigModule, fileLoader } from 'nest-typed-config';
import { AppService } from './app.service';
import { Configuration } from './config';

@Module({
    imports: [
        TypedConfigModule.forRoot({
            schema: Configuration,
            load: fileLoader(),
            isGlobal: true,
        }),
    ],
    providers: [AppService],
})
export class AppModule {}

That's all! You can now inject Configuration into any service:

// app.service.ts
import { Configuration } from './config';

@Injectable()
export class AppService {
    constructor(private readonly config: Configuration) {}

    display() {
        // Enjoy full TypeScript support
        console.log(`http://${this.config.host}:${this.config.port}`)
    }
}

Answer 11

Answer №6

To enhance the default service, you can create your own custom service like this:

import { Injectable } from "@nestjs/common";
import { ConfigService } from "@nestjs/config";
import { ConfigSchema } from "src/other/configuration";

@Injectable()
export class TypedConfigService {
  constructor(private configService: ConfigService<ConfigSchema>) {}

  get<T extends keyof ConfigSchema>(key: T) {
    return this.configService.get(key) as ConfigSchema[T];
  }
}

Answer 12

To enhance the default service, you can create your own custom service like this:

import { Injectable } from "@nestjs/common";
import { ConfigService } from "@nestjs/config";
import { ConfigSchema } from "src/other/configuration";

@Injectable()
export class TypedConfigService {
  constructor(private configService: ConfigService<ConfigSchema>) {}

  get<T extends keyof ConfigSchema>(key: T) {
    return this.configService.get(key) as ConfigSchema[T];
  }
}

Is NestJS the best choice for enforcing strong typing with TypeScript configurations?

Answer №1

Answer №2

Answer №3

Answer №4

Answer №5

Answer №6

Similar questions

Struggling to maintain consistent updates on a child element while using the @Input property

Error message: Angular JS function is not defined

Creating a custom HTTP interceptor that can intercept a response and handle errors within the 'response' property

AngularJS allows for the population of a JSON array from user input using the ng-model directive

How is it possible that this component is able to work with slotting without needing to specify the slot name

When setupFilesAfterEnv is added, mock functions may not function properly in .test files

JavaScript does not recognize jsPDF

What is the reason why the VIEW SOURCE feature does not display filled dropdown list boxes?

preventing sliding in a specific angle within the angularjs ionic framework

Is e.preventDefault() failing to work in Next.js?

"Exploring the Constraints of MongoDB's Range Functionality

Maintain the spacing of an element when utilizing *ngFor

Using jQuery to assign the value of a hidden element to data being posted

How to Properly Manipulate DOM Elements in an Angular Directive

What is the initial component that Angular will activate or run?

Fresh class retains the characteristics of the former class

Issues arise when the Angular controller fails to load

Updating Reference Models in Mongoose: A Simple Guide to Updating a Single Model

What could be causing the cleaning command to malfunction in a React Native project managed by Gradle?

Tips for making my JavaScript form open a new window after submitting