@bleedingdev/modern-js-plugin-bff 3.5.0-ultramodern.1 → 3.5.0-ultramodern.100

package/dist/cjs/runtime/effect-client/request-context.js

@@ -0,0 +1,64 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __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__, {
+    applyRequestContext: ()=>applyRequestContext,
+    createEffectRequestContext: ()=>createEffectRequestContext
+});
+const external_guards_js_namespaceObject = require("./guards.js");
+const createEffectRequestContext = (createRequestContextHeaders, requestContext)=>{
+    if (!(0, external_guards_js_namespaceObject.isRecord)(requestContext)) return {};
+    const headers = createRequestContextHeaders ? createRequestContextHeaders(requestContext) : {};
+    return {
+        ...requestContext,
+        headers
+    };
+};
+const applyRequestContext = (normalizedRequest, request, createRequestContext)=>{
+    if (!(0, external_guards_js_namespaceObject.isRecord)(request) || !(0, external_guards_js_namespaceObject.isRecord)(request.requestContext)) return normalizedRequest;
+    const requestContext = createRequestContext(request.requestContext);
+    const requestHeaders = (0, external_guards_js_namespaceObject.isRecord)(requestContext.headers) ? requestContext.headers : {};
+    if (0 === Object.keys(requestHeaders).length) return normalizedRequest;
+    return {
+        ...normalizedRequest,
+        headers: {
+            ...(0, external_guards_js_namespaceObject.isRecord)(normalizedRequest.headers) ? normalizedRequest.headers : {},
+            ...requestHeaders
+        }
+    };
+};
+exports.applyRequestContext = __webpack_exports__.applyRequestContext;
+exports.createEffectRequestContext = __webpack_exports__.createEffectRequestContext;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "applyRequestContext",
+    "createEffectRequestContext"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,66 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __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__, {
+    normalizeRequest: ()=>normalizeRequest
+});
+const external_guards_js_namespaceObject = require("./guards.js");
+const METHODS_WITHOUT_BODY = new Set([
+    'GET',
+    'DELETE',
+    'HEAD',
+    'OPTIONS'
+]);
+const normalizeRequest = (method, request)=>{
+    if (!(0, external_guards_js_namespaceObject.isRecord)(request)) return {};
+    const payload = {
+        ...request
+    };
+    if ((0, external_guards_js_namespaceObject.isRecord)(request.path) && !(0, external_guards_js_namespaceObject.isRecord)(payload.params)) payload.params = request.path;
+    if ((0, external_guards_js_namespaceObject.isRecord)(request.urlParams) && !(0, external_guards_js_namespaceObject.isRecord)(payload.query)) payload.query = request.urlParams;
+    if ((0, external_guards_js_namespaceObject.isRecord)(request.headers) && !(0, external_guards_js_namespaceObject.isRecord)(payload.headers)) payload.headers = request.headers;
+    if ('payload' in request && void 0 !== request.payload) if ("u" > typeof FormData && request.payload instanceof FormData && !('formData' in payload)) payload.formData = request.payload;
+    else if (METHODS_WITHOUT_BODY.has(method)) {
+        if ((0, external_guards_js_namespaceObject.isRecord)(request.payload)) payload.query = (0, external_guards_js_namespaceObject.isRecord)(payload.query) ? {
+            ...payload.query,
+            ...request.payload
+        } : request.payload;
+        else if (!('body' in payload)) payload.body = request.payload;
+    } else if (!(0, external_guards_js_namespaceObject.isRecord)(request.payload) || 'data' in payload) {
+        if (!('body' in payload)) payload.body = request.payload;
+    } else payload.data = request.payload;
+    return payload;
+};
+exports.normalizeRequest = __webpack_exports__.normalizeRequest;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "normalizeRequest"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -30,189 +30,17 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     createGeneratedEffectClient: ()=>createGeneratedEffectClient
 });
-const index_js_namespaceObject = require("../data-platform/index.js");
-const METHODS_WITHOUT_BODY = new Set([
-    'GET',
-    'DELETE',
-    'HEAD',
-    'OPTIONS'
-]);
-const DATA_REQUEST_MODES = new Set([
-    'cache-first',
-    'stale-while-revalidate',
-    'network-only'
-]);
-const DATA_MUTATION_MODES = new Set([
-    'optimistic',
-    'pessimistic',
-    'fire-and-forget'
-]);
-const isRecord = (value)=>'object' == typeof value && null !== value;
-const stringOrUndefined = (value)=>'string' == typeof value && value.length > 0 ? value : void 0;
-const isDataRequestMode = (value)=>'string' == typeof value && DATA_REQUEST_MODES.has(value);
-const isDataMutationMode = (value)=>'string' == typeof value && DATA_MUTATION_MODES.has(value);
-const normalizeOrigin = (value)=>{
-    if ('string' != typeof value || 0 === value.length) return;
-    try {
-        return new URL(value).origin;
-    } catch  {
-        return;
-    }
-};
-const resolveRuntimeFetch = ()=>'function' == typeof fetch ? fetch.bind(globalThis) : void 0;
-const resolveOrigin = (defaultOrigin)=>{
-    if ("u" > typeof window && window.location && 'string' == typeof window.location.origin && window.location.origin) return window.location.origin;
-    const globalLocation = globalThis?.location;
-    if (globalLocation && 'string' == typeof globalLocation.origin && globalLocation.origin) return globalLocation.origin;
-    return defaultOrigin;
-};
-const normalizeRequest = (method, request)=>{
-    if (!isRecord(request)) return {};
-    const payload = {
-        ...request
-    };
-    if (isRecord(request.path) && !isRecord(payload.params)) payload.params = request.path;
-    if (isRecord(request.urlParams) && !isRecord(payload.query)) payload.query = request.urlParams;
-    if (isRecord(request.headers) && !isRecord(payload.headers)) payload.headers = request.headers;
-    if ('payload' in request && void 0 !== request.payload) if ("u" > typeof FormData && request.payload instanceof FormData && !('formData' in payload)) payload.formData = request.payload;
-    else if (METHODS_WITHOUT_BODY.has(method)) {
-        if (isRecord(request.payload)) payload.query = isRecord(payload.query) ? {
-            ...payload.query,
-            ...request.payload
-        } : request.payload;
-        else if (!('body' in payload)) payload.body = request.payload;
-    } else if (!isRecord(request.payload) || 'data' in payload) {
-        if (!('body' in payload)) payload.body = request.payload;
-    } else payload.data = request.payload;
-    return payload;
-};
-const resolveTargetOrigin = (dataPlatform, defaultOrigin)=>{
-    const explicitTargetOrigin = stringOrUndefined(dataPlatform.targetOrigin) || stringOrUndefined(dataPlatform.endpointOrigin);
-    if (explicitTargetOrigin) return explicitTargetOrigin;
-    return defaultOrigin;
-};
-const shouldAttachEnvelopeHeader = (dataPlatform, defaultOrigin)=>{
-    if (true === dataPlatform.allowCrossOriginEnvelope) return true;
-    const currentOrigin = normalizeOrigin(resolveOrigin(defaultOrigin));
-    const targetOrigin = normalizeOrigin(resolveTargetOrigin(dataPlatform, defaultOrigin));
-    if (!currentOrigin || !targetOrigin) return true;
-    return currentOrigin === targetOrigin;
-};
-const toEnvelopeInput = (normalizedRequest)=>{
-    const payload = {};
-    if (isRecord(normalizedRequest.params)) payload.path = normalizedRequest.params;
-    if (isRecord(normalizedRequest.query)) payload.query = normalizedRequest.query;
-    if ('data' in normalizedRequest && void 0 !== normalizedRequest.data) payload.data = normalizedRequest.data;
-    if ('body' in normalizedRequest && void 0 !== normalizedRequest.body) payload.body = normalizedRequest.body;
-    if ("u" > typeof FormData && normalizedRequest.formData instanceof FormData) payload.formData = Array.from(normalizedRequest.formData.entries()).map(([key, value])=>[
-            key,
-            String(value)
-        ]);
-    if ("u" > typeof URLSearchParams && normalizedRequest.formUrlencoded instanceof URLSearchParams) payload.formUrlencoded = normalizedRequest.formUrlencoded.toString();
-    return payload;
-};
+const external_batch_js_namespaceObject = require("./batch.js");
+const external_envelope_js_namespaceObject = require("./envelope.js");
+const external_request_context_js_namespaceObject = require("./request-context.js");
 const createGeneratedEffectClient = (manifest, config, requestRuntime)=>{
     const createRequest = requestRuntime.createRequest;
     const configureRequest = 'function' == typeof requestRuntime.configure ? requestRuntime.configure : void 0;
     const createRequestContextHeaders = 'function' == typeof requestRuntime.createRequestContextHeaders ? requestRuntime.createRequestContextHeaders : void 0;
-    const defaultOrigin = config.defaultOrigin;
     const httpMethodDecider = config.httpMethodDecider || 'functionName';
     const port = config.useEnvPort && "u" > typeof process && process.env && process.env.PORT ? process.env.PORT : config.port;
-    if (config.requestId && configureRequest) {
-        const configurePayload = {
-            requestId: config.requestId,
-            requireEnvelope: true,
-            identityBinding: {
-                enabled: true,
-                strict: true
-            },
-            operationContract: {
-                enabled: true,
-                strict: true,
-                requireSchemaHash: true,
-                requireOperationVersion: true
-            },
-            setDomain: ()=>resolveOrigin(defaultOrigin)
-        };
-        const runtimeFetch = resolveRuntimeFetch();
-        if (false !== config.batch.enabled && runtimeFetch) configurePayload.request = (0, index_js_namespaceObject.createDataBatchTransport)({
-            fetch: runtimeFetch,
-            endpoint: config.batch.endpoint,
-            flushIntervalMs: config.batch.flushIntervalMs,
-            maxBatchSize: config.batch.maxBatchSize,
-            maxBatchBytes: config.batch.maxBatchBytes,
-            requestTimeoutMs: config.batch.requestTimeoutMs,
-            allowedMethods: config.batch.allowedMethods
-        });
-        configureRequest(configurePayload);
-    }
-    const createEffectRequestContext = (requestContext)=>{
-        if (!isRecord(requestContext)) return {};
-        const headers = createRequestContextHeaders ? createRequestContextHeaders(requestContext) : {};
-        return {
-            ...requestContext,
-            headers
-        };
-    };
-    const applyRequestContext = (normalizedRequest, request)=>{
-        if (!isRecord(request) || !isRecord(request.requestContext)) return normalizedRequest;
-        const requestContext = createEffectRequestContext(request.requestContext);
-        const requestHeaders = isRecord(requestContext.headers) ? requestContext.headers : {};
-        if (0 === Object.keys(requestHeaders).length) return normalizedRequest;
-        return {
-            ...normalizedRequest,
-            headers: {
-                ...requestHeaders,
-                ...isRecord(normalizedRequest.headers) ? normalizedRequest.headers : {}
-            }
-        };
-    };
-    const prepareEffectRequest = (endpoint, operation, request)=>{
-        const normalizedRequest = applyRequestContext(normalizeRequest(endpoint.method, request), request);
-        const dataPlatform = isRecord(request) && isRecord(request.dataPlatform) ? request.dataPlatform : {};
-        const strictEnvelope = true === dataPlatform.requireEnvelope || true === dataPlatform.strict;
-        if (!strictEnvelope && !shouldAttachEnvelopeHeader(dataPlatform, defaultOrigin)) return normalizedRequest;
-        try {
-            const namespace = stringOrUndefined(dataPlatform.appNamespace) || config.appNamespace;
-            const origin = stringOrUndefined(dataPlatform.origin) || resolveOrigin(defaultOrigin);
-            const envelope = (0, index_js_namespaceObject.createRequestEnvelope)({
-                operation: {
-                    ...operation,
-                    appNamespace: namespace
-                },
-                scope: {
-                    appNamespace: namespace,
-                    origin,
-                    tenantId: stringOrUndefined(dataPlatform.tenantId),
-                    userId: stringOrUndefined(dataPlatform.userId),
-                    sessionId: stringOrUndefined(dataPlatform.sessionId)
-                },
-                requestInput: {
-                    method: endpoint.method,
-                    routePath: endpoint.routePath,
-                    payload: toEnvelopeInput(normalizedRequest)
-                },
-                requestMode: isDataRequestMode(dataPlatform.requestMode) ? dataPlatform.requestMode : void 0,
-                mutationMode: isDataMutationMode(dataPlatform.mutationMode) ? dataPlatform.mutationMode : void 0,
-                selectionPlan: isRecord(dataPlatform.selectionPlan) ? dataPlatform.selectionPlan : void 0,
-                traceContext: isRecord(dataPlatform.traceContext) ? dataPlatform.traceContext : void 0,
-                requireTraceContext: true === dataPlatform.requireTraceContext
-            });
-            const headerName = stringOrUndefined(dataPlatform.envelopeHeader) || index_js_namespaceObject.DEFAULT_DATA_ENVELOPE_HEADER;
-            const headers = isRecord(normalizedRequest.headers) ? {
-                ...normalizedRequest.headers
-            } : {};
-            if (false === dataPlatform.batch) headers[index_js_namespaceObject.DEFAULT_DATA_BATCH_HEADER] = 'off';
-            headers[headerName] = (0, index_js_namespaceObject.encodeRequestEnvelopeHeader)(envelope);
-            return {
-                ...normalizedRequest,
-                headers
-            };
-        } catch (error) {
-            if (strictEnvelope) throw error;
-            return normalizedRequest;
-        }
-    };
+    (0, external_batch_js_namespaceObject.configureGeneratedEffectClientRuntime)(config, configureRequest);
+    const createEffectRequestContext = (requestContext)=>(0, external_request_context_js_namespaceObject.createEffectRequestContext)(createRequestContextHeaders, requestContext);
     const client = {};
     const operationManifest = {};
     for (const endpoint of manifest.endpoints){
@@ -245,7 +73,13 @@ const createGeneratedEffectClient = (manifest, config, requestRuntime)=>{
                 requestId: config.requestId
             } : {}
         });
-        const call = (request = {})=>sender(prepareEffectRequest(endpoint, operation, request));
+        const call = (request = {})=>sender((0, external_envelope_js_namespaceObject.prepareEffectRequest)({
+                endpoint,
+                operation,
+                request,
+                config,
+                createEffectRequestContext
+            }));
         client[endpoint.group] ??= {};
         client[endpoint.group][endpoint.endpoint] = call;
         operationManifest[endpoint.group] ??= {};

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

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+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/adapter.js

@@ -39,7 +39,6 @@ __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);
@@ -50,17 +49,9 @@ const before = [
     '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.prefix = '/api';
         this.setHandlers = async ()=>{
@@ -71,7 +62,7 @@ class HonoAdapter {
                     name: 'hono-bff-api',
                     path,
                     method,
-                    handler,
+                    handler: this.withErrorBoundary(handler),
                     order: 'post',
                     before
                 }));
@@ -92,85 +83,47 @@ class HonoAdapter {
                 });
             }
         };
-        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}`);
-                }
-                return (0, external_safe_failure_js_namespaceObject.createSafeFailureResponse)(err);
-            });
-        };
-        this.registerMiddleware = async (options)=>{
-            const { prefix } = options;
+        this.registerMiddleware = async (options = {})=>{
             const { bffRuntimeFramework } = this.api.getServerContext();
             if ('hono' !== bffRuntimeFramework) {
                 this.isHono = false;
                 return;
             }
+            const { prefix } = options;
             this.prefix = prefix || this.prefix;
             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);
+            globalMiddlewares.push(...this.apiMiddleware);
+        };
+        this.handleRouteError = async (error, c)=>{
+            try {
+                const onErrorHandler = this.api.getServerConfig()?.onError;
+                if (onErrorHandler) {
+                    const result = await onErrorHandler(error, c);
+                    if (result instanceof Response) return result;
+                } else utils_namespaceObject.logger.error(error);
+            } catch (configError) {
+                utils_namespaceObject.logger.error(`Error in serverConfig.onError handler: ${configError}`);
             }
+            return (0, external_safe_failure_js_namespaceObject.createSafeFailureResponse)(error);
         };
-        this.onApiHandlersUpdated = async ()=>{
-            if (!this.isHono) return;
-            await this.setHandlers();
-            await this.registerApiRoutes();
+        this.withErrorBoundary = (handler)=>{
+            const handlers = Array.isArray(handler) ? handler : [
+                handler
+            ];
+            const [firstHandler, ...restHandlers] = handlers;
+            if (!firstHandler) return handler;
+            const boundary = async (c, next)=>{
+                try {
+                    return await firstHandler(c, next);
+                } catch (error) {
+                    return this.handleRouteError(error, c);
+                }
+            };
+            return Array.isArray(handler) ? [
+                boundary,
+                ...restHandlers
+            ] : boundary;
         };
         this.api = api;
     }

package/dist/cjs/runtime/safe-failure.js

@@ -35,6 +35,7 @@ const SAFE_FAILURE_CODES = {
     500: 'INTERNAL_SERVER_ERROR',
     503: 'SERVICE_UNAVAILABLE'
 };
+const INVALID_HTTP_HEADER_VALUE = /[\0-\x08\x0a-\x1f\x7f]/u;
 const readErrorProperty = (error, key)=>{
     if ('object' != typeof error || null === error || !(key in error)) return;
     return error[key];
@@ -47,7 +48,7 @@ const normalizeRetryAfter = (value)=>{
     if ('number' == typeof value && Number.isFinite(value) && value >= 0) return String(Math.ceil(value));
     if ('string' == typeof value) {
         const trimmed = value.trim();
-        return trimmed.length > 0 ? trimmed : void 0;
+        return trimmed.length > 0 && !INVALID_HTTP_HEADER_VALUE.test(trimmed) ? trimmed : void 0;
     }
     if (value instanceof Date) return value.toUTCString();
 };

package/dist/cjs/server.js

@@ -43,15 +43,17 @@ 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 adapter_js_namespaceObject = require("./runtime/hono/adapter.js");
+const RUNTIME_ADAPTER_LOADERS = {
+    hono: async (api)=>[
+            new adapter_js_namespaceObject.HonoAdapter(api)
+        ],
+    effect: async (api)=>{
+        const { EffectAdapter } = await import("./runtime/effect/adapter.js");
+        return [
+            new EffectAdapter(api)
+        ];
+    }
 };
 const normalizePrefixList = (prefix)=>{
     if (Array.isArray(prefix)) return prefix.filter(Boolean);
@@ -64,9 +66,6 @@ function resolveRuntimeFramework(runtimeFramework) {
     return 'hono' === runtimeFramework ? 'hono' : 'effect';
 }
 class Storage {
-    reset() {
-        this.middlewares = [];
-    }
     constructor(){
         this.middlewares = [];
     }
@@ -78,7 +77,6 @@ const server = ()=>({
             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;
@@ -124,29 +122,20 @@ const server = ()=>({
                         ]
                     });
                 }
+                const runtimeAdapters = await RUNTIME_ADAPTER_LOADERS[runtimeFramework](api);
                 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?.()));
+                if ('file-change' === event.type && apiRouter) {
+                    const appContext = api.getServerContext();
+                    const apiHandlerInfos = await apiRouter.getApiHandlers();
+                    api.updateServerContext({
+                        ...appContext,
+                        apiHandlerInfos
+                    });
                 }
             });
             const prepareApiServer = async (input, next)=>{