@modern-js/plugin-express 2.0.0-beta.3 → 2.0.0-beta.6

package/dist/js/node/utils.js

@@ -1,35 +1,87 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+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 __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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+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());
+  });
+};
+var utils_exports = {};
+__export(utils_exports, {
+  createRouteHandler: () => createRouteHandler,
+  isNormalMethod: () => isNormalMethod
 });
-exports.isNormalMethod = exports.createRouteHandler = void 0;
-require("reflect-metadata");
-var _bffCore = require("@modern-js/bff-core");
-var _bffRuntime = require("@modern-js/bff-runtime");
-var _typeIs = _interopRequireDefault(require("type-is"));
-var _formidable = _interopRequireDefault(require("formidable"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+module.exports = __toCommonJS(utils_exports);
+var import_reflect_metadata = require("reflect-metadata");
+var import_bff_core = require("@modern-js/bff-core");
+var import_bff_runtime = require("@modern-js/bff-runtime");
+var import_type_is = __toESM(require("type-is"));
+var import_formidable = __toESM(require("formidable"));
 const handleResponseMeta = (res, handler) => {
-  const responseMeta = Reflect.getMetadata(_bffCore.HttpMetadata.Response, handler);
+  const responseMeta = Reflect.getMetadata(import_bff_core.HttpMetadata.Response, handler);
   if (Array.isArray(responseMeta)) {
     for (const meta of responseMeta) {
       const metaType = meta.type;
       const metaValue = meta.value;
       switch (metaType) {
-        case _bffCore.ResponseMetaType.Headers:
-          // eslint-disable-next-line @typescript-eslint/ban-types
+        case import_bff_core.ResponseMetaType.Headers:
           for (const [key, value] of Object.entries(metaValue)) {
             res.append(key, value);
           }
           break;
-        case _bffCore.ResponseMetaType.Redirect:
+        case import_bff_core.ResponseMetaType.Redirect:
           res.redirect(metaValue);
           break;
-        case _bffCore.ResponseMetaType.StatusCode:
+        case import_bff_core.ResponseMetaType.StatusCode:
           res.status(metaValue);
           break;
         default:
@@ -38,91 +90,86 @@ const handleResponseMeta = (res, handler) => {
     }
   }
 };
-const createRouteHandler = handler => {
-  const apiHandler = async (req, res, next) => {
-    const input = await getInputFromRequest(req);
-    if ((0, _bffCore.isWithMetaHandler)(handler)) {
+const createRouteHandler = (handler) => {
+  const apiHandler = (req, res, next) => __async(void 0, null, function* () {
+    const input = yield getInputFromRequest(req);
+    if ((0, import_bff_core.isWithMetaHandler)(handler)) {
       try {
         handleResponseMeta(res, handler);
         if (res.headersSent) {
           return;
         }
-        const result = await handler(input);
-        if (result && typeof result === 'object') {
-          // eslint-disable-next-line consistent-return
+        const result = yield handler(input);
+        if (result && typeof result === "object") {
           return res.json(result);
         }
       } catch (error) {
-        if (error instanceof _bffCore.ValidationError) {
+        if (error instanceof import_bff_core.ValidationError) {
           res.status(error.status);
-          // eslint-disable-next-line consistent-return
           return res.json({
             message: error.message
           });
         }
         throw error;
       }
-    } else if ((0, _bffRuntime.isSchemaHandler)(handler)) {
-      const result = await handler(input);
-      if (result.type !== 'HandleSuccess') {
-        if (result.type === 'InputValidationError') {
+    } else if ((0, import_bff_runtime.isSchemaHandler)(handler)) {
+      const result1 = yield handler(input);
+      if (result1.type !== "HandleSuccess") {
+        if (result1.type === "InputValidationError") {
           res.status(400);
         } else {
           res.status(500);
         }
-        // eslint-disable-next-line consistent-return
-        return res.json(result.message);
+        return res.json(result1.message);
       } else {
         res.status(200);
-        // eslint-disable-next-line consistent-return
-        return res.json(result.value);
+        return res.json(result1.value);
       }
     } else {
       const args = Object.values(input.params).concat(input);
       try {
-        const body = await handler(...args);
-
-        // this should never happen
+        const body = yield handler(...args);
         if (res.headersSent) {
-          // eslint-disable-next-line consistent-return
-          return await Promise.resolve();
+          return yield Promise.resolve();
         }
-        if (typeof body !== 'undefined') {
-          // eslint-disable-next-line consistent-return
+        if (typeof body !== "undefined") {
           return res.json(body);
         }
       } catch (e) {
-        // eslint-disable-next-line consistent-return
         return next(e);
       }
     }
-  };
+  });
   Object.defineProperties(apiHandler, Object.getOwnPropertyDescriptors(handler));
   return apiHandler;
 };
-exports.createRouteHandler = createRouteHandler;
-const isNormalMethod = httpMethod => _bffCore.httpMethods.includes(httpMethod);
-exports.isNormalMethod = isNormalMethod;
-const getInputFromRequest = async request => {
+const isNormalMethod = (httpMethod) => import_bff_core.httpMethods.includes(httpMethod);
+const getInputFromRequest = (request) => __async(void 0, null, function* () {
   const draft = {
     params: request.params,
     query: request.query,
     headers: request.headers,
     cookies: request.headers.cookie
   };
-  if ((0, _typeIs.default)(request, ['application/json'])) {
+  if ((0, import_type_is.default)(request, [
+    "application/json"
+  ])) {
     draft.data = request.body;
-  } else if ((0, _typeIs.default)(request, ['multipart/form-data'])) {
-    draft.formData = await resolveFormData(request);
-  } else if ((0, _typeIs.default)(request, ['application/x-www-form-urlencoded'])) {
+  } else if ((0, import_type_is.default)(request, [
+    "multipart/form-data"
+  ])) {
+    draft.formData = yield resolveFormData(request);
+  } else if ((0, import_type_is.default)(request, [
+    "application/x-www-form-urlencoded"
+  ])) {
     draft.formUrlencoded = request.body;
   } else {
     draft.body = request.body;
   }
   return draft;
-};
-const resolveFormData = request => {
-  const form = (0, _formidable.default)({
+});
+const resolveFormData = (request) => {
+  const form = (0, import_formidable.default)({
     multiples: true
   });
   return new Promise((resolve, reject) => {
@@ -130,7 +177,12 @@ const resolveFormData = request => {
       if (err) {
         reject(err);
       }
-      resolve(_objectSpread(_objectSpread({}, fields), files));
+      resolve(__spreadValues(__spreadValues({}, fields), files));
     });
   });
-};
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRouteHandler,
+  isNormalMethod
+});

package/dist/js/treeshaking/cli/index.js

@@ -0,0 +1,58 @@
+import * as path from "path";
+import { createRuntimeExportsUtils } from "@modern-js/utils";
+import { getRelativeRuntimePath } from "@modern-js/bff-core";
+var cli_default = function() {
+    return {
+        name: "@modern-js/plugin-express",
+        setup: function(api) {
+            var bffExportsUtils;
+            var useAppContext = api.useAppContext;
+            var runtimeModulePath = path.resolve(__dirname, "../runtime");
+            return {
+                config: function config() {
+                    var appContext = useAppContext();
+                    var appDirectory = appContext.appDirectory;
+                    bffExportsUtils = createRuntimeExportsUtils(appContext.internalDirectory, "server");
+                    var serverRuntimePath = bffExportsUtils.getPath();
+                    var relativeRuntimePath = getRelativeRuntimePath(appDirectory, serverRuntimePath);
+                    if (process.env.NODE_ENV === "production") {
+                        return {
+                            source: {
+                                alias: {
+                                    "@modern-js/runtime/server": relativeRuntimePath,
+                                    "@modern-js/runtime/express": relativeRuntimePath
+                                }
+                            }
+                        };
+                    } else {
+                        return {
+                            source: {
+                                alias: {
+                                    "@modern-js/runtime/server": serverRuntimePath,
+                                    "@modern-js/runtime/express": serverRuntimePath
+                                }
+                            }
+                        };
+                    }
+                },
+                collectServerPlugins: function collectServerPlugins(param) {
+                    var plugins = param.plugins;
+                    plugins.push({
+                        "@modern-js/plugin-express": "@modern-js/plugin-express/server"
+                    });
+                    return {
+                        plugins: plugins
+                    };
+                },
+                addRuntimeExports: function addRuntimeExports(input) {
+                    var currentFile = bffExportsUtils.getPath();
+                    var relativeRuntimeModulePath = path.relative(path.dirname(currentFile), runtimeModulePath);
+                    var relativeFramePath = path.relative(path.dirname(currentFile), require.resolve("express"));
+                    bffExportsUtils.addExport("const pluginRuntime = require('".concat(relativeRuntimeModulePath, "');\n           const express = require('").concat(relativeFramePath, "')\n           module.exports = {\n            express: express,\n             ...pluginRuntime\n           }\n          "));
+                    return input;
+                }
+            };
+        }
+    };
+};
+export { cli_default as default };

package/dist/js/treeshaking/context.js

@@ -0,0 +1,3 @@
+import { createStorage } from "@modern-js/bff-core";
+var ref = createStorage(), run = ref.run, useContext = ref.useContext;
+export { run, useContext };

package/dist/js/treeshaking/index.js

@@ -0,0 +1,4 @@
+import plugin from "./plugin";
+export * from "./context";
+var src_default = plugin;
+export { src_default as default };