@modern-js/server-core 2.65.4 → 2.65.6-alpha.0

package/dist/esm/plugins/compat/hooks.js

@@ -0,0 +1,70 @@
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+function getHookRunners(context) {
+  var hooks = context.hooks;
+  return {
+    config: function(params) {
+      return hooks.modifyConfig.call(params);
+    },
+    prepare: function() {
+      return hooks.onPrepare.call();
+    },
+    reset: function(params) {
+      return hooks.onReset.call(params);
+    },
+    fallback: function(input) {
+      return hooks.fallback.call(input);
+    },
+    prepareWebServer: function(input) {
+      return hooks.prepareWebServer.call(input);
+    },
+    prepareApiServer: function(input) {
+      return hooks.prepareApiServer.call(input);
+    },
+    afterMatch: function(ctx) {
+      return hooks.afterMatch.call(ctx);
+    },
+    afterRender: function(ctx) {
+      return hooks.afterRender.call(ctx);
+    },
+    afterStreamingRender: function(ctx) {
+      return hooks.afterStreamingRender.call(ctx);
+    }
+  };
+}
+function transformHookRunner(hookRunnerName) {
+  switch (hookRunnerName) {
+    case "config":
+      return "modifyConfig";
+    case "prepare":
+      return "onPrepare";
+    case "reset":
+      return "onReset";
+    default:
+      return hookRunnerName;
+  }
+}
+function handleSetupResult(setupResult, api) {
+  if (!setupResult) {
+    return;
+  }
+  Object.keys(setupResult).forEach(function(key) {
+    var fn = setupResult[key];
+    if (typeof fn === "function") {
+      var newAPI = transformHookRunner(key);
+      if (api[newAPI]) {
+        api[newAPI](function() {
+          for (var _len = arguments.length, params = new Array(_len), _key = 0; _key < _len; _key++) {
+            params[_key] = arguments[_key];
+          }
+          var res = fn.apply(void 0, _to_consumable_array(params));
+          return res;
+        });
+      }
+    }
+  });
+}
+export {
+  getHookRunners,
+  handleSetupResult,
+  transformHookRunner
+};

package/dist/esm/plugins/compat/index.js

@@ -0,0 +1,45 @@
+import { _ as _object_without_properties } from "@swc/helpers/_/_object_without_properties";
+import { createAsyncHook, createAsyncPipelineHook } from "@modern-js/plugin-v2";
+import { getHookRunners } from "./hooks";
+import { handleSetupResult } from "./hooks";
+var compatPlugin = function() {
+  return {
+    name: "@modern-js/server-compat",
+    registryHooks: {
+      fallback: createAsyncHook(),
+      prepareWebServer: createAsyncPipelineHook(),
+      prepareApiServer: createAsyncPipelineHook(),
+      afterMatch: createAsyncPipelineHook(),
+      afterRender: createAsyncPipelineHook(),
+      afterStreamingRender: createAsyncPipelineHook()
+    },
+    _registryApi: function(getServerContext, updateServerContext) {
+      var getInternalContext = function() {
+        return getServerContext()._internalContext;
+      };
+      return {
+        useConfigContext: function() {
+          return getInternalContext().config;
+        },
+        useAppContext: function() {
+          var _getServerContext = getServerContext(), _internalContext = _getServerContext._internalContext, serverContext = _object_without_properties(_getServerContext, [
+            "_internalContext"
+          ]);
+          return serverContext;
+        },
+        setAppContext: function(context) {
+          return updateServerContext(context);
+        },
+        useHookRunners: function() {
+          return getHookRunners(getInternalContext());
+        }
+      };
+    },
+    setup: function() {
+    }
+  };
+};
+export {
+  compatPlugin,
+  handleSetupResult
+};

package/dist/esm/plugins/customServer/index.js

@@ -3,6 +3,7 @@ import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
 import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import { time } from "@modern-js/runtime-utils/time";
+import { isArray, isFunction } from "@modern-js/utils";
 import { ServerTimings } from "../../constants";
 import { getLoaderCtx } from "../../helper";
 import { transformResponse } from "../../utils";
@@ -16,20 +17,16 @@ var isHtmlResponse = function(response) {
 };
 var CustomServer = /* @__PURE__ */ function() {
   "use strict";
-  function CustomServer2(runner, serverBase, pwd) {
+  function CustomServer2(hooks, serverBase, pwd) {
     _class_call_check(this, CustomServer2);
-    this.runner = runner;
+    this.hooks = hooks;
     this.serverBase = serverBase;
     var webExtension = [];
-    this.serverMiddlewarePromise = runner.prepareWebServer({
+    this.serverMiddlewarePromise = hooks.prepareWebServer.call({
       pwd,
       config: {
         middleware: webExtension
       }
-    }, {
-      onLast: function() {
-        return [];
-      }
     });
   }
   var _proto = CustomServer2.prototype;
@@ -50,9 +47,7 @@ var CustomServer = /* @__PURE__ */ function() {
               getCost = time();
               return [
                 4,
-                _this.runner.afterMatch(afterMatchCtx, {
-                  onLast: noop
-                })
+                _this.hooks.afterMatch.call(afterMatchCtx)
               ];
             case 1:
               _state.sent();
@@ -105,15 +100,30 @@ var CustomServer = /* @__PURE__ */ function() {
                   3
                 ];
               afterStreamingRenderContext = createAfterStreamingRenderContext(baseHookCtx, routeInfo);
-              c.res = transformResponse(c.res, function(chunk) {
-                var context = afterStreamingRenderContext(chunk);
-                return _this.runner.afterStreamingRender(context, {
-                  onLast: function(param) {
-                    var _$chunk = param.chunk;
-                    return _$chunk;
-                  }
+              c.res = transformResponse(c.res, function() {
+                var _ref2 = _async_to_generator(function(chunk) {
+                  var context, _ref3, newChunk;
+                  return _ts_generator(this, function(_state2) {
+                    switch (_state2.label) {
+                      case 0:
+                        context = afterStreamingRenderContext(chunk);
+                        return [
+                          4,
+                          _this.hooks.afterStreamingRender.call(context)
+                        ];
+                      case 1:
+                        _ref3 = _state2.sent(), newChunk = _ref3.chunk;
+                        return [
+                          2,
+                          newChunk
+                        ];
+                    }
+                  });
                 });
-              });
+                return function(chunk) {
+                  return _ref2.apply(this, arguments);
+                };
+              }());
               return [
                 3,
                 6
@@ -128,9 +138,7 @@ var CustomServer = /* @__PURE__ */ function() {
               getCost1 = time();
               return [
                 4,
-                _this.runner.afterRender(afterRenderCtx, {
-                  onLast: noop
-                })
+                _this.hooks.afterRender.call(afterRenderCtx)
               ];
             case 5:
               _state.sent();
@@ -170,7 +178,7 @@ var CustomServer = /* @__PURE__ */ function() {
             ];
           case 1:
             serverMiddleware = _state.sent();
-            if (!serverMiddleware) {
+            if (!serverMiddleware || !isFunction(serverMiddleware) && !isArray(serverMiddleware)) {
               return [
                 2,
                 renderMiddlewares

package/dist/esm/plugins/default.js

@@ -1,3 +1,4 @@
+import { compatPlugin } from "./compat";
 import { logPlugin } from "./log";
 import { initMonitorsPlugin, injectServerTiming, injectloggerPlugin } from "./monitors";
 import { processedByPlugin } from "./processedBy";
@@ -14,6 +15,7 @@ function createSilenceLogger() {
 function createDefaultPlugins() {
   var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
   var plugins = [
+    compatPlugin(),
     logPlugin(),
     initMonitorsPlugin(),
     injectRenderHandlerPlugin(options),

package/dist/esm/plugins/index.js

@@ -4,10 +4,13 @@ import { injectServerTiming, injectloggerPlugin } from "./monitors";
 import { processedByPlugin } from "./processedBy";
 import { logPlugin } from "./log";
 import { createDefaultPlugins } from "./default";
+import { compatPlugin, handleSetupResult } from "./compat";
 export {
+  compatPlugin,
   createDefaultPlugins,
   faviconPlugin,
   getRenderHandler,
+  handleSetupResult,
   injectRenderHandlerPlugin,
   injectServerTiming,
   injectloggerPlugin,

package/dist/esm/plugins/render/index.js

@@ -13,19 +13,19 @@ var renderPlugin = function() {
       return {
         prepare: function prepare() {
           return _async_to_generator(function() {
-            var _config_render, _api_useAppContext, middlewares, routes, render, pwd, serverBase, runner, config, customServer, serverMiddleware, pageRoutes, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, route, originUrlPath, _route_entryName, entryName, urlPath, customServerHookMiddleware, customServerMiddleware, err;
+            var _config_render, _api_useAppContext, middlewares, routes, render, pwd, serverBase, hooks, config, customServer, serverMiddleware, pageRoutes, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, route, originUrlPath, _route_entryName, entryName, urlPath, customServerHookMiddleware, customServerMiddleware, err;
             return _ts_generator(this, function(_state) {
               switch (_state.label) {
                 case 0:
                   _api_useAppContext = api.useAppContext(), middlewares = _api_useAppContext.middlewares, routes = _api_useAppContext.routes, render = _api_useAppContext.render, pwd = _api_useAppContext.distDirectory, serverBase = _api_useAppContext.serverBase;
-                  runner = api.useHookRunners();
+                  hooks = api.getHooks();
                   config = api.useConfigContext();
                   if (!routes) {
                     return [
                       2
                     ];
                   }
-                  customServer = new CustomServer(runner, serverBase, pwd);
+                  customServer = new CustomServer(hooks, serverBase, pwd);
                   serverMiddleware = ((_config_render = config.render) === null || _config_render === void 0 ? void 0 : _config_render.middleware) && getServerMidFromUnstableMid(config.render.middleware);
                   pageRoutes = getPageRoutes(routes);
                   middlewares.push({

package/dist/esm/serverBase.js

@@ -5,48 +5,54 @@ import { _ as _class_private_method_init } from "@swc/helpers/_/_class_private_m
 import { _ as _create_class } from "@swc/helpers/_/_create_class";
 import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
-import { createContext } from "@modern-js/plugin";
+import { server } from "@modern-js/plugin-v2/server";
 import { Hono } from "hono";
-import { PluginManager } from "./pluginManager";
-var _getAppContext = /* @__PURE__ */ new WeakSet(), _applyMiddlewares = /* @__PURE__ */ new WeakSet();
+import { handleSetupResult } from "./plugins/compat/hooks";
+import { loadConfig } from "./utils";
+var _applyMiddlewares = /* @__PURE__ */ new WeakSet();
 var ServerBase = /* @__PURE__ */ function() {
   "use strict";
   function ServerBase2(options) {
     _class_call_check(this, ServerBase2);
-    _class_private_method_init(this, _getAppContext);
     _class_private_method_init(this, _applyMiddlewares);
+    this.plugins = [];
+    this.serverContext = null;
     this.options = options;
-    var config = options.config, serverConfig = options.serverConfig;
-    var appContext = _class_private_method_get(this, _getAppContext, getAppContext).call(this);
-    this.appContext = appContext;
-    this.pluginManager = new PluginManager({
-      cliConfig: config,
-      appContext,
-      serverConfig
-    });
     this.app = new Hono();
   }
   var _proto = ServerBase2.prototype;
   _proto.init = function init() {
     var _this = this;
     return _async_to_generator(function() {
-      var runner;
+      var _this_options, serverConfig, cliConfig, mergedConfig, serverContext;
       return _ts_generator(this, function(_state) {
         switch (_state.label) {
           case 0:
+            _this_options = _this.options, serverConfig = _this_options.serverConfig, cliConfig = _this_options.config;
+            mergedConfig = loadConfig({
+              cliConfig,
+              serverConfig: serverConfig || {}
+            });
+            _this.addPlugins(mergedConfig.plugins || []);
             return [
               4,
-              _this.pluginManager.init()
+              server.run({
+                plugins: _this.plugins,
+                options: _this.options,
+                config: mergedConfig,
+                handleSetupResult
+              })
             ];
           case 1:
-            runner = _state.sent();
-            _this.runner = runner;
+            serverContext = _state.sent().serverContext;
+            serverContext.serverBase = _this;
             return [
               4,
-              runner.prepare()
+              serverContext.hooks.onPrepare.call()
             ];
           case 2:
             _state.sent();
+            _this.serverContext = serverContext;
             _class_private_method_get(_this, _applyMiddlewares, applyMiddlewares).call(_this);
             return [
               2,
@@ -57,9 +63,16 @@ var ServerBase = /* @__PURE__ */ function() {
     })();
   };
   _proto.addPlugins = function addPlugins(plugins) {
-    this.pluginManager.addPlugins(plugins);
+    var _this_plugins;
+    (_this_plugins = this.plugins).push.apply(_this_plugins, _to_consumable_array(plugins));
   };
   _create_class(ServerBase2, [
+    {
+      key: "hooks",
+      get: function get() {
+        return this.serverContext.hooks;
+      }
+    },
     {
       key: "all",
       get: function get() {
@@ -129,25 +142,8 @@ var ServerBase = /* @__PURE__ */ function() {
   ]);
   return ServerBase2;
 }();
-function getAppContext() {
-  var _this_options = this.options, context = _this_options.appContext, pwd = _this_options.pwd, routes = _this_options.routes, metaName = _this_options.metaName;
-  var appContext = {
-    routes,
-    middlewares: [],
-    appDirectory: (context === null || context === void 0 ? void 0 : context.appDirectory) || "",
-    apiDirectory: context === null || context === void 0 ? void 0 : context.apiDirectory,
-    internalDirectory: (context === null || context === void 0 ? void 0 : context.internalDirectory) || "",
-    lambdaDirectory: context === null || context === void 0 ? void 0 : context.lambdaDirectory,
-    sharedDirectory: (context === null || context === void 0 ? void 0 : context.sharedDirectory) || "",
-    distDirectory: pwd,
-    plugins: [],
-    metaName: metaName || "modern-js",
-    serverBase: this
-  };
-  return createContext(appContext);
-}
 function applyMiddlewares() {
-  var middlewares = this.appContext.get().middlewares;
+  var middlewares = this.serverContext.middlewares;
   var preMiddlewares = [];
   var defaultMiddlewares = [];
   var postMiddlewares = [];
@@ -242,8 +238,8 @@ function createServerBase(options) {
   if (options == null) {
     throw new Error("can not start server without options");
   }
-  var server = new ServerBase(options);
-  return server;
+  var server2 = new ServerBase(options);
+  return server2;
 }
 export {
   ServerBase,

package/dist/esm/types/index.js

@@ -1,4 +1,4 @@
 export * from "./config";
-export * from "./plugin";
+export * from "./plugins";
 export * from "./render";
 export * from "./server";

package/dist/esm/types/plugins/index.js

@@ -0,0 +1,2 @@
+export * from "./new";
+export * from "./old";

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

@@ -44,7 +44,30 @@ const connectMid2HonoMid = (handler) => {
     });
   };
 };
+const connectMockMid2HonoMid = (handler) => {
+  return async (context, next) => {
+    return new Promise((resolve, reject) => {
+      const { req, res } = context.env.node;
+      if (handler.length < 3) {
+        res.once("finish", () => {
+          context.finalized = true;
+          resolve();
+        });
+        handler(req, res, noop);
+      } else {
+        handler(req, res, (err) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(next());
+          }
+        });
+      }
+    });
+  };
+};
 export {
   connectMid2HonoMid,
+  connectMockMid2HonoMid,
   httpCallBack2HonoMid
 };

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

@@ -1,9 +1,10 @@
-import { httpCallBack2HonoMid, connectMid2HonoMid } from "./hono";
+import { httpCallBack2HonoMid, connectMid2HonoMid, connectMockMid2HonoMid } from "./hono";
 import { createNodeServer, sendResponse, createWebRequest, writeReadableStreamToWritable } from "./node";
 import { serverStaticPlugin, injectResourcePlugin, getHtmlTemplates, getServerManifest, injectNodeSeverPlugin, injectRscManifestPlugin } from "./plugins";
 import { loadServerPlugins, loadServerEnv, loadServerRuntimeConfig, loadServerCliConfig, loadCacheConfig } from "./helper";
 export {
   connectMid2HonoMid,
+  connectMockMid2HonoMid,
   createNodeServer,
   createWebRequest,
   getHtmlTemplates,

package/dist/esm-node/index.js

@@ -1,10 +1,9 @@
 import { createErrorHtml, onError, ErrorDigest } from "./utils";
 import { AGGRED_DIR } from "./constants";
 import { createServerBase } from "./serverBase";
-import { PluginManager } from "./pluginManager";
 import { getLoaderCtx } from "./helper";
 export * from "./plugins";
-export * from "./types/plugin";
+export * from "./types/plugins";
 export * from "./types/render";
 export * from "@modern-js/plugin";
 export * from "./types/config";
@@ -12,7 +11,6 @@ export * from "./types/requestHandler";
 export {
   AGGRED_DIR,
   ErrorDigest,
-  PluginManager,
   createErrorHtml,
   createServerBase,
   getLoaderCtx,

package/dist/esm-node/plugins/compat/hooks.js

@@ -0,0 +1,66 @@
+function getHookRunners(context) {
+  const { hooks } = context;
+  return {
+    config: (params) => {
+      return hooks.modifyConfig.call(params);
+    },
+    prepare: () => {
+      return hooks.onPrepare.call();
+    },
+    reset: (params) => {
+      return hooks.onReset.call(params);
+    },
+    fallback: (input) => {
+      return hooks.fallback.call(input);
+    },
+    prepareWebServer: (input) => {
+      return hooks.prepareWebServer.call(input);
+    },
+    prepareApiServer: (input) => {
+      return hooks.prepareApiServer.call(input);
+    },
+    afterMatch: (ctx) => {
+      return hooks.afterMatch.call(ctx);
+    },
+    afterRender: (ctx) => {
+      return hooks.afterRender.call(ctx);
+    },
+    afterStreamingRender: (ctx) => {
+      return hooks.afterStreamingRender.call(ctx);
+    }
+  };
+}
+function transformHookRunner(hookRunnerName) {
+  switch (hookRunnerName) {
+    case "config":
+      return "modifyConfig";
+    case "prepare":
+      return "onPrepare";
+    case "reset":
+      return "onReset";
+    default:
+      return hookRunnerName;
+  }
+}
+function handleSetupResult(setupResult, api) {
+  if (!setupResult) {
+    return;
+  }
+  Object.keys(setupResult).forEach((key) => {
+    const fn = setupResult[key];
+    if (typeof fn === "function") {
+      const newAPI = transformHookRunner(key);
+      if (api[newAPI]) {
+        api[newAPI]((...params) => {
+          const res = fn(...params);
+          return res;
+        });
+      }
+    }
+  });
+}
+export {
+  getHookRunners,
+  handleSetupResult,
+  transformHookRunner
+};

package/dist/esm-node/plugins/compat/index.js

@@ -0,0 +1,40 @@
+import { createAsyncHook, createAsyncPipelineHook } from "@modern-js/plugin-v2";
+import { getHookRunners } from "./hooks";
+import { handleSetupResult } from "./hooks";
+const compatPlugin = () => ({
+  name: "@modern-js/server-compat",
+  registryHooks: {
+    fallback: createAsyncHook(),
+    prepareWebServer: createAsyncPipelineHook(),
+    prepareApiServer: createAsyncPipelineHook(),
+    afterMatch: createAsyncPipelineHook(),
+    afterRender: createAsyncPipelineHook(),
+    afterStreamingRender: createAsyncPipelineHook()
+  },
+  _registryApi: (getServerContext, updateServerContext) => {
+    const getInternalContext = () => {
+      return getServerContext()._internalContext;
+    };
+    return {
+      useConfigContext: () => {
+        return getInternalContext().config;
+      },
+      useAppContext: () => {
+        const { _internalContext, ...serverContext } = getServerContext();
+        return serverContext;
+      },
+      setAppContext: (context) => {
+        return updateServerContext(context);
+      },
+      useHookRunners: () => {
+        return getHookRunners(getInternalContext());
+      }
+    };
+  },
+  setup: () => {
+  }
+});
+export {
+  compatPlugin,
+  handleSetupResult
+};

package/dist/esm-node/plugins/customServer/index.js

@@ -1,4 +1,5 @@
 import { time } from "@modern-js/runtime-utils/time";
+import { isArray, isFunction } from "@modern-js/utils";
 import { ServerTimings } from "../../constants";
 import { getLoaderCtx } from "../../helper";
 import { transformResponse } from "../../utils";
@@ -18,9 +19,7 @@ class CustomServer {
       const baseHookCtx = createBaseHookContext(c);
       const afterMatchCtx = getAfterMatchCtx(entryName, baseHookCtx);
       const getCost = time();
-      await this.runner.afterMatch(afterMatchCtx, {
-        onLast: noop
-      });
+      await this.hooks.afterMatch.call(afterMatchCtx);
       const cost = getCost();
       cost && (monitors === null || monitors === void 0 ? void 0 : monitors.timing(ServerTimings.SERVER_HOOK_AFTER_MATCH, cost));
       const { url, status } = afterMatchCtx.router;
@@ -50,18 +49,15 @@ class CustomServer {
       }
       if (routeInfo.isStream) {
         const afterStreamingRenderContext = createAfterStreamingRenderContext(baseHookCtx, routeInfo);
-        c.res = transformResponse(c.res, (chunk) => {
+        c.res = transformResponse(c.res, async (chunk) => {
           const context = afterStreamingRenderContext(chunk);
-          return this.runner.afterStreamingRender(context, {
-            onLast: ({ chunk: chunk2 }) => chunk2
-          });
+          const { chunk: newChunk } = await this.hooks.afterStreamingRender.call(context);
+          return newChunk;
         });
       } else {
         const afterRenderCtx = await getAfterRenderCtx(c, baseHookCtx, routeInfo);
         const getCost2 = time();
-        await this.runner.afterRender(afterRenderCtx, {
-          onLast: noop
-        });
+        await this.hooks.afterRender.call(afterRenderCtx);
         const cost2 = getCost2();
         cost2 && (monitors === null || monitors === void 0 ? void 0 : monitors.timing(ServerTimings.SERVER_HOOK_AFTER_RENDER, cost2));
         if (afterRenderCtx.response.private_overrided) {
@@ -74,7 +70,7 @@ class CustomServer {
   }
   async getServerMiddleware(renderMiddlewares) {
     const serverMiddleware = await this.serverMiddlewarePromise;
-    if (!serverMiddleware) {
+    if (!serverMiddleware || !isFunction(serverMiddleware) && !isArray(serverMiddleware)) {
       return renderMiddlewares;
     }
     if (Array.isArray(serverMiddleware)) {
@@ -110,17 +106,15 @@ class CustomServer {
       }
     };
   }
-  constructor(runner, serverBase, pwd) {
-    this.runner = runner;
+  constructor(hooks, serverBase, pwd) {
+    this.hooks = hooks;
     this.serverBase = serverBase;
     const webExtension = [];
-    this.serverMiddlewarePromise = runner.prepareWebServer({
+    this.serverMiddlewarePromise = hooks.prepareWebServer.call({
       pwd,
       config: {
         middleware: webExtension
       }
-    }, {
-      onLast: () => []
     });
   }
 }

package/dist/esm-node/plugins/default.js

@@ -1,3 +1,4 @@
+import { compatPlugin } from "./compat";
 import { logPlugin } from "./log";
 import { initMonitorsPlugin, injectServerTiming, injectloggerPlugin } from "./monitors";
 import { processedByPlugin } from "./processedBy";
@@ -13,6 +14,7 @@ function createSilenceLogger() {
 }
 function createDefaultPlugins(options = {}) {
   const plugins = [
+    compatPlugin(),
     logPlugin(),
     initMonitorsPlugin(),
     injectRenderHandlerPlugin(options),