@modern-js/plugin-data-loader 2.5.0 → 2.7.0

package/dist/cjs/server/index.js

@@ -17,188 +17,23 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var server_exports = {};
 __export(server_exports, {
-  default: () => server_default,
-  getPathWithoutEntry: () => getPathWithoutEntry,
-  handleRequest: () => handleRequest,
-  isRedirectResponse: () => isRedirectResponse,
-  isResponse: () => isResponse
+  default: () => server_default
 });
 module.exports = __toCommonJS(server_exports);
 var import_path = __toESM(require("path"));
-var import_node = require("@remix-run/node");
-var import_react_router_dom = require("react-router-dom");
+var import_fs = __toESM(require("fs"));
 var import_utils = require("@modern-js/utils");
-var import_constants = require("../common/constants");
-(0, import_node.installGlobals)();
-const redirectStatusCodes = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
-function isRedirectResponse(response) {
-  return redirectStatusCodes.has(response.status);
-}
-function isResponse(value) {
-  return value != null && typeof value.status === "number" && typeof value.statusText === "string" && typeof value.headers === "object" && typeof value.body !== "undefined";
-}
-const json = (data, init = {}) => {
-  const responseInit = typeof init === "number" ? { status: init } : init;
-  const headers = new Headers(responseInit.headers);
-  if (!headers.has("Content-Type")) {
-    headers.set("Content-Type", "application/json; charset=utf-8");
-  }
-  return new import_node.Response(JSON.stringify(data), {
-    ...responseInit,
-    headers
-  });
-};
-const callRouteLoader = async ({
-  routeId,
-  loader,
-  params,
-  request,
-  loadContext
-}) => {
-  if (!loader) {
-    throw new Error(
-      `You made a ${request.method} request to ${request.url} but did not provide a default component or \`loader\` for route "${routeId}", so there is no way to handle the request.`
-    );
-  }
-  let result;
-  try {
-    result = await loader({
-      request,
-      params
-    });
-  } catch (error) {
-    if (!isResponse(error)) {
-      throw error;
-    }
-    result = error;
-  }
-  if (result === void 0) {
-    throw new Error(
-      `You defined a loader for route "${routeId}" but didn't return anything from your \`loader\` function. Please return a value or \`null\`.`
-    );
-  }
-  return isResponse(result) ? result : json(result);
-};
-const createLoaderHeaders = (requestHeaders) => {
-  const headers = new Headers();
-  for (const [key, values] of Object.entries(requestHeaders)) {
-    if (values) {
-      if (Array.isArray(values)) {
-        for (const value of values) {
-          headers.append(key, value);
-        }
-      } else {
-        headers.set(key, values);
-      }
-    }
-  }
-  return headers;
-};
-const createLoaderRequest = (context) => {
-  const origin = `${context.protocol}://${context.host}`;
-  const url = new URL(context.url, origin);
-  const controller = new AbortController();
-  const init = {
-    method: context.method,
-    headers: createLoaderHeaders(context.headers),
-    signal: controller.signal
-  };
-  return new Request(url.href, init);
-};
-const sendLoaderResponse = async (res, nodeResponse) => {
-  res.statusMessage = nodeResponse.statusText;
-  res.statusCode = nodeResponse.status;
-  for (const [key, value] of nodeResponse.headers.entries()) {
-    res.setHeader(key, value);
-  }
-  if (nodeResponse.body) {
-    await (0, import_node.writeReadableStreamToWritable)(nodeResponse.body, res);
-  } else {
-    res.end();
-  }
-};
-const getPathWithoutEntry = (pathname, entryPath) => {
-  if (entryPath === "/") {
-    return pathname;
-  }
-  return pathname.replace(entryPath, "");
-};
-const matchEntry = (pathname, entries) => {
-  return entries.find((entry) => pathname.startsWith(entry.urlPath));
-};
-const handleRequest = async ({
-  context,
-  serverRoutes,
-  distDir
-}) => {
-  const { method, query } = context;
-  const routeId = query[import_constants.LOADER_ID_PARAM];
-  if (!routeId || method.toLowerCase() !== "get") {
-    return;
-  }
-  const entry = matchEntry(context.path, serverRoutes);
-  if (!entry) {
-    return;
-  }
-  const routesPath = import_path.default.join(
-    distDir,
-    import_utils.SERVER_BUNDLE_DIRECTORY,
-    `${entry.entryName || import_utils.MAIN_ENTRY_NAME}-server-loaders`
-  );
-  const { routes } = await Promise.resolve().then(() => __toESM(require(routesPath)));
-  if (!routes) {
-    return;
-  }
-  const { res } = context;
-  const pathname = getPathWithoutEntry(context.path, entry.urlPath);
-  const matches = (0, import_react_router_dom.matchRoutes)(routes, pathname);
-  if (!matches) {
-    res.statusCode = 403;
-    res.end(`Route ${pathname} was not matched`);
-    return;
-  }
-  const match = matches == null ? void 0 : matches.find((match2) => match2.route.id === routeId);
-  if (!match) {
-    res.statusCode = 403;
-    res.end(`Route ${routeId} does not match URL ${context.path}`);
-    return;
-  }
-  const request = createLoaderRequest(context);
-  let response;
-  try {
-    response = await callRouteLoader({
-      loader: match.route.loader,
-      routeId: match.route.id,
-      params: match.params,
-      request,
-      loadContext: {}
-    });
-    if (isRedirectResponse(response)) {
-      const headers = new Headers(response.headers);
-      headers.set("X-Modernjs-Redirect", headers.get("Location"));
-      headers.delete("Location");
-      response = new import_node.Response(null, {
-        status: 204,
-        headers
-      });
-    }
-  } catch (error) {
-    const message = String(error);
-    response = new import_node.Response(message, {
-      status: 500,
-      headers: {
-        "Content-Type": "text/plain"
-      }
-    });
-  }
-  sendLoaderResponse(res, response);
-};
+var import_runtime2 = require("../runtime");
 var server_default = () => ({
   name: "@modern-js/plugin-data-loader",
   setup: () => ({
@@ -207,19 +42,30 @@ var server_default = () => ({
       distDir
     }) {
       return async (context) => {
+        const entry = (0, import_runtime2.matchEntry)(context.path, serverRoutes);
+        if (!entry) {
+          return;
+        }
+        const routesPath = import_path.default.join(
+          distDir,
+          import_utils.SERVER_BUNDLE_DIRECTORY,
+          `${entry.entryName || import_utils.MAIN_ENTRY_NAME}-server-loaders.js`
+        );
+        if (!import_fs.default.existsSync(routesPath)) {
+          return;
+        }
+        const { routes, handleRequest } = await Promise.resolve().then(() => __toESM(require(routesPath)));
+        if (!routes) {
+          return;
+        }
         return handleRequest({
           serverRoutes,
-          distDir,
-          context
+          context,
+          routes
         });
       };
     }
   })
 });
 // Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getPathWithoutEntry,
-  handleRequest,
-  isRedirectResponse,
-  isResponse
-});
+0 && (module.exports = {});

package/dist/esm/cli/{create-request.js → createRequest.js}

@@ -124,7 +124,8 @@ var __generator = this && this.__generator || function(thisArg, body) {
 };
 import { compile } from "path-to-regexp";
 import { redirect } from "react-router-dom";
-import { LOADER_ID_PARAM, DIRECT_PARAM } from "../common/constants";
+import { LOADER_ID_PARAM, DIRECT_PARAM, CONTENT_TYPE_DEFERRED } from "../common/constants";
+import { parseDeferredReadableStream } from "./data";
 var getRequestUrl = function(param) {
     var params = param.params, request = param.request, routeId = param.routeId;
     var url = new URL(request.url);
@@ -141,10 +142,41 @@ var handleRedirectResponse = function(res) {
     var headers = res.headers;
     var location = headers.get("X-Modernjs-Redirect");
     if (location) {
-        return redirect(location);
+        throw redirect(location);
     }
     return res;
 };
+var handleDeferredResponse = function() {
+    var _ref = _asyncToGenerator(function(res) {
+        var _res_headers_get;
+        return __generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    if (!(((_res_headers_get = res.headers.get("Content-Type")) === null || _res_headers_get === void 0 ? void 0 : _res_headers_get.match(CONTENT_TYPE_DEFERRED)) && res.body)) return [
+                        3,
+                        2
+                    ];
+                    return [
+                        4,
+                        parseDeferredReadableStream(res.body)
+                    ];
+                case 1:
+                    return [
+                        2,
+                        _state.sent()
+                    ];
+                case 2:
+                    return [
+                        2,
+                        res
+                    ];
+            }
+        });
+    });
+    return function handleDeferredResponse(res) {
+        return _ref.apply(this, arguments);
+    };
+}();
 var createRequest = function(routeId) {
     var method = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "get";
     return function() {
@@ -171,9 +203,16 @@ var createRequest = function(routeId) {
                         if (!res.ok) {
                             throw res;
                         }
+                        res = handleRedirectResponse(res);
+                        return [
+                            4,
+                            handleDeferredResponse(res)
+                        ];
+                    case 2:
+                        res = _state.sent();
                         return [
                             2,
-                            handleRedirectResponse(res)
+                            res
                         ];
                 }
             });