@modern-js/plugin-data-loader 0.0.0-next-20221104140607

package/dist/js/treeshaking/server/index.js

@@ -0,0 +1,365 @@
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import { installGlobals, writeReadableStreamToWritable, Response as NodeResponse } from '@remix-run/node';
+import { matchRoutes } from 'react-router-dom';
+// Polyfill Web Fetch API
+installGlobals();
+var LOADER_SEARCH_PARAM = '_loader';
+var redirectStatusCodes = new Set([301, 302, 303, 307, 308]);
+export function isRedirectResponse(response) {
+  return redirectStatusCodes.has(response.status);
+}
+export function isResponse(value) {
+  return value != null && typeof value.status === 'number' && typeof value.statusText === 'string' && _typeof(value.headers) === 'object' && typeof value.body !== 'undefined';
+}
+
+var json = function json(data) {
+  var init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var responseInit = typeof init === 'number' ? {
+    status: init
+  } : init;
+  var 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), _objectSpread(_objectSpread({}, responseInit), {}, {
+    headers: headers
+  }));
+}; // TODO: 添加 context
+
+
+var callRouteLoader = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref) {
+    var routeId, loader, params, request, loadContext, result;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            routeId = _ref.routeId, loader = _ref.loader, params = _ref.params, request = _ref.request, loadContext = _ref.loadContext;
+
+            if (loader) {
+              _context.next = 3;
+              break;
+            }
+
+            throw new Error("You made a ".concat(request.method, " request to ").concat(request.url, " but did not provide ") + "a default component or `loader` for route \"".concat(routeId, "\", ") + "so there is no way to handle the request.");
+
+          case 3:
+            _context.prev = 3;
+            _context.next = 6;
+            return loader({
+              request: request,
+              params: params
+            });
+
+          case 6:
+            result = _context.sent;
+            _context.next = 14;
+            break;
+
+          case 9:
+            _context.prev = 9;
+            _context.t0 = _context["catch"](3);
+
+            if (isResponse(_context.t0)) {
+              _context.next = 13;
+              break;
+            }
+
+            throw _context.t0;
+
+          case 13:
+            result = _context.t0;
+
+          case 14:
+            if (!(result === undefined)) {
+              _context.next = 16;
+              break;
+            }
+
+            throw new Error("You defined a loader for route \"".concat(routeId, "\" but didn't return ") + "anything from your `loader` function. Please return a value or `null`.");
+
+          case 16:
+            return _context.abrupt("return", isResponse(result) ? result : json(result));
+
+          case 17:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee, null, [[3, 9]]);
+  }));
+
+  return function callRouteLoader(_x) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+
+var createLoaderHeaders = function createLoaderHeaders(requestHeaders) {
+  var headers = new Headers();
+
+  for (var _i = 0, _Object$entries = Object.entries(requestHeaders); _i < _Object$entries.length; _i++) {
+    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+        _key = _Object$entries$_i[0],
+        values = _Object$entries$_i[1];
+
+    if (values) {
+      if (Array.isArray(values)) {
+        var _iterator = _createForOfIteratorHelper(values),
+            _step;
+
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var value = _step.value;
+            headers.append(_key, value);
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+      } else {
+        headers.set(_key, values);
+      }
+    }
+  }
+
+  return headers;
+};
+
+var createLoaderRequest = function createLoaderRequest(context) {
+  var origin = "".concat(context.protocol, "://").concat(context.host); // eslint-disable-next-line node/no-unsupported-features/node-builtins, node/prefer-global/url
+
+  var url = new URL(context.url, origin);
+  var controller = new AbortController();
+  var init = {
+    method: context.method,
+    headers: createLoaderHeaders(context.headers),
+    signal: controller.signal
+  };
+  return new Request(url.href, init);
+};
+
+var sendLoaderResponse = /*#__PURE__*/function () {
+  var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(res, nodeResponse) {
+    var _iterator2, _step2, _step2$value, _key2, value;
+
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            res.statusMessage = nodeResponse.statusText;
+            res.statusCode = nodeResponse.status;
+            _iterator2 = _createForOfIteratorHelper(nodeResponse.headers.entries());
+
+            try {
+              for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                _step2$value = _slicedToArray(_step2.value, 2), _key2 = _step2$value[0], value = _step2$value[1];
+                res.setHeader(_key2, value);
+              }
+            } catch (err) {
+              _iterator2.e(err);
+            } finally {
+              _iterator2.f();
+            }
+
+            if (!nodeResponse.body) {
+              _context2.next = 9;
+              break;
+            }
+
+            _context2.next = 7;
+            return writeReadableStreamToWritable(nodeResponse.body, res);
+
+          case 7:
+            _context2.next = 10;
+            break;
+
+          case 9:
+            res.end();
+
+          case 10:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+
+  return function sendLoaderResponse(_x2, _x3) {
+    return _ref3.apply(this, arguments);
+  };
+}();
+
+export var getPathWithoutEntry = function getPathWithoutEntry(pathname, entryPath) {
+  if (entryPath === '/') {
+    return pathname;
+  }
+
+  return pathname.replace(entryPath, '');
+};
+
+var matchEntry = function matchEntry(pathname, entries) {
+  return entries.find(function (entry) {
+    return pathname.startsWith(entry.urlPath);
+  });
+};
+
+export var handleRequest = /*#__PURE__*/function () {
+  var _ref5 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(_ref4) {
+    var context, serverRoutes, distDir, method, query, routeId, entry, _yield$import, routes, res, pathname, matches, match, request, response, message;
+
+    return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            context = _ref4.context, serverRoutes = _ref4.serverRoutes, distDir = _ref4.distDir;
+            method = context.method, query = context.query;
+            routeId = query[LOADER_SEARCH_PARAM];
+
+            if (!(!routeId || method.toLowerCase() !== 'get')) {
+              _context3.next = 5;
+              break;
+            }
+
+            return _context3.abrupt("return");
+
+          case 5:
+            entry = matchEntry(context.path, serverRoutes);
+
+            if (entry) {
+              _context3.next = 8;
+              break;
+            }
+
+            return _context3.abrupt("return");
+
+          case 8:
+            _context3.next = 10;
+            return import("".concat(distDir, "/loader-routes/").concat(entry.entryName));
+
+          case 10:
+            _yield$import = _context3.sent;
+            routes = _yield$import.routes;
+
+            if (routes) {
+              _context3.next = 14;
+              break;
+            }
+
+            return _context3.abrupt("return");
+
+          case 14:
+            res = context.res;
+            pathname = getPathWithoutEntry(context.path, entry.urlPath);
+            matches = matchRoutes(routes, pathname);
+
+            if (matches) {
+              _context3.next = 21;
+              break;
+            }
+
+            res.statusCode = 403;
+            res.end("Route ".concat(pathname, " was not matched"));
+            return _context3.abrupt("return");
+
+          case 21:
+            match = matches === null || matches === void 0 ? void 0 : matches.find(function (match) {
+              return match.route.id === routeId;
+            });
+
+            if (match) {
+              _context3.next = 26;
+              break;
+            }
+
+            res.statusCode = 403;
+            res.end("Route ".concat(routeId, " does not match URL ").concat(context.path));
+            return _context3.abrupt("return");
+
+          case 26:
+            request = createLoaderRequest(context);
+            _context3.prev = 27;
+            _context3.next = 30;
+            return callRouteLoader({
+              loader: match.route.loader,
+              routeId: match.route.id,
+              params: match.params,
+              request: request,
+              loadContext: {}
+            });
+
+          case 30:
+            response = _context3.sent;
+            _context3.next = 37;
+            break;
+
+          case 33:
+            _context3.prev = 33;
+            _context3.t0 = _context3["catch"](27);
+            message = String(_context3.t0);
+            response = new NodeResponse(message, {
+              status: 500,
+              headers: {
+                'Content-Type': 'text/plain'
+              }
+            });
+
+          case 37:
+            sendLoaderResponse(res, response);
+
+          case 38:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3, null, [[27, 33]]);
+  }));
+
+  return function handleRequest(_x4) {
+    return _ref5.apply(this, arguments);
+  };
+}();
+export default (function () {
+  return {
+    name: '@modern-js/plugin-data-loader',
+    setup: function setup() {
+      return {
+        preparebeforeRouteHandler: function preparebeforeRouteHandler(_ref6) {
+          var serverRoutes = _ref6.serverRoutes,
+              distDir = _ref6.distDir;
+          return /*#__PURE__*/function () {
+            var _ref7 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(context) {
+              return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+                while (1) {
+                  switch (_context4.prev = _context4.next) {
+                    case 0:
+                      return _context4.abrupt("return", handleRequest({
+                        serverRoutes: serverRoutes,
+                        distDir: distDir,
+                        context: context
+                      }));
+
+                    case 1:
+                    case "end":
+                      return _context4.stop();
+                  }
+                }
+              }, _callee4);
+            }));
+
+            return function (_x5) {
+              return _ref7.apply(this, arguments);
+            };
+          }();
+        }
+      };
+    }
+  };
+});

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

@@ -0,0 +1,16 @@
+export declare const getRequestUrl: ({
+  params,
+  request,
+  routeId
+}: {
+  params: Record<string, string>;
+  request: Request;
+  routeId: string;
+}) => URL;
+export declare const createRequest: (routeId: string, method?: string) => ({
+  params,
+  request
+}: {
+  params: Record<string, string>;
+  request: Request;
+}) => Promise<Response>;

package/dist/types/cli/generate-client.d.ts

@@ -0,0 +1,7 @@
+export declare const generateClient: ({
+  basedir,
+  filename
+}: {
+  basedir: string;
+  filename: string;
+}) => string;

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

@@ -0,0 +1,4 @@
+import type { LoaderContext } from 'webpack';
+export default function loader(this: LoaderContext<{
+  routesDir: string;
+}>, source: string): Promise<string>;

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

@@ -0,0 +1,20 @@
+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 declare 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;
+
+export default _default;

package/package.json

@@ -0,0 +1,103 @@
+{
+  "name": "@modern-js/plugin-data-loader",
+  "description": "The meta-framework suite designed from scratch for frontend-focused modern web development.",
+  "homepage": "https://modernjs.dev",
+  "bugs": "https://github.com/modern-js-dev/modern.js/issues",
+  "repository": "modern-js-dev/modern.js",
+  "license": "MIT",
+  "keywords": [
+    "react",
+    "framework",
+    "modern",
+    "modern.js"
+  ],
+  "version": "0.0.0-next-20221104140607",
+  "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",
+  "exports": {
+    "./loader": {
+      "jsnext:source": "./src/cli/loader.ts",
+      "default": "./dist/js/node/cli/loader.js"
+    },
+    "./server": {
+      "jsnext:source": "./src/server/index.ts",
+      "default": "./dist/js/node/server/index.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "loader": [
+        "./dist/types/cli/loader.d.ts"
+      ],
+      "server": [
+        "./dist/types/server/index.d.ts"
+      ]
+    }
+  },
+  "dependencies": {
+    "@babel/core": "^7.18.0",
+    "@babel/runtime": "^7.18.0",
+    "@modern-js/babel-compiler": "0.0.0-next-20221104140607",
+    "@modern-js/utils": "0.0.0-next-20221104140607",
+    "@remix-run/node": "^1.7.0",
+    "path-to-regexp": "^6.2.0",
+    "react-router-dom": "^6.4.2"
+  },
+  "devDependencies": {
+    "@modern-js/core": "0.0.0-next-20221104140607",
+    "@modern-js/runtime": "0.0.0-next-20221104140607",
+    "@modern-js/server-core": "0.0.0-next-20221104140607",
+    "@modern-js/types": "0.0.0-next-20221104140607",
+    "@scripts/build": "0.0.0-next-20221104140607",
+    "@scripts/jest-config": "0.0.0-next-20221104140607",
+    "@types/babel__core": "^7.1.15",
+    "@types/jest": "^27",
+    "@types/node": "^14",
+    "@types/supertest": "^2.0.11",
+    "isomorphic-fetch": "^3.0.0",
+    "jest": "^27",
+    "memfs": "^3.3.0",
+    "supertest": "^6.1.6",
+    "ts-jest": "^27.0.5",
+    "typescript": "^4",
+    "webpack": "^5.74.0",
+    "webpack-chain": "^6.5.1"
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "wireit": {
+    "build": {
+      "command": "modern build",
+      "files": [
+        "src/**/*",
+        "tsconfig.json",
+        "package.json"
+      ],
+      "output": [
+        "dist/**/*"
+      ]
+    },
+    "test": {
+      "command": "jest --passWithNoTests",
+      "files": [
+        "src/**/*",
+        "tsconfig.json",
+        "package.json",
+        "tests/**/*"
+      ],
+      "output": []
+    }
+  },
+  "scripts": {
+    "new": "modern new",
+    "build": "wireit",
+    "dev": "modern build --watch",
+    "test": "wireit"
+  }
+}