@modern-js/plugin-bff 2.67.1 → 2.67.3

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

@@ -0,0 +1,6 @@
+export * from "@modern-js/bff-core";
+import { useHonoContext } from "@modern-js/server-core";
+export * from "./operators";
+export {
+  useHonoContext
+};

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

@@ -0,0 +1,79 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { useHonoContext } from "@modern-js/server-core";
+var Pipe = function(func) {
+  return {
+    name: "pipe",
+    execute: function execute(executeHelper, next) {
+      return _async_to_generator(function() {
+        var inputs, ctx, res, isPiped, end, output;
+        return _ts_generator(this, function(_state) {
+          switch (_state.label) {
+            case 0:
+              inputs = executeHelper.inputs;
+              ctx = useHonoContext();
+              res = ctx.res;
+              if (!(typeof func === "function"))
+                return [
+                  3,
+                  3
+                ];
+              isPiped = true;
+              end = function(value) {
+                isPiped = false;
+                if (typeof value === "function") {
+                  value(res);
+                  return;
+                }
+                return value;
+              };
+              return [
+                4,
+                func(inputs, end)
+              ];
+            case 1:
+              output = _state.sent();
+              if (!isPiped) {
+                if (output) {
+                  return [
+                    2,
+                    executeHelper.result = output
+                  ];
+                } else {
+                  return [
+                    2
+                  ];
+                }
+              }
+              executeHelper.inputs = output;
+              return [
+                4,
+                next()
+              ];
+            case 2:
+              _state.sent();
+              _state.label = 3;
+            case 3:
+              return [
+                2
+              ];
+          }
+        });
+      })();
+    }
+  };
+};
+var Middleware = function(middleware) {
+  return {
+    name: "middleware",
+    metadata: function metadata(helper) {
+      var middlewares = helper.getMetadata("pipe") || [];
+      middlewares.push(middleware);
+      helper.setMetadata("middleware", middlewares);
+    }
+  };
+};
+export {
+  Middleware,
+  Pipe
+};

package/dist/esm/server.js

@@ -6,7 +6,9 @@ import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import path from "path";
 import { ApiRouter } from "@modern-js/bff-core";
 import { API_DIR, isProd, isWebOnly, requireExistModule } from "@modern-js/utils";
+import { isFunction } from "@modern-js/utils";
 import { API_APP_NAME } from "./constants";
+import { HonoAdapter } from "./runtime/hono/adapter";
 var Storage = /* @__PURE__ */ function() {
   "use strict";
   function Storage2() {
@@ -34,6 +36,7 @@ function server_default() {
       var transformAPI = createTransformAPI(storage);
       var apiAppPath = "";
       var apiRouter;
+      var honoAdapter = new HonoAdapter(api);
       return {
         prepare: function prepare() {
           return _async_to_generator(function() {
@@ -121,7 +124,7 @@ function server_default() {
                   handler = _state.sent();
                   _state.label = 5;
                 case 5:
-                  if (handler) {
+                  if (handler && isFunction(handler)) {
                     globalMiddlewares.push({
                       name: "bind-bff",
                       handler: function(c, next) {
@@ -139,6 +142,10 @@ function server_default() {
                       ]
                     });
                   }
+                  honoAdapter.registerMiddleware({
+                    prefix,
+                    enableHandleWeb
+                  });
                   return [
                     2
                   ];
@@ -171,7 +178,7 @@ function server_default() {
                   if (!(event.type === "file-change"))
                     return [
                       3,
-                      3
+                      5
                     ];
                   return [
                     4,
@@ -183,8 +190,20 @@ function server_default() {
                   api.setAppContext(_object_spread_props(_object_spread({}, appContext1), {
                     apiHandlerInfos
                   }));
-                  _state.label = 3;
+                  return [
+                    4,
+                    honoAdapter.setHandlers()
+                  ];
                 case 3:
+                  _state.sent();
+                  return [
+                    4,
+                    honoAdapter.registerApiRoutes()
+                  ];
+                case 4:
+                  _state.sent();
+                  _state.label = 5;
+                case 5:
                   return [
                     2
                   ];

package/dist/esm/utils/createHonoRoutes.js

@@ -0,0 +1,330 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _instanceof } from "@swc/helpers/_/_instanceof";
+import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+import { _ as _type_of } from "@swc/helpers/_/_type_of";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { HttpMetadata, ResponseMetaType, ValidationError, isWithMetaHandler } from "@modern-js/bff-core";
+import typeIs from "type-is";
+var createHonoRoutes = function(handlerInfos) {
+  return handlerInfos.map(function(param) {
+    var routePath = param.routePath, handler = param.handler, httpMethod = param.httpMethod;
+    var routeMiddlwares = Reflect.getMetadata("middleware", handler) || [];
+    var honoHandler = createHonoHandler(handler);
+    return {
+      method: httpMethod.toLowerCase(),
+      path: routePath,
+      handler: routeMiddlwares.length > 0 ? _to_consumable_array(routeMiddlwares).concat([
+        honoHandler
+      ]) : honoHandler
+    };
+  });
+};
+var handleResponseMeta = function(c, handler) {
+  var responseMeta = Reflect.getMetadata(HttpMetadata.Response, handler);
+  if (Array.isArray(responseMeta)) {
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+    try {
+      for (var _iterator = responseMeta[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var meta = _step.value;
+        switch (meta.type) {
+          case ResponseMetaType.Headers:
+            var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = void 0;
+            try {
+              for (var _iterator1 = Object.entries(meta.value)[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+                var _step_value = _sliced_to_array(_step1.value, 2), key = _step_value[0], value = _step_value[1];
+                c.header(key, value);
+              }
+            } catch (err) {
+              _didIteratorError1 = true;
+              _iteratorError1 = err;
+            } finally {
+              try {
+                if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                  _iterator1.return();
+                }
+              } finally {
+                if (_didIteratorError1) {
+                  throw _iteratorError1;
+                }
+              }
+            }
+            break;
+          case ResponseMetaType.Redirect:
+            return c.redirect(meta.value);
+          case ResponseMetaType.StatusCode:
+            c.status(meta.value);
+            break;
+          default:
+            break;
+        }
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+  }
+  return null;
+};
+var createHonoHandler = function(handler) {
+  return function() {
+    var _ref = _async_to_generator(function(c, next) {
+      var input, response, result, error, args, body, e, error1;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            _state.trys.push([
+              0,
+              13,
+              ,
+              14
+            ]);
+            return [
+              4,
+              getHonoInput(c)
+            ];
+          case 1:
+            input = _state.sent();
+            if (!isWithMetaHandler(handler))
+              return [
+                3,
+                6
+              ];
+            _state.label = 2;
+          case 2:
+            _state.trys.push([
+              2,
+              4,
+              ,
+              5
+            ]);
+            response = handleResponseMeta(c, handler);
+            if (response) {
+              return [
+                2,
+                response
+              ];
+            }
+            if (c.finalized)
+              return [
+                2
+              ];
+            return [
+              4,
+              handler(input)
+            ];
+          case 3:
+            result = _state.sent();
+            return [
+              2,
+              result && (typeof result === "undefined" ? "undefined" : _type_of(result)) === "object" ? c.json(result) : c.body(result)
+            ];
+          case 4:
+            error = _state.sent();
+            if (_instanceof(error, ValidationError)) {
+              c.status(error.status);
+              return [
+                2,
+                c.json({
+                  message: error.message
+                })
+              ];
+            }
+            throw error;
+          case 5:
+            return [
+              3,
+              12
+            ];
+          case 6:
+            args = Object.values(input.params).concat(input);
+            _state.label = 7;
+          case 7:
+            _state.trys.push([
+              7,
+              11,
+              ,
+              12
+            ]);
+            return [
+              4,
+              handler.apply(void 0, _to_consumable_array(args))
+            ];
+          case 8:
+            body = _state.sent();
+            if (!c.finalized)
+              return [
+                3,
+                10
+              ];
+            return [
+              4,
+              Promise.resolve()
+            ];
+          case 9:
+            return [
+              2,
+              _state.sent()
+            ];
+          case 10:
+            if (typeof body !== "undefined") {
+              return [
+                2,
+                c.json(body)
+              ];
+            }
+            return [
+              3,
+              12
+            ];
+          case 11:
+            e = _state.sent();
+            return [
+              2,
+              next()
+            ];
+          case 12:
+            return [
+              3,
+              14
+            ];
+          case 13:
+            error1 = _state.sent();
+            next();
+            return [
+              3,
+              14
+            ];
+          case 14:
+            return [
+              2
+            ];
+        }
+      });
+    });
+    return function(c, next) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+};
+var getHonoInput = function() {
+  var _ref = _async_to_generator(function(c) {
+    var draft, contentType, error;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          draft = {
+            params: c.req.param(),
+            query: c.req.query(),
+            headers: c.req.header(),
+            cookies: c.req.header("cookie")
+          };
+          _state.label = 1;
+        case 1:
+          _state.trys.push([
+            1,
+            10,
+            ,
+            11
+          ]);
+          contentType = c.req.header("content-type") || "";
+          if (!typeIs.is(contentType, [
+            "application/json"
+          ]))
+            return [
+              3,
+              3
+            ];
+          return [
+            4,
+            c.req.json()
+          ];
+        case 2:
+          draft.data = _state.sent();
+          return [
+            3,
+            9
+          ];
+        case 3:
+          if (!typeIs.is(contentType, [
+            "multipart/form-data"
+          ]))
+            return [
+              3,
+              5
+            ];
+          return [
+            4,
+            c.req.parseBody()
+          ];
+        case 4:
+          draft.formData = _state.sent();
+          return [
+            3,
+            9
+          ];
+        case 5:
+          if (!typeIs.is(contentType, [
+            "application/x-www-form-urlencoded"
+          ]))
+            return [
+              3,
+              7
+            ];
+          return [
+            4,
+            c.req.parseBody()
+          ];
+        case 6:
+          draft.formUrlencoded = _state.sent();
+          return [
+            3,
+            9
+          ];
+        case 7:
+          return [
+            4,
+            c.req.json()
+          ];
+        case 8:
+          draft.body = _state.sent();
+          _state.label = 9;
+        case 9:
+          return [
+            3,
+            11
+          ];
+        case 10:
+          error = _state.sent();
+          draft.body = null;
+          return [
+            3,
+            11
+          ];
+        case 11:
+          return [
+            2,
+            draft
+          ];
+      }
+    });
+  });
+  return function getHonoInput2(c) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var createHonoRoutes_default = createHonoRoutes;
+export {
+  createHonoHandler,
+  createHonoRoutes_default as default
+};

package/dist/esm-node/cli.js

@@ -8,6 +8,7 @@ import runtimeGenerator from "./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) => {
@@ -96,8 +97,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 }) => {
@@ -140,6 +148,9 @@ const bffPlugin = () => ({
               `./${API_DIR}`,
               /create-request/
             ]
+          },
+          output: {
+            externals: honoRuntimePath
           }
         };
       },
@@ -160,7 +171,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/esm-node/runtime/hono/adapter.js

@@ -0,0 +1,86 @@
+import { Hono } from "@modern-js/server-core";
+import { isProd } from "@modern-js/utils";
+import createHonoRoutes from "../../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 = createHonoRoutes(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 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 (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;
+  }
+}
+export {
+  HonoAdapter
+};

package/dist/esm-node/runtime/hono/index.js

@@ -0,0 +1,6 @@
+export * from "@modern-js/bff-core";
+import { useHonoContext } from "@modern-js/server-core";
+export * from "./operators";
+export {
+  useHonoContext
+};

package/dist/esm-node/runtime/hono/operators.js

@@ -0,0 +1,46 @@
+import { useHonoContext } from "@modern-js/server-core";
+const Pipe = (func) => {
+  return {
+    name: "pipe",
+    async execute(executeHelper, next) {
+      const { inputs } = executeHelper;
+      const ctx = 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);
+    }
+  };
+};
+export {
+  Middleware,
+  Pipe
+};