@modern-js/server-core 2.48.6 → 2.49.1-alpha.0

package/dist/esm/base/serverBase.js

@@ -0,0 +1,383 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
+import { _ as _create_class } from "@swc/helpers/_/_create_class";
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { INTERNAL_SERVER_PLUGINS } from "@modern-js/utils/universal/constants";
+import { Hono } from "hono";
+import { AppContext, ConfigContext, serverManager, createPlugin } from "../core";
+import { getRuntimeEnv } from "./utils";
+var ServerBase = /* @__PURE__ */ function() {
+  "use strict";
+  function ServerBase2(options) {
+    _class_call_check(this, ServerBase2);
+    this.serverConfig = {};
+    this.options = options;
+    this.app = new Hono();
+  }
+  var _proto = ServerBase2.prototype;
+  _proto.init = function init() {
+    var _this = this;
+    return _async_to_generator(function() {
+      var options, runtimeEnv, _tmp, _tmp1;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            options = _this.options;
+            runtimeEnv = getRuntimeEnv();
+            _tmp = runtimeEnv === "node";
+            if (!_tmp)
+              return [
+                3,
+                2
+              ];
+            return [
+              4,
+              _this.initServerConfig(options)
+            ];
+          case 1:
+            _tmp = _state.sent();
+            _state.label = 2;
+          case 2:
+            _tmp;
+            return [
+              4,
+              _this.injectContext(options)
+            ];
+          case 3:
+            _state.sent();
+            return [
+              4,
+              _this.createHookRunner()
+            ];
+          case 4:
+            _this.runner = _state.sent();
+            _tmp1 = runtimeEnv === "node";
+            if (!_tmp1)
+              return [
+                3,
+                6
+              ];
+            return [
+              4,
+              _this.initConfig(_this.runner, options)
+            ];
+          case 5:
+            _tmp1 = _state.sent();
+            _state.label = 6;
+          case 6:
+            _tmp1;
+            return [
+              4,
+              _this.injectContext(options)
+            ];
+          case 7:
+            _state.sent();
+            return [
+              4,
+              _this.runner.prepare()
+            ];
+          case 8:
+            _state.sent();
+            return [
+              2,
+              _this
+            ];
+        }
+      });
+    })();
+  };
+  _proto.createHookRunner = function createHookRunner() {
+    var _this = this;
+    return _async_to_generator(function() {
+      var runtimeEnv, internalPlugins, _tmp, externalPlugins, loadedPlugins, hooksRunner;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            serverManager.clear();
+            runtimeEnv = getRuntimeEnv();
+            if (!(runtimeEnv === "node"))
+              return [
+                3,
+                2
+              ];
+            return [
+              4,
+              _this.loadInternalPlugins()
+            ];
+          case 1:
+            _tmp = _state.sent();
+            return [
+              3,
+              3
+            ];
+          case 2:
+            _tmp = [];
+            _state.label = 3;
+          case 3:
+            internalPlugins = _tmp;
+            externalPlugins = _this.loadExternalPlugins();
+            loadedPlugins = _to_consumable_array(internalPlugins).concat(_to_consumable_array(externalPlugins));
+            loadedPlugins.forEach(function(p) {
+              serverManager.usePlugin(p);
+            });
+            return [
+              4,
+              serverManager.init()
+            ];
+          case 4:
+            hooksRunner = _state.sent();
+            return [
+              2,
+              hooksRunner
+            ];
+        }
+      });
+    })();
+  };
+  _proto.loadInternalPlugins = function loadInternalPlugins() {
+    var _this = this;
+    return _async_to_generator(function() {
+      var _this_options, tmp, plugins, appContext, pwd, loadPluginsModule, loadPlugins, internalPlugins;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            _this_options = _this.options, tmp = _this_options.internalPlugins, plugins = tmp === void 0 ? INTERNAL_SERVER_PLUGINS : tmp, appContext = _this_options.appContext, pwd = _this_options.pwd;
+            loadPluginsModule = "../core/loadPlugins";
+            return [
+              4,
+              import(loadPluginsModule)
+            ];
+          case 1:
+            loadPlugins = _state.sent().loadPlugins;
+            internalPlugins = loadPlugins(appContext.appDirectory || pwd, plugins);
+            return [
+              2,
+              internalPlugins
+            ];
+        }
+      });
+    })();
+  };
+  _proto.loadExternalPlugins = function loadExternalPlugins() {
+    var _this_options = this.options, _this_options_plugins = _this_options.plugins, plugins = _this_options_plugins === void 0 ? [] : _this_options_plugins;
+    var configPlugins = this.serverConfig.plugins || [];
+    var externalPlugins = _to_consumable_array(plugins).concat(_to_consumable_array(configPlugins));
+    return externalPlugins.map(function(plugin) {
+      return createPlugin(plugin.setup, plugin);
+    });
+  };
+  _proto.initServerConfig = function initServerConfig(options) {
+    var _this = this;
+    return _async_to_generator(function() {
+      var pwd, serverConfigFile, utilsModuleName, _ref, getServerConfigPath, requireConfig, serverConfigPath, serverConfig;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            pwd = options.pwd, serverConfigFile = options.serverConfigFile;
+            utilsModuleName = "./utils/serverConfig";
+            return [
+              4,
+              import(utilsModuleName)
+            ];
+          case 1:
+            _ref = _state.sent(), getServerConfigPath = _ref.getServerConfigPath, requireConfig = _ref.requireConfig;
+            return [
+              4,
+              getServerConfigPath(pwd, serverConfigFile)
+            ];
+          case 2:
+            serverConfigPath = _state.sent();
+            serverConfig = requireConfig(serverConfigPath);
+            _this.serverConfig = serverConfig;
+            return [
+              2
+            ];
+        }
+      });
+    })();
+  };
+  _proto.injectContext = function injectContext(options) {
+    var _this = this;
+    return _async_to_generator(function() {
+      var appContext, config, pwd;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            return [
+              4,
+              _this.initAppContext()
+            ];
+          case 1:
+            appContext = _state.sent();
+            config = options.config, pwd = options.pwd;
+            ConfigContext.set(config);
+            AppContext.set(_object_spread_props(_object_spread({}, appContext), {
+              serverBase: _this,
+              distDirectory: pwd
+            }));
+            return [
+              2
+            ];
+        }
+      });
+    })();
+  };
+  _proto.initAppContext = function initAppContext() {
+    var _this = this;
+    return _async_to_generator(function() {
+      var options, pwd, _options_plugins, plugins, appContext, serverPlugins;
+      return _ts_generator(this, function(_state) {
+        options = _this.options;
+        pwd = options.pwd, _options_plugins = options.plugins, plugins = _options_plugins === void 0 ? [] : _options_plugins, appContext = options.appContext;
+        serverPlugins = plugins.map(function(p) {
+          return {
+            server: p
+          };
+        });
+        return [
+          2,
+          {
+            appDirectory: (appContext === null || appContext === void 0 ? void 0 : appContext.appDirectory) || "",
+            apiDirectory: appContext === null || appContext === void 0 ? void 0 : appContext.apiDirectory,
+            lambdaDirectory: appContext === null || appContext === void 0 ? void 0 : appContext.lambdaDirectory,
+            sharedDirectory: appContext.sharedDirectory || "",
+            distDirectory: pwd,
+            plugins: serverPlugins
+          }
+        ];
+      });
+    })();
+  };
+  _proto.runConfigHook = function runConfigHook(runner, serverConfig) {
+    var newServerConfig = runner.config(serverConfig || {});
+    return newServerConfig;
+  };
+  _proto.initConfig = function initConfig(runner, options) {
+    var _this = this;
+    return _async_to_generator(function() {
+      var path, utilsModuleName, _ref, ensureAbsolutePath, OUTPUT_CONFIG_FILE, configModuleName, loadConfig, pwd, config, serverConfig, finalServerConfig, resolvedConfigPath;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            return [
+              4,
+              import("path").catch(function(_) {
+                return {};
+              })
+            ];
+          case 1:
+            path = _state.sent();
+            utilsModuleName = "@modern-js/utils";
+            return [
+              4,
+              import(utilsModuleName)
+            ];
+          case 2:
+            _ref = _state.sent(), ensureAbsolutePath = _ref.ensureAbsolutePath, OUTPUT_CONFIG_FILE = _ref.OUTPUT_CONFIG_FILE;
+            configModuleName = "./utils/serverConfig";
+            return [
+              4,
+              import(configModuleName)
+            ];
+          case 3:
+            loadConfig = _state.sent().loadConfig;
+            pwd = options.pwd, config = options.config;
+            serverConfig = _this.serverConfig;
+            finalServerConfig = _this.runConfigHook(runner, serverConfig);
+            resolvedConfigPath = ensureAbsolutePath(pwd, path.join(config.output.path || "dist", OUTPUT_CONFIG_FILE));
+            options.config = loadConfig({
+              cliConfig: config,
+              serverConfig: finalServerConfig,
+              resolvedConfigPath
+            });
+            return [
+              2
+            ];
+        }
+      });
+    })();
+  };
+  _create_class(ServerBase2, [
+    {
+      key: "all",
+      get: function get() {
+        return this.app.all.bind(this.app);
+      }
+    },
+    {
+      key: "use",
+      get: function get() {
+        return this.app.use.bind(this.app);
+      }
+    },
+    {
+      key: "get",
+      get: function get() {
+        return this.app.get.bind(this.app);
+      }
+    },
+    {
+      key: "post",
+      get: function get() {
+        return this.app.post.bind(this.app);
+      }
+    },
+    {
+      key: "put",
+      get: function get() {
+        return this.app.put.bind(this.app);
+      }
+    },
+    {
+      key: "delete",
+      get: function get() {
+        return this.app.delete.bind(this.app);
+      }
+    },
+    {
+      key: "patch",
+      get: function get() {
+        return this.app.patch.bind(this.app);
+      }
+    },
+    {
+      key: "handle",
+      get: function get() {
+        return this.app.fetch.bind(this.app);
+      }
+    },
+    {
+      key: "request",
+      get: function get() {
+        return this.app.request.bind(this.app);
+      }
+    },
+    {
+      key: "notFound",
+      get: function get() {
+        return this.app.notFound.bind(this.app);
+      }
+    },
+    {
+      key: "onError",
+      get: function get() {
+        return this.app.onError.bind(this.app);
+      }
+    }
+  ]);
+  return ServerBase2;
+}();
+function createServerBase(options) {
+  if (options == null) {
+    throw new Error("can not start server without options");
+  }
+  var server = new ServerBase(options);
+  return server;
+}
+export {
+  ServerBase,
+  createServerBase
+};

package/dist/esm/base/utils/debug.js

@@ -0,0 +1,5 @@
+import { createDebugger } from "@modern-js/utils";
+var debug = createDebugger("prod-server");
+export {
+  debug
+};

package/dist/esm/base/utils/entry.js

@@ -0,0 +1,6 @@
+var sortRoutes = function(route1, route2) {
+  return route2.urlPath.length - route1.urlPath.length;
+};
+export {
+  sortRoutes
+};

package/dist/esm/base/utils/env.js

@@ -0,0 +1,20 @@
+var getRuntimeEnv = function() {
+  var _globalThis_process_release, _globalThis_process, _globalThis;
+  if (((_globalThis = globalThis) === null || _globalThis === void 0 ? void 0 : (_globalThis_process = _globalThis.process) === null || _globalThis_process === void 0 ? void 0 : (_globalThis_process_release = _globalThis_process.release) === null || _globalThis_process_release === void 0 ? void 0 : _globalThis_process_release.name) === "node") {
+    return "node";
+  }
+  return "other";
+};
+var checkIsProd = function() {
+  var env = getRuntimeEnv();
+  switch (env) {
+    case "node":
+      return process.env.NODE_ENV === "production";
+    default:
+      return false;
+  }
+};
+export {
+  checkIsProd,
+  getRuntimeEnv
+};

package/dist/esm/base/utils/error.js

@@ -0,0 +1,12 @@
+var ERROR_PAGE_TEXT = {
+  404: "This page could not be found.",
+  500: "Internal Server Error."
+};
+var createErrorHtml = function(status) {
+  var text = ERROR_PAGE_TEXT[status] || "";
+  var title = "".concat(status, ": ").concat(text);
+  return '<!DOCTYPE html>\n  <html lang="en">\n  <head>\n    <meta charset="utf-8">\n    <meta name="viewport" content="width=device-width">\n    <title>'.concat(title, '</title>\n    <style>\n      html,body {\n        margin: 0;\n      }\n\n      .page-container {\n        color: #000;\n        background: #fff;\n        height: 100vh;\n        text-align: center;\n        display: flex;\n        flex-direction: column;\n        align-items: center;\n        justify-content: center;\n      }\n    </style>\n  </head>\n  <body>\n    <div class="page-container">\n    <h1>').concat(status, "</h1>\n    <div>").concat(text, "</div>\n  </body>\n  </html>\n  ");
+};
+export {
+  createErrorHtml
+};

package/dist/esm/base/utils/index.js

@@ -0,0 +1,7 @@
+export * from "./env";
+export * from "./request";
+export * from "./transformStream";
+export * from "./middlewareCollector";
+export * from "./error";
+export * from "./warmup";
+export * from "./entry";

package/dist/esm/base/utils/middlewareCollector.js

@@ -0,0 +1,31 @@
+var mergeExtension = function(users) {
+  var output = [];
+  return {
+    middleware: output.concat(users)
+  };
+};
+var createMiddlewareCollecter = function() {
+  var webMiddlewares = [];
+  var apiMiddlewares = [];
+  var addWebMiddleware = function(input) {
+    webMiddlewares.push(input);
+  };
+  var addAPIMiddleware = function(input) {
+    apiMiddlewares.push(input);
+  };
+  var getMiddlewares = function() {
+    return {
+      web: webMiddlewares,
+      api: apiMiddlewares
+    };
+  };
+  return {
+    getMiddlewares,
+    addWebMiddleware,
+    addAPIMiddleware
+  };
+};
+export {
+  createMiddlewareCollecter,
+  mergeExtension
+};

package/dist/esm/base/utils/request.js

@@ -0,0 +1,39 @@
+import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
+function parseQuery(request) {
+  var url = request.url;
+  var q = url.split("?")[1];
+  var query = {};
+  if (q) {
+    q.split("&").forEach(function(item) {
+      var _item_split = _sliced_to_array(item.split("="), 2), key = _item_split[0], value = _item_split[1];
+      query[key] = value;
+    });
+  }
+  return query;
+}
+function parseHeaders(request) {
+  var headersData = {};
+  request.headers.forEach(function(value, key) {
+    headersData[key] = value;
+  });
+  return headersData;
+}
+function getPathname(request) {
+  var match = request.url.match(/^https?:\/\/[^/]+(\/[^?]*)/);
+  return match ? match[1] : "/";
+}
+function getHost(request) {
+  var headers = request.headers;
+  var host = headers.get("X-Forwarded-Host");
+  if (!host) {
+    host = headers.get("Host");
+  }
+  host = (host === null || host === void 0 ? void 0 : host.split(/\s*,\s*/, 1)[0]) || "undefined";
+  return host;
+}
+export {
+  getHost,
+  getPathname,
+  parseHeaders,
+  parseQuery
+};

package/dist/esm/base/utils/serverConfig.js

@@ -0,0 +1,58 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { compatRequire, fs, DEFAULT_SERVER_CONFIG } from "@modern-js/utils";
+import mergeDeep from "merge-deep";
+var getServerConfigPath = function() {
+  var _ref = _async_to_generator(function(distDirectory) {
+    var serverConfigFile, path, serverConfigPath;
+    var _arguments = arguments;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          serverConfigFile = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : DEFAULT_SERVER_CONFIG;
+          return [
+            4,
+            import("path")
+          ];
+        case 1:
+          path = _state.sent();
+          serverConfigPath = path.join(distDirectory, serverConfigFile);
+          return [
+            2,
+            "".concat(serverConfigPath, ".js")
+          ];
+      }
+    });
+  });
+  return function getServerConfigPath2(distDirectory) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var requireConfig = function(serverConfigPath) {
+  if (fs.pathExistsSync(serverConfigPath)) {
+    return compatRequire(serverConfigPath);
+  }
+  return {};
+};
+var loadConfig = function(param) {
+  var cliConfig = param.cliConfig, serverConfig = param.serverConfig, resolvedConfigPath = param.resolvedConfigPath;
+  var config = null;
+  if (process.env.NODE_ENV === "production") {
+    var resolvedConfig = requireConfig(resolvedConfigPath);
+    config = mergeDeep(_object_spread_props(_object_spread({}, resolvedConfig), {
+      plugins: []
+    }), serverConfig, cliConfig);
+  } else {
+    config = mergeDeep(_object_spread_props(_object_spread({}, cliConfig), {
+      plugins: []
+    }), serverConfig);
+  }
+  return config;
+};
+export {
+  getServerConfigPath,
+  loadConfig,
+  requireConfig
+};

package/dist/esm/base/utils/transformStream.js

@@ -0,0 +1,90 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+function createTransformStream(fn) {
+  var decoder = new TextDecoder();
+  var encoder = new TextEncoder();
+  return new TransformStream({
+    transform: function transform(chunk, controller) {
+      return _async_to_generator(function() {
+        var content, newContent;
+        return _ts_generator(this, function(_state) {
+          switch (_state.label) {
+            case 0:
+              content = decoder.decode(chunk);
+              return [
+                4,
+                fn(content)
+              ];
+            case 1:
+              newContent = _state.sent();
+              controller.enqueue(encoder.encode(newContent));
+              return [
+                2
+              ];
+          }
+        });
+      })();
+    }
+  });
+}
+function transformResponse(response, transformCb) {
+  var readable = null;
+  if (response.body) {
+    var stream = createTransformStream(function() {
+      var _ref = _async_to_generator(function(before) {
+        return _ts_generator(this, function(_state) {
+          if (Array.isArray(transformCb)) {
+            return [
+              2,
+              transformCb.reduce(function() {
+                var _ref2 = _async_to_generator(function(before2, cb) {
+                  return _ts_generator(this, function(_state2) {
+                    switch (_state2.label) {
+                      case 0:
+                        return [
+                          4,
+                          before2
+                        ];
+                      case 1:
+                        return [
+                          2,
+                          cb.apply(void 0, [
+                            _state2.sent()
+                          ])
+                        ];
+                    }
+                  });
+                });
+                return function(before2, cb) {
+                  return _ref2.apply(this, arguments);
+                };
+              }(), Promise.resolve(before))
+            ];
+          } else {
+            return [
+              2,
+              transformCb(before)
+            ];
+          }
+          return [
+            2
+          ];
+        });
+      });
+      return function(before) {
+        return _ref.apply(this, arguments);
+      };
+    }());
+    response.body.pipeThrough(stream);
+    readable = stream.readable;
+  }
+  return new Response(readable, {
+    status: response.status,
+    headers: response.headers,
+    statusText: response.statusText
+  });
+}
+export {
+  createTransformStream,
+  transformResponse
+};

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

@@ -0,0 +1,9 @@
+function warmup(bundles) {
+  bundles.forEach(function(bundle) {
+    bundle && import(bundle).catch(function(_) {
+    });
+  });
+}
+export {
+  warmup
+};

package/dist/esm/core/index.js

@@ -0,0 +1 @@
+export * from "./plugin";

package/dist/esm/core/loadPlugins.js

@@ -0,0 +1,26 @@
+import { compatRequire, getInternalPlugins, tryResolve } from "@modern-js/utils";
+import { createPlugin } from "../core/plugin";
+var resolvePlugin = function(p, appDirectory) {
+  var isPluginInstance = typeof p !== "string";
+  if (isPluginInstance) {
+    return {
+      module: createPlugin(p.setup, p)
+    };
+  }
+  var pluginPath = tryResolve(p, appDirectory);
+  var module = compatRequire(pluginPath);
+  var pluginInstance = module();
+  return {
+    module: createPlugin(pluginInstance.setup, pluginInstance)
+  };
+};
+var loadPlugins = function(appDirectory, internalPlugins) {
+  var loadedPlugins = getInternalPlugins(appDirectory, internalPlugins);
+  return loadedPlugins.map(function(plugin) {
+    var module = resolvePlugin(plugin, appDirectory).module;
+    return module;
+  });
+};
+export {
+  loadPlugins
+};