@modern-js/plugin-bff 2.67.1 → 2.67.3

package/dist/cjs/cli.js

@@ -42,6 +42,7 @@ var import_runtimeGenerator = __toESM(require("./utils/runtimeGenerator"));
 const DEFAULT_API_PREFIX = "/api";
 const TS_CONFIG_FILENAME = "tsconfig.json";
 const RUNTIME_CREATE_REQUEST = "@modern-js/plugin-bff/runtime/create-request";
+const RUNTIME_HONO = "@modern-js/plugin-bff/hono";
 const bffPlugin = () => ({
   name: "@modern-js/plugin-bff",
   setup: (api) => {
@@ -130,8 +131,15 @@ const bffPlugin = () => ({
         await generator();
       }
     };
+    const isHono = () => {
+      const { bffRuntimeFramework } = api.useAppContext();
+      return bffRuntimeFramework === "hono";
+    };
     return {
       config() {
+        const honoRuntimePath = isHono() ? {
+          [RUNTIME_HONO]: RUNTIME_HONO
+        } : void 0;
         return {
           tools: {
             bundlerChain: (chain, { CHAIN_ID, isServer }) => {
@@ -174,6 +182,9 @@ const bffPlugin = () => ({
               `./${import_utils.API_DIR}`,
               /create-request/
             ]
+          },
+          output: {
+            externals: honoRuntimePath
           }
         };
       },
@@ -194,7 +205,7 @@ const bffPlugin = () => ({
           isSPA: false,
           isSSR: false
         }));
-        if (bff === null || bff === void 0 ? void 0 : bff.enableHandleWeb) {
+        if (!isHono() && (bff === null || bff === void 0 ? void 0 : bff.enableHandleWeb)) {
           return {
             routes: routes.map((route) => {
               return {

package/dist/cjs/runtime/hono/adapter.js

@@ -0,0 +1,120 @@
+"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 adapter_exports = {};
+__export(adapter_exports, {
+  HonoAdapter: () => HonoAdapter
+});
+module.exports = __toCommonJS(adapter_exports);
+var import_server_core = require("@modern-js/server-core");
+var import_utils = require("@modern-js/utils");
+var import_createHonoRoutes = __toESM(require("../../utils/createHonoRoutes"));
+const before = [
+  "custom-server-hook",
+  "custom-server-middleware",
+  "render"
+];
+class HonoAdapter {
+  wrapInArray(handler) {
+    if (Array.isArray(handler)) {
+      return handler;
+    } else {
+      return [
+        handler
+      ];
+    }
+  }
+  constructor(api) {
+    this.apiMiddleware = [];
+    this.apiServer = null;
+    this.isHono = true;
+    this.setHandlers = async () => {
+      if (!this.isHono) {
+        return;
+      }
+      const { apiHandlerInfos } = this.api.useAppContext();
+      const honoHandlers = (0, import_createHonoRoutes.default)(apiHandlerInfos);
+      this.apiMiddleware = honoHandlers.map(({ path, method, handler }) => ({
+        name: "hono-bff-api",
+        path,
+        method,
+        handler,
+        order: "post",
+        before
+      }));
+    };
+    this.registerApiRoutes = async () => {
+      if (!this.isHono) {
+        return;
+      }
+      this.apiServer = new import_server_core.Hono();
+      this.apiMiddleware.forEach(({ path = "*", method = "all", handler }) => {
+        var _this_apiServer;
+        const handlers = this.wrapInArray(handler);
+        (_this_apiServer = this.apiServer) === null || _this_apiServer === void 0 ? void 0 : _this_apiServer[method](path, ...handlers);
+      });
+    };
+    this.registerMiddleware = async (options) => {
+      const { prefix } = options;
+      const { bffRuntimeFramework } = this.api.useAppContext();
+      if (bffRuntimeFramework !== "hono") {
+        this.isHono = false;
+        return;
+      }
+      const { middlewares: globalMiddlewares } = this.api.useAppContext();
+      await this.setHandlers();
+      if ((0, import_utils.isProd)()) {
+        globalMiddlewares.push(...this.apiMiddleware);
+      } else {
+        await this.registerApiRoutes();
+        const dynamicApiMiddleware = {
+          name: "dynamic-bff-handler",
+          path: `${prefix}/*`,
+          method: "all",
+          order: "post",
+          before,
+          handler: async (c, next) => {
+            if (this.apiServer) {
+              const response = await this.apiServer.fetch(c.req, c.env);
+              if (response.status !== 404) {
+                return new Response(response.body, response);
+              }
+            }
+            await next();
+          }
+        };
+        globalMiddlewares.push(dynamicApiMiddleware);
+      }
+    };
+    this.api = api;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HonoAdapter
+});

package/dist/cjs/runtime/hono/index.js

@@ -0,0 +1,33 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var hono_exports = {};
+__export(hono_exports, {
+  useHonoContext: () => import_server_core.useHonoContext
+});
+module.exports = __toCommonJS(hono_exports);
+__reExport(hono_exports, require("@modern-js/bff-core"), module.exports);
+var import_server_core = require("@modern-js/server-core");
+__reExport(hono_exports, require("./operators"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useHonoContext,
+  ...require("@modern-js/bff-core"),
+  ...require("./operators")
+});

package/dist/cjs/runtime/hono/operators.js

@@ -0,0 +1,71 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var operators_exports = {};
+__export(operators_exports, {
+  Middleware: () => Middleware,
+  Pipe: () => Pipe
+});
+module.exports = __toCommonJS(operators_exports);
+var import_server_core = require("@modern-js/server-core");
+const Pipe = (func) => {
+  return {
+    name: "pipe",
+    async execute(executeHelper, next) {
+      const { inputs } = executeHelper;
+      const ctx = (0, import_server_core.useHonoContext)();
+      const { res } = ctx;
+      if (typeof func === "function") {
+        let isPiped = true;
+        const end = (value) => {
+          isPiped = false;
+          if (typeof value === "function") {
+            value(res);
+            return;
+          }
+          return value;
+        };
+        const output = await func(inputs, end);
+        if (!isPiped) {
+          if (output) {
+            return executeHelper.result = output;
+          } else {
+            return;
+          }
+        }
+        executeHelper.inputs = output;
+        await next();
+      }
+    }
+  };
+};
+const Middleware = (middleware) => {
+  return {
+    name: "middleware",
+    metadata(helper) {
+      const middlewares = helper.getMetadata("pipe") || [];
+      middlewares.push(middleware);
+      helper.setMetadata("middleware", middlewares);
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Middleware,
+  Pipe
+});

package/dist/cjs/server.js

@@ -34,7 +34,9 @@ module.exports = __toCommonJS(server_exports);
 var import_path = __toESM(require("path"));
 var import_bff_core = require("@modern-js/bff-core");
 var import_utils = require("@modern-js/utils");
+var import_utils2 = require("@modern-js/utils");
 var import_constants = require("./constants");
+var import_adapter = require("./runtime/hono/adapter");
 class Storage {
   reset() {
     this.middlewares = [];
@@ -55,6 +57,7 @@ var server_default = () => ({
     const transformAPI = createTransformAPI(storage);
     let apiAppPath = "";
     let apiRouter;
+    const honoAdapter = new import_adapter.HonoAdapter(api);
     return {
       async prepare() {
         var _config_bff, _config_bff1, _config_bff2;
@@ -96,7 +99,7 @@ var server_default = () => ({
             onLast: () => null
           });
         }
-        if (handler) {
+        if (handler && (0, import_utils2.isFunction)(handler)) {
           globalMiddlewares.push({
             name: "bind-bff",
             handler: (c, next) => {
@@ -114,6 +117,10 @@ var server_default = () => ({
             ]
           });
         }
+        honoAdapter.registerMiddleware({
+          prefix,
+          enableHandleWeb
+        });
       },
       async reset({ event }) {
         storage.reset();
@@ -134,6 +141,8 @@ var server_default = () => ({
             ...appContext2,
             apiHandlerInfos
           });
+          await honoAdapter.setHandlers();
+          await honoAdapter.registerApiRoutes();
         }
       },
       async prepareApiServer(props, next) {

package/dist/cjs/utils/createHonoRoutes.js

@@ -0,0 +1,148 @@
+"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 createHonoRoutes_exports = {};
+__export(createHonoRoutes_exports, {
+  createHonoHandler: () => createHonoHandler,
+  default: () => createHonoRoutes_default
+});
+module.exports = __toCommonJS(createHonoRoutes_exports);
+var import_bff_core = require("@modern-js/bff-core");
+var import_type_is = __toESM(require("type-is"));
+const createHonoRoutes = (handlerInfos) => {
+  return handlerInfos.map(({ routePath, handler, httpMethod }) => {
+    const routeMiddlwares = Reflect.getMetadata("middleware", handler) || [];
+    const honoHandler = createHonoHandler(handler);
+    return {
+      method: httpMethod.toLowerCase(),
+      path: routePath,
+      handler: routeMiddlwares.length > 0 ? [
+        ...routeMiddlwares,
+        honoHandler
+      ] : honoHandler
+    };
+  });
+};
+const handleResponseMeta = (c, handler) => {
+  const responseMeta = Reflect.getMetadata(import_bff_core.HttpMetadata.Response, handler);
+  if (Array.isArray(responseMeta)) {
+    for (const meta of responseMeta) {
+      switch (meta.type) {
+        case import_bff_core.ResponseMetaType.Headers:
+          for (const [key, value] of Object.entries(meta.value)) {
+            c.header(key, value);
+          }
+          break;
+        case import_bff_core.ResponseMetaType.Redirect:
+          return c.redirect(meta.value);
+        case import_bff_core.ResponseMetaType.StatusCode:
+          c.status(meta.value);
+          break;
+        default:
+          break;
+      }
+    }
+  }
+  return null;
+};
+const createHonoHandler = (handler) => {
+  return async (c, next) => {
+    try {
+      const input = await getHonoInput(c);
+      if ((0, import_bff_core.isWithMetaHandler)(handler)) {
+        try {
+          const response = handleResponseMeta(c, handler);
+          if (response) {
+            return response;
+          }
+          if (c.finalized)
+            return;
+          const result = await handler(input);
+          return result && typeof result === "object" ? c.json(result) : c.body(result);
+        } catch (error) {
+          if (error instanceof import_bff_core.ValidationError) {
+            c.status(error.status);
+            return c.json({
+              message: error.message
+            });
+          }
+          throw error;
+        }
+      } else {
+        const args = Object.values(input.params).concat(input);
+        try {
+          const body = await handler(...args);
+          if (c.finalized) {
+            return await Promise.resolve();
+          }
+          if (typeof body !== "undefined") {
+            return c.json(body);
+          }
+        } catch {
+          return next();
+        }
+      }
+    } catch (error) {
+      next();
+    }
+  };
+};
+const getHonoInput = async (c) => {
+  const draft = {
+    params: c.req.param(),
+    query: c.req.query(),
+    headers: c.req.header(),
+    cookies: c.req.header("cookie")
+  };
+  try {
+    const contentType = c.req.header("content-type") || "";
+    if (import_type_is.default.is(contentType, [
+      "application/json"
+    ])) {
+      draft.data = await c.req.json();
+    } else if (import_type_is.default.is(contentType, [
+      "multipart/form-data"
+    ])) {
+      draft.formData = await c.req.parseBody();
+    } else if (import_type_is.default.is(contentType, [
+      "application/x-www-form-urlencoded"
+    ])) {
+      draft.formUrlencoded = await c.req.parseBody();
+    } else {
+      draft.body = await c.req.json();
+    }
+  } catch (error) {
+    draft.body = null;
+  }
+  return draft;
+};
+var createHonoRoutes_default = createHonoRoutes;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createHonoHandler
+});

package/dist/esm/cli.js

@@ -1,4 +1,5 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
 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";
@@ -13,6 +14,7 @@ import runtimeGenerator from "./utils/runtimeGenerator";
 var DEFAULT_API_PREFIX = "/api";
 var TS_CONFIG_FILENAME = "tsconfig.json";
 var RUNTIME_CREATE_REQUEST = "@modern-js/plugin-bff/runtime/create-request";
+var RUNTIME_HONO = "@modern-js/plugin-bff/hono";
 var bffPlugin = function() {
   return {
     name: "@modern-js/plugin-bff",
@@ -200,8 +202,13 @@ var bffPlugin = function() {
           return _ref.apply(this, arguments);
         };
       }();
+      var isHono = function() {
+        var bffRuntimeFramework = api.useAppContext().bffRuntimeFramework;
+        return bffRuntimeFramework === "hono";
+      };
       return {
         config: function config() {
+          var honoRuntimePath = isHono() ? _define_property({}, RUNTIME_HONO, RUNTIME_HONO) : void 0;
           return {
             tools: {
               bundlerChain: function(chain, param) {
@@ -245,6 +252,9 @@ var bffPlugin = function() {
                 "./".concat(API_DIR),
                 /create-request/
               ]
+            },
+            output: {
+              externals: honoRuntimePath
             }
           };
         },
@@ -269,7 +279,7 @@ var bffPlugin = function() {
               isSSR: false
             };
           });
-          if (bff === null || bff === void 0 ? void 0 : bff.enableHandleWeb) {
+          if (!isHono() && (bff === null || bff === void 0 ? void 0 : bff.enableHandleWeb)) {
             return {
               routes: routes.map(function(route) {
                 return _object_spread_props(_object_spread({}, route), {

package/dist/esm/runtime/hono/adapter.js

@@ -0,0 +1,184 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+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 { Hono } from "@modern-js/server-core";
+import { isProd } from "@modern-js/utils";
+import createHonoRoutes from "../../utils/createHonoRoutes";
+var before = [
+  "custom-server-hook",
+  "custom-server-middleware",
+  "render"
+];
+var HonoAdapter = /* @__PURE__ */ function() {
+  "use strict";
+  function HonoAdapter2(api) {
+    _class_call_check(this, HonoAdapter2);
+    var _this = this;
+    this.apiMiddleware = [];
+    this.apiServer = null;
+    this.isHono = true;
+    this.setHandlers = /* @__PURE__ */ _async_to_generator(function() {
+      var apiHandlerInfos, honoHandlers;
+      return _ts_generator(this, function(_state) {
+        if (!_this.isHono) {
+          return [
+            2
+          ];
+        }
+        apiHandlerInfos = _this.api.useAppContext().apiHandlerInfos;
+        honoHandlers = createHonoRoutes(apiHandlerInfos);
+        _this.apiMiddleware = honoHandlers.map(function(param) {
+          var path = param.path, method = param.method, handler = param.handler;
+          return {
+            name: "hono-bff-api",
+            path,
+            method,
+            handler,
+            order: "post",
+            before
+          };
+        });
+        return [
+          2
+        ];
+      });
+    });
+    this.registerApiRoutes = /* @__PURE__ */ _async_to_generator(function() {
+      return _ts_generator(this, function(_state) {
+        if (!_this.isHono) {
+          return [
+            2
+          ];
+        }
+        _this.apiServer = new Hono();
+        _this.apiMiddleware.forEach(function(param) {
+          var _param_path = param.path, path = _param_path === void 0 ? "*" : _param_path, _param_method = param.method, method = _param_method === void 0 ? "all" : _param_method, handler = param.handler;
+          var _this_apiServer;
+          var _this_apiServer1;
+          var handlers = _this.wrapInArray(handler);
+          (_this_apiServer1 = _this.apiServer) === null || _this_apiServer1 === void 0 ? void 0 : (_this_apiServer = _this_apiServer1)[method].apply(_this_apiServer, [
+            path
+          ].concat(_to_consumable_array(handlers)));
+        });
+        return [
+          2
+        ];
+      });
+    });
+    this.registerMiddleware = function() {
+      var _ref = _async_to_generator(function(options) {
+        var prefix, bffRuntimeFramework, _this_api_useAppContext, globalMiddlewares, _globalMiddlewares, dynamicApiMiddleware;
+        return _ts_generator(this, function(_state) {
+          switch (_state.label) {
+            case 0:
+              prefix = options.prefix;
+              bffRuntimeFramework = _this.api.useAppContext().bffRuntimeFramework;
+              if (bffRuntimeFramework !== "hono") {
+                _this.isHono = false;
+                return [
+                  2
+                ];
+              }
+              _this_api_useAppContext = _this.api.useAppContext(), globalMiddlewares = _this_api_useAppContext.middlewares;
+              return [
+                4,
+                _this.setHandlers()
+              ];
+            case 1:
+              _state.sent();
+              if (!isProd())
+                return [
+                  3,
+                  2
+                ];
+              (_globalMiddlewares = globalMiddlewares).push.apply(_globalMiddlewares, _to_consumable_array(_this.apiMiddleware));
+              return [
+                3,
+                4
+              ];
+            case 2:
+              return [
+                4,
+                _this.registerApiRoutes()
+              ];
+            case 3:
+              _state.sent();
+              dynamicApiMiddleware = {
+                name: "dynamic-bff-handler",
+                path: "".concat(prefix, "/*"),
+                method: "all",
+                order: "post",
+                before,
+                handler: function() {
+                  var _ref2 = _async_to_generator(function(c, next) {
+                    var response;
+                    return _ts_generator(this, function(_state2) {
+                      switch (_state2.label) {
+                        case 0:
+                          if (!_this.apiServer)
+                            return [
+                              3,
+                              2
+                            ];
+                          return [
+                            4,
+                            _this.apiServer.fetch(c.req, c.env)
+                          ];
+                        case 1:
+                          response = _state2.sent();
+                          if (response.status !== 404) {
+                            return [
+                              2,
+                              new Response(response.body, response)
+                            ];
+                          }
+                          _state2.label = 2;
+                        case 2:
+                          return [
+                            4,
+                            next()
+                          ];
+                        case 3:
+                          _state2.sent();
+                          return [
+                            2
+                          ];
+                      }
+                    });
+                  });
+                  return function(c, next) {
+                    return _ref2.apply(this, arguments);
+                  };
+                }()
+              };
+              globalMiddlewares.push(dynamicApiMiddleware);
+              _state.label = 4;
+            case 4:
+              return [
+                2
+              ];
+          }
+        });
+      });
+      return function(options) {
+        return _ref.apply(this, arguments);
+      };
+    }();
+    this.api = api;
+  }
+  var _proto = HonoAdapter2.prototype;
+  _proto.wrapInArray = function wrapInArray(handler) {
+    if (Array.isArray(handler)) {
+      return handler;
+    } else {
+      return [
+        handler
+      ];
+    }
+  };
+  return HonoAdapter2;
+}();
+export {
+  HonoAdapter
+};