@bleedingdev/modern-js-plugin-bff 3.2.0-ultramodern.0

package/dist/cjs/runtime/effect-client/index.js

@@ -0,0 +1,178 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    Effect: ()=>Effect_namespaceObject,
+    HttpApi: ()=>httpapi_namespaceObject.HttpApi,
+    HttpApiClient: ()=>httpapi_namespaceObject.HttpApiClient,
+    HttpApiEndpoint: ()=>httpapi_namespaceObject.HttpApiEndpoint,
+    HttpApiGroup: ()=>httpapi_namespaceObject.HttpApiGroup,
+    HttpApiSchema: ()=>httpapi_namespaceObject.HttpApiSchema,
+    Layer: ()=>Layer_namespaceObject,
+    Rpc: ()=>rpc_namespaceObject.Rpc,
+    RpcClient: ()=>rpc_namespaceObject.RpcClient,
+    RpcGroup: ()=>rpc_namespaceObject.RpcGroup,
+    RpcSchema: ()=>rpc_namespaceObject.RpcSchema,
+    RpcSerialization: ()=>rpc_namespaceObject.RpcSerialization,
+    Schema: ()=>Schema_namespaceObject,
+    makeEffectHttpApiClient: ()=>makeEffectHttpApiClient,
+    makeEffectRpcClient: ()=>makeEffectRpcClient,
+    mask: ()=>mask,
+    runEffectRequest: ()=>runEffectRequest,
+    runEffectView: ()=>runEffectView,
+    view: ()=>view
+});
+const Effect_namespaceObject = require("effect/Effect");
+const Exit_namespaceObject = require("effect/Exit");
+const Layer_namespaceObject = require("effect/Layer");
+const ManagedRuntime_namespaceObject = require("effect/ManagedRuntime");
+const Scope_namespaceObject = require("effect/Scope");
+const http_namespaceObject = require("effect/unstable/http");
+const httpapi_namespaceObject = require("effect/unstable/httpapi");
+const rpc_namespaceObject = require("effect/unstable/rpc");
+const Schema_namespaceObject = require("effect/Schema");
+function isRecord(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+function applySelection(value, selection) {
+    if (true === selection || void 0 === selection) return value;
+    if (Array.isArray(value)) return value.map((item)=>applySelection(item, selection));
+    if (!isRecord(value) || !isRecord(selection)) return value;
+    const masked = {};
+    for (const key of Object.keys(selection))if (key in value) masked[key] = applySelection(value[key], selection[key]);
+    return masked;
+}
+function view() {
+    return (selection)=>selection;
+}
+function mask(value, selection) {
+    return applySelection(value, selection);
+}
+function runEffectView(request, selection) {
+    return new Promise((resolve, reject)=>{
+        request.then((value)=>resolve(mask(value, selection)), (reason)=>reject(reason));
+    });
+}
+function getRpcSerializationLayer(serialization) {
+    switch(serialization){
+        case 'ndjson':
+            return rpc_namespaceObject.RpcSerialization.layerNdjson;
+        case 'jsonRpc':
+            return rpc_namespaceObject.RpcSerialization.layerJsonRpc();
+        case 'ndJsonRpc':
+            return rpc_namespaceObject.RpcSerialization.layerNdJsonRpc();
+        case 'msgPack':
+            return rpc_namespaceObject.RpcSerialization.layerMsgPack;
+        default:
+            return rpc_namespaceObject.RpcSerialization.layerJsonRpc();
+    }
+}
+function makeEffectHttpApiClient(api, options) {
+    return httpapi_namespaceObject.HttpApiClient.make(api, {
+        baseUrl: options?.baseUrl
+    }).pipe(Effect_namespaceObject.provide(http_namespaceObject.FetchHttpClient.layer));
+}
+function makeEffectRpcClient(group, options) {
+    const protocolLayer = Layer_namespaceObject.provide(rpc_namespaceObject.RpcClient.layerProtocolHttp({
+        url: options.url
+    }), Layer_namespaceObject.mergeAll(getRpcSerializationLayer(options.serialization), http_namespaceObject.FetchHttpClient.layer));
+    const middlewareLayer = options.middlewareLayer ?? Layer_namespaceObject.empty;
+    const runtimeLayer = Layer_namespaceObject.mergeAll(protocolLayer, middlewareLayer);
+    return Effect_namespaceObject.tryPromise({
+        try: async ()=>{
+            const runtime = ManagedRuntime_namespaceObject.make(runtimeLayer);
+            const scope = await runtime.runPromise(Scope_namespaceObject.make());
+            try {
+                const client = await runtime.runPromise(rpc_namespaceObject.RpcClient.make(group, {
+                    flatten: options.flatten
+                }).pipe(Effect_namespaceObject.provideService(Scope_namespaceObject.Scope, scope)));
+                let disposed = false;
+                const clientWithDispose = Object.assign(client, {
+                    dispose: async ()=>{
+                        if (!disposed) {
+                            disposed = true;
+                            await runtime.runPromise(Scope_namespaceObject.close(scope, Exit_namespaceObject["void"]));
+                        }
+                        await runtime.dispose();
+                    }
+                });
+                return clientWithDispose;
+            } catch (error) {
+                try {
+                    await runtime.runPromise(Scope_namespaceObject.close(scope, Exit_namespaceObject["void"]));
+                } catch  {}
+                try {
+                    await runtime.dispose();
+                } catch  {}
+                throw error;
+            }
+        },
+        catch: (error)=>error instanceof Error ? error : new Error(String(error))
+    });
+}
+const runEffectRequest = Effect_namespaceObject.runPromise;
+exports.Effect = __webpack_exports__.Effect;
+exports.HttpApi = __webpack_exports__.HttpApi;
+exports.HttpApiClient = __webpack_exports__.HttpApiClient;
+exports.HttpApiEndpoint = __webpack_exports__.HttpApiEndpoint;
+exports.HttpApiGroup = __webpack_exports__.HttpApiGroup;
+exports.HttpApiSchema = __webpack_exports__.HttpApiSchema;
+exports.Layer = __webpack_exports__.Layer;
+exports.Rpc = __webpack_exports__.Rpc;
+exports.RpcClient = __webpack_exports__.RpcClient;
+exports.RpcGroup = __webpack_exports__.RpcGroup;
+exports.RpcSchema = __webpack_exports__.RpcSchema;
+exports.RpcSerialization = __webpack_exports__.RpcSerialization;
+exports.Schema = __webpack_exports__.Schema;
+exports.makeEffectHttpApiClient = __webpack_exports__.makeEffectHttpApiClient;
+exports.makeEffectRpcClient = __webpack_exports__.makeEffectRpcClient;
+exports.mask = __webpack_exports__.mask;
+exports.runEffectRequest = __webpack_exports__.runEffectRequest;
+exports.runEffectView = __webpack_exports__.runEffectView;
+exports.view = __webpack_exports__.view;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "Effect",
+    "HttpApi",
+    "HttpApiClient",
+    "HttpApiEndpoint",
+    "HttpApiGroup",
+    "HttpApiSchema",
+    "Layer",
+    "Rpc",
+    "RpcClient",
+    "RpcGroup",
+    "RpcSchema",
+    "RpcSerialization",
+    "Schema",
+    "makeEffectHttpApiClient",
+    "makeEffectRpcClient",
+    "mask",
+    "runEffectRequest",
+    "runEffectView",
+    "view"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,168 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    HonoAdapter: ()=>HonoAdapter
+});
+const server_core_namespaceObject = require("@modern-js/server-core");
+const utils_namespaceObject = require("@modern-js/utils");
+const createHonoRoutes_js_namespaceObject = require("../../utils/createHonoRoutes.js");
+var createHonoRoutes_js_default = /*#__PURE__*/ __webpack_require__.n(createHonoRoutes_js_namespaceObject);
+const before = [
+    'custom-server-hook',
+    'custom-server-middleware',
+    'render'
+];
+const kParentHonoVars = Symbol.for('modernjs.hono.parentVars');
+class HonoAdapter {
+    wrapInArray(handler) {
+        if (Array.isArray(handler)) return handler;
+        return [
+            handler
+        ];
+    }
+    constructor(api){
+        this.apiMiddleware = [];
+        this.apiServer = null;
+        this.isHono = true;
+        this.setHandlers = async ()=>{
+            if (!this.isHono) return;
+            const { apiHandlerInfos } = this.api.getServerContext();
+            const honoHandlers = createHonoRoutes_js_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 server_core_namespaceObject.Hono();
+            this.apiServer.use('*', server_core_namespaceObject.run);
+            this.apiServer.use('*', async (c, next)=>{
+                const nodeReq = c.env?.node?.req;
+                const parentVars = nodeReq?.[kParentHonoVars];
+                if (parentVars && 'object' == typeof parentVars) {
+                    delete nodeReq[kParentHonoVars];
+                    for (const [key, value] of Object.entries(parentVars))if (void 0 === c.get(key)) c.set(key, value);
+                }
+                await next();
+            });
+            this.apiMiddleware.forEach(({ path = '*', method = 'all', handler })=>{
+                const handlers = this.wrapInArray(handler);
+                if (0 === handlers.length) return;
+                const firstHandler = handlers[0];
+                const restHandlers = handlers.slice(1);
+                const m = method;
+                const server = this.apiServer;
+                if (!server) return;
+                const register = server[m];
+                register.call(server, path, firstHandler, ...restHandlers);
+            });
+            this.apiServer.onError(async (err, c)=>{
+                try {
+                    const serverConfig = this.api.getServerConfig();
+                    const onErrorHandler = serverConfig?.onError;
+                    if (onErrorHandler) {
+                        const result = await onErrorHandler(err, c);
+                        if (result instanceof Response) return result;
+                    } else utils_namespaceObject.logger.error(err);
+                } catch (configError) {
+                    utils_namespaceObject.logger.error(`Error in serverConfig.onError handler: ${configError}`);
+                }
+                const status = 'object' == typeof err && null !== err && 'status' in err && 'number' == typeof err.status ? err.status : 500;
+                return new Response(JSON.stringify({
+                    message: err instanceof Error ? err.message : '[BFF] Internal Server Error'
+                }), {
+                    status,
+                    headers: {
+                        'content-type': 'application/json; charset=utf-8'
+                    }
+                });
+            });
+        };
+        this.registerMiddleware = async (options)=>{
+            const { prefix } = options;
+            const { bffRuntimeFramework } = this.api.getServerContext();
+            if ('hono' !== bffRuntimeFramework) {
+                this.isHono = false;
+                return;
+            }
+            const { middlewares: globalMiddlewares } = this.api.getServerContext();
+            await this.setHandlers();
+            if ((0, utils_namespaceObject.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 nodeReq = c.env?.node?.req;
+                            if (nodeReq) {
+                                const parentVars = c?.var;
+                                nodeReq[kParentHonoVars] = parentVars && 'object' == typeof parentVars ? {
+                                    ...parentVars
+                                } : parentVars;
+                            }
+                            const response = await this.apiServer.fetch(c.req.raw, c.env);
+                            if (404 !== response.status) return new Response(response.body, response);
+                        }
+                        await next();
+                    }
+                };
+                globalMiddlewares.push(dynamicApiMiddleware);
+            }
+        };
+        this.onApiHandlersUpdated = async ()=>{
+            if (!this.isHono) return;
+            await this.setHandlers();
+            await this.registerApiRoutes();
+        };
+        this.api = api;
+    }
+}
+exports.HonoAdapter = __webpack_exports__.HonoAdapter;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "HonoAdapter"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,65 @@
+"use strict";
+var __webpack_modules__ = {
+    "./operators" (module) {
+        module.exports = require("./operators.js");
+    },
+    "@modern-js/bff-core" (module) {
+        module.exports = require("@modern-js/bff-core");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    var _modern_js_bff_core__rspack_import_0 = __webpack_require__("@modern-js/bff-core");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _modern_js_bff_core__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_modern_js_bff_core__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _operators__rspack_import_1 = __webpack_require__("./operators");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _operators__rspack_import_1)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_operators__rspack_import_1[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+})();
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,68 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    Middleware: ()=>Middleware,
+    Pipe: ()=>Pipe
+});
+const server_core_namespaceObject = require("@modern-js/server-core");
+const Pipe = (func)=>({
+        name: 'pipe',
+        async execute (executeHelper, next) {
+            const { inputs } = executeHelper;
+            const ctx = (0, server_core_namespaceObject.useHonoContext)();
+            const { res } = ctx;
+            if ('function' == typeof func) {
+                let isPiped = true;
+                const end = (value)=>{
+                    isPiped = false;
+                    if ('function' == typeof value) return void value(res);
+                    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)=>({
+        name: 'middleware',
+        metadata (helper) {
+            const middlewares = helper.getMetadata('pipe') || [];
+            middlewares.push(middleware);
+            helper.setMetadata('middleware', middlewares);
+        }
+    });
+exports.Middleware = __webpack_exports__.Middleware;
+exports.Pipe = __webpack_exports__.Pipe;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "Middleware",
+    "Pipe"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/server.js

@@ -0,0 +1,179 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    default: ()=>server
+});
+const bff_core_namespaceObject = require("@modern-js/bff-core");
+const utils_namespaceObject = require("@modern-js/utils");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const adapter_js_namespaceObject = require("./runtime/effect/adapter.js");
+const hono_adapter_js_namespaceObject = require("./runtime/hono/adapter.js");
+const RUNTIME_ADAPTER_FACTORIES = {
+    hono: [
+        (api)=>new hono_adapter_js_namespaceObject.HonoAdapter(api)
+    ],
+    effect: [
+        (api)=>new adapter_js_namespaceObject.EffectAdapter(api)
+    ]
+};
+const normalizePrefixList = (prefix)=>{
+    if (Array.isArray(prefix)) return prefix.filter(Boolean);
+    return [
+        prefix || '/api'
+    ];
+};
+const getPrimaryPrefix = (prefix)=>normalizePrefixList(prefix)[0] || '/api';
+function resolveRuntimeFramework(runtimeFramework) {
+    return 'hono' === runtimeFramework ? 'hono' : 'effect';
+}
+class Storage {
+    reset() {
+        this.middlewares = [];
+    }
+    constructor(){
+        this.middlewares = [];
+    }
+}
+const server = ()=>({
+        name: '@modern-js/plugin-bff',
+        setup: (api)=>{
+            const storage = new Storage();
+            let apiRouter = null;
+            const appContext = api.getServerContext();
+            const runtimeFramework = resolveRuntimeFramework(appContext.bffRuntimeFramework);
+            const runtimeAdapters = RUNTIME_ADAPTER_FACTORIES[runtimeFramework].map((createAdapter)=>createAdapter(api));
+            api.onPrepare(async ()=>{
+                const appContext = api.getServerContext();
+                const { render } = appContext;
+                const { middlewares } = storage;
+                api.updateServerContext({
+                    ...appContext,
+                    apiMiddlewares: middlewares
+                });
+                const config = api.getServerConfig();
+                const prefixList = normalizePrefixList(config?.bff?.prefix);
+                const prefix = getPrimaryPrefix(config?.bff?.prefix);
+                const enableHandleWeb = config?.bff?.enableHandleWeb;
+                const httpMethodDecider = config?.bff?.httpMethodDecider;
+                const { distDirectory: pwd, middlewares: globalMiddlewares } = api.getServerContext();
+                const webOnly = await (0, utils_namespaceObject.isWebOnly)();
+                if ('hono' === runtimeFramework) {
+                    let handler;
+                    if (webOnly) handler = async (c, next)=>{
+                        c.body('');
+                        await next();
+                    };
+                    else {
+                        const runner = api.getHooks();
+                        const renderHandler = enableHandleWeb ? render : null;
+                        handler = await runner.prepareApiServer.call({
+                            pwd: pwd,
+                            prefix,
+                            render: renderHandler,
+                            httpMethodDecider
+                        });
+                    }
+                    if (handler && (0, utils_namespaceObject.isFunction)(handler)) globalMiddlewares.push({
+                        name: 'bind-bff',
+                        handler: (c, next)=>{
+                            if (!prefixList.some((item)=>c.req.path.startsWith(item)) && !enableHandleWeb) return next();
+                            return handler(c, next);
+                        },
+                        order: 'post',
+                        before: [
+                            'custom-server-hook',
+                            'custom-server-middleware',
+                            'render'
+                        ]
+                    });
+                }
+                await Promise.all(runtimeAdapters.map((adapter)=>adapter.registerMiddleware({
+                        prefix,
+                        enableHandleWeb
+                    })));
+            });
+            api.onReset(async ({ event })=>{
+                storage.reset();
+                const appContext = api.getServerContext();
+                const { middlewares } = storage;
+                api.updateServerContext({
+                    ...appContext,
+                    apiMiddlewares: middlewares
+                });
+                if ('file-change' === event.type) {
+                    if ('hono' === runtimeFramework && apiRouter) {
+                        const apiHandlerInfos = await apiRouter.getApiHandlers();
+                        const appContext = api.getServerContext();
+                        api.updateServerContext({
+                            ...appContext,
+                            apiHandlerInfos
+                        });
+                    }
+                    await Promise.all(runtimeAdapters.map((adapter)=>adapter.onApiHandlersUpdated?.()));
+                }
+            });
+            const prepareApiServer = async (input, next)=>{
+                if ('hono' !== runtimeFramework) return next(input);
+                const { pwd, prefix, httpMethodDecider } = input;
+                const defaultApiDirectory = external_path_default().resolve(pwd, utils_namespaceObject.API_DIR);
+                const appContext = api.getServerContext();
+                const apiDirectory = 'string' == typeof appContext.apiDirectory ? appContext.apiDirectory : defaultApiDirectory;
+                const lambdaDirectory = 'string' == typeof appContext.lambdaDirectory ? appContext.lambdaDirectory : void 0;
+                apiRouter = new bff_core_namespaceObject.ApiRouter({
+                    appDir: pwd,
+                    apiDir: apiDirectory,
+                    lambdaDir: lambdaDirectory,
+                    prefix,
+                    httpMethodDecider
+                });
+                const apiHandlerInfos = await apiRouter.getApiHandlers();
+                api.updateServerContext({
+                    ...appContext,
+                    apiRouter,
+                    apiHandlerInfos
+                });
+                return next(input);
+            };
+            api.prepareApiServer(prepareApiServer);
+        }
+    });
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});