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

package/dist/esm/runtime/effect/index.mjs

@@ -0,0 +1,438 @@
+import * as __rspack_external_effect_Layer_16f7a8fc from "effect/Layer";
+import { HttpRouter, HttpServerResponse, HttpTraceContext } from "effect/unstable/http";
+import { HttpApiBuilder, OpenApi } from "effect/unstable/httpapi";
+import { RpcSerialization, RpcServer } from "effect/unstable/rpc";
+import { DEFAULT_DATA_BATCH_ENDPOINT, DEFAULT_DATA_BATCH_HEADER, DEFAULT_DATA_ENVELOPE_HEADER, decodeRequestEnvelopeHeader, validateRequestEnvelope, validateSelectionPlan } from "../data-platform/index.mjs";
+import * as __rspack_external__effect_opentelemetry_8bbbb5af from "@effect/opentelemetry";
+import * as __rspack_external_effect_Config_29be8a92 from "effect/Config";
+import * as __rspack_external_effect_Effect_194ac36c from "effect/Effect";
+import * as __rspack_external_effect_Option_4d691636 from "effect/Option";
+import * as __rspack_external_effect_Schema_f8472650 from "effect/Schema";
+export * from "effect/unstable/http";
+export * from "effect/unstable/httpapi";
+export * from "effect/unstable/rpc";
+function normalizeOpenApiPath(pathname) {
+    if (!pathname.startsWith('/')) return `/${pathname}`;
+    return pathname;
+}
+function getOpenApiOptions(openapi) {
+    if (!openapi || 'object' != typeof openapi) return;
+    if (!openapi.path) return;
+    return {
+        path: normalizeOpenApiPath(openapi.path)
+    };
+}
+function normalizeRpcPath(pathname) {
+    if (!pathname || '/' === pathname) return '/rpc';
+    if (!pathname.startsWith('/')) return `/${pathname}`;
+    return pathname;
+}
+function normalizeBatchPath(pathname) {
+    if (!pathname || '/' === pathname) return DEFAULT_DATA_BATCH_ENDPOINT;
+    if (!pathname.startsWith('/')) return `/${pathname}`;
+    return pathname;
+}
+function isPlainObject(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+function toTextLength(value) {
+    if ("u" > typeof TextEncoder) return new TextEncoder().encode(value).length;
+    if ("u" > typeof Buffer) return Buffer.byteLength(value);
+    return value.length;
+}
+function toHeaderRecord(headers) {
+    const record = {};
+    headers.forEach((value, key)=>{
+        record[key] = value;
+    });
+    return record;
+}
+function normalizeItemMethod(method) {
+    return (method || 'GET').toUpperCase();
+}
+function normalizeBatchAllowedMethods(allowedMethods) {
+    const source = Array.isArray(allowedMethods) && allowedMethods.length > 0 ? allowedMethods : [
+        'GET'
+    ];
+    return new Set(source.map((method)=>method.toUpperCase()));
+}
+function isBatchRequestPayload(value) {
+    return isPlainObject(value) && 1 === value.protocolVersion && 'string' == typeof value.batchId && 'number' == typeof value.sentAt && Array.isArray(value.items);
+}
+function createBatchValidationResponse(message, status = 400) {
+    return new Response(JSON.stringify({
+        message
+    }), {
+        status,
+        headers: {
+            'content-type': 'application/json; charset=utf-8'
+        }
+    });
+}
+function toBatchItemError(id, status, message) {
+    return {
+        id,
+        status,
+        headers: {
+            'content-type': 'application/json; charset=utf-8'
+        },
+        body: JSON.stringify({
+            message
+        })
+    };
+}
+function promiseWithTimeout(effect, timeoutMs) {
+    if (timeoutMs <= 0) return effect;
+    return new Promise((resolve, reject)=>{
+        const timer = setTimeout(()=>{
+            reject(new Error(`Batch item timeout after ${String(timeoutMs)}ms`));
+        }, timeoutMs);
+        effect.then((value)=>{
+            clearTimeout(timer);
+            resolve(value);
+        }, (error)=>{
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}
+async function mapWithConcurrency(items, concurrency, mapper) {
+    if (0 === items.length) return [];
+    const normalizedConcurrency = Math.max(1, concurrency);
+    const output = new Array(items.length);
+    let index = 0;
+    const workers = Array.from({
+        length: Math.min(normalizedConcurrency, items.length)
+    }, async ()=>{
+        while(true){
+            const currentIndex = index;
+            index += 1;
+            if (currentIndex >= items.length) return;
+            output[currentIndex] = await mapper(items[currentIndex], currentIndex);
+        }
+    });
+    await Promise.all(workers);
+    return output;
+}
+function getRequestPathname(request) {
+    try {
+        return new URL(request.url).pathname;
+    } catch  {
+        return new URL(request.url, 'http://localhost').pathname;
+    }
+}
+function normalizeMountPrefix(prefix) {
+    if (!prefix || '/' === prefix) return '';
+    return prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
+}
+function getMountedPrefixFromContext(request, context) {
+    if (!isPlainObject(context) || 'string' != typeof context.path) return '';
+    const contextPath = normalizeMountPrefix(context.path);
+    const requestPath = normalizeMountPrefix(getRequestPathname(request));
+    if (!contextPath || !requestPath || contextPath === requestPath || !contextPath.endsWith(requestPath)) return '';
+    return normalizeMountPrefix(contextPath.slice(0, contextPath.length - requestPath.length));
+}
+function removeMountedPrefixFromBatchPath(pathWithQuery, prefix) {
+    const normalizedPrefix = normalizeMountPrefix(prefix);
+    if (!normalizedPrefix) return pathWithQuery;
+    const [pathname, ...queryParts] = pathWithQuery.split('?');
+    if (!pathname) return pathWithQuery;
+    let nextPathname = pathname;
+    if (pathname === normalizedPrefix) nextPathname = '/';
+    else if (pathname.startsWith(`${normalizedPrefix}/`)) {
+        const sliced = pathname.slice(normalizedPrefix.length);
+        nextPathname = sliced.startsWith('/') ? sliced : `/${sliced}`;
+    }
+    if (0 === queryParts.length) return nextPathname;
+    return `${nextPathname}?${queryParts.join('?')}`;
+}
+function getRequestOrigin(request) {
+    try {
+        return new URL(request.url).origin;
+    } catch  {
+        return new URL(request.url, 'http://localhost').origin;
+    }
+}
+function getExpectedEnvelopeOrigin(request) {
+    const origin = request.headers.get('origin');
+    if (origin && 'null' !== origin) return origin;
+    return getRequestOrigin(request);
+}
+function isRpcRequest(request, rpcPath) {
+    const pathname = getRequestPathname(request);
+    return pathname === rpcPath || pathname.startsWith(`${rpcPath}/`);
+}
+function getRpcSerializationLayer(serialization) {
+    switch(serialization){
+        case 'ndjson':
+            return RpcSerialization.layerNdjson;
+        case 'jsonRpc':
+            return RpcSerialization.layerJsonRpc();
+        case 'ndJsonRpc':
+            return RpcSerialization.layerNdJsonRpc();
+        case 'msgPack':
+            return RpcSerialization.layerMsgPack;
+        default:
+            return RpcSerialization.layerJsonRpc();
+    }
+}
+function createRpcApiHandler(options) {
+    const rpcPath = normalizeRpcPath(options.path);
+    const rpcLayer = __rspack_external_effect_Layer_16f7a8fc.provide(RpcServer.layerHttp({
+        group: options.group,
+        path: rpcPath,
+        protocol: 'http',
+        disableTracing: options.disableTracing,
+        spanPrefix: options.spanPrefix,
+        spanAttributes: options.spanAttributes
+    }), __rspack_external_effect_Layer_16f7a8fc.mergeAll(options.layer, getRpcSerializationLayer(options.serialization)));
+    return HttpRouter.toWebHandler(rpcLayer);
+}
+function createOpenApiLayer(api, openapi) {
+    const openApiOptions = getOpenApiOptions(openapi);
+    if (!openApiOptions) return null;
+    return HttpRouter.add('GET', openApiOptions.path, HttpServerResponse.jsonUnsafe(OpenApi.fromApi(api)));
+}
+function createInvalidEnvelopeResponse(message, errors) {
+    return new Response(JSON.stringify({
+        message,
+        ...errors && errors.length > 0 ? {
+            errors
+        } : {}
+    }), {
+        status: 400,
+        headers: {
+            'content-type': 'application/json; charset=utf-8'
+        }
+    });
+}
+function validateDataPlatformRequestEnvelope(request, options) {
+    const isEnabled = options?.enabled ?? true;
+    if (!isEnabled) return null;
+    const envelopeHeader = options?.envelopeHeader || DEFAULT_DATA_ENVELOPE_HEADER;
+    const encodedEnvelope = request.headers.get(envelopeHeader);
+    if (!encodedEnvelope) {
+        if (options?.requireEnvelope) return createInvalidEnvelopeResponse(`Missing required data envelope header: ${envelopeHeader}`);
+        return null;
+    }
+    const envelope = decodeRequestEnvelopeHeader(encodedEnvelope);
+    if (!envelope) return createInvalidEnvelopeResponse(`Invalid data envelope header format: ${envelopeHeader}`);
+    const validation = validateRequestEnvelope(envelope, {
+        expectedProtocolVersion: 1,
+        expectedNamespace: options?.expectedNamespace,
+        expectedOrigin: options?.validateOrigin === false ? void 0 : getExpectedEnvelopeOrigin(request),
+        requireTraceContext: options?.requireTraceContext
+    });
+    if (!validation.ok) return createInvalidEnvelopeResponse('Invalid data envelope', validation.errors);
+    if (envelope.selectionPlan) {
+        const selectionValidation = validateSelectionPlan(envelope.selectionPlan, {
+            maxDepth: options?.selection?.maxDepth,
+            maxFields: options?.selection?.maxFields,
+            allowedLeafPaths: options?.selection?.allowedLeafPaths
+        });
+        if (!selectionValidation.ok) return createInvalidEnvelopeResponse('Invalid data envelope selection plan', selectionValidation.errors);
+    }
+    return null;
+}
+function mergeDataPlatformOptions(base, override) {
+    if (!base && !override) return;
+    const baseSelection = base?.selection;
+    const overrideSelection = override?.selection;
+    const baseBatch = base?.batch;
+    const overrideBatch = override?.batch;
+    return {
+        ...base,
+        ...override,
+        selection: baseSelection || overrideSelection ? {
+            ...baseSelection,
+            ...overrideSelection
+        } : void 0,
+        batch: baseBatch || overrideBatch ? {
+            ...baseBatch,
+            ...overrideBatch
+        } : void 0
+    };
+}
+function defineEffectBff(definition) {
+    const createHandler = (options)=>{
+        const rpcDefinition = definition.rpc;
+        let mergedRpcOptions = rpcDefinition;
+        if (rpcDefinition && options?.rpc) mergedRpcOptions = {
+            ...rpcDefinition,
+            ...options.rpc
+        };
+        return createHttpApiHandler({
+            api: definition.api,
+            layer: definition.layer,
+            openapi: options?.openapi,
+            rpc: mergedRpcOptions,
+            dataPlatform: mergeDataPlatformOptions(definition.dataPlatform, options?.dataPlatform)
+        });
+    };
+    const client = void 0;
+    return {
+        ...definition,
+        createHandler,
+        client
+    };
+}
+function defineEffectRpcBff(definition) {
+    const createHandler = (options)=>createRpcApiHandler({
+            ...definition,
+            ...options
+        });
+    return {
+        ...definition,
+        createHandler
+    };
+}
+function createHttpApiHandler(options) {
+    const apiLayer = options.layer;
+    const openApiLayer = createOpenApiLayer(options.api, options.openapi);
+    const mergedLayer = openApiLayer ? __rspack_external_effect_Layer_16f7a8fc.mergeAll(apiLayer, openApiLayer) : apiLayer;
+    const httpApiHandler = HttpRouter.toWebHandler(mergedLayer);
+    const dataPlatformBatchOptions = options.dataPlatform?.batch;
+    const batchEnabled = dataPlatformBatchOptions?.enabled !== false;
+    const batchPath = normalizeBatchPath(dataPlatformBatchOptions?.endpoint);
+    const batchMaxSize = Math.max(1, dataPlatformBatchOptions?.maxBatchSize ?? 16);
+    const batchMaxBytes = Math.max(1024, dataPlatformBatchOptions?.maxBatchBytes ?? 65536);
+    const batchConcurrency = Math.max(1, dataPlatformBatchOptions?.maxConcurrency ?? 4);
+    const batchItemTimeoutMs = Math.max(0, dataPlatformBatchOptions?.requestTimeoutMs ?? 10000);
+    const batchAllowedMethods = normalizeBatchAllowedMethods(dataPlatformBatchOptions?.allowedMethods);
+    const envelopeHeader = options.dataPlatform?.envelopeHeader || DEFAULT_DATA_ENVELOPE_HEADER;
+    const normalizedEnvelopeHeader = envelopeHeader.toLowerCase();
+    const withDataPlatformValidation = async (request, context)=>{
+        const validationError = validateDataPlatformRequestEnvelope(request, options.dataPlatform);
+        if (validationError) return validationError;
+        return httpApiHandler.handler(request, context);
+    };
+    const handleBatchRequest = async (request, context)=>{
+        const mountedPrefix = getMountedPrefixFromContext(request, context);
+        const method = normalizeItemMethod(request.method);
+        if ('POST' !== method) return createBatchValidationResponse('Batch endpoint only supports POST requests', 405);
+        const contentType = request.headers.get('content-type') || '';
+        if (!contentType.includes('application/json')) return createBatchValidationResponse('Batch endpoint requires application/json content-type', 415);
+        const payloadText = await request.text();
+        if (toTextLength(payloadText) > batchMaxBytes) return createBatchValidationResponse(`Batch payload exceeds max size (${String(batchMaxBytes)} bytes)`, 413);
+        let payload;
+        try {
+            payload = JSON.parse(payloadText);
+        } catch  {
+            return createBatchValidationResponse('Invalid batch payload JSON');
+        }
+        if (!isBatchRequestPayload(payload)) return createBatchValidationResponse('Invalid batch payload shape');
+        if (0 === payload.items.length) return createBatchValidationResponse('Batch payload items cannot be empty');
+        if (payload.items.length > batchMaxSize) return createBatchValidationResponse(`Batch item count exceeds max size (${String(batchMaxSize)})`, 413);
+        const responseItems = await mapWithConcurrency(payload.items, batchConcurrency, async (rawItem, index)=>{
+            const fallbackId = `item_${String(index)}`;
+            const itemId = isPlainObject(rawItem) && 'string' == typeof rawItem.id ? rawItem.id : fallbackId;
+            if (!isPlainObject(rawItem)) return toBatchItemError(itemId, 400, 'Invalid batch item; expected object');
+            if ('string' != typeof rawItem.path || 0 === rawItem.path.length) return toBatchItemError(itemId, 400, 'Invalid batch item path');
+            if (!rawItem.path.startsWith('/')) return toBatchItemError(itemId, 400, 'Batch item path must start with "/"');
+            const normalizedItemPath = removeMountedPrefixFromBatchPath(rawItem.path, mountedPrefix);
+            const itemPathname = normalizedItemPath.split('?')[0] || normalizedItemPath;
+            if (itemPathname === batchPath || itemPathname.startsWith(`${batchPath}/`)) return toBatchItemError(itemId, 400, 'Batch item path cannot target batch endpoint');
+            const itemMethod = normalizeItemMethod('string' == typeof rawItem.method ? rawItem.method : void 0);
+            if (!batchAllowedMethods.has(itemMethod)) return toBatchItemError(itemId, 405, `Batch item method ${itemMethod} is not allowed`);
+            if (void 0 !== rawItem.body && null !== rawItem.body && 'string' != typeof rawItem.body) return toBatchItemError(itemId, 400, 'Batch item body must be a string when provided');
+            if (('GET' === itemMethod || 'HEAD' === itemMethod) && 'string' == typeof rawItem.body) return toBatchItemError(itemId, 400, `${itemMethod} batch item cannot include body`);
+            const normalizedHeaders = {};
+            if (void 0 !== rawItem.headers) {
+                if (!isPlainObject(rawItem.headers)) return toBatchItemError(itemId, 400, 'Batch item headers must be an object');
+                for (const [key, value] of Object.entries(rawItem.headers)){
+                    if ('string' != typeof value) return toBatchItemError(itemId, 400, `Invalid header "${key}" for batch item`);
+                    normalizedHeaders[key.toLowerCase()] = value;
+                }
+            }
+            if (!normalizedHeaders.traceparent) {
+                const encodedEnvelope = normalizedHeaders[normalizedEnvelopeHeader];
+                if ('string' == typeof encodedEnvelope) {
+                    const envelope = decodeRequestEnvelopeHeader(encodedEnvelope);
+                    if (envelope?.traceparent) normalizedHeaders.traceparent = envelope.traceparent;
+                }
+            }
+            if (!normalizedHeaders.traceparent) {
+                const requestTraceparent = request.headers.get('traceparent');
+                if (requestTraceparent) normalizedHeaders.traceparent = requestTraceparent;
+            }
+            const targetUrl = new URL(normalizedItemPath, request.url);
+            const requestHeaders = new Headers(normalizedHeaders);
+            const body = 'GET' === itemMethod || 'HEAD' === itemMethod ? void 0 : rawItem.body;
+            if (void 0 === body) requestHeaders.delete('content-type');
+            const itemRequest = new Request(targetUrl.toString(), {
+                method: itemMethod,
+                headers: requestHeaders,
+                body
+            });
+            try {
+                const itemResponse = await promiseWithTimeout(withDataPlatformValidation(itemRequest, context), batchItemTimeoutMs);
+                if (!(itemResponse instanceof Response)) return toBatchItemError(itemId, 500, 'Invalid response returned by batch item handler');
+                const bodyText = await itemResponse.text();
+                const responseItem = {
+                    id: itemId,
+                    status: itemResponse.status,
+                    headers: toHeaderRecord(itemResponse.headers),
+                    ...bodyText ? {
+                        body: bodyText
+                    } : {}
+                };
+                return responseItem;
+            } catch (error) {
+                if (error instanceof Response) {
+                    const bodyText = await error.text();
+                    return {
+                        id: itemId,
+                        status: error.status,
+                        headers: toHeaderRecord(error.headers),
+                        ...bodyText ? {
+                            body: bodyText
+                        } : {}
+                    };
+                }
+                const message = error instanceof Error ? error.message : String(error);
+                return toBatchItemError(itemId, 500, message);
+            }
+        });
+        const responsePayload = {
+            protocolVersion: 1,
+            batchId: payload.batchId,
+            receivedAt: Date.now(),
+            items: responseItems
+        };
+        return new Response(JSON.stringify(responsePayload), {
+            status: 200,
+            headers: {
+                'content-type': 'application/json; charset=utf-8',
+                [DEFAULT_DATA_BATCH_HEADER]: '1',
+                'x-modernjs-data-batch-id': payload.batchId
+            }
+        });
+    };
+    const handleHttpApiRequest = async (request, context)=>{
+        const pathname = getRequestPathname(request);
+        if (batchEnabled && pathname === batchPath) return handleBatchRequest(request, context);
+        return withDataPlatformValidation(request, context);
+    };
+    if (!options.rpc) return {
+        handler: handleHttpApiRequest,
+        dispose: async ()=>{
+            await httpApiHandler.dispose();
+        }
+    };
+    const rpcPath = normalizeRpcPath(options.rpc.path);
+    const rpcHandler = createRpcApiHandler(options.rpc);
+    return {
+        handler: async (request, context)=>{
+            if (isRpcRequest(request, rpcPath)) return rpcHandler.handler(request, context);
+            return handleHttpApiRequest(request);
+        },
+        dispose: async ()=>{
+            await Promise.all([
+                httpApiHandler.dispose(),
+                rpcHandler.dispose()
+            ]);
+        }
+    };
+}
+export { useEffectContext } from "./context.mjs";
+export { HttpApiBuilder, HttpTraceContext, __rspack_external__effect_opentelemetry_8bbbb5af as OpenTelemetry, __rspack_external_effect_Config_29be8a92 as Config, __rspack_external_effect_Effect_194ac36c as Effect, __rspack_external_effect_Layer_16f7a8fc as Layer, __rspack_external_effect_Option_4d691636 as Option, __rspack_external_effect_Schema_f8472650 as Schema, createHttpApiHandler, defineEffectBff, defineEffectRpcBff };

package/dist/esm/runtime/effect-client/index.mjs

@@ -0,0 +1,90 @@
+import * as __rspack_external_effect_Effect_194ac36c from "effect/Effect";
+import * as __rspack_external_effect_Layer_16f7a8fc from "effect/Layer";
+import { FetchHttpClient } from "effect/unstable/http";
+import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+import { Rpc, RpcClient, RpcGroup, RpcSchema, RpcSerialization } from "effect/unstable/rpc";
+import * as __rspack_external_effect_Schema_f8472650 from "effect/Schema";
+import * as __rspack_external_effect_Exit_a10cfb96 from "effect/Exit";
+import * as __rspack_external_effect_ManagedRuntime_94dd2709 from "effect/ManagedRuntime";
+import * as __rspack_external_effect_Scope_3211a2d6 from "effect/Scope";
+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 RpcSerialization.layerNdjson;
+        case 'jsonRpc':
+            return RpcSerialization.layerJsonRpc();
+        case 'ndJsonRpc':
+            return RpcSerialization.layerNdJsonRpc();
+        case 'msgPack':
+            return RpcSerialization.layerMsgPack;
+        default:
+            return RpcSerialization.layerJsonRpc();
+    }
+}
+function makeEffectHttpApiClient(api, options) {
+    return HttpApiClient.make(api, {
+        baseUrl: options?.baseUrl
+    }).pipe(__rspack_external_effect_Effect_194ac36c.provide(FetchHttpClient.layer));
+}
+function makeEffectRpcClient(group, options) {
+    const protocolLayer = __rspack_external_effect_Layer_16f7a8fc.provide(RpcClient.layerProtocolHttp({
+        url: options.url
+    }), __rspack_external_effect_Layer_16f7a8fc.mergeAll(getRpcSerializationLayer(options.serialization), FetchHttpClient.layer));
+    const middlewareLayer = options.middlewareLayer ?? __rspack_external_effect_Layer_16f7a8fc.empty;
+    const runtimeLayer = __rspack_external_effect_Layer_16f7a8fc.mergeAll(protocolLayer, middlewareLayer);
+    return __rspack_external_effect_Effect_194ac36c.tryPromise({
+        try: async ()=>{
+            const runtime = __rspack_external_effect_ManagedRuntime_94dd2709.make(runtimeLayer);
+            const scope = await runtime.runPromise(__rspack_external_effect_Scope_3211a2d6.make());
+            try {
+                const client = await runtime.runPromise(RpcClient.make(group, {
+                    flatten: options.flatten
+                }).pipe(__rspack_external_effect_Effect_194ac36c.provideService(__rspack_external_effect_Scope_3211a2d6.Scope, scope)));
+                let disposed = false;
+                const clientWithDispose = Object.assign(client, {
+                    dispose: async ()=>{
+                        if (!disposed) {
+                            disposed = true;
+                            await runtime.runPromise(__rspack_external_effect_Scope_3211a2d6.close(scope, __rspack_external_effect_Exit_a10cfb96["void"]));
+                        }
+                        await runtime.dispose();
+                    }
+                });
+                return clientWithDispose;
+            } catch (error) {
+                try {
+                    await runtime.runPromise(__rspack_external_effect_Scope_3211a2d6.close(scope, __rspack_external_effect_Exit_a10cfb96["void"]));
+                } catch  {}
+                try {
+                    await runtime.dispose();
+                } catch  {}
+                throw error;
+            }
+        },
+        catch: (error)=>error instanceof Error ? error : new Error(String(error))
+    });
+}
+const runEffectRequest = __rspack_external_effect_Effect_194ac36c.runPromise;
+export { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, Rpc, RpcClient, RpcGroup, RpcSchema, RpcSerialization, __rspack_external_effect_Effect_194ac36c as Effect, __rspack_external_effect_Layer_16f7a8fc as Layer, __rspack_external_effect_Schema_f8472650 as Schema, makeEffectHttpApiClient, makeEffectRpcClient, mask, runEffectRequest, runEffectView, view };

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

@@ -0,0 +1,124 @@
+import { Hono, run } from "@modern-js/server-core";
+import { isProd, logger } from "@modern-js/utils";
+import createHonoRoutes from "../../utils/createHonoRoutes.mjs";
+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(apiHandlerInfos);
+            this.apiMiddleware = honoHandlers.map(({ path, method, handler })=>({
+                    name: 'hono-bff-api',
+                    path,
+                    method,
+                    handler,
+                    order: 'post',
+                    before: before
+                }));
+        };
+        this.registerApiRoutes = async ()=>{
+            if (!this.isHono) return;
+            this.apiServer = new Hono();
+            this.apiServer.use('*', 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 logger.error(err);
+                } catch (configError) {
+                    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 (isProd()) globalMiddlewares.push(...this.apiMiddleware);
+            else {
+                await this.registerApiRoutes();
+                const dynamicApiMiddleware = {
+                    name: 'dynamic-bff-handler',
+                    path: `${prefix}/*`,
+                    method: 'all',
+                    order: 'post',
+                    before: 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;
+    }
+}
+export { HonoAdapter };

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

@@ -0,0 +1,2 @@
+export * from "@modern-js/bff-core";
+export * from "./operators.mjs";