feat: display all validation errors at once

Closes #5

Author: Julien-R44

package.json

@@ -55,7 +55,7 @@
     "prepublishOnly": "nr build",
     "release": "bumpp --commit --push --tag && pnpm publish",
     "start": "node --loader=ts-node/esm src/index.ts",
-    "test": "ts-node bin/test.ts",
+    "test": "cross-env NODE_ENV=testing ts-node bin/test.ts",
     "test:watch": "nodemon --ignore ./tests/fixtures bin/test.ts",
     "typecheck": "tsc --noEmit"
   },
@@ -69,6 +69,7 @@
     }
   },
   "dependencies": {
+    "@poppinss/colors": "^3.0.2",
     "@poppinss/validator-lite": "^1.0.1",
     "unconfig": "^0.3.6",
     "validator": "^13.7.0"
@@ -83,6 +84,7 @@
     "@types/node": "^18.7.15",
     "@types/validator": "^13.7.6",
     "bumpp": "^8.2.1",
+    "cross-env": "^7.0.3",
     "eslint": "^8.23.0",
     "nodemon": "^2.0.19",
     "pnpm": "^7.11.0",

pnpm-lock.yaml

@@ -1,14 +1,9 @@
 import { cwd } from 'process'
 import { type Plugin, loadEnv } from 'vite'
 import { createConfigLoader as createLoader } from 'unconfig'
-import { Exception } from './exception'
-import type {
-  FullPluginOptions,
-  PluginOptions,
-  PoppinsSchema,
-  Schema,
-  ZodSchema,
-} from './contracts'
+import { builtinValidation } from './validators/builtin'
+import { zodValidation } from './validators/zod'
+import type { FullPluginOptions, PluginOptions, Schema } from './contracts'
 import type { ConfigEnv, UserConfig } from 'vite'
 
 /**
@@ -29,33 +24,6 @@ async function loadConfig(rootDir: string) {
   return result.config
 }
 
-/**
- * Validate the env values with builtin validator
- */
-async function builtinValidation(env: Record<string, string>, schema: PoppinsSchema) {
-  for (const [key, validator] of Object.entries(schema!)) {
-    const res = validator(key, env[key])
-    process.env[key] = res
-  }
-}
-
-/**
- * Validate the env values with Zod validator
- */
-async function zodValidation(env: Record<string, string>, schema: ZodSchema) {
-  for (const [key, validator] of Object.entries(schema!)) {
-    const result = validator.safeParse(env[key])
-
-    if (!result.success) {
-      throw new Exception(
-        `E_INVALID_ENV_VALUE: Invalid value for "${key}" : ${result.error.issues[0].message}`,
-        'E_INVALID_ENV_VALUE'
-      )
-    }
-    process.env[key] = result.data
-  }
-}
-
 /**
  * Returns the schema and the validator
  */

src/index.ts

@@ -0,0 +1,3 @@
+import { Colors, FakeColors } from '@poppinss/colors'
+
+export const colors = process.env.NODE_ENV === 'testing' ? new FakeColors() : new Colors()

src/utils/colors.ts

@@ -0,0 +1,36 @@
+import { colors } from '../../utils/colors'
+import type { PoppinsSchema } from '../../contracts'
+
+export function errorReporter(errors: any[]) {
+  let finalMessage = colors.red('Failed to validate environment variables : \n')
+
+  for (const error of errors) {
+    const errorKey = `[${colors.magenta(error.key)}]`
+    finalMessage += `\n${errorKey}: \n`
+
+    const message = error.err.message.replace(`${error.err.code}: `, '')
+    finalMessage += `  ${colors.yellow(message)} \n`
+  }
+
+  return finalMessage as string
+}
+
+/**
+ * Validate the env values with builtin validator
+ */
+export function builtinValidation(env: Record<string, string>, schema: PoppinsSchema) {
+  const errors = []
+
+  for (const [key, validator] of Object.entries(schema!)) {
+    try {
+      const res = validator(key, env[key])
+      process.env[key] = res
+    } catch (err) {
+      errors.push({ key, err })
+    }
+  }
+
+  if (errors.length) {
+    throw new Error(errorReporter(errors))
+  }
+}

src/validators/builtin/index.ts

@@ -0,0 +1,38 @@
+import { colors } from '../../utils/colors'
+import type { ZodSchema } from 'zod'
+
+export function errorReporter(errors: any[]) {
+  let finalMessage = colors.red('Failed to validate environment variables : \n')
+
+  for (const error of errors) {
+    const errorKey = `[${colors.magenta(error.key)}]`
+    finalMessage += `\n${errorKey}: \n`
+
+    const message = `Invalid value for "${error.key}" : ${error.err.issues[0].message}`
+    finalMessage += `  ${colors.yellow(message)} \n`
+  }
+
+  return finalMessage as string
+}
+
+/**
+ * Validate the env values with Zod validator
+ */
+export async function zodValidation(env: Record<string, string>, schema: ZodSchema) {
+  const errors = []
+
+  for (const [key, validator] of Object.entries(schema!)) {
+    const result = validator.safeParse(env[key])
+
+    if (!result.success) {
+      errors.push({ key, err: result.error })
+      continue
+    }
+
+    process.env[key] = result.data
+  }
+
+  if (errors.length) {
+    throw new Error(errorReporter(errors))
+  }
+}

src/validators/zod/index.ts

@@ -1,3 +1,6 @@
+/* eslint-disable @typescript-eslint/prefer-ts-expect-error */
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+
 import { join } from 'path'
 import { test } from '@japa/runner'
 import { Filesystem } from '@poppinss/dev-utils'
@@ -13,46 +16,51 @@ test.group('vite-plugin-validate-env', (group) => {
   })
 
   test('Basic validation', async ({ assert }) => {
-    const plugin = ValidateEnv({
-      VITE_TEST: Schema.boolean(),
-    })
+    assert.plan(1)
 
+    const plugin = ValidateEnv({ VITE_TEST: Schema.boolean() })
     await fs.add(`.env.development`, `VITE_TEST=not boolean`)
 
-    // @ts-expect-error - `config` is the handler
-    const fn = plugin.config!.bind(plugin, viteConfig, viteEnvConfig)
-    await assert.rejects(
-      fn,
-      'E_INVALID_ENV_VALUE: Value for environment variable "VITE_TEST" must be a boolean, instead received "not boolean"'
-    )
+    try {
+      // @ts-ignore
+      await plugin.config(viteConfig, viteEnvConfig)
+    } catch (error: any) {
+      assert.include(error.message, '"VITE_TEST" must be a boolean')
+    }
   })
 
   test('Custom error message', async ({ assert }) => {
-    const plugin = ValidateEnv({
-      VITE_TEST: Schema.boolean({ message: 'Heyhey' }),
-    })
+    assert.plan(2)
 
+    const plugin = ValidateEnv({ VITE_TEST: Schema.boolean({ message: 'Heyhey' }) })
     await fs.add(`.env.development`, `VITE_TEST=not boolean`)
 
-    // @ts-expect-error - `config` is the handler
-    const fn = plugin.config!.bind(plugin, viteConfig, viteEnvConfig)
-    await assert.rejects(fn, 'E_INVALID_ENV_VALUE: Heyhey')
+    try {
+      // @ts-ignore
+      await plugin.config(viteConfig, viteEnvConfig)
+    } catch (error: any) {
+      assert.include(error.message, 'VITE_TEST')
+      assert.include(error.message, 'Heyhey')
+    }
   })
 
   test('Custom validator method', async ({ assert }) => {
+    assert.plan(1)
+
     const plugin = ValidateEnv({
       VITE_TEST: (_key, value) => {
-        if (value !== 'valid') {
-          throw new Error('Value must be "valid"')
-        }
+        if (value !== 'valid') throw new Error('Value must be "valid"')
       },
     })
 
     await fs.add(`.env.development`, `VITE_TEST=not valid`)
 
-    // @ts-expect-error - `config` is the handler
-    const fn = plugin.config!.bind(plugin, viteConfig, viteEnvConfig)
-    await assert.rejects(fn, 'Value must be "valid"')
+    try {
+      // @ts-ignore
+      await plugin.config(viteConfig, viteEnvConfig)
+    } catch (error: any) {
+      assert.include(error.message, 'Value must be "valid"')
+    }
   })
 
   test('Parsing result', async ({ assert }) => {
@@ -72,12 +80,14 @@ test.group('vite-plugin-validate-env', (group) => {
 
     await fs.add(`.env.development`, `VITE_URL_TRAILING=test.com`)
 
-    // @ts-expect-error - `config` is the handler
+    // @ts-ignore
     await plugin.config!(viteConfig, viteEnvConfig)
     assert.equal(process.env.VITE_URL_TRAILING, 'test.com/')
   })
 
   test('Dedicated config file', async ({ assert }) => {
+    assert.plan(1)
+
     const plugin = ValidateEnv()
 
     await fs.add(`.env.development`, `VITE_MY_VAR=true`)
@@ -90,9 +100,12 @@ test.group('vite-plugin-validate-env', (group) => {
     }`
     )
 
-    // @ts-expect-error - `config` is the handler
-    const fn = plugin.config!.bind(plugin, viteConfig, viteEnvConfig)
-    await assert.rejects(fn, 'Error validating')
+    try {
+      // @ts-ignore
+      await plugin.config(viteConfig, viteEnvConfig)
+    } catch (error: any) {
+      assert.include(error.message, 'Error validating')
+    }
   })
 
   test('Should fail if no schema is found', async ({ assert }) => {
@@ -106,17 +119,39 @@ test.group('vite-plugin-validate-env', (group) => {
   })
 
   test('Should pick up var with custom prefix', async ({ assert }) => {
+    assert.plan(1)
+
+    const plugin = ValidateEnv({ CUSTOM_TEST: Schema.boolean() })
+
+    await fs.add(`.env.development`, `CUSTOM_TEST=not boolean`)
+
+    try {
+      // @ts-ignore
+      await plugin.config({ ...viteConfig, envPrefix: 'CUSTOM_' }, viteEnvConfig)
+    } catch (error: any) {
+      assert.include(
+        error.message,
+        'Value for environment variable "CUSTOM_TEST" must be a boolean, instead received "not boolean"'
+      )
+    }
+  })
+
+  test('Display multiple errors', async ({ assert }) => {
+    assert.plan(2)
+
     const plugin = ValidateEnv({
-      CUSTOM_TEST: Schema.boolean(),
+      VITE_TEST: Schema.boolean(),
+      VITE_TEST2: Schema.boolean(),
     })
 
-    await fs.add(`.env.development`, `CUSTOM_TEST=not boolean`)
+    await fs.add(`.env.development`, '')
 
-    // @ts-expect-error - `config` is the handler
-    const fn = plugin.config!.bind(plugin, { ...viteConfig, envPrefix: 'CUSTOM_' }, viteEnvConfig)
-    await assert.rejects(
-      fn,
-      'E_INVALID_ENV_VALUE: Value for environment variable "CUSTOM_TEST" must be a boolean, instead received "not boolean"'
-    )
+    try {
+      // @ts-ignore
+      await plugin.config(viteConfig, viteEnvConfig)
+    } catch (error: any) {
+      assert.include(error.message, 'Missing environment variable "VITE_TEST"')
+      assert.include(error.message, 'Missing environment variable "VITE_TEST2"')
+    }
   })
 })