@modern-js/plugin-data-loader 2.5.0-alpha.0 → 2.6.0

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

@@ -1,9 +1,179 @@
 import path from "path";
 import {
-  MAIN_ENTRY_NAME,
-  SERVER_BUNDLE_DIRECTORY
-} from "@modern-js/utils";
-import { matchEntry } from "../runtime";
+  installGlobals,
+  writeReadableStreamToWritable,
+  Response as NodeResponse
+} from "@remix-run/node";
+import {
+  matchRoutes
+} from "react-router-dom";
+import { MAIN_ENTRY_NAME, SERVER_BUNDLE_DIRECTORY } from "@modern-js/utils";
+import { LOADER_ID_PARAM } from "../common/constants";
+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 NodeResponse(JSON.stringify(data), {
+    ...responseInit,
+    headers
+  });
+};
+const callRouteLoader = async ({
+  routeId,
+  loader,
+  params,
+  request,
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  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 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[LOADER_ID_PARAM];
+  if (!routeId || method.toLowerCase() !== "get") {
+    return;
+  }
+  const entry = matchEntry(context.path, serverRoutes);
+  if (!entry) {
+    return;
+  }
+  const routesPath = path.join(
+    distDir,
+    SERVER_BUNDLE_DIRECTORY,
+    `${entry.entryName || MAIN_ENTRY_NAME}-server-loaders`
+  );
+  const { routes } = await import(routesPath);
+  if (!routes) {
+    return;
+  }
+  const { res } = context;
+  const pathname = getPathWithoutEntry(context.path, entry.urlPath);
+  const matches = 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 NodeResponse(null, {
+        status: 204,
+        headers
+      });
+    }
+  } catch (error) {
+    const message = String(error);
+    response = new NodeResponse(message, {
+      status: 500,
+      headers: {
+        "Content-Type": "text/plain"
+      }
+    });
+  }
+  sendLoaderResponse(res, response);
+};
 var server_default = () => ({
   name: "@modern-js/plugin-data-loader",
   setup: () => ({
@@ -12,29 +182,19 @@ var server_default = () => ({
       distDir
     }) {
       return async (context) => {
-        const entry = matchEntry(context.path, serverRoutes);
-        if (!entry) {
-          throw new Error("Route is not matched");
-        }
-        const routesPath = path.join(
-          distDir,
-          SERVER_BUNDLE_DIRECTORY,
-          `${entry.entryName || MAIN_ENTRY_NAME}-server-loaders`
-        );
-        const { routes, handleRequest } = await import(routesPath);
-        if (!routes) {
-          throw new Error("Missing route info");
-          ;
-        }
         return handleRequest({
           serverRoutes,
-          context,
-          routes
+          distDir,
+          context
         });
       };
     }
   })
 });
 export {
-  server_default as default
+  server_default as default,
+  getPathWithoutEntry,
+  handleRequest,
+  isRedirectResponse,
+  isResponse
 };

package/dist/types/cli/create-request.d.ts

@@ -1,4 +1,3 @@
-import { type UNSAFE_DeferredData as DeferredData } from '@modern-js/utils/remix-router';
 export declare const getRequestUrl: ({
   params,
   request,
@@ -14,4 +13,4 @@ export declare const createRequest: (routeId: string, method?: string) => ({
 }: {
   params: Record<string, string>;
   request: Request;
-}) => Promise<DeferredData | Response>;
+}) => Promise<Response>;

package/dist/types/server/index.d.ts

@@ -1,4 +1,19 @@
 import type { ServerPlugin } from '@modern-js/server-core';
+import type { ModernServerContext, ServerRoute } from '@modern-js/types';
+import { Response as NodeResponse } from '@remix-run/node';
+export type ServerContext = Pick<ModernServerContext, 'req' | 'res' | 'params' | 'headers' | 'method' | 'url' | 'host' | 'protocol' | 'origin' | 'href' | 'path' | 'query'>;
+export declare function isRedirectResponse(response: NodeResponse): boolean;
+export declare function isResponse(value: any): value is NodeResponse;
+export declare const getPathWithoutEntry: (pathname: string, entryPath: string) => string;
+export declare const handleRequest: ({
+  context,
+  serverRoutes,
+  distDir
+}: {
+  context: ServerContext;
+  serverRoutes: ServerRoute[];
+  distDir: string;
+}) => Promise<void>;
 
 declare const _default: () => ServerPlugin;
 

package/package.json

@@ -11,10 +11,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.5.0-alpha.0",
-  "engines": {
-    "node": ">=14.17.6"
-  },
+  "version": "2.6.0",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
@@ -27,10 +24,6 @@
     "./server": {
       "jsnext:source": "./src/server/index.ts",
       "default": "./dist/cjs/server/index.js"
-    },
-    "./runtime": {
-      "jsnext:source": "./src/runtime/index.ts",
-      "default": "./dist/esm/runtime/index.js"
     }
   },
   "typesVersions": {
@@ -40,19 +33,16 @@
       ],
       "server": [
         "./dist/types/server/index.d.ts"
-      ],
-      "runtime": [
-        "./dist/types/runtime/index.d.ts"
       ]
     }
   },
   "dependencies": {
     "@babel/core": "^7.18.0",
     "@babel/runtime": "^7.18.0",
-    "@remix-run/node": "^1.12.0",
+    "@remix-run/node": "^1.9.0",
     "path-to-regexp": "^6.2.0",
-    "react-router-dom": "^6.8.1",
-    "@modern-js/utils": "2.5.0-alpha.0"
+    "react-router-dom": "^6.6.0",
+    "@modern-js/utils": "2.6.0"
   },
   "devDependencies": {
     "@types/babel__core": "^7.1.15",
@@ -67,12 +57,11 @@
     "typescript": "^4",
     "webpack": "^5.75.0",
     "webpack-chain": "^6.5.1",
-    "@modern-js/core": "2.5.0",
-    "@modern-js/types": "2.5.0",
-    "@scripts/build": "2.5.0",
-    "@modern-js/server-core": "2.5.0",
-    "@modern-js/plugin-module-babel": "2.5.0",
-    "@scripts/jest-config": "2.5.0"
+    "@modern-js/core": "2.6.0",
+    "@modern-js/server-core": "2.6.0",
+    "@modern-js/types": "2.6.0",
+    "@scripts/build": "2.6.0",
+    "@scripts/jest-config": "2.6.0"
   },
   "sideEffects": false,
   "publishConfig": {

package/dist/cjs/cli/data.js

@@ -1,162 +0,0 @@
-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 data_exports = {};
-__export(data_exports, {
-  parseDeferredReadableStream: () => parseDeferredReadableStream
-});
-module.exports = __toCommonJS(data_exports);
-var import_remix_router = require("@modern-js/utils/remix-router");
-const DEFERRED_VALUE_PLACEHOLDER_PREFIX = "__deferred_promise:";
-async function parseDeferredReadableStream(stream) {
-  if (!stream) {
-    throw new Error("parseDeferredReadableStream requires stream argument");
-  }
-  let deferredData;
-  const deferredResolvers = {};
-  try {
-    const sectionReader = readStreamSections(stream);
-    const initialSectionResult = await sectionReader.next();
-    const initialSection = initialSectionResult.value;
-    if (!initialSection) {
-      throw new Error("no critical data");
-    }
-    const criticalData = JSON.parse(initialSection);
-    if (typeof criticalData === "object" && criticalData !== null) {
-      for (const [eventKey, value] of Object.entries(criticalData)) {
-        if (typeof value !== "string" || !value.startsWith(DEFERRED_VALUE_PLACEHOLDER_PREFIX)) {
-          continue;
-        }
-        deferredData = deferredData || {};
-        deferredData[eventKey] = new Promise((resolve, reject) => {
-          deferredResolvers[eventKey] = {
-            resolve: (value2) => {
-              resolve(value2);
-              delete deferredResolvers[eventKey];
-            },
-            reject: (error) => {
-              reject(error);
-              delete deferredResolvers[eventKey];
-            }
-          };
-        });
-      }
-    }
-    (async () => {
-      try {
-        for await (const section of sectionReader) {
-          const [event, ...sectionDataStrings] = section.split(":");
-          const sectionDataString = sectionDataStrings.join(":");
-          const data = JSON.parse(sectionDataString);
-          if (event === "data") {
-            for (const [key, value] of Object.entries(data)) {
-              if (deferredResolvers[key]) {
-                deferredResolvers[key].resolve(value);
-              }
-            }
-          } else if (event === "error") {
-            for (const [key, value] of Object.entries(data)) {
-              const err = new Error(value.message);
-              err.stack = value.stack;
-              if (deferredResolvers[key]) {
-                deferredResolvers[key].reject(err);
-              }
-            }
-          }
-        }
-        for (const [key, resolver] of Object.entries(deferredResolvers)) {
-          resolver.reject(
-            new import_remix_router.AbortedDeferredError(`Deferred ${key} will never resolved`)
-          );
-        }
-      } catch (error) {
-        for (const resolver of Object.values(deferredResolvers)) {
-          resolver.reject(error);
-        }
-      }
-    })();
-    return new import_remix_router.UNSAFE_DeferredData({ ...criticalData, ...deferredData });
-  } catch (error) {
-    for (const resolver of Object.values(deferredResolvers)) {
-      resolver.reject(error);
-    }
-    throw error;
-  }
-}
-async function* readStreamSections(stream) {
-  const reader = stream.getReader();
-  let buffer = [];
-  let sections = [];
-  let closed = false;
-  const encoder = new TextEncoder();
-  const decoder = new TextDecoder();
-  const readStreamSection = async () => {
-    if (sections.length > 0) {
-      return sections.shift();
-    }
-    while (!closed && sections.length === 0) {
-      const chunk = await reader.read();
-      if (chunk.done) {
-        closed = true;
-        break;
-      }
-      buffer.push(chunk.value);
-      try {
-        const bufferedString = decoder.decode(mergeArrays(...buffer));
-        const splitSections = bufferedString.split("\n\n");
-        if (splitSections.length >= 2) {
-          sections.push(...splitSections.slice(0, -1));
-          buffer = [encoder.encode(splitSections.slice(-1).join("\n\n"))];
-        }
-        if (sections.length > 0) {
-          break;
-        }
-      } catch {
-        continue;
-      }
-    }
-    if (sections.length > 0) {
-      return sections.shift();
-    }
-    if (buffer.length > 0) {
-      const bufferedString = decoder.decode(mergeArrays(...buffer));
-      sections = bufferedString.split("\n\n").filter((s) => s);
-      buffer = [];
-    }
-    return sections.shift();
-  };
-  let section = await readStreamSection();
-  while (section) {
-    yield section;
-    section = await readStreamSection();
-  }
-}
-function mergeArrays(...arrays) {
-  const out = new Uint8Array(
-    arrays.reduce((total, arr) => total + arr.length, 0)
-  );
-  let offset = 0;
-  for (const arr of arrays) {
-    out.set(arr, offset);
-    offset += arr.length;
-  }
-  return out;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  parseDeferredReadableStream
-});

package/dist/cjs/runtime/index.js

@@ -1,159 +0,0 @@
-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 runtime_exports = {};
-__export(runtime_exports, {
-  handleRequest: () => handleRequest,
-  isRedirectResponse: () => isRedirectResponse,
-  isResponse: () => isResponse,
-  matchEntry: () => matchEntry
-});
-module.exports = __toCommonJS(runtime_exports);
-var import_node = require("@remix-run/node");
-var import_utils = require("@modern-js/utils");
-var import_remix_router = require("@modern-js/utils/remix-router");
-var import_constants = require("../common/constants");
-var import_response = require("./response");
-(0, import_node.installGlobals)();
-const redirectStatusCodes = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
-function isRedirectResponse(status) {
-  return redirectStatusCodes.has(status);
-}
-function isResponse(value) {
-  return value != null && typeof value.status === "number" && typeof value.statusText === "string" && typeof value.headers === "object" && typeof value.body !== "undefined";
-}
-function convertModernRedirectResponse(headers) {
-  const newHeaders = new Headers(headers);
-  newHeaders.set("X-Modernjs-Redirect", headers.get("Location"));
-  newHeaders.delete("Location");
-  return new import_node.Response(null, {
-    status: 204,
-    headers: newHeaders
-  });
-}
-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 matchEntry = (pathname, entries) => {
-  return entries.find((entry) => pathname.startsWith(entry.urlPath));
-};
-const handleRequest = async ({
-  context,
-  serverRoutes,
-  routes
-}) => {
-  const { method, query } = context;
-  const routeId = query[import_constants.LOADER_ID_PARAM];
-  if (!routeId) {
-    throw new Error(`Missing parameter: ${import_constants.LOADER_ID_PARAM}`);
-  }
-  if (method.toLowerCase() !== "get") {
-    throw new Error("Only support httpp GET method");
-  }
-  const entry = matchEntry(context.path, serverRoutes);
-  if (!entry) {
-    throw new Error("Route is not matched");
-  }
-  const dataRoutes = (0, import_utils.transformNestedRoutes)(routes);
-  const staticHandler = (0, import_remix_router.createStaticHandler)(dataRoutes, {
-    basename: entry.urlPath
-  });
-  const { res } = context;
-  const request = createLoaderRequest(context);
-  let response;
-  try {
-    response = await staticHandler.queryRoute(request, {
-      routeId,
-      requestContext: context
-    });
-    if (isResponse(response) && isRedirectResponse(response.status)) {
-      response = convertModernRedirectResponse(response.headers);
-    } else if (import_remix_router.UNSAFE_DEFERRED_SYMBOL in response) {
-      const deferredData = response[import_remix_router.UNSAFE_DEFERRED_SYMBOL];
-      const body = (0, import_response.createDeferredReadableStream)(deferredData, request.signal);
-      const init = deferredData.init || {};
-      if (init.status && isRedirectResponse(init.status)) {
-        if (!init.headers) {
-          throw new Error("redirect response includes no headers");
-        }
-        response = convertModernRedirectResponse(new Headers(init.headers));
-      } else {
-        const headers = new Headers(init.headers);
-        headers.set("Content-Type", "text/modernjs-deferred");
-        init.headers = headers;
-        response = new import_node.Response(body, init);
-      }
-    } else {
-      response = isResponse(response) ? response : new import_node.Response(JSON.stringify(response), {
-        headers: {
-          "Content-Type": "application/json; charset=utf-8"
-        }
-      });
-    }
-  } catch (error) {
-    const message = error instanceof import_remix_router.ErrorResponse ? error.data : String(error);
-    response = new import_node.Response(message, {
-      status: 500,
-      headers: {
-        "Content-Type": "text/plain"
-      }
-    });
-  }
-  sendLoaderResponse(res, response);
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  handleRequest,
-  isRedirectResponse,
-  isResponse,
-  matchEntry
-});