refactor: some minor refactor

Author: Julien-R44

README.md

@@ -183,27 +183,30 @@ By using `env` instead of `import.meta.env` in your code, TypeScript will now th
 
 ## Validation without Vite
 
-If you want to load and validate your environment variables the same way the plugin would do it, but without actually running Vite, you can use the additionally exposed `loadAndValidateEnv` function:
+In some cases, you might want to validate environment variables outside of Vite and reuse the same schema. You can do so by using the `loadAndValidateEnv` function directly. This function will validate and also load the environment variables inside the `process.env` object.
+
+> ![WARNING]
+> `process.env` only accept string values, so don't be surprised if a `number` or `boolean` variable comes back as a string when accessing it after validation.
+
 
 ```ts
 import { loadAndValidateEnv } from '@julr/vite-plugin-validate-env';
 
 const env = await loadAndValidateEnv(
-  { // Simulated Vite configuration
+  {
     mode: 'development', // required
-    root: process.cwd(), // optional
-    envDir: process.cwd(), // optional
-    envPrefix: 'VITE_', // optional
+    root: import.meta.dirname, // optional
   },
-  { // Plugin options
+  { 
+    // Plugin options. Also optional if you 
+    // are using a dedicated `env.ts` file
     validator: 'builtin',
-    schema: {
-      VITE_MY_VAR: Schema.string()
-    },
+    schema: { VITE_MY_VAR: Schema.string() },
   },
 );
 
-Object.assign(process.env, env);
+console.log(env.VITE_MY_VAR);
+console.log(process.env.VITE_MY_VAR)
 ```
 
 ## 💖 Sponsors

src/index.ts

@@ -124,35 +124,30 @@ export const ValidateEnv = (options?: PluginOptions): Plugin => {
     // @ts-expect-error - only used for testing as we need to keep each instance of the plugin unique to a test
     ui: process.env.NODE_ENV === 'testing' ? ui : undefined,
     name: 'vite-plugin-validate-env',
-    config: ({ envDir, envPrefix, root }, { mode }) =>
-      validateEnv(ui, { envDir, envPrefix, root, mode }, options).then((variables) => ({
-        define: variables.reduce(
-          (acc, { key, value }) => {
-            acc[`import.meta.env.${key}`] = JSON.stringify(value)
-            return acc
-          },
-          {} as Record<string, string>,
-        ),
-      })),
+    config: async ({ envDir, envPrefix, root }, { mode }) => {
+      const env = await validateEnv(ui, { envDir, envPrefix, root, mode }, options)
+      const define = Object.fromEntries(
+        env.map(({ key, value }) => [`import.meta.env.${key}`, JSON.stringify(value)]),
+      )
+
+      return { define }
+    },
   }
 }
 
 /**
- * Load environment variables using the provided Vite configuration
- * and validate them against a schema the same way `ValidateEnv` does it
- * @returns An object mapping environment variable names to validation results
+ * Validate environment variables and load them inside `process.env`
+ * Can be useful when you want to validate outside of Vite's build process.
  */
-export const loadAndValidateEnv = (config: ConfigOptions, options?: PluginOptions) => {
+export const loadAndValidateEnv = async (config: ConfigOptions, options?: PluginOptions) => {
   const ui = initUi()
-  return validateEnv(ui, config, options).then((variables) =>
-    variables.reduce(
-      (acc, { key, value }) => {
-        acc[key] = value
-        return acc
-      },
-      {} as Record<string, any>,
-    ),
-  )
+  const variables = await validateEnv(ui, config, options)
+
+  for (const { key, value } of variables) {
+    process.env[key] = value
+  }
+
+  return Object.fromEntries(variables.map(({ key, value }) => [key, value]))
 }
 
 export const defineConfig = <T extends PluginOptions>(config: T): T => config

tests/common.spec.ts

@@ -1,6 +1,6 @@
 import { test } from '@japa/runner'
 
-import { Schema } from '../src/index.js'
+import { loadAndValidateEnv, Schema } from '../src/index.js'
 import { createEnvFile, executeValidateEnv, ValidateEnv } from './helpers.js'
 
 test.group('vite-plugin-validate-env', () => {
@@ -183,3 +183,33 @@ test.group('vite-plugin-validate-env', () => {
     assert.isDefined(messages.find((message) => message.includes('cyan(VITE_TESTX): not boolean')))
   })
 })
+
+test.group('vite-plugin-validate-env - node usage', () => {
+  test('Basic validation', async ({ assert, fs }) => {
+    await createEnvFile({ VITE_TEST: 'not boolean' })
+    const validate = async () =>
+      await loadAndValidateEnv(
+        { mode: 'development', root: fs.basePath },
+        { VITE_TEST: Schema.boolean() },
+      )
+
+    await assert.rejects(async () => {
+      await validate()
+    }, /"VITE_TEST" env variable must be a boolean \(Current value: "not boolean"\)/)
+
+    delete process.env.VITE_TEST
+  })
+
+  test('assign to process.env', async ({ assert, fs }) => {
+    await createEnvFile({ VITE_TEST: 'true' })
+    const result = await loadAndValidateEnv(
+      { mode: 'development', root: fs.basePath },
+      { VITE_TEST: Schema.boolean() },
+    )
+
+    assert.deepEqual(result, { VITE_TEST: true })
+    assert.equal(process.env.VITE_TEST, 'true')
+
+    delete process.env.VITE_TEST
+  })
+})