Mastering TypeScript Environment Variables

Table of Contents#

1. Fundamental Concepts of TypeScript Environment Variables
2. Usage Methods
3. Common Practices
4. Best Practices
5. Conclusion
6. References

Fundamental Concepts of TypeScript Environment Variables#

What are Environment Variables?#

Environment variables are dynamic-named values that can affect the way running processes will behave on a computer. They are used to store configuration information such as API keys, database connection strings, and other sensitive or environment-specific data. In a Node.js application (which TypeScript often compiles to), environment variables are stored in the process.env object.

Why Use TypeScript with Environment Variables?#

TypeScript's type system allows us to catch errors related to environment variables at compile-time rather than at runtime. By defining types for our environment variables, we can ensure that the values we expect are present and of the correct type. This helps in writing more robust and maintainable code.

Usage Methods#

Setting Environment Variables#

In a development environment, we can set environment variables in several ways:

1. Using .env Files#

The dotenv package is a popular way to load environment variables from a .env file into process.env in a Node.js application. First, install the dotenv package:

npm install dotenv

Create a .env file in the root of your project:

API_KEY=your_api_key
DB_CONNECTION_STRING=mongodb://localhost:27017/your_database

In your TypeScript file, load the .env file:

import * as dotenv from 'dotenv';
dotenv.config();
 
const apiKey = process.env.API_KEY;
const dbConnectionString = process.env.DB_CONNECTION_STRING;
 
console.log(apiKey, dbConnectionString);

2. Setting Environment Variables in the Terminal#

You can also set environment variables directly in the terminal:

export API_KEY=your_api_key
node dist/index.js

Typing Environment Variables#

To take advantage of TypeScript's type system, we can create an interface to define the shape of our environment variables.

interface EnvVariables {
    API_KEY: string;
    DB_CONNECTION_STRING: string;
}
 
const env: EnvVariables = {
    API_KEY: process.env.API_KEY as string,
    DB_CONNECTION_STRING: process.env.DB_CONNECTION_STRING as string
};
 
console.log(env.API_KEY);

Common Practices#

Separate Environment Configurations#

It's common to have different configurations for different environments. For example, you might have a .env.development, .env.staging, and .env.production file.

# Load development environment variables
dotenv.config({ path: '.env.development' });
 
# Load production environment variables
dotenv.config({ path: '.env.production' });

Keep Sensitive Information Secure#

Environment variables are often used to store sensitive information such as API keys and passwords. Make sure to add your .env file to your .gitignore file to prevent it from being committed to version control.

Best Practices#

Use a Validation Function#

To ensure that all required environment variables are set, we can create a validation function.

interface EnvVariables {
    API_KEY: string;
    DB_CONNECTION_STRING: string;
}
 
function validateEnv(): EnvVariables {
    const env: Partial<EnvVariables> = {};
 
    if (!process.env.API_KEY) {
        throw new Error('API_KEY environment variable is not set');
    }
    env.API_KEY = process.env.API_KEY;
 
    if (!process.env.DB_CONNECTION_STRING) {
        throw new Error('DB_CONNECTION_STRING environment variable is not set');
    }
    env.DB_CONNECTION_STRING = process.env.DB_CONNECTION_STRING;
 
    return env as EnvVariables;
}
 
const env = validateEnv();

Provide Default Values#

In some cases, it might be useful to provide default values for environment variables.

const apiKey = process.env.API_KEY || 'default_api_key';

Conclusion#

TypeScript environment variables are a powerful tool for managing configuration in your applications. By understanding the fundamental concepts, using the right usage methods, following common practices, and adopting best practices, you can write more reliable and maintainable code. Remember to keep your sensitive information secure and take advantage of TypeScript's type system to catch errors early.

References#

• dotenv package documentation
• Node.js process.env documentation
• TypeScript official documentation