Add support for loading env values

.vscode/launch.json

@@ -0,0 +1,21 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "node",
+            "name": "vscode-jest-tests",
+            "request": "launch",
+            "args": [
+                "--runInBand"
+            ],
+            "cwd": "${workspaceFolder}",
+            "console": "integratedTerminal",
+            "internalConsoleOptions": "neverOpen",
+            "disableOptimisticBPs": true,
+            "program": "${workspaceFolder}/node_modules/jest/bin/jest"
+        }
+    ]
+}

src/index.ts

@@ -1,3 +1,4 @@
+import parseEnvFile from './parser';
 import { EnvVarSymbols, UndefinedEnvVars } from './types/EnvVars';
 import { SymbolWithDescription } from './types/helpers';
 import { InternalOptions, Options } from './types/Options';
@@ -7,6 +8,7 @@ let _symbolizedEnvVars: Record<string, SymbolWithDescription>;
 let _options: InternalOptions = {
   required: {},
   optional: {},
+  options: {},
 };
 
 const createSymbol = (description: string): SymbolWithDescription => Symbol(description) as SymbolWithDescription;
@@ -36,13 +38,17 @@ function symbolizeVars<T>(input: Record<string, string>) {
 export default function setEnv<T extends UndefinedEnvVars, V extends UndefinedEnvVars>(
   options: Options<T, V>,
 ): {
-  readonly [K in keyof (T & Partial<V>)]: (T & Partial<V>)[K];
-} {
+    readonly [K in keyof (T & Partial<V>)]: (T & Partial<V>)[K];
+  } {
   _options = {
     ..._options,
     ...options,
   };
 
+  if (_options.options.loadDotEnv) {
+    parseEnvFile(_options.options);
+  }
+
   const symbolizedRequiredEnvVars = symbolizeVars<EnvVarSymbols<T>>(_options.required);
   _requiredEnvVars = Object.values(symbolizedRequiredEnvVars);
 

src/parser.ts

@@ -0,0 +1,50 @@
+import * as fs from 'fs';
+import { join } from 'path';
+import { ConfigOptions } from './types/Options';
+
+function parseLine(line: string): Record<string, string> {
+  const delimiter = '=';
+  const lineRegex = /^\s*[a-zA-Z_][a-zA-Z0-9_]*\s*="?'?.*'?"?$/g;
+  let [key, val] = line.split(delimiter);
+
+  // Ignore comments, or lines which don't conform to acceptable patterns
+  if (key.startsWith('#') || key.startsWith('//') || !lineRegex.test(line)) {
+    return {};
+  }
+
+  key = key.trim();
+  val = val.trim();
+  // Get rid of wrapping double or single quotes
+  if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
+    val = val.substr(1, val.length - 2);
+  }
+
+  return { [key]: val };
+}
+
+export function parseEnvFile(options: ConfigOptions = {}): void {
+  const fullPath = options.envFile || join(process.cwd(), '.env');
+
+  if (!fs.existsSync(fullPath)) {
+    return;
+  }
+
+  const envFileContents = fs.readFileSync(fullPath).toString();
+  let envVarPairs: Record<string, string> = {};
+  const eol = /\r?\n/;
+
+  const lines = envFileContents.split(eol);
+  lines.forEach((line: string) => {
+    envVarPairs = { ...envVarPairs, ...parseLine(line) };
+  });
+
+  // Toss everything into the environment
+  Object.entries(envVarPairs).forEach(([key, val]) => {
+    // Prefer env vars that have been set by the OS
+    if (key in process.env === false) {
+      process.env[key] = val;
+    }
+  });
+}
+
+export default parseEnvFile;

src/test/index.test.ts

@@ -1,9 +1,13 @@
 import 'jest';
+import fs from 'fs';
 import setEnvDefault from '..';
+import parseEnvFile from '../parser';
 
 describe('simple-env', () => {
   // Fresh setEnv for each test
   let setEnv: typeof setEnvDefault;
+  const readFileSpy = jest.spyOn(fs, 'readFileSync');
+  const existsSyncSpy = jest.spyOn(fs, 'existsSync');
 
   beforeEach(async () => {
     // Reset module cache and dynamically import it again
@@ -54,6 +58,7 @@ describe('simple-env', () => {
 
   describe('set', () => {
     afterEach(() => {
+      process.env = {};
       jest.resetModules();
     });
 
@@ -99,5 +104,98 @@ describe('simple-env', () => {
       expect(Object.getOwnPropertyDescriptors(env)).not.toHaveProperty('something');
       expect(Object.getOwnPropertyDescriptors(env)).toHaveProperty('somethingElse');
     });
+
+    it('will invoke the parser is loadDotEnv is true', () => {
+      existsSyncSpy.mockReturnValue(true);
+      readFileSpy.mockImplementation(() => Buffer.from('TEST=test'));
+
+      setEnv({ optional: { something: 'SOMETHING' }, options: { loadDotEnv: true } });
+
+      expect(process.env).toHaveProperty('TEST');
+    });
+
+    it('will not invoke the parser by default', () => {
+      existsSyncSpy.mockReturnValue(true);
+      readFileSpy.mockImplementation(() => Buffer.from('TEST=test'));
+
+      setEnv({ optional: { something: 'SOMETHING' } });
+
+      expect(process.env).not.toHaveProperty('TEST');
+    });
+  });
+
+  describe('parser', () => {
+    beforeEach(() => {
+      process.env = {};
+    });
+
+    afterEach(() => {
+      jest.resetModules();
+    });
+
+    it('will not overwrite vars that already exist', () => {
+      const originalValue = 'I already exist';
+      const newValue = 'I should not';
+      process.env = { TEST: originalValue };
+
+      readFileSpy.mockImplementation(() => Buffer.from(`TEST=${newValue}`));
+      existsSyncSpy.mockReturnValue(true);
+
+      parseEnvFile();
+
+      expect(process.env.TEST).toEqual(originalValue);
+    });
+
+    it('will reject malformed lines', () => {
+      const fakeFile =
+      `
+      bad
+      good=this
+      4=bad
+      good2='this'
+      good3="this"
+      `;
+      readFileSpy.mockImplementation(() => Buffer.from(fakeFile));
+      existsSyncSpy.mockReturnValue(true);
+
+      parseEnvFile();
+
+      expect(process.env.good).toEqual('this');
+      expect(process.env.good2).toEqual('this');
+      expect(process.env.good3).toEqual('this');
+    });
+
+    it('will ignore comments in the file', () => {
+      const fakeFile =
+      `
+      #comment\n
+      //comment\n
+      TEST=test
+      `;
+      readFileSpy.mockImplementation(() => Buffer.from(fakeFile));
+      existsSyncSpy.mockReturnValue(true);
+
+      parseEnvFile();
+
+      expect(process.env.TEST).toEqual('test');
+    });
+
+    it('will not do anything if the .env file does not exist', () => {
+      readFileSpy.mockImplementation(() => Buffer.from('TEST=test'));
+      existsSyncSpy.mockReturnValue(false);
+
+      parseEnvFile();
+
+      expect(process.env.TEST).toBeUndefined();
+    });
+
+    it('will read an env variable from a .env file into process.env', () => {
+      readFileSpy.mockImplementation(() => Buffer.from('TEST=test'));
+      existsSyncSpy.mockReturnValue(true);
+
+      parseEnvFile();
+
+      expect(process.env.TEST).toEqual('test');
+    });
   });
 });

src/types/Options.ts

@@ -1,9 +1,15 @@
 import { DefaultEnvVars, UndefinedEnvVars } from './EnvVars';
 import { RemoveKeys } from './helpers';
 
+export interface ConfigOptions {
+  envFile?: string;
+  loadDotEnv?: boolean;
+}
+
 export interface Options<Required extends UndefinedEnvVars = DefaultEnvVars, Optional extends UndefinedEnvVars = DefaultEnvVars> {
   required?: Required;
   optional?: RemoveKeys<Optional, keyof Required>;
+  options?: ConfigOptions;
 }
 
 export interface InternalOptions extends Omit<Required<Options>, 'optional'> {