make sure we are always returning original promise

Author: AbhiPrasad

packages/sveltekit/src/server/load.ts

@@ -1,50 +1,64 @@
 import { captureException } from '@sentry/node';
-import { addExceptionMechanism, objectify } from '@sentry/utils';
+import { addExceptionMechanism, objectify, isThenable } from '@sentry/utils';
 import type { HttpError, ServerLoad } from '@sveltejs/kit';
 
 function isHttpError(err: unknown): err is HttpError {
   return typeof err === 'object' && err !== null && 'status' in err && 'body' in err;
 }
 
+function captureAndThrowError(e: unknown): void {
+  // In case we have a primitive, wrap it in the equivalent wrapper class (string -> String, etc.) so that we can
+  // store a seen flag on it.
+  const objectifiedErr = objectify(e);
+
+  // The error() helper is commonly used to throw errors in load functions: https://kit.svelte.dev/docs/modules#sveltejs-kit-error
+  // If we detect a thrown error that is an instance of HttpError, we don't want to capture 4xx errors as they
+  // could be noisy.
+  if (isHttpError(objectifiedErr) && objectifiedErr.status < 500 && objectifiedErr.status >= 400) {
+    throw objectifiedErr;
+  }
+
+  captureException(objectifiedErr, scope => {
+    scope.addEventProcessor(event => {
+      addExceptionMechanism(event, {
+        type: 'sveltekit',
+        handled: false,
+        data: {
+          function: 'load',
+        },
+      });
+      return event;
+    });
+
+    return scope;
+  });
+
+  throw objectifiedErr;
+}
+
 /**
  * Wrap load function with Sentry
  *
  * @param origLoad SvelteKit user defined load function
  */
 export function wrapLoadWithSentry(origLoad: ServerLoad): ServerLoad {
   return new Proxy(origLoad, {
-    apply: async (wrappingTarget, thisArg, args: Parameters<ServerLoad>) => {
+    apply: (wrappingTarget, thisArg, args: Parameters<ServerLoad>) => {
+      let maybePromiseResult;
+
       try {
-        return await wrappingTarget.apply(thisArg, args);
+        maybePromiseResult = wrappingTarget.apply(thisArg, args);
       } catch (e) {
-        // In case we have a primitive, wrap it in the equivalent wrapper class (string -> String, etc.) so that we can
-        // store a seen flag on it.
-        const objectifiedErr = objectify(e) as unknown;
-
-        // The error() helper is commonly used to throw errors in load functions: https://kit.svelte.dev/docs/modules#sveltejs-kit-error
-        // If we detect a thrown error that is an instance of HttpError, we don't want to capture 4xx errors as they
-        // could be noisy.
-        if (isHttpError(objectifiedErr) && objectifiedErr.status < 500 && objectifiedErr.status >= 400) {
-          throw objectifiedErr;
-        }
-
-        captureException(objectifiedErr, scope => {
-          scope.addEventProcessor(event => {
-            addExceptionMechanism(event, {
-              type: 'sveltekit',
-              handled: false,
-              data: {
-                function: 'load',
-              },
-            });
-            return event;
-          });
-
-          return scope;
-        });
+        captureAndThrowError(e);
+      }
 
-        throw objectifiedErr;
+      if (isThenable(maybePromiseResult)) {
+        Promise.resolve(maybePromiseResult).then(null, e => {
+          captureAndThrowError(e);
+        });
       }
+
+      return maybePromiseResult;
     },
   });
 }