Refactor validation

Author: amccarthy1

src/date.ts

@@ -1,18 +1,12 @@
 import type { Declaration, OptionalProps } from './types'
 
-type Params = {
-  validator?: (value: Date) => void
-} & OptionalProps<Date>
-export function DateVar({
-  validator,
-  ...props
-}: Params = {}): Declaration<Date> {
+type Params = OptionalProps<Date>
+export function DateVar(props: Params = {}): Declaration<Date> {
   const parser = (value: string) => {
     const dateValue = new Date(value)
     if (dateValue.toString() === 'Invalid Date') {
       throw new Error('Value did not match a valid date format!')
     }
-    if (validator) validator(dateValue)
     return dateValue
   }
   return {

src/env.ts

@@ -10,10 +10,13 @@ const parseValue = <T>(
     if (typeof declaration.defaultValue === 'undefined') {
       throw new Error(`No value specified for ${envVarName}`)
     }
+    if (declaration.validator) declaration.validator(declaration.defaultValue)
     return [key, declaration.defaultValue]
   }
   try {
-    return [key, declaration.parser(envValue)]
+    const value: T = declaration.parser(envValue)
+    if (declaration.validator) declaration.validator(value)
+    return [key, value]
   } catch (error) {
     throw new Error(`Error while parsing env var ${envVarName}: ${error}`)
   }
@@ -22,11 +25,19 @@ const parseValue = <T>(
 export function optional<T>({
   parser,
   defaultValue,
+  validator,
   ...others
 }: Declaration<T>): Declaration<T | null> {
   return {
     parser,
     defaultValue: defaultValue || null,
+    validator:
+      validator &&
+      ((value: T | null) => {
+        if (value !== null) {
+          validator(value)
+        }
+      }),
     ...others,
   }
 }

src/index.ts

@@ -4,4 +4,4 @@ export { EnumVar } from './enum'
 export { IntVar } from './integer'
 export { StringVar } from './string'
 export { optional, TypedEnv } from './env'
-export type { Declaration, Parser } from './types'
+export type { Declaration, Parser, Validator } from './types'

src/integer.ts

@@ -1,23 +1,17 @@
 import type { Declaration, OptionalProps } from './types'
 
-type Params = {
-  validator?: (intValue: number) => void
-} & OptionalProps<number>
+type Params = OptionalProps<number>
 
 const invalidIntMessage = 'Value is not an integer!'
 
-export function IntVar({
-  validator,
-  ...props
-}: Params = {}): Declaration<number> {
+export function IntVar(props: Params = {}): Declaration<number> {
   const parser = (value: string) => {
     if (value.trim() === '') {
       // Special case; whitespace-only string will parse but should not.
       throw new Error(invalidIntMessage)
     }
     const numberValue = Number(value)
     if (!Number.isInteger(numberValue)) throw new Error(invalidIntMessage)
-    if (validator) validator(numberValue)
     return numberValue
   }
   return {

src/string.ts

@@ -2,20 +2,17 @@ import type { Declaration, OptionalProps } from './types'
 
 type Params = {
   pattern?: RegExp
-  validator?: (value: string) => void
 } & OptionalProps<string>
 
 export function StringVar({
   pattern,
-  validator,
   ...props
 }: Params = {}): Declaration<string> {
   const parser = (value: string) => {
     if (pattern) {
       if (!pattern.exec(value))
         throw new Error(`Did not match pattern ${pattern}`)
     }
-    if (validator) validator(value)
     return value
   }
   return {

src/types.ts

@@ -1,8 +1,10 @@
 export type Parser<T> = (value: string) => T
+export type Validator<T> = (value: T) => void
 
 export type OptionalProps<T> = {
   variable?: string
   defaultValue?: T
+  validator?: Validator<T>
 }
 
 export type Declaration<T> = {

test/date.test.ts

@@ -19,17 +19,3 @@ test('Throws for invalid date formats', async () => {
     'Value did not match a valid date format!'
   )
 })
-
-test('Supports custom validators', async () => {
-  const datevar = DateVar({
-    validator: (v) => {
-      if (v < new Date('2011-11-11')) {
-        throw new Error(
-          'This date precedes the release of The Elder Scrolls V: Skyrim!'
-        )
-      }
-    },
-  })
-  expect(() => datevar.parser('11/10/11')).toThrow('Skyrim')
-  expect(() => datevar.parser('11/11/11')).not.toThrow('Skyrim')
-})

test/enum.test.ts

@@ -1,12 +1,18 @@
 import { EnumVar } from '../src/enum'
 
-test('Enums work', async () => {
+describe('EnumVar', () => {
   const envOptions = ['dev', 'staging', 'prod'] as const
   const enumVar = EnumVar({ options: envOptions })
-  expect(enumVar.parser('dev')).toEqual('dev')
-  expect(enumVar.parser('staging')).toEqual('staging')
-  expect(enumVar.parser('prod')).toEqual('prod')
-  expect(() => enumVar.parser('production')).toThrow(
-    'Value did not match one of dev,staging,prod'
-  )
+
+  test('can handle success cases', async () => {
+    expect(enumVar.parser('dev')).toEqual('dev')
+    expect(enumVar.parser('staging')).toEqual('staging')
+    expect(enumVar.parser('prod')).toEqual('prod')
+  })
+
+  test('can handle failure cases', async () => {
+    expect(() => enumVar.parser('production')).toThrow(
+      'Value did not match one of dev,staging,prod'
+    )
+  })
 })

test/env.test.ts

@@ -97,6 +97,19 @@ describe('TypedEnv', () => {
     expect(TypedEnv(schema, envWithB).A).toEqual('Real Value')
   })
 
+  test('runs validation on default values', async () => {
+    expect(() =>
+      TypedEnv({
+        A: IntVar({
+          defaultValue: 1,
+          validator(v) {
+            if (v < 2) throw new Error('too small')
+          },
+        }),
+      })
+    ).toThrow('too small')
+  })
+
   test('handles optional variables', async () => {
     const rawEnv = {
       A: 'A',
@@ -123,4 +136,20 @@ describe('TypedEnv', () => {
     expect(TypedEnv(schema).SOME_RANDOM_VAR_NAME).toEqual('SOME_VALUE')
     delete process.env.SOME_RANDOM_VAR_NAME
   })
+
+  test("Validators don't fire for nulls on optionals", async () => {
+    const schema = {
+      A: optional(
+        IntVar({
+          validator() {
+            throw new Error('nope')
+          },
+        })
+      ),
+    }
+    const rawEnv = { A: '1' }
+    const emptyEnv = {}
+    expect(() => TypedEnv(schema, rawEnv)).toThrow('nope')
+    expect(TypedEnv(schema, emptyEnv).A).toBeNull()
+  })
 })

test/integer.test.ts

@@ -0,0 +1,24 @@
+import { IntVar } from '../src/integer'
+
+describe('IntVar', () => {
+  test('can parse base 10 integers', async () => {
+    const intvar = IntVar()
+    expect(intvar.parser('12345')).toEqual(12345)
+    expect(intvar.parser('-54321')).toEqual(-54321)
+    expect(() => intvar.parser('1.5')).toThrow()
+  })
+
+  test('can parse bases other than 10', async () => {
+    const intvar = IntVar()
+    expect(intvar.parser('0xffff')).toEqual(0xffff)
+    expect(intvar.parser('0b101101101')).toEqual(365)
+    expect(() => intvar.parser('0xfffg')).toThrow('not an integer')
+  })
+
+  test('throws errors for random garbage', async () => {
+    const intvar = IntVar()
+    expect(() => intvar.parser('')).toThrow('not an integer')
+    expect(() => intvar.parser(' ')).toThrow('not an integer')
+    expect(() => intvar.parser('false')).toThrow('not an integer')
+  })
+})