feat(makeEnvPublic): ✨ allow passing multiple env vars and don't throw

Author: HofmannZ

README.md

@@ -166,12 +166,15 @@ export const getStaticProps: GetStaticProps = async (context) => {
 };
 ```
 
-#### `makeEnvPublic(key: string): void`
+#### `makeEnvPublic(key: string | string[]): void`
 
-Makes the environment variable with the given key public. This is useful if you
+Makes an environment variable with a given key public. This is useful if you
 want to use an environment variable in the browser, but it was was not declared
 with a `NEXT_PUBLIC_` prefix.
 
+For ease of use you can also make multiple env vars public at once by passing an
+array of keys.
+
 ##### Example
 
 ```js
@@ -183,6 +186,9 @@ const { makeEnvPublic } = require('next-runtime-env/build/make-env-public');
 // will make it public and available as `NEXT_PUBLIC_FOO`.
 makeEnvPublic('FOO');
 
+// Or you can make multiple env vars public at once.
+makeEnvPublic(['BAR', 'BAZ']);
+
 // This will generate the `__ENV.js` file and include `NEXT_PUBLIC_FOO`.
 configureRuntimeEnv();
 ```

src/make-env-public.spec.ts

@@ -1,36 +1,56 @@
 import { makeEnvPublic } from './make-env-public';
 
+const warnSpy = jest.spyOn(console, 'warn');
+
+beforeAll(() => {
+  warnSpy.mockImplementation();
+});
+
+afterAll(() => {
+  warnSpy.mockRestore();
+});
+
 describe('makeEnvPublic()', () => {
   afterEach(() => {
     delete process.env.FOO;
+    delete process.env.BAR;
+    delete process.env.BAZ;
     delete process.env.NEXT_PUBLIC_FOO;
+    delete process.env.NEXT_PUBLIC_BAR;
+    delete process.env.NEXT_PUBLIC_BAZ;
   });
 
   it('should prefix an env var with NEXT_PUBLIC_', () => {
     process.env.FOO = 'foo';
 
     makeEnvPublic('FOO');
 
-    expect(process.env.FOO).toBeDefined();
-    expect(process.env.NEXT_PUBLIC_FOO).toBeDefined();
+    expect(process.env.FOO).toEqual('foo');
+    expect(process.env.NEXT_PUBLIC_FOO).toEqual('foo');
   });
 
-  it('should copy the value to the new NEXT_PUBLIC_ env var', () => {
+  it('should prefix multiple env vars with NEXT_PUBLIC_', () => {
     process.env.FOO = 'foo';
+    process.env.BAR = 'bar';
+    process.env.BAZ = 'baz';
 
-    makeEnvPublic('FOO');
+    makeEnvPublic(['FOO', 'BAR', 'BAZ']);
 
     expect(process.env.FOO).toEqual('foo');
     expect(process.env.NEXT_PUBLIC_FOO).toEqual('foo');
+    expect(process.env.BAR).toEqual('bar');
+    expect(process.env.NEXT_PUBLIC_BAR).toEqual('bar');
+    expect(process.env.BAZ).toEqual('baz');
+    expect(process.env.NEXT_PUBLIC_BAZ).toEqual('baz');
   });
 
-  it('should throw when the env var already starts with NEXT_PUBLIC_', () => {
+  it('should warn when the env var already starts with NEXT_PUBLIC_', () => {
     process.env.NEXT_PUBLIC_FOO = 'foo';
 
-    expect(() => {
-      makeEnvPublic('NEXT_PUBLIC_FOO');
-    }).toThrowError(
-      'The environment variable "NEXT_PUBLIC_FOO" is already public.'
+    makeEnvPublic('NEXT_PUBLIC_FOO');
+
+    expect(warnSpy).toHaveBeenCalledWith(
+      '> [next-runtime-env] The environment variable "NEXT_PUBLIC_FOO" is already public.'
     );
   });
 });

src/make-env-public.ts

@@ -1,14 +1,34 @@
-/**
- * Make a private environment variable public, so that it can be accessed in the
- * browser.
- */
-export function makeEnvPublic(key: string): void {
+function prefixKey(key: string) {
   // Check if the key already is already public.
   if (/^NEXT_PUBLIC_/i.test(key)) {
-    throw new Error(`The environment variable "${key}" is already public.`);
+    // eslint-disable-next-line no-console
+    console.warn(
+      `> [next-runtime-env] The environment variable "${key}" is already public.`
+    );
   }
 
   const prefixedKey = `NEXT_PUBLIC_${key}`;
 
   process.env[prefixedKey] = process.env[key];
 }
+
+/**
+ * Make a private environment variable public, so that it can be accessed in the
+ * browser.
+ *
+ * Usage:
+ * ```ts
+ * // Make a single variable public.
+ * makeEnvPublic('FOO');
+ *
+ * // Make multiple variables public.
+ * makeEnvPublic(['FOO', 'BAR', 'BAZ']);
+ * ```
+ */
+export function makeEnvPublic(key: string | string[]): void {
+  if (typeof key === 'string') {
+    prefixKey(key);
+  } else {
+    key.forEach(prefixKey);
+  }
+}