@modern-js/plugin-data-loader 2.51.0 → 2.53.0

package/dist/cjs/runtime/errors.js

@@ -0,0 +1,103 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var errors_exports = {};
+__export(errors_exports, {
+  errorResponseToJson: () => errorResponseToJson,
+  sanitizeError: () => sanitizeError,
+  sanitizeErrors: () => sanitizeErrors,
+  serializeError: () => serializeError,
+  serializeErrors: () => serializeErrors
+});
+module.exports = __toCommonJS(errors_exports);
+var import_remix_router = require("@modern-js/runtime-utils/remix-router");
+function sanitizeError(error) {
+  if (error instanceof Error && process.env.NODE_ENV !== "development" && process.env.NODE_ENV !== "test") {
+    const sanitized = new Error("Unexpected Server Error");
+    sanitized.stack = void 0;
+    return sanitized;
+  }
+  return error;
+}
+function sanitizeErrors(errors) {
+  return Object.entries(errors).reduce((acc, [routeId, error]) => {
+    return Object.assign(acc, {
+      [routeId]: sanitizeError(error)
+    });
+  }, {});
+}
+function serializeError(error) {
+  const sanitized = sanitizeError(error);
+  return {
+    message: sanitized.message,
+    stack: sanitized.stack
+  };
+}
+function serializeErrors(errors) {
+  if (!errors) {
+    return null;
+  }
+  const entries = Object.entries(errors);
+  const serialized = {};
+  for (const [key, val] of entries) {
+    if ((0, import_remix_router.isRouteErrorResponse)(val)) {
+      serialized[key] = {
+        ...val,
+        __type: "RouteErrorResponse"
+      };
+    } else if (val instanceof Error) {
+      const sanitized = sanitizeError(val);
+      serialized[key] = {
+        message: sanitized.message,
+        stack: sanitized.stack,
+        __type: "Error",
+        // If this is a subclass (i.e., ReferenceError), send up the type so we
+        // can re-create the same type during hydration.  This will only apply
+        // in dev mode since all production errors are sanitized to normal
+        // Error instances
+        ...sanitized.name !== "Error" ? {
+          __subType: sanitized.name
+        } : {}
+      };
+    } else {
+      serialized[key] = val;
+    }
+  }
+  return serialized;
+}
+function errorResponseToJson(errorResponse) {
+  return (0, import_remix_router.json)(
+    // @ts-expect-error This is "private" from users but intended for internal use
+    serializeError(errorResponse.error || new Error("Unexpected Server Error")),
+    {
+      status: errorResponse.status,
+      statusText: errorResponse.statusText,
+      headers: {
+        "X-Modernjs-Error": "yes"
+      }
+    }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  errorResponseToJson,
+  sanitizeError,
+  sanitizeErrors,
+  serializeError,
+  serializeErrors
+});

package/dist/cjs/runtime/index.js

@@ -31,6 +31,7 @@ var import_time = require("@modern-js/runtime-utils/time");
 var import_constants = require("@modern-js/utils/universal/constants");
 var import_constants2 = require("../common/constants");
 var import_response = require("./response");
+var import_errors = require("./errors");
 const redirectStatusCodes = /* @__PURE__ */ new Set([
   301,
   302,
@@ -66,7 +67,7 @@ const handleRequest = async ({ request, serverRoutes, routes: routesConfig, cont
   }
   const basename = entry.urlPath;
   const end = (0, import_time.time)();
-  const { logger, reporter } = context;
+  const { reporter } = context;
   const routes = (0, import_browser.transformNestedRoutes)(routesConfig, reporter);
   const { queryRoute } = (0, import_remix_router.createStaticHandler)(routes, {
     basename
@@ -106,18 +107,20 @@ const handleRequest = async ({ request, serverRoutes, routes: routesConfig, cont
     const cost = end();
     reporter === null || reporter === void 0 ? void 0 : reporter.reportTiming(`${import_constants.LOADER_REPORTER_NAME}-navigation`, cost);
   } catch (error) {
-    const message = (0, import_remix_router.isRouteErrorResponse)(error) ? error.data : String(error);
-    if (error instanceof Error) {
-      logger === null || logger === void 0 ? void 0 : logger.error(`Error: ${error.name} ${error.message} ${error.stack}`);
+    if (isResponse(error)) {
+      error.headers.set("X-Modernjs-Catch", "yes");
+      response = error;
+    } else if ((0, import_remix_router.isRouteErrorResponse)(error)) {
+      response = (0, import_errors.errorResponseToJson)(error);
     } else {
-      logger === null || logger === void 0 ? void 0 : logger.error(message);
+      const errorInstance = error instanceof Error || error instanceof DOMException ? error : new Error("Unexpected Server Error");
+      response = (0, import_remix_router.json)((0, import_errors.serializeError)(errorInstance), {
+        status: 500,
+        headers: {
+          "X-Modernjs-Error": "yes"
+        }
+      });
     }
-    response = new Response(message, {
-      status: 500,
-      headers: {
-        "Content-Type": "text/plain"
-      }
-    });
   }
   return response;
 };

package/dist/esm/runtime/errors.js

@@ -0,0 +1,90 @@
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+import { _ as _instanceof } from "@swc/helpers/_/_instanceof";
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
+import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
+import { isRouteErrorResponse, json } from "@modern-js/runtime-utils/remix-router";
+function sanitizeError(error) {
+  if (_instanceof(error, Error) && process.env.NODE_ENV !== "development" && process.env.NODE_ENV !== "test") {
+    var sanitized = new Error("Unexpected Server Error");
+    sanitized.stack = void 0;
+    return sanitized;
+  }
+  return error;
+}
+function sanitizeErrors(errors) {
+  return Object.entries(errors).reduce(function(acc, param) {
+    var _param = _sliced_to_array(param, 2), routeId = _param[0], error = _param[1];
+    return Object.assign(acc, _define_property({}, routeId, sanitizeError(error)));
+  }, {});
+}
+function serializeError(error) {
+  var sanitized = sanitizeError(error);
+  return {
+    message: sanitized.message,
+    stack: sanitized.stack
+  };
+}
+function serializeErrors(errors) {
+  if (!errors) {
+    return null;
+  }
+  var entries = Object.entries(errors);
+  var serialized = {};
+  var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+  try {
+    for (var _iterator = entries[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var _step_value = _sliced_to_array(_step.value, 2), key = _step_value[0], val = _step_value[1];
+      if (isRouteErrorResponse(val)) {
+        serialized[key] = _object_spread_props(_object_spread({}, val), {
+          __type: "RouteErrorResponse"
+        });
+      } else if (_instanceof(val, Error)) {
+        var sanitized = sanitizeError(val);
+        serialized[key] = _object_spread({
+          message: sanitized.message,
+          stack: sanitized.stack,
+          __type: "Error"
+        }, sanitized.name !== "Error" ? {
+          __subType: sanitized.name
+        } : {});
+      } else {
+        serialized[key] = val;
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  return serialized;
+}
+function errorResponseToJson(errorResponse) {
+  return json(
+    // @ts-expect-error This is "private" from users but intended for internal use
+    serializeError(errorResponse.error || new Error("Unexpected Server Error")),
+    {
+      status: errorResponse.status,
+      statusText: errorResponse.statusText,
+      headers: {
+        "X-Modernjs-Error": "yes"
+      }
+    }
+  );
+}
+export {
+  errorResponseToJson,
+  sanitizeError,
+  sanitizeErrors,
+  serializeError,
+  serializeErrors
+};

package/dist/esm/runtime/index.js

@@ -1,7 +1,7 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _instanceof } from "@swc/helpers/_/_instanceof";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
-import { createStaticHandler, UNSAFE_DEFERRED_SYMBOL as DEFERRED_SYMBOL, isRouteErrorResponse } from "@modern-js/runtime-utils/remix-router";
+import { createStaticHandler, UNSAFE_DEFERRED_SYMBOL as DEFERRED_SYMBOL, isRouteErrorResponse, json } from "@modern-js/runtime-utils/remix-router";
 import { transformNestedRoutes } from "@modern-js/runtime-utils/browser";
 import { isPlainObject } from "@modern-js/utils/lodash";
 import { matchEntry, createRequestContext, reporterCtx } from "@modern-js/runtime-utils/node";
@@ -9,6 +9,7 @@ import { time } from "@modern-js/runtime-utils/time";
 import { LOADER_REPORTER_NAME } from "@modern-js/utils/universal/constants";
 import { CONTENT_TYPE_DEFERRED, LOADER_ID_PARAM } from "../common/constants";
 import { createDeferredReadableStream } from "./response";
+import { errorResponseToJson, serializeError } from "./errors";
 var redirectStatusCodes = /* @__PURE__ */ new Set([
   301,
   302,
@@ -37,7 +38,7 @@ function convertModernRedirectResponse(headers, basename) {
 }
 var handleRequest = function() {
   var _ref = _async_to_generator(function(param) {
-    var request, serverRoutes, routesConfig, context, url, routeId, entry, basename, end, logger, reporter, routes, queryRoute, requestContext, response, deferredData, body, init, headers, cost, error, message;
+    var request, serverRoutes, routesConfig, context, url, routeId, entry, basename, end, reporter, routes, queryRoute, requestContext, response, deferredData, body, init, headers, cost, error, errorInstance;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
@@ -52,7 +53,7 @@ var handleRequest = function() {
           }
           basename = entry.urlPath;
           end = time();
-          logger = context.logger, reporter = context.reporter;
+          reporter = context.reporter;
           routes = transformNestedRoutes(routesConfig, reporter);
           queryRoute = createStaticHandler(routes, {
             basename
@@ -108,18 +109,20 @@ var handleRequest = function() {
           ];
         case 3:
           error = _state.sent();
-          message = isRouteErrorResponse(error) ? error.data : String(error);
-          if (_instanceof(error, Error)) {
-            logger === null || logger === void 0 ? void 0 : logger.error("Error: ".concat(error.name, " ").concat(error.message, " ").concat(error.stack));
+          if (isResponse(error)) {
+            error.headers.set("X-Modernjs-Catch", "yes");
+            response = error;
+          } else if (isRouteErrorResponse(error)) {
+            response = errorResponseToJson(error);
           } else {
-            logger === null || logger === void 0 ? void 0 : logger.error(message);
+            errorInstance = _instanceof(error, Error) || _instanceof(error, DOMException) ? error : new Error("Unexpected Server Error");
+            response = json(serializeError(errorInstance), {
+              status: 500,
+              headers: {
+                "X-Modernjs-Error": "yes"
+              }
+            });
           }
-          response = new Response(message, {
-            status: 500,
-            headers: {
-              "Content-Type": "text/plain"
-            }
-          });
           return [
             3,
             4

package/dist/esm-node/runtime/errors.js

@@ -0,0 +1,75 @@
+import { isRouteErrorResponse, json } from "@modern-js/runtime-utils/remix-router";
+function sanitizeError(error) {
+  if (error instanceof Error && process.env.NODE_ENV !== "development" && process.env.NODE_ENV !== "test") {
+    const sanitized = new Error("Unexpected Server Error");
+    sanitized.stack = void 0;
+    return sanitized;
+  }
+  return error;
+}
+function sanitizeErrors(errors) {
+  return Object.entries(errors).reduce((acc, [routeId, error]) => {
+    return Object.assign(acc, {
+      [routeId]: sanitizeError(error)
+    });
+  }, {});
+}
+function serializeError(error) {
+  const sanitized = sanitizeError(error);
+  return {
+    message: sanitized.message,
+    stack: sanitized.stack
+  };
+}
+function serializeErrors(errors) {
+  if (!errors) {
+    return null;
+  }
+  const entries = Object.entries(errors);
+  const serialized = {};
+  for (const [key, val] of entries) {
+    if (isRouteErrorResponse(val)) {
+      serialized[key] = {
+        ...val,
+        __type: "RouteErrorResponse"
+      };
+    } else if (val instanceof Error) {
+      const sanitized = sanitizeError(val);
+      serialized[key] = {
+        message: sanitized.message,
+        stack: sanitized.stack,
+        __type: "Error",
+        // If this is a subclass (i.e., ReferenceError), send up the type so we
+        // can re-create the same type during hydration.  This will only apply
+        // in dev mode since all production errors are sanitized to normal
+        // Error instances
+        ...sanitized.name !== "Error" ? {
+          __subType: sanitized.name
+        } : {}
+      };
+    } else {
+      serialized[key] = val;
+    }
+  }
+  return serialized;
+}
+function errorResponseToJson(errorResponse) {
+  return json(
+    // @ts-expect-error This is "private" from users but intended for internal use
+    serializeError(errorResponse.error || new Error("Unexpected Server Error")),
+    {
+      status: errorResponse.status,
+      statusText: errorResponse.statusText,
+      headers: {
+        "X-Modernjs-Error": "yes"
+      }
+    }
+  );
+}
+export {
+  errorResponseToJson,
+  sanitizeError,
+  sanitizeErrors,
+  serializeError,
+  serializeErrors
+};

package/dist/esm-node/runtime/index.js

@@ -1,4 +1,4 @@
-import { createStaticHandler, UNSAFE_DEFERRED_SYMBOL as DEFERRED_SYMBOL, isRouteErrorResponse } from "@modern-js/runtime-utils/remix-router";
+import { createStaticHandler, UNSAFE_DEFERRED_SYMBOL as DEFERRED_SYMBOL, isRouteErrorResponse, json } from "@modern-js/runtime-utils/remix-router";
 import { transformNestedRoutes } from "@modern-js/runtime-utils/browser";
 import { isPlainObject } from "@modern-js/utils/lodash";
 import { matchEntry, createRequestContext, reporterCtx } from "@modern-js/runtime-utils/node";
@@ -6,6 +6,7 @@ import { time } from "@modern-js/runtime-utils/time";
 import { LOADER_REPORTER_NAME } from "@modern-js/utils/universal/constants";
 import { CONTENT_TYPE_DEFERRED, LOADER_ID_PARAM } from "../common/constants";
 import { createDeferredReadableStream } from "./response";
+import { errorResponseToJson, serializeError } from "./errors";
 const redirectStatusCodes = /* @__PURE__ */ new Set([
   301,
   302,
@@ -41,7 +42,7 @@ const handleRequest = async ({ request, serverRoutes, routes: routesConfig, cont
   }
   const basename = entry.urlPath;
   const end = time();
-  const { logger, reporter } = context;
+  const { reporter } = context;
   const routes = transformNestedRoutes(routesConfig, reporter);
   const { queryRoute } = createStaticHandler(routes, {
     basename
@@ -81,18 +82,20 @@ const handleRequest = async ({ request, serverRoutes, routes: routesConfig, cont
     const cost = end();
     reporter === null || reporter === void 0 ? void 0 : reporter.reportTiming(`${LOADER_REPORTER_NAME}-navigation`, cost);
   } catch (error) {
-    const message = isRouteErrorResponse(error) ? error.data : String(error);
-    if (error instanceof Error) {
-      logger === null || logger === void 0 ? void 0 : logger.error(`Error: ${error.name} ${error.message} ${error.stack}`);
+    if (isResponse(error)) {
+      error.headers.set("X-Modernjs-Catch", "yes");
+      response = error;
+    } else if (isRouteErrorResponse(error)) {
+      response = errorResponseToJson(error);
     } else {
-      logger === null || logger === void 0 ? void 0 : logger.error(message);
+      const errorInstance = error instanceof Error || error instanceof DOMException ? error : new Error("Unexpected Server Error");
+      response = json(serializeError(errorInstance), {
+        status: 500,
+        headers: {
+          "X-Modernjs-Error": "yes"
+        }
+      });
     }
-    response = new Response(message, {
-      status: 500,
-      headers: {
-        "Content-Type": "text/plain"
-      }
-    });
   }
   return response;
 };

package/dist/types/runtime/errors.d.ts

@@ -0,0 +1,60 @@
+/**
+ * The following code is modified based on
+ * https://github.com/remix-run/remix/blob/main/packages/remix-server-runtime/errors.ts
+ *
+ * MIT Licensed
+ * Author Michael Jackson
+ * Copyright 2021 Remix Software Inc.
+ * https://github.com/remix-run/remix/blob/main/LICENSE.md
+ */
+import type { ErrorResponse, StaticHandlerContext } from '@modern-js/runtime-utils/remix-router';
+/**
+ * This thing probably warrants some explanation.
+ *
+ * The whole point here is to emulate componentDidCatch for server rendering and
+ * data loading. It can get tricky. React can do this on component boundaries
+ * but doesn't support it for server rendering or data loading. We know enough
+ * with nested routes to be able to emulate the behavior (because we know them
+ * statically before rendering.)
+ *
+ * Each route can export an `ErrorBoundary`.
+ *
+ * - When rendering throws an error, the nearest error boundary will render
+ *   (normal react componentDidCatch). This will be the route's own boundary, but
+ *   if none is provided, it will bubble up to the parents.
+ * - When data loading throws an error, the nearest error boundary will render
+ * - When performing an action, the nearest error boundary for the action's
+ *   route tree will render (no redirect happens)
+ *
+ * During normal react rendering, we do nothing special, just normal
+ * componentDidCatch.
+ *
+ * For server rendering, we mutate `renderBoundaryRouteId` to know the last
+ * layout that has an error boundary that tried to render. This emulates which
+ * layout would catch a thrown error. If the rendering fails, we catch the error
+ * on the server, and go again a second time with the emulator holding on to the
+ * information it needs to render the same error boundary as a dynamically
+ * thrown render error.
+ *
+ * When data loading, server or client side, we use the emulator to likewise
+ * hang on to the error and re-render at the appropriate layout (where a thrown
+ * error would have been caught by cDC).
+ *
+ * When actions throw, it all works the same. There's an edge case to be aware
+ * of though. Actions normally are required to redirect, but in the case of
+ * errors, we render the action's route with the emulator holding on to the
+ * error. If during this render a parent route/loader throws we ignore that new
+ * error and render the action's original error as deeply as possible. In other
+ * words, we simply ignore the new error and use the action's error in place
+ * because it came first, and that just wouldn't be fair to let errors cut in
+ * line.
+ */
+export declare function sanitizeError<T = unknown>(error: T): Error | T;
+export declare function sanitizeErrors(errors: NonNullable<StaticHandlerContext['errors']>): {};
+export type SerializedError = {
+    message: string;
+    stack?: string;
+};
+export declare function serializeError(error: Error): SerializedError;
+export declare function serializeErrors(errors: StaticHandlerContext['errors']): StaticHandlerContext['errors'];
+export declare function errorResponseToJson(errorResponse: ErrorResponse): Response;

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.51.0",
+  "version": "2.53.0",
   "engines": {
     "node": ">=16.2.0"
   },
@@ -49,8 +49,8 @@
     "@babel/core": "^7.23.2",
     "path-to-regexp": "^6.2.0",
     "@swc/helpers": "0.5.3",
-    "@modern-js/utils": "2.51.0",
-    "@modern-js/runtime-utils": "2.51.0"
+    "@modern-js/utils": "2.53.0",
+    "@modern-js/runtime-utils": "2.53.0"
   },
   "devDependencies": {
     "@types/babel__core": "^7.20.1",
@@ -66,11 +66,11 @@
     "webpack": "^5.91.0",
     "react": "^18",
     "react-dom": "^18",
-    "@modern-js/core": "2.51.0",
-    "@modern-js/server-core": "2.51.0",
-    "@modern-js/types": "2.51.0",
-    "@scripts/jest-config": "2.51.0",
-    "@scripts/build": "2.51.0"
+    "@modern-js/core": "2.53.0",
+    "@modern-js/server-core": "2.53.0",
+    "@modern-js/types": "2.53.0",
+    "@scripts/build": "2.53.0",
+    "@scripts/jest-config": "2.53.0"
   },
   "peerDependencies": {
     "react": ">=17.0.0"