dotenv-safe

What is dotenv-safe?

The dotenv-safe npm package is used to load environment variables from a .env file into process.env, ensuring that all necessary environment variables are defined and preventing the application from running if any required variables are missing. It extends the functionality of the dotenv package by adding a layer of safety and validation.

What are dotenv-safe's main functionalities?

Load Environment Variables

This feature loads environment variables from a .env file into process.env, ensuring that all required variables are defined. If any required variables are missing, it will throw an error and prevent the application from running.

require('dotenv-safe').config();

Validation of Required Variables

This feature allows you to specify an example .env file that lists all required environment variables. The package will validate that all variables in the example file are present in the actual .env file, ensuring that no required variables are missing.

require('dotenv-safe').config({ example: './.env.example' });

Custom Path for .env File

This feature allows you to specify custom paths for both the .env file and the example file. This is useful if your environment files are located in a different directory.

require('dotenv-safe').config({ path: './config/.env', example: './config/.env.example' });

Other packages similar to dotenv-safe

dotenv

The dotenv package is a simpler version of dotenv-safe. It loads environment variables from a .env file into process.env but does not include validation of required variables. It is useful for basic use cases where validation is not necessary.

env-cmd

The env-cmd package allows you to specify environment variables in a JSON or .env file and load them into your application. It also supports multiple environment files for different environments (e.g., development, production). However, it does not provide the same level of validation as dotenv-safe.

envalid

The envalid package is a more advanced alternative that not only loads environment variables but also validates and sanitizes them. It provides a more robust solution for ensuring that environment variables are correctly defined and of the correct type. It is more feature-rich compared to dotenv-safe but may require more setup.

README

dotenv-safe

Identical to dotenv, but ensures that all needed environment variables are defined after reading from .env. The names of the needed variables are read from .env.example, which should be commited along with your project.

dotenv-safe only checks if all the needed variable names exist in process.env after initialising. It does not assume anything about the presence, format or validity of the values.

Installation

npm install dotenv-safe

pnpm install dotenv-safe

yarn add dotenv-safe

Example

# .env.example, committed to repo
SECRET=
TOKEN=
KEY=

# .env, private
SECRET=topsecret
TOKEN=

// index.js
require('dotenv-safe').config();

Or, if you are using ES modules:

// index.mjs
import { config } from 'dotenv-safe';
config();

Since the provided .env file does not contain all the variables defined in .env.example, an exception is thrown:

MissingEnvVarsError: The following variables were defined in .env.example but are not present in the environment:
  TOKEN, KEY
Make sure to add them to .env or directly to the environment.

If you expect any of these variables to be empty, you can use the allowEmptyValues option:
require('dotenv-safe').config({
  allowEmptyValues: true
});

Not all the variables have to be defined in .env; they can be supplied externally. For example, the following would work:

$ TOKEN=abc KEY=xyz node index.js

Usage

Requiring and loading is identical:

require('dotenv-safe').config();

This will load environment variables from .env as usual, but will also read any variables defined in .env.example. If any variables are already defined in the environment before reading from .env, they will not be overwritten. If any variables are missing from the environment, a MissingEnvVarsError will be thrown, which lists the missing variables. Otherwise, returns an object with the following format:

{
  parsed: { SECRET: 'topsecret', TOKEN: '' },          // parsed representation of .env
  required: { SECRET: 'topsecret', TOKEN: 'external' } /* key-value pairs required by .env.example
                                                          and defined by environment */
}

If all the required variables were successfully read but an error was thrown when trying to read the .env file, the error will be included in the result object under the error key.

dotenv-safe compares the actual environment after loading .env (if any) with the example file, so it will work correctly if environment variables are missing in .env but provided through other means such as a shell script.

Preloading

You can use the --require (-r) command line option to preload dotenv-safe. By doing this, you do not need to require and load dotenv in your application code. This is the preferred approach when using import instead of require.

$ node -r dotenv-safe/config your_script.js

See the dotenv README for more information.

Continuous integration (CI)

It can be useful to depend on a different set of example variables when running in a CI environment. This can be done by checking if the CI environment variable is defined, which is supported by virtually all CI solutions. For example:

require('dotenv-safe').config({
  example: process.env.CI ? '.env.ci.example' : '.env.example'
});

Options

Same options and methods supported by dotenv, in addition to the options below:

require('dotenv-safe').config({
    allowEmptyValues: true,
    example: './.my-env-example-filename'
});

Starting from version 9.0.0, dotenv is a peer dependency of dotenv-safe. This means that the actual version of dotenv used defaults to the latest available at install time, or whatever is specified by your application.

allowEmptyValues

If a variable is defined in the example file and has an empty value in the environment, enabling this option will not throw an error after loading. Defaults to false.

example

Path to example environment file. Defaults to .env.example.

Motivation

I regularly use apps that depend on .env files but don't validate if all the necessary variables have been defined correctly. Instead of having to document and validate this manually, I prefer to commit a self-documenting .env.example file that may have placeholder or example values filled in. This can be used as a template or starting point for an actual .env file.