@nestjs/config

  • Version 2.0.0
  • Published
  • 39.3 kB
  • 4 dependencies
  • MIT license

Install

npm i @nestjs/config
yarn add @nestjs/config
pnpm add @nestjs/config

Overview

Nest - modern, fast, powerful node.js web framework (@config)

Index

Functions

function getConfigToken

getConfigToken: (token: string) => string;

    function registerAs

    registerAs: <
    TConfig extends ConfigObject,
    TFactory extends ConfigFactory<ConfigObject> = ConfigFactory<TConfig>
    >(
    token: string,
    configFactory: TFactory
    ) => TFactory & ConfigFactoryKeyHost<ReturnType<TFactory>>;
    • Registers the configuration object behind a specified token.

    Classes

    class ConfigModule

    class ConfigModule {}

      property envVariablesLoaded

      static readonly envVariablesLoaded: Promise<void>;
      • This promise resolves when "dotenv" completes loading environment variables. When "ignoreEnvFile" is set to true, then it will resolve immediately after the "ConfigModule#forRoot" method is called.

      method forFeature

      static forFeature: (config: ConfigFactory) => DynamicModule;
      • Registers configuration object (partial registration).

        Parameter config

      method forRoot

      static forRoot: (options?: ConfigModuleOptions) => DynamicModule;
      • Loads process environment variables depending on the "ignoreEnvFile" flag and "envFilePath" value. Also, registers custom configurations globally.

        Parameter options

      class ConfigService

      class ConfigService<
      K = Record<string, unknown>,
      WasValidated extends boolean = false
      > {}

        constructor

        constructor(internalConfig?: Record<string, any>);

          method get

          get: {
          <T = any>(propertyPath: KeyOf<K>): ExcludeUndefinedIf<WasValidated, T>;
          <T = K, P extends Path<T> = any, R = PathValue<T, P>>(
          propertyPath: P,
          options: ConfigGetOptions
          ): ExcludeUndefinedIf<WasValidated, R>;
          <T = any>(propertyPath: KeyOf<K>, defaultValue: NoInferType<T>): T;
          <T = K, P extends Path<T> = any, R = PathValue<T, P>>(
          propertyPath: P,
          defaultValue: NoInferType<R>,
          options: ConfigGetOptions
          ): R;
          };
          • Get a configuration value (either custom configuration or process environment variable) based on property path (you can use dot notation to traverse nested object, e.g. "database.host").

            Parameter propertyPath

          • Get a configuration value (either custom configuration or process environment variable) based on property path (you can use dot notation to traverse nested object, e.g. "database.host").

            Parameter propertyPath

            Parameter options

          • Get a configuration value (either custom configuration or process environment variable) based on property path (you can use dot notation to traverse nested object, e.g. "database.host"). It returns a default value if the key does not exist.

            Parameter propertyPath

            Parameter defaultValue

          • Get a configuration value (either custom configuration or process environment variable) based on property path (you can use dot notation to traverse nested object, e.g. "database.host"). It returns a default value if the key does not exist.

            Parameter propertyPath

            Parameter defaultValue

            Parameter options

          Interfaces

          interface ConfigFactoryKeyHost

          interface ConfigFactoryKeyHost<T = unknown> {}

            property KEY

            KEY: string;

              method asProvider

              asProvider: () => {
              imports: [ReturnType<typeof ConfigModule.forFeature>];
              useFactory: (config: T) => T;
              inject: [string];
              };

                interface ConfigGetOptions

                interface ConfigGetOptions {}

                  property infer

                  infer: true;
                  • If present, "get" method will try to automatically infer a type of property based on the type argument specified at the "ConfigService" class-level (example: ConfigService).

                  interface ConfigModuleOptions

                  interface ConfigModuleOptions {}

                    property cache

                    cache?: boolean;
                    • If "true", values from the process.env object will be cached in the memory. This improves the overall application performance. See: https://github.com/nodejs/node/issues/3104

                    property encoding

                    encoding?: string;
                    • Environment file encoding.

                    property envFilePath

                    envFilePath?: string | string[];
                    • Path to the environment file(s) to be loaded.

                    property expandVariables

                    expandVariables?: boolean | DotenvExpandOptions;
                    • A boolean value indicating the use of expanded variables, or object containing options to pass to dotenv-expand. If .env contains expanded variables, they'll only be parsed if this property is set to true.

                    property ignoreEnvFile

                    ignoreEnvFile?: boolean;
                    • If "true", environment files (.env) will be ignored.

                    property ignoreEnvVars

                    ignoreEnvVars?: boolean;
                    • If "true", predefined environment variables will not be validated.

                    property isGlobal

                    isGlobal?: boolean;
                    • If "true", registers ConfigModule as a global module. See: https://docs.nestjs.com/modules#global-modules

                    property load

                    load?: Array<ConfigFactory>;
                    • Array of custom configuration files to be loaded. See: https://docs.nestjs.com/techniques/configuration

                    property validate

                    validate?: (config: Record<string, any>) => Record<string, any>;
                    • Custom function to validate environment variables. It takes an object containing environment variables as input and outputs validated environment variables. If exception is thrown in the function it would prevent the application from bootstrapping. Also, environment variables can be edited through this function, changes will be reflected in the process.env object.

                    property validationOptions

                    validationOptions?: Record<string, any>;
                    • Schema validation options. See: https://joi.dev/api/?v=17.3.0#anyvalidatevalue-options

                    property validationSchema

                    validationSchema?: any;
                    • Environment variables validation schema (Joi).

                    Type Aliases

                    type ConfigFactory

                    type ConfigFactory<T extends ConfigObject = ConfigObject> =
                    () => ConfigFactoryReturnValue<T>;

                      type ConfigObject

                      type ConfigObject = Record<string, any>;

                        type ConfigType

                        type ConfigType<T extends (...args: any) => any> = T extends (
                        ...args: any
                        ) => infer ReturnVal
                        ? ReturnVal extends Promise<infer AsyncReturnVal>
                        ? AsyncReturnVal
                        : ReturnVal
                        : any;

                          type NoInferType

                          type NoInferType<T> = [T][T extends any ? 0 : never];

                            type Path

                            type Path<T> = keyof T extends string
                            ? PathImpl2<T> extends string | keyof T
                            ? PathImpl2<T>
                            : keyof T
                            : never;

                              type PathImpl

                              type PathImpl<T, Key extends keyof T> = Key extends string
                              ? T[Key] extends Record<string, any>
                              ?
                              | `${Key}.${PathImpl<T[Key], Exclude<keyof T[Key], keyof any[]>> &
                              string}`
                              | `${Key}.${Exclude<keyof T[Key], keyof any[]> & string}`
                              : never
                              : never;

                                type PathImpl2

                                type PathImpl2<T> = PathImpl<T, keyof T> | keyof T;

                                  type PathValue

                                  type PathValue<T, P extends Path<T>> = P extends `${infer Key}.${infer Rest}`
                                  ? Key extends keyof T
                                  ? Rest extends Path<T[Key]>
                                  ? PathValue<T[Key], Rest>
                                  : never
                                  : never
                                  : P extends keyof T
                                  ? T[P]
                                  : never;

                                    Package Files (11)

                                    Dependencies (4)

                                    Dev Dependencies (26)

                                    Peer Dependencies (3)

                                    Badge

                                    To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                    You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@nestjs/config.

                                    • Markdown
                                      [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@nestjs/config)
                                    • HTML
                                      <a href="https://www.jsdocs.io/package/@nestjs/config"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>