avoid printing full error during development (#59)

* avoid printing error in development

* add description

* add changeset

* change message

* add more tests

Author: dferber90

.changeset/fair-candles-visit.md

@@ -0,0 +1,5 @@
+---
+'@vercel/flags': patch
+---
+
+emit reduced console info when falling back to defaultValue during development

packages/flags/src/next/index.test.ts

@@ -190,6 +190,23 @@ describe('flag on app router', () => {
     expect(mockDecide).toHaveBeenCalledTimes(1);
   });
 
+  it('falls back to the defaultValue if a sync decide throws', async () => {
+    const mockDecide = vi.fn(() => {
+      throw new Error('custom error');
+    });
+
+    const f = flag<boolean>({
+      key: 'first-flag',
+      decide: mockDecide,
+      defaultValue: false,
+    });
+
+    mocks.headers.mockReturnValueOnce(new Headers());
+
+    await expect(f()).resolves.toEqual(false);
+    expect(mockDecide).toHaveBeenCalledTimes(1);
+  });
+
   it('falls back to the defaultValue when a decide function returns undefined', async () => {
     const syncFlag = flag<boolean>({
       key: 'sync-flag',
@@ -249,12 +266,10 @@ describe('flag on pages router', () => {
 
     expect(f).toHaveProperty('key', 'first-flag');
 
-    const fakeRequest = {
-      headers: {},
-      cookies: {},
-    } as unknown as IncomingMessage & { cookies: NextApiRequestCookies };
+    const [firstRequest, socket1] = createRequest();
 
-    await expect(f(fakeRequest)).resolves.toEqual(false);
+    await expect(f(firstRequest)).resolves.toEqual(false);
+    socket1.destroy();
   });
 
   it('caches for the duration of a request', async () => {
@@ -433,6 +448,25 @@ describe('flag on pages router', () => {
     expect(catchFn).not.toHaveBeenCalled();
     expect(mockDecide).toHaveBeenCalledTimes(1);
   });
+
+  it('falls back to the defaultValue if a sync decide throws', async () => {
+    const mockDecide = vi.fn(() => {
+      throw new Error('custom error');
+    });
+
+    const [firstRequest, socket1] = createRequest();
+    const f = flag<boolean>({
+      key: 'first-flag',
+      decide: mockDecide,
+      defaultValue: false,
+    });
+
+    mocks.headers.mockReturnValueOnce(new Headers());
+
+    await expect(f(firstRequest)).resolves.toEqual(false);
+    expect(mockDecide).toHaveBeenCalledTimes(1);
+    socket1.destroy();
+  });
 });
 
 describe('dynamic io', () => {

packages/flags/src/next/index.ts

@@ -279,60 +279,50 @@ function getRun<ValueType, EntitiesType>(
       return decision;
     }
 
-    // fall back to defaultValue if it is set,
-    let decisionPromise: Promise<ValueType> | ValueType;
-    try {
-      decisionPromise = Promise.resolve<ValueType>(
-        decide({
-          headers: readonlyHeaders,
-          cookies: readonlyCookies,
-          entities,
-        }),
-      )
-        // catch errors in async "decide" functions
-        .then<ValueType, ValueType>(
-          (value) => {
-            if (value !== undefined) return value;
-            if (definition.defaultValue !== undefined)
-              return definition.defaultValue;
-            throw new Error(
-              `@vercel/flags: Flag "${definition.key}" must have a defaultValue or a decide function that returns a value`,
-            );
-          },
-          (error: Error) => {
-            if (isInternalNextError(error)) throw error;
-
-            // try to recover if defaultValue is set
-            if (definition.defaultValue !== undefined) {
+    // We use an async iife to ensure we can catch both sync and async errors of
+    // the original decide function, as that one is not guaranted to be async.
+    //
+    // Also fall back to defaultValue when the decide function returns undefined or throws an error.
+    const decisionPromise = (async () => {
+      return decide({
+        headers: readonlyHeaders,
+        cookies: readonlyCookies,
+        entities,
+      });
+    })()
+      // catch errors in async "decide" functions
+      .then<ValueType, ValueType>(
+        (value) => {
+          if (value !== undefined) return value;
+          if (definition.defaultValue !== undefined)
+            return definition.defaultValue;
+          throw new Error(
+            `@vercel/flags: Flag "${definition.key}" must have a defaultValue or a decide function that returns a value`,
+          );
+        },
+        (error: Error) => {
+          if (isInternalNextError(error)) throw error;
+
+          // try to recover if defaultValue is set
+          if (definition.defaultValue !== undefined) {
+            if (process.env.NODE_ENV === 'development') {
+              console.info(
+                `@vercel/flags: Flag "${definition.key}" is falling back to its defaultValue`,
+              );
+            } else {
               console.warn(
-                `@vercel/flags: Flag "${definition.key}" is falling back to the defaultValue after catching the following error`,
+                `@vercel/flags: Flag "${definition.key}" is falling back to its defaultValue after catching the following error`,
                 error,
               );
-              return definition.defaultValue;
             }
-            console.warn(
-              `@vercel/flags: Flag "${definition.key}" could not be evaluated`,
-            );
-            throw error;
-          },
-        );
-    } catch (error) {
-      if (isInternalNextError(error)) throw error;
-
-      // catch errors in sync "decide" functions
-      if (definition.defaultValue !== undefined) {
-        console.warn(
-          `@vercel/flags: Flag "${definition.key}" is falling back to the defaultValue after catching the following error`,
-          error,
-        );
-        decisionPromise = Promise.resolve(definition.defaultValue);
-      } else {
-        console.warn(
-          `@vercel/flags: Flag "${definition.key}" could not be evaluated`,
-        );
-        throw error;
-      }
-    }
+            return definition.defaultValue;
+          }
+          console.warn(
+            `@vercel/flags: Flag "${definition.key}" could not be evaluated`,
+          );
+          throw error;
+        },
+      );
 
     setCachedValuePromise(
       readonlyHeaders,