@modern-js/server-core 2.48.2 → 2.48.3-alpha.0

package/dist/cjs/base/utils/warmup.js

@@ -0,0 +1,43 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __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 warmup_exports = {};
+__export(warmup_exports, {
+  warmup: () => warmup
+});
+module.exports = __toCommonJS(warmup_exports);
+function warmup(bundles) {
+  bundles.forEach((bundle) => {
+    bundle && Promise.resolve().then(() => __toESM(require(bundle))).catch((_) => {
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  warmup
+});

package/dist/cjs/core/hono.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 hono_exports = {};
+module.exports = __toCommonJS(hono_exports);

package/dist/cjs/core/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var core_exports = {};
+module.exports = __toCommonJS(core_exports);
+__reExport(core_exports, require("./plugin"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./plugin")
+});

package/dist/cjs/{loadPlugins.js → core/loadPlugins.js}

@@ -22,7 +22,7 @@ __export(loadPlugins_exports, {
 });
 module.exports = __toCommonJS(loadPlugins_exports);
 var import_utils = require("@modern-js/utils");
-var import_plugin = require("./plugin");
+var import_plugin = require("../core/plugin");
 const resolvePlugin = (p, appDirectory) => {
   const isPluginInstance = typeof p !== "string";
   if (isPluginInstance) {
@@ -37,12 +37,9 @@ const resolvePlugin = (p, appDirectory) => {
     module: (0, import_plugin.createPlugin)(pluginInstance.setup, pluginInstance)
   };
 };
-const loadPlugins = (appDirectory, configPlugins, options) => {
-  const loadedPlugins = (0, import_utils.getInternalPlugins)(appDirectory, options.internalPlugins);
-  return [
-    ...loadedPlugins,
-    ...configPlugins
-  ].map((plugin) => {
+const loadPlugins = (appDirectory, internalPlugins) => {
+  const loadedPlugins = (0, import_utils.getInternalPlugins)(appDirectory, internalPlugins);
+  return loadedPlugins.map((plugin) => {
     const { module: module2 } = resolvePlugin(plugin, appDirectory);
     return module2;
   });

package/dist/cjs/{plugin.js → core/plugin.js}

@@ -35,10 +35,9 @@ const prepare = (0, import_plugin.createWaterfall)();
 const prepareLoaderHandler = (0, import_plugin.createAsyncPipeline)();
 const prepareWebServer = (0, import_plugin.createAsyncPipeline)();
 const prepareApiServer = (0, import_plugin.createAsyncPipeline)();
-const onApiChange = (0, import_plugin.createWaterfall)();
+const onApiChange = (0, import_plugin.createAsyncWaterfall)();
 const repack = (0, import_plugin.createWaterfall)();
 const beforeServerInit = (0, import_plugin.createAsyncWaterfall)();
-const afterServerInit = (0, import_plugin.createAsyncWaterfall)();
 const setupCompiler = (0, import_plugin.createParallelWorkflow)();
 const beforeRouteSet = (0, import_plugin.createAsyncPipeline)();
 const afterRouteSet = (0, import_plugin.createAsyncPipeline)();
@@ -82,7 +81,6 @@ const serverHooks = {
   repack,
   onApiChange,
   beforeServerInit,
-  afterServerInit,
   setupCompiler,
   beforeRouteSet,
   afterRouteSet,

package/dist/cjs/core/render.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 render_exports = {};
+module.exports = __toCommonJS(render_exports);

package/dist/cjs/core/server.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 server_exports = {};
+module.exports = __toCommonJS(server_exports);

package/dist/cjs/index.js

@@ -15,14 +15,16 @@ var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "defau
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var src_exports = {};
 module.exports = __toCommonJS(src_exports);
-__reExport(src_exports, require("./plugin"), module.exports);
+__reExport(src_exports, require("./core/plugin"), module.exports);
+__reExport(src_exports, require("./core/render"), module.exports);
 __reExport(src_exports, require("@modern-js/plugin"), module.exports);
-__reExport(src_exports, require("./loadPlugins"), module.exports);
+__reExport(src_exports, require("./core/loadPlugins"), module.exports);
 __reExport(src_exports, require("./types/config"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ...require("./plugin"),
+  ...require("./core/plugin"),
+  ...require("./core/render"),
   ...require("@modern-js/plugin"),
-  ...require("./loadPlugins"),
+  ...require("./core/loadPlugins"),
   ...require("./types/config")
 });

package/dist/esm/base/adapters/node/bff.js

@@ -0,0 +1,128 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _object_without_properties } from "@swc/helpers/_/_object_without_properties";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { isWebOnly } from "@modern-js/utils";
+import { getRenderHandler } from "../../../base/middlewares";
+import { createMiddlewareCollecter, getRuntimeEnv } from "../../utils";
+var bindBFFHandler = function() {
+  var _ref = _async_to_generator(function(server, options) {
+    var prefix, enableHandleWeb, httpMethodDecider, runtimeEnv, _createMiddlewareCollecter, getMiddlewares, collector, runner, webOnly, handler, renderHandler, _tmp;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          prefix = options.config.bff.prefix || "/api";
+          enableHandleWeb = options.config.bff.enableHandleWeb;
+          httpMethodDecider = options.config.bff.httpMethodDecider;
+          runtimeEnv = getRuntimeEnv();
+          if (runtimeEnv !== "node") {
+            return [
+              2
+            ];
+          }
+          _createMiddlewareCollecter = createMiddlewareCollecter(), getMiddlewares = _createMiddlewareCollecter.getMiddlewares, collector = _object_without_properties(_createMiddlewareCollecter, [
+            "getMiddlewares"
+          ]);
+          runner = server.runner;
+          return [
+            4,
+            runner.gather(collector)
+          ];
+        case 1:
+          _state.sent();
+          return [
+            4,
+            isWebOnly()
+          ];
+        case 2:
+          webOnly = _state.sent();
+          if (!webOnly)
+            return [
+              3,
+              3
+            ];
+          handler = function() {
+            var _ref2 = _async_to_generator(function(c, next) {
+              return _ts_generator(this, function(_state2) {
+                switch (_state2.label) {
+                  case 0:
+                    c.body("");
+                    return [
+                      4,
+                      next()
+                    ];
+                  case 1:
+                    _state2.sent();
+                    return [
+                      2
+                    ];
+                }
+              });
+            });
+            return function(c, next) {
+              return _ref2.apply(this, arguments);
+            };
+          }();
+          return [
+            3,
+            8
+          ];
+        case 3:
+          if (!enableHandleWeb)
+            return [
+              3,
+              5
+            ];
+          return [
+            4,
+            getRenderHandler(options)
+          ];
+        case 4:
+          _tmp = _state.sent();
+          return [
+            3,
+            6
+          ];
+        case 5:
+          _tmp = null;
+          _state.label = 6;
+        case 6:
+          renderHandler = _tmp;
+          return [
+            4,
+            server.runner.prepareApiServer({
+              pwd: options.pwd,
+              prefix,
+              render: renderHandler,
+              httpMethodDecider
+            }, {
+              onLast: function() {
+                return null;
+              }
+            })
+          ];
+        case 7:
+          handler = _state.sent();
+          _state.label = 8;
+        case 8:
+          if (handler) {
+            server.all("*", function(c, next) {
+              if (!c.req.path.startsWith(prefix) && !enableHandleWeb) {
+                return next();
+              } else {
+                return handler(c, next);
+              }
+            });
+          }
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return function bindBFFHandler2(server, options) {
+    return _ref.apply(this, arguments);
+  };
+}();
+export {
+  bindBFFHandler
+};

package/dist/esm/base/adapters/node/hono.js

@@ -0,0 +1,83 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+var httpCallBack2HonoMid = function(handler) {
+  return function() {
+    var _ref = _async_to_generator(function(context, next) {
+      var _context_env_node, req, res;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            _context_env_node = context.env.node, req = _context_env_node.req, res = _context_env_node.res;
+            req.__honoRequest = context.req;
+            req.__templates = context.get("templates") || {};
+            req.__serverManifest = context.get("serverManifest") || {};
+            return [
+              4,
+              handler(req, res)
+            ];
+          case 1:
+            _state.sent();
+            if (!res.headersSent)
+              return [
+                3,
+                2
+              ];
+            context.finalized = true;
+            return [
+              3,
+              4
+            ];
+          case 2:
+            return [
+              4,
+              next()
+            ];
+          case 3:
+            _state.sent();
+            _state.label = 4;
+          case 4:
+            return [
+              2
+            ];
+        }
+      });
+    });
+    return function(context, next) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+};
+var noop = function() {
+};
+var connectMid2HonoMid = function(handler) {
+  return function() {
+    var _ref = _async_to_generator(function(context, next) {
+      return _ts_generator(this, function(_state) {
+        return [
+          2,
+          new Promise(function(resolve, reject) {
+            var _context_env_node = context.env.node, req = _context_env_node.req, res = _context_env_node.res;
+            if (handler.length < 3) {
+              resolve(handler(req, res, noop));
+            } else {
+              handler(req, res, function(err) {
+                if (err) {
+                  reject(err);
+                } else {
+                  resolve(next());
+                }
+              });
+            }
+          })
+        ];
+      });
+    });
+    return function(context, next) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+};
+export {
+  connectMid2HonoMid,
+  httpCallBack2HonoMid
+};

package/dist/esm/base/adapters/node/index.js

@@ -0,0 +1,19 @@
+import { loadServerEnv } from "./loadServer";
+import { httpCallBack2HonoMid, connectMid2HonoMid } from "./hono";
+import { createNodeServer, sendResponse, createWebRequest } from "./node";
+import { bindBFFHandler } from "./bff";
+import { createStaticMiddleware, registerMockHandlers, injectServerManifest, injectTemplates, getHtmlTemplates } from "./middlewares";
+export {
+  bindBFFHandler,
+  connectMid2HonoMid,
+  createNodeServer,
+  createStaticMiddleware,
+  createWebRequest,
+  getHtmlTemplates,
+  httpCallBack2HonoMid,
+  injectServerManifest,
+  injectTemplates,
+  loadServerEnv,
+  registerMockHandlers,
+  sendResponse
+};

package/dist/esm/base/adapters/node/loadServer.js

@@ -0,0 +1,73 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import path from "path";
+import { fs, dotenv, dotenvExpand } from "@modern-js/utils";
+function loadServerEnv(options) {
+  return _loadServerEnv.apply(this, arguments);
+}
+function _loadServerEnv() {
+  _loadServerEnv = _async_to_generator(function(options) {
+    var pwd, serverEnv, defaultEnvPath, serverEnvPath, _i, _iter, envPath, _tmp, envConfig;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          pwd = options.pwd;
+          serverEnv = process.env.MODERN_ENV;
+          defaultEnvPath = path.resolve(pwd, ".env");
+          serverEnvPath = path.resolve(pwd, ".env.".concat(serverEnv));
+          _i = 0, _iter = [
+            serverEnvPath,
+            defaultEnvPath
+          ];
+          _state.label = 1;
+        case 1:
+          if (!(_i < _iter.length))
+            return [
+              3,
+              6
+            ];
+          envPath = _iter[_i];
+          return [
+            4,
+            fs.pathExists(envPath)
+          ];
+        case 2:
+          _tmp = _state.sent();
+          if (!_tmp)
+            return [
+              3,
+              4
+            ];
+          return [
+            4,
+            fs.stat(envPath)
+          ];
+        case 3:
+          _tmp = !_state.sent().isDirectory();
+          _state.label = 4;
+        case 4:
+          if (_tmp) {
+            envConfig = dotenv.config({
+              path: envPath
+            });
+            dotenvExpand(envConfig);
+          }
+          _state.label = 5;
+        case 5:
+          _i++;
+          return [
+            3,
+            1
+          ];
+        case 6:
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return _loadServerEnv.apply(this, arguments);
+}
+export {
+  loadServerEnv
+};

package/dist/esm/base/adapters/node/middlewares/index.js

@@ -0,0 +1,4 @@
+export * from "./mock";
+export * from "./serverStatic";
+export * from "./templates";
+export * from "./serverManifest";