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

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

@@ -0,0 +1,143 @@
+import {
+  installGlobals,
+  writeReadableStreamToWritable,
+  Response as NodeResponse
+} from "@remix-run/node";
+import {
+  transformNestedRoutes
+} from "@modern-js/utils";
+import {
+  createStaticHandler,
+  ErrorResponse,
+  UNSAFE_DEFERRED_SYMBOL as DEFERRED_SYMBOL
+} from "@modern-js/utils/remix-router";
+import { LOADER_ID_PARAM } from "../common/constants";
+import { createDeferredReadableStream } from "./response";
+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 NodeResponse(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 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[LOADER_ID_PARAM];
+  if (!routeId) {
+    throw new Error(`Missing parameter: ${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 = transformNestedRoutes(routes);
+  const staticHandler = 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 (DEFERRED_SYMBOL in response) {
+      const deferredData = response[DEFERRED_SYMBOL];
+      const body = 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 NodeResponse(body, init);
+      }
+    } else {
+      response = isResponse(response) ? response : new NodeResponse(JSON.stringify(response), {
+        headers: {
+          "Content-Type": "application/json; charset=utf-8"
+        }
+      });
+    }
+  } catch (error) {
+    const message = error instanceof ErrorResponse ? error.data : String(error);
+    response = new NodeResponse(message, {
+      status: 500,
+      headers: {
+        "Content-Type": "text/plain"
+      }
+    });
+  }
+  sendLoaderResponse(res, response);
+};
+export {
+  handleRequest,
+  isRedirectResponse,
+  isResponse,
+  matchEntry
+};

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

@@ -0,0 +1,79 @@
+import { TextEncoder } from "util";
+import { serializeJson } from "@modern-js/utils";
+function isTrackedPromise(value) {
+  return value != null && typeof value.then === "function" && value._tracked === true;
+}
+const DEFERRED_VALUE_PLACEHOLDER_PREFIX = "__deferred_promise:";
+function createDeferredReadableStream(deferredData, signal) {
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    async start(controller) {
+      const criticalData = {};
+      const preresolvedKeys = [];
+      for (const [key, value] of Object.entries(deferredData.data)) {
+        if (isTrackedPromise(value)) {
+          criticalData[key] = `${DEFERRED_VALUE_PLACEHOLDER_PREFIX}${key}`;
+          if (typeof value._data !== "undefined" || typeof value._error !== "undefined") {
+            preresolvedKeys.push(key);
+          }
+        } else {
+          criticalData[key] = value;
+        }
+      }
+      controller.enqueue(encoder.encode(`${JSON.stringify(criticalData)}
+
+`));
+      for (const preresolvedKey of preresolvedKeys) {
+        enqueueTrackedPromise(
+          controller,
+          encoder,
+          preresolvedKey,
+          deferredData.data[preresolvedKey]
+        );
+      }
+      const unsubscribe = deferredData.subscribe((aborted, settledKey) => {
+        if (settledKey) {
+          enqueueTrackedPromise(
+            controller,
+            encoder,
+            settledKey,
+            deferredData.data[settledKey]
+          );
+        }
+      });
+      await deferredData.resolveData(signal);
+      unsubscribe();
+      controller.close();
+    }
+  });
+  return stream;
+}
+function enqueueTrackedPromise(controller, encoder, settledKey, promise) {
+  var _a;
+  if ("_error" in promise) {
+    const { _error } = promise;
+    controller.enqueue(
+      encoder.encode(
+        `error:${serializeJson({
+          [settledKey]: {
+            message: _error.message,
+            stack: _error.stack
+          }
+        })}
+
+`
+      )
+    );
+  } else {
+    controller.enqueue(
+      encoder.encode(
+        `data:${JSON.stringify({ [settledKey]: (_a = promise._data) != null ? _a : null })}
+
+`
+      )
+    );
+  }
+}
+export {
+  createDeferredReadableStream
+};

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

@@ -0,0 +1,40 @@
+import path from "path";
+import {
+  MAIN_ENTRY_NAME,
+  SERVER_BUNDLE_DIRECTORY
+} from "@modern-js/utils";
+import { matchEntry } from "../runtime";
+var server_default = () => ({
+  name: "@modern-js/plugin-data-loader",
+  setup: () => ({
+    preparebeforeRouteHandler({
+      serverRoutes,
+      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
+        });
+      };
+    }
+  })
+});
+export {
+  server_default as default
+};

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

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

package/dist/types/cli/data.d.ts

@@ -0,0 +1,6 @@
+/**
+ * modified from https://github.com/remix-run/remix/blob/main/packages/remix-react/data.ts
+ * license at https://github.com/remix-run/remix/blob/main/LICENSE.md
+ */
+import { UNSAFE_DeferredData as DeferredData } from '@modern-js/utils/remix-router';
+export declare function parseDeferredReadableStream(stream: ReadableStream<Uint8Array>): Promise<DeferredData>;

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

@@ -0,0 +1,15 @@
+import type { ModernServerContext, NestedRoute, 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(status: number): boolean;
+export declare function isResponse(value: any): value is NodeResponse;
+export declare const matchEntry: (pathname: string, entries: ServerRoute[]) => ServerRoute | undefined;
+export declare const handleRequest: ({
+  context,
+  serverRoutes,
+  routes
+}: {
+  context: ServerContext;
+  serverRoutes: ServerRoute[];
+  routes: NestedRoute[];
+}) => Promise<void>;

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

@@ -0,0 +1,2 @@
+import { type UNSAFE_DeferredData as DeferredData } from '@modern-js/utils/remix-router';
+export declare function createDeferredReadableStream(deferredData: DeferredData, signal: AbortSignal): any;

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

@@ -1,19 +1,4 @@
 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,20 +11,26 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.4.0",
+  "version": "2.5.0-alpha.0",
+  "engines": {
+    "node": ">=14.17.6"
+  },
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
-  "main": "./dist/js/node/index.js",
-  "module": "./dist/js/treeshaking/index.js",
-  "jsnext:modern": "./dist/js/modern/index.js",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
   "exports": {
     "./loader": {
       "jsnext:source": "./src/cli/loader.ts",
-      "default": "./dist/js/node/cli/loader.js"
+      "default": "./dist/cjs/cli/loader.js"
     },
     "./server": {
       "jsnext:source": "./src/server/index.ts",
-      "default": "./dist/js/node/server/index.js"
+      "default": "./dist/cjs/server/index.js"
+    },
+    "./runtime": {
+      "jsnext:source": "./src/runtime/index.ts",
+      "default": "./dist/esm/runtime/index.js"
     }
   },
   "typesVersions": {
@@ -34,16 +40,19 @@
       ],
       "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.9.0",
+    "@remix-run/node": "^1.12.0",
     "path-to-regexp": "^6.2.0",
-    "react-router-dom": "^6.6.0",
-    "@modern-js/utils": "2.4.0"
+    "react-router-dom": "^6.8.1",
+    "@modern-js/utils": "2.5.0-alpha.0"
   },
   "devDependencies": {
     "@types/babel__core": "^7.1.15",
@@ -58,11 +67,12 @@
     "typescript": "^4",
     "webpack": "^5.75.0",
     "webpack-chain": "^6.5.1",
-    "@modern-js/core": "2.4.0",
-    "@modern-js/server-core": "2.4.0",
-    "@modern-js/types": "2.4.0",
-    "@scripts/jest-config": "2.4.0",
-    "@scripts/build": "2.4.0"
+    "@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"
   },
   "sideEffects": false,
   "publishConfig": {

package/dist/js/modern/cli/loader.js

@@ -1,40 +0,0 @@
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
-import { generateClient } from "./generate-client";
-function loader(source) {
-  return __async(this, null, function* () {
-    var _a;
-    this.cacheable();
-    const target = (_a = this._compiler) == null ? void 0 : _a.options.target;
-    if (target === "node") {
-      return source;
-    }
-    const options = this.getOptions();
-    const code = generateClient({
-      mapFile: options.mapFile,
-      loaderId: options.loaderId
-    });
-    return code;
-  });
-}
-export {
-  loader as default
-};

package/dist/js/modern/server/index.js

@@ -1,237 +0,0 @@
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
-import path from "path";
-import {
-  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), __spreadProps(__spreadValues({}, responseInit), {
-    headers
-  }));
-};
-const callRouteLoader = (_0) => __async(void 0, [_0], function* ({
-  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 = yield 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 = (res, nodeResponse) => __async(void 0, null, function* () {
-  res.statusMessage = nodeResponse.statusText;
-  res.statusCode = nodeResponse.status;
-  for (const [key, value] of nodeResponse.headers.entries()) {
-    res.setHeader(key, value);
-  }
-  if (nodeResponse.body) {
-    yield 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 = (_0) => __async(void 0, [_0], function* ({
-  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 } = yield 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 = yield 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: () => ({
-    preparebeforeRouteHandler({
-      serverRoutes,
-      distDir
-    }) {
-      return (context) => __async(this, null, function* () {
-        return handleRequest({
-          serverRoutes,
-          distDir,
-          context
-        });
-      });
-    }
-  })
-});
-export {
-  server_default as default,
-  getPathWithoutEntry,
-  handleRequest,
-  isRedirectResponse,
-  isResponse
-};