Add the ability to pass multiple env keys (#159)

* Add the ability to pass multiple env keys

* Fix linter errors

packages/backend-tools/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @l2beat/backend-tools
 
+## 0.5.2
+
+### Patch Changes
+
+- Add the ability to pass multiple env variable keys
+
 ## 0.5.1
 
 ### Patch Changes

packages/backend-tools/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@l2beat/backend-tools",
   "description": "Common utilities for L2BEAT projects.",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "license": "MIT",
   "repository": "https://github.com/l2beat/tools",
   "bugs": {

packages/backend-tools/src/env.test.ts

@@ -20,6 +20,12 @@ describe(Env.name, () => {
       const env = new Env({})
       expect(() => env.string('TEST_A')).toThrow()
     })
+
+    it('supports array keys', () => {
+      const env = new Env({ TEST_A: 'foo', TEST_C: 'bar' })
+      expect(env.string(['TEST_B', 'TEST_A'])).toEqual('foo')
+      expect(env.string(['TEST_C', 'TEST_A'])).toEqual('bar')
+    })
   })
 
   describe(Env.prototype.integer.name, () => {
@@ -44,6 +50,12 @@ describe(Env.name, () => {
       const env = new Env({ TEST_A: 'foo' })
       expect(() => env.integer('TEST_A')).toThrow()
     })
+
+    it('supports array keys', () => {
+      const env = new Env({ TEST_A: '69', TEST_C: '-420' })
+      expect(env.integer(['TEST_B', 'TEST_A'])).toEqual(69)
+      expect(env.integer(['TEST_C', 'TEST_A'])).toEqual(-420)
+    })
   })
 
   describe(Env.prototype.boolean.name, () => {
@@ -68,5 +80,11 @@ describe(Env.name, () => {
       const env = new Env({ TEST_A: '69' })
       expect(() => env.boolean('TEST_A')).toThrow()
     })
+
+    it('supports array keys', () => {
+      const env = new Env({ TEST_A: 'true', TEST_C: 'false' })
+      expect(env.boolean(['TEST_B', 'TEST_A'])).toEqual(true)
+      expect(env.boolean(['TEST_C', 'TEST_A'])).toEqual(false)
+    })
   })
 })

packages/backend-tools/src/env.ts

@@ -8,66 +8,92 @@ export function getEnv(): Env {
 export class Env {
   constructor(private readonly env: Record<string, string | undefined>) {}
 
-  string(key: string, fallback?: string): string {
+  private resolve(
+    key: string | string[],
+  ): { value: string; key: string } | undefined {
+    if (Array.isArray(key)) {
+      for (const k of key) {
+        const value = this.env[k]
+        if (value !== undefined) {
+          return { value, key: k }
+        }
+      }
+      return undefined
+    }
     const value = this.env[key]
+    return value !== undefined ? { value, key } : value
+  }
+
+  string(key: string | string[], fallback?: string): string {
+    const value = this.optionalString(key)
     if (value !== undefined) {
       return value
     }
     if (fallback !== undefined) {
       return fallback
     }
-    throw new Error(`Missing environment variable ${key}!`)
+    throwMissingEnvVar(key)
   }
 
-  optionalString(key: string): string | undefined {
-    return this.env[key]
+  optionalString(key: string | string[]): string | undefined {
+    return this.resolve(key)?.value
   }
 
-  integer(key: string, fallback?: number): number {
+  integer(key: string | string[], fallback?: number): number {
     const value = this.optionalInteger(key)
     if (value !== undefined) {
       return value
     }
     if (fallback !== undefined) {
       return fallback
     }
-    throw new Error(`Missing environment variable ${key}!`)
+    throwMissingEnvVar(key)
   }
 
-  optionalInteger(key: string): number | undefined {
-    const value = this.env[key]
-    if (value !== undefined) {
-      const result = parseInt(value)
-      if (result.toString() === value) {
+  optionalInteger(key: string | string[]): number | undefined {
+    const resolved = this.resolve(key)
+    if (resolved) {
+      const result = parseInt(resolved.value)
+      if (result.toString() === resolved.value) {
         return result
       }
-      throw new Error(`Environment variable ${key} is not an integer!`)
+      throw new Error(`Environment variable ${resolved.key} is not an integer!`)
     }
   }
 
-  boolean(key: string, fallback?: boolean): boolean {
+  boolean(key: string | string[], fallback?: boolean): boolean {
     const value = this.optionalBoolean(key)
     if (value !== undefined) {
       return value
     }
     if (fallback !== undefined) {
       return fallback
     }
-    throw new Error(`Missing environment variable ${key}!`)
+    throwMissingEnvVar(key)
   }
 
-  optionalBoolean(key: string): boolean | undefined {
-    const value = this.env[key]
-    if (value !== undefined) {
-      const lowerCased = value.toLowerCase()
+  optionalBoolean(key: string | string[]): boolean | undefined {
+    const resolved = this.resolve(key)
+    if (resolved) {
+      const lowerCased = resolved.value.toLowerCase()
 
       const trueValues = ['true', 'yes', '1']
       const falseValues = ['false', 'no', '0']
 
       if (trueValues.includes(lowerCased)) return true
       if (falseValues.includes(lowerCased)) return false
 
-      throw new Error(`Environment variable ${key} is not a boolean value!`)
+      throw new Error(
+        `Environment variable ${resolved.key} is not a boolean value!`,
+      )
     }
   }
 }
+
+function throwMissingEnvVar(keys: string | string[]): never {
+  if (Array.isArray(keys)) {
+    throw new Error(`Missing environment variables: ${keys.join(', ')}!`)
+  } else {
+    throw new Error(`Missing environment variable: ${keys}!`)
+  }
+}