Configuration Management in Node.js

dotenv and config Package

Effective configuration management is crucial for software development, particularly when building an application operating across various development, staging, and production environments. In Node.js with TypeScript, configuration management can be implemented efficiently. In this post, we will showcase two approaches to configuration management: utilizing the dotenv and condfig`packages

Setting up the Environment

Before we get started, ensure that Node.js and TypeScript are installed on your system. To initialize your Node.js project and install TypeScript, use the following commands:

$ mkdir node-ts-config
$ cd node-ts-config
$ npm init -y
$ npm install -D typescript ts-node

Next, create a tsconfig.json file to manage your TypeScript configurations:

{
    "compilerOptions": {
        "target": "ES2020",
        "module": "commonjs",
        "outDir": "dist",
        "strict": true,
        "esModuleInterop": true,
        "skipLibCheck": true,
        "forceConsistentCasingInFileNames": true
    }
}

Method 1: Using dotenv for Configuration Management

The first method involves using dotenv, a module that loads environment variables from a .env file into process.env.

Install dotenv and its types as follows:

$ npm install dotenv
$ npm install -D @types/dotenv

Create a new .env file in your project root directory and add your configuration:

DB_HOST=localhost
DB_USER=root
DB_PASS=s1mpl3

Then, create a configuration file to load these variables and expose them:

import dotenv from 'dotenv';

dotenv.config();

interface Config {
    db: {
        host: string,
        user: string,
        pass: string
    }
}

const config: Config = {
    db: {
        host: process.env.DB_HOST || '',
        user: process.env.DB_USER || '',
        pass: process.env.DB_PASS || ''
    }
}

export default config;

You can now import this configuration into your project:

import config from './config';

console.log(config.db.host);
console.log(config.db.user);
console.log(config.db.pass);

This approach allows separate configurations for different environments by creating .env.development, .env.staging, and .env.production files and loading the correct .env file based on the current NODE_ENV.

Method 2: Using the config Package for Configuration Management

The second method involves using the npm config package, which stores configurations in a config directory.

Install the config package as follows:

$ npm install config

Create a new directory named config and a configuration file inside it:

$ mkdir config
$ touch config/default.ts

Add your default configurations into default.ts:

const config = {
    db: {
        host: 'localhost',
        user: 'root',
        pass: 's1mpl3',
    },
};

export default config;

The config package automatically reads the configuration files based on the current NODE_ENV. Here's how you can import and use the configuration:

import config from 'config';

const dbConfig = config.get('db');

console.log(dbConfig.host);
console.log(dbConfig.user);
console.log(dbConfig.pass);

This method also supports different configurations for different environments by creating development.ts, staging.ts, and production.ts files in the config directory. The config package automatically chooses the correct file based on NODE_ENV.

Conclusion

We've discussed two techniques for managing configurations in a TypeScript Node.js application. These methods involve using either the dotenv package or the config package. Both options offer a resilient and adaptable approach to configuration handling by keeping them separate from the code. This makes it easier to adjust the application to different environments. The decision on which technique to use typically depends on the project's specific requirements and one's own preferences.