@modern-js/plugin-bff 2.67.1 → 2.67.3

package/dist/esm-node/server.js

@@ -1,7 +1,9 @@
 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";
 class Storage {
   reset() {
     this.middlewares = [];
@@ -22,6 +24,7 @@ var server_default = () => ({
     const transformAPI = createTransformAPI(storage);
     let apiAppPath = "";
     let apiRouter;
+    const honoAdapter = new HonoAdapter(api);
     return {
       async prepare() {
         var _config_bff, _config_bff1, _config_bff2;
@@ -63,7 +66,7 @@ var server_default = () => ({
             onLast: () => null
           });
         }
-        if (handler) {
+        if (handler && isFunction(handler)) {
           globalMiddlewares.push({
             name: "bind-bff",
             handler: (c, next) => {
@@ -81,6 +84,10 @@ var server_default = () => ({
             ]
           });
         }
+        honoAdapter.registerMiddleware({
+          prefix,
+          enableHandleWeb
+        });
       },
       async reset({ event }) {
         storage.reset();
@@ -101,6 +108,8 @@ var server_default = () => ({
             ...appContext2,
             apiHandlerInfos
           });
+          await honoAdapter.setHandlers();
+          await honoAdapter.registerApiRoutes();
         }
       },
       async prepareApiServer(props, next) {

package/dist/esm-node/utils/createHonoRoutes.js

@@ -0,0 +1,114 @@
+import { HttpMetadata, ResponseMetaType, ValidationError, isWithMetaHandler } from "@modern-js/bff-core";
+import typeIs from "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(HttpMetadata.Response, handler);
+  if (Array.isArray(responseMeta)) {
+    for (const meta of responseMeta) {
+      switch (meta.type) {
+        case ResponseMetaType.Headers:
+          for (const [key, value] of Object.entries(meta.value)) {
+            c.header(key, value);
+          }
+          break;
+        case ResponseMetaType.Redirect:
+          return c.redirect(meta.value);
+        case 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 (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 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 (typeIs.is(contentType, [
+      "application/json"
+    ])) {
+      draft.data = await c.req.json();
+    } else if (typeIs.is(contentType, [
+      "multipart/form-data"
+    ])) {
+      draft.formData = await c.req.parseBody();
+    } else if (typeIs.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;
+export {
+  createHonoHandler,
+  createHonoRoutes_default as default
+};

package/dist/types/runtime/hono/adapter.d.ts

@@ -0,0 +1,18 @@
+import type { MiddlewareHandler, PluginAPI, ServerMiddleware } from '@modern-js/server-core';
+import { Hono } from '@modern-js/server-core';
+interface MiddlewareOptions {
+    prefix: string;
+    enableHandleWeb?: boolean;
+}
+export declare class HonoAdapter {
+    apiMiddleware: ServerMiddleware[];
+    apiServer: Hono | null;
+    api: PluginAPI;
+    isHono: boolean;
+    constructor(api: PluginAPI);
+    setHandlers: () => Promise<void>;
+    registerApiRoutes: () => Promise<void>;
+    registerMiddleware: (options: MiddlewareOptions) => Promise<void>;
+    wrapInArray(handler: MiddlewareHandler[] | MiddlewareHandler): MiddlewareHandler[];
+}
+export {};

package/dist/types/runtime/hono/index.d.ts

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

package/dist/types/runtime/hono/operators.d.ts

@@ -0,0 +1,10 @@
+import type { Operator } from '@modern-js/bff-core';
+import { type Context, type Next } from '@modern-js/server-core';
+export type EndFunction = ((func: (res: Response) => void) => void) & ((data: unknown) => void);
+type MaybeAsync<T> = T | Promise<T>;
+type PipeFunction<T> = (value: T, end: EndFunction) => MaybeAsync<void> | MaybeAsync<T>;
+export declare const Pipe: <T>(func: PipeFunction<T>) => Operator<T>;
+export type Pipe = typeof Pipe;
+export declare const Middleware: (middleware: (c: Context, next: Next) => void) => Operator<void>;
+export type Middleware = typeof Middleware;
+export {};

package/dist/types/utils/createHonoRoutes.d.ts

@@ -0,0 +1,10 @@
+import type { APIHandlerInfo } from '@modern-js/bff-core';
+import type { Context, Next } from '@modern-js/server-core';
+type Handler = APIHandlerInfo['handler'];
+declare const createHonoRoutes: (handlerInfos: APIHandlerInfo[]) => {
+    method: any;
+    path: string;
+    handler: any[] | ((c: Context, next: Next) => Promise<void | Response>);
+}[];
+export declare const createHonoHandler: (handler: Handler) => (c: Context, next: Next) => Promise<void | Response>;
+export default createHonoRoutes;

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.67.1",
+  "version": "2.67.3",
   "jsnext:source": "./src/cli.ts",
   "types": "./dist/types/cli.d.ts",
   "main": "./dist/cjs/cli.js",
@@ -42,6 +42,11 @@
       "jsnext:source": "./src/loader.ts",
       "default": "./dist/cjs/loader.js"
     },
+    "./hono": {
+      "types": "./dist/types/runtime/hono/index.d.ts",
+      "jsnext:source": "./src/runtime/hono/index.ts",
+      "default": "./dist/cjs/runtime/hono/index.js"
+    },
     "./runtime/create-request": {
       "types": "./dist/types/create-request/index.d.ts",
       "jsnext:source": "./src/runtime/create-request/index.ts",
@@ -59,6 +64,9 @@
       "server": [
         "./dist/types/server.d.ts"
       ],
+      "hono": [
+        "./dist/types/runtime/hono/index.d.ts"
+      ],
       "runtime/create-request": [
         "./dist/types/runtime/create-request/index.d.ts"
       ]
@@ -66,30 +74,33 @@
   },
   "dependencies": {
     "@babel/core": "^7.26.0",
+    "type-is": "^1.6.18",
     "@swc/helpers": "0.5.13",
-    "@modern-js/bff-core": "2.67.1",
-    "@modern-js/create-request": "2.67.1",
-    "@modern-js/server-core": "2.67.1",
-    "@modern-js/server-utils": "2.67.1",
-    "@modern-js/utils": "2.67.1"
+    "@modern-js/bff-core": "2.67.3",
+    "@modern-js/create-request": "2.67.3",
+    "@modern-js/server-core": "2.67.3",
+    "@modern-js/server-utils": "2.67.3",
+    "@modern-js/utils": "2.67.3"
   },
   "devDependencies": {
     "@types/babel__core": "^7.20.5",
     "@types/jest": "^29",
     "@types/node": "^14",
+    "@types/type-is": "^1.6.3",
     "jest": "^29",
     "memfs": "^3.5.1",
     "ts-jest": "^29.1.0",
     "typescript": "^5",
     "webpack": "^5.98.0",
-    "@modern-js/plugin-v2": "2.67.1",
-    "@modern-js/app-tools": "2.67.1",
-    "@modern-js/bff-runtime": "2.67.1",
-    "@modern-js/core": "2.67.1",
-    "@modern-js/runtime": "2.67.1",
-    "@modern-js/types": "2.67.1",
-    "@scripts/jest-config": "2.66.0",
-    "@scripts/build": "2.66.0"
+    "zod": "^3.22.3",
+    "@modern-js/plugin-v2": "2.67.3",
+    "@modern-js/app-tools": "2.67.3",
+    "@modern-js/bff-runtime": "2.67.3",
+    "@modern-js/core": "2.67.3",
+    "@modern-js/types": "2.67.3",
+    "@modern-js/runtime": "2.67.3",
+    "@scripts/build": "2.66.0",
+    "@scripts/jest-config": "2.66.0"
   },
   "sideEffects": false,
   "publishConfig": {