Rework optionals to use undefined instead of null (#2)

Author: amccarthy1

src/env.ts

@@ -7,10 +7,11 @@ const parseValue = <T>(
   const envVarName = declaration.variable ?? key
   const envValue = env[envVarName]
   if (typeof envValue === 'undefined') {
-    if (typeof declaration.defaultValue === 'undefined') {
+    if (!Object.prototype.hasOwnProperty.apply(declaration, ['defaultValue'])) {
       throw new Error(`No value specified for ${envVarName}`)
     }
-    if (declaration.validator) declaration.validator(declaration.defaultValue)
+    if (declaration.validator)
+      declaration.validator(declaration.defaultValue as T)
     return [key, declaration.defaultValue]
   }
   try {
@@ -27,6 +28,26 @@ export function optional<T>({
   defaultValue,
   validator,
   ...others
+}: Declaration<T>): Declaration<T | undefined> {
+  return {
+    parser,
+    defaultValue: defaultValue || undefined,
+    validator:
+      validator &&
+      ((value: T | undefined) => {
+        if (typeof value !== 'undefined') {
+          validator(value)
+        }
+      }),
+    ...others,
+  }
+}
+
+export function nullable<T>({
+  parser,
+  defaultValue,
+  validator,
+  ...others
 }: Declaration<T>): Declaration<T | null> {
   return {
     parser,

test/env.test.ts

@@ -4,6 +4,7 @@ import { EnumVar } from '../src'
 import { optional, TypedEnv } from '../src'
 import { IntVar } from '../src'
 import { StringVar } from '../src'
+import { nullable } from '../src/env'
 
 describe('TypedEnv', () => {
   test('basic parsing works', async () => {
@@ -110,15 +111,15 @@ describe('TypedEnv', () => {
     ).toThrow('too small')
   })
 
-  test('handles optional variables', async () => {
+  test('handles nullable variables', async () => {
     const rawEnv = {
       A: 'A',
     }
     expect(
       TypedEnv(
         {
-          A: optional(StringVar()),
-          B: optional(StringVar()),
+          A: nullable(StringVar()),
+          B: nullable(StringVar()),
         },
         rawEnv
       )
@@ -137,9 +138,9 @@ describe('TypedEnv', () => {
     delete process.env.SOME_RANDOM_VAR_NAME
   })
 
-  test("Validators don't fire for nulls on optionals", async () => {
+  test("Validators don't fire for nulls on nullables", async () => {
     const schema = {
-      A: optional(
+      A: nullable(
         IntVar({
           validator() {
             throw new Error('nope')
@@ -152,4 +153,26 @@ describe('TypedEnv', () => {
     expect(() => TypedEnv(schema, rawEnv)).toThrow('nope')
     expect(TypedEnv(schema, emptyEnv).A).toBeNull()
   })
+
+  test('Optionals return undefined instead of null', async () => {
+    const schema = {
+      A: optional(StringVar()),
+      B: optional(
+        StringVar({
+          validator() {
+            throw new Error('nope')
+          },
+        })
+      ),
+      C: optional(
+        StringVar({
+          validator() {
+            return true
+          },
+        })
+      ),
+    }
+    const emptyEnv = { C: 'foo' }
+    expect(TypedEnv(schema, emptyEnv).A).toBeUndefined()
+  })
 })