@bleedingdev/modern-js-plugin-bff 3.5.0-ultramodern.30 → 3.5.0-ultramodern.31

package/dist/cjs/runtime/effect/handler.js

@@ -1,17 +1,17 @@
 "use strict";
 var __webpack_modules__ = {
-    "../data-platform" (module) {
-        module.exports = require("../data-platform/index.js");
-    },
     "./entry-shape" (module) {
         module.exports = require("./entry-shape.js");
     },
+    "./handler/definition" (module) {
+        module.exports = require("./handler/definition.js");
+    },
+    "./handler/http" (module) {
+        module.exports = require("./handler/http.js");
+    },
     "effect/Config" (module) {
         module.exports = require("effect/Config");
     },
-    "effect/Context" (module) {
-        module.exports = require("effect/Context");
-    },
     "effect/Effect" (module) {
         module.exports = require("effect/Effect");
     },
@@ -81,19 +81,14 @@ function __webpack_require__(moduleId) {
 var __webpack_exports__ = {};
 (()=>{
     __webpack_require__.r(__webpack_exports__);
-    var effect_Context__rspack_import_0 = __webpack_require__("effect/Context");
-    var effect_Layer__rspack_import_1 = __webpack_require__("effect/Layer");
-    var effect_unstable_http__rspack_import_2 = __webpack_require__("effect/unstable/http");
-    var effect_unstable_httpapi__rspack_import_3 = __webpack_require__("effect/unstable/httpapi");
-    var effect_unstable_rpc__rspack_import_4 = __webpack_require__("effect/unstable/rpc");
-    var _data_platform__rspack_import_5 = __webpack_require__("../data-platform");
-    var _entry_shape__rspack_import_6 = __webpack_require__("./entry-shape");
-    var effect_Config__rspack_import_7 = __webpack_require__("effect/Config");
-    var effect_Effect__rspack_import_8 = __webpack_require__("effect/Effect");
-    var effect_Option__rspack_import_9 = __webpack_require__("effect/Option");
-    var effect_Schema__rspack_import_10 = __webpack_require__("effect/Schema");
+    var effect_Config__rspack_import_0 = __webpack_require__("effect/Config");
+    var effect_Effect__rspack_import_1 = __webpack_require__("effect/Effect");
+    var effect_Layer__rspack_import_2 = __webpack_require__("effect/Layer");
+    var effect_Option__rspack_import_3 = __webpack_require__("effect/Option");
+    var effect_Schema__rspack_import_4 = __webpack_require__("effect/Schema");
+    var effect_unstable_http__rspack_import_5 = __webpack_require__("effect/unstable/http");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in effect_unstable_http__rspack_import_2)if ([
+    for(const __rspack_import_key in effect_unstable_http__rspack_import_5)if ([
         "Config",
         "Layer",
         "Schema",
@@ -107,10 +102,11 @@ var __webpack_exports__ = {};
         "EFFECT_VALIDATOR_AWARE_FACTORY",
         "isValidatorAwareHandlerFactory",
         "Option"
-    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>effect_unstable_http__rspack_import_2[__rspack_import_key];
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>effect_unstable_http__rspack_import_5[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var effect_unstable_httpapi__rspack_import_6 = __webpack_require__("effect/unstable/httpapi");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in effect_unstable_httpapi__rspack_import_3)if ([
+    for(const __rspack_import_key in effect_unstable_httpapi__rspack_import_6)if ([
         "Config",
         "Layer",
         "Schema",
@@ -124,10 +120,11 @@ var __webpack_exports__ = {};
         "EFFECT_VALIDATOR_AWARE_FACTORY",
         "isValidatorAwareHandlerFactory",
         "Option"
-    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>effect_unstable_httpapi__rspack_import_3[__rspack_import_key];
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>effect_unstable_httpapi__rspack_import_6[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var effect_unstable_rpc__rspack_import_7 = __webpack_require__("effect/unstable/rpc");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in effect_unstable_rpc__rspack_import_4)if ([
+    for(const __rspack_import_key in effect_unstable_rpc__rspack_import_7)if ([
         "Config",
         "Layer",
         "Schema",
@@ -141,512 +138,24 @@ var __webpack_exports__ = {};
         "EFFECT_VALIDATOR_AWARE_FACTORY",
         "isValidatorAwareHandlerFactory",
         "Option"
-    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>effect_unstable_rpc__rspack_import_4[__rspack_import_key];
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>effect_unstable_rpc__rspack_import_7[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    const emptyEffectServiceContext = effect_Context__rspack_import_0.empty();
-    const isEffectServiceContext = (context)=>'object' == typeof context && null !== context && 'mapUnsafe' in context;
-    const toEffectServiceContext = (context)=>isEffectServiceContext(context) ? context : emptyEffectServiceContext;
-    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 _data_platform__rspack_import_5.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 createJsonValidationResponse(message, status = 400) {
-        return new Response(JSON.stringify({
-            message
-        }), {
-            status,
-            headers: {
-                'content-type': 'application/json; charset=utf-8'
-            }
-        });
-    }
-    function cloneWithoutJsonBodyHeaders(request) {
-        const headers = new Headers(request.headers);
-        headers.delete('content-type');
-        headers.delete('content-length');
-        return new Request(request.url, {
-            method: request.method,
-            headers,
-            signal: request.signal
-        });
-    }
-    async function prepareJsonRequestBody(request) {
-        const method = normalizeItemMethod(request.method);
-        if ('GET' === method || 'HEAD' === method) return request;
-        const contentType = (request.headers.get('content-type') || '').toLowerCase();
-        if (!contentType.includes('application/json')) return request;
-        if (null === request.body) return cloneWithoutJsonBodyHeaders(request);
-        try {
-            const bodyText = await request.clone().text();
-            if ('' === bodyText) return cloneWithoutJsonBodyHeaders(request);
-            JSON.parse(bodyText);
-        } catch  {
-            return createJsonValidationResponse('Invalid JSON request body');
-        }
-        return request;
-    }
-    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 effect_unstable_rpc__rspack_import_4.RpcSerialization.layerNdjson;
-            case 'jsonRpc':
-                return effect_unstable_rpc__rspack_import_4.RpcSerialization.layerJsonRpc();
-            case 'ndJsonRpc':
-                return effect_unstable_rpc__rspack_import_4.RpcSerialization.layerNdJsonRpc();
-            case 'msgPack':
-                return effect_unstable_rpc__rspack_import_4.RpcSerialization.layerMsgPack;
-            default:
-                return effect_unstable_rpc__rspack_import_4.RpcSerialization.layerJsonRpc();
-        }
-    }
-    function createRpcApiHandler(options) {
-        const rpcPath = normalizeRpcPath(options.path);
-        const rpcLayer = effect_Layer__rspack_import_1.provide(effect_unstable_rpc__rspack_import_4.RpcServer.layerHttp({
-            group: options.group,
-            path: rpcPath,
-            protocol: 'http',
-            disableTracing: options.disableTracing,
-            spanPrefix: options.spanPrefix,
-            spanAttributes: options.spanAttributes
-        }), effect_Layer__rspack_import_1.mergeAll(options.layer, getRpcSerializationLayer(options.serialization)));
-        return effect_unstable_http__rspack_import_2.HttpRouter.toWebHandler(rpcLayer);
-    }
-    function createOpenApiLayer(api, openapi) {
-        const openApiOptions = getOpenApiOptions(openapi);
-        if (!openApiOptions) return null;
-        return effect_unstable_http__rspack_import_2.HttpRouter.add('GET', openApiOptions.path, effect_unstable_http__rspack_import_2.HttpServerResponse.jsonUnsafe(effect_unstable_httpapi__rspack_import_3.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 || _data_platform__rspack_import_5.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 = (0, _data_platform__rspack_import_5.decodeRequestEnvelopeHeader)(encodedEnvelope);
-        if (!envelope) return createInvalidEnvelopeResponse(`Invalid data envelope header format: ${envelopeHeader}`);
-        const validation = (0, _data_platform__rspack_import_5.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 = (0, _data_platform__rspack_import_5.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),
-                validateRequest: options?.validateRequest
-            });
-        };
-        Object.defineProperty(createHandler, _entry_shape__rspack_import_6.EFFECT_VALIDATOR_AWARE_FACTORY, {
-            value: true
-        });
-        const client = createLoaderMaterializedClientPlaceholder();
-        return {
-            ...definition,
-            createHandler,
-            client
-        };
-    }
-    const LOADER_CLIENT_IGNORED_KEYS = new Set([
-        'then',
-        'catch',
-        'finally',
-        'toJSON',
-        '$$typeof'
-    ]);
-    function createLoaderMaterializedClientPlaceholder() {
-        const explain = (property)=>{
-            throw new Error(`[BFF][Effect] client.${String(property)} is not available here: the typed client only exists when the API entry is imported through the "@api/index" transformed path (the BFF loader replaces it with generated client code). On the server, use HttpApiClient or call the Effect layer directly.`);
-        };
-        return new Proxy(Object.create(null), {
-            get (_target, property) {
-                if ('symbol' == typeof property || LOADER_CLIENT_IGNORED_KEYS.has(property)) return;
-                return explain(property);
-            }
-        });
-    }
-    function defineEffectRpcBff(definition) {
-        const createHandler = (options)=>createRpcApiHandler({
-                ...definition,
-                ...options
-            });
-        return {
-            ...definition,
-            createHandler
-        };
-    }
-    function createHttpApiHandler(options) {
-        const apiLayer = options.layer.pipe(effect_Layer__rspack_import_1.provide(effect_unstable_http__rspack_import_2.HttpServer.layerServices));
-        const openApiLayer = createOpenApiLayer(options.api, options.openapi);
-        const mergedLayer = openApiLayer ? effect_Layer__rspack_import_1.mergeAll(apiLayer, openApiLayer) : apiLayer;
-        const httpApiHandler = effect_unstable_http__rspack_import_2.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 || _data_platform__rspack_import_5.DEFAULT_DATA_ENVELOPE_HEADER;
-        const normalizedEnvelopeHeader = envelopeHeader.toLowerCase();
-        const withDataPlatformValidation = async (request, context)=>{
-            const policyDenial = options.validateRequest?.(request);
-            if (policyDenial) return policyDenial;
-            const preparedRequest = await prepareJsonRequestBody(request);
-            if (preparedRequest instanceof Response) return preparedRequest;
-            const validationError = validateDataPlatformRequestEnvelope(preparedRequest, options.dataPlatform);
-            if (validationError) return validationError;
-            return httpApiHandler.handler(preparedRequest, toEffectServiceContext(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 = (0, _data_platform__rspack_import_5.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',
-                    [_data_platform__rspack_import_5.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)) {
-                    const policyDenial = options.validateRequest?.(request);
-                    if (policyDenial) return policyDenial;
-                    return rpcHandler.handler(request, toEffectServiceContext(context));
-                }
-                return handleHttpApiRequest(request);
-            },
-            dispose: async ()=>{
-                await Promise.all([
-                    httpApiHandler.dispose(),
-                    rpcHandler.dispose()
-                ]);
-            }
-        };
-    }
+    var _entry_shape__rspack_import_8 = __webpack_require__("./entry-shape");
+    var _handler_definition__rspack_import_9 = __webpack_require__("./handler/definition");
+    var _handler_http__rspack_import_10 = __webpack_require__("./handler/http");
     __webpack_require__.d(__webpack_exports__, {
-        Config: ()=>effect_Config__rspack_import_7,
-        EFFECT_VALIDATOR_AWARE_FACTORY: ()=>_entry_shape__rspack_import_6.EFFECT_VALIDATOR_AWARE_FACTORY,
-        Effect: ()=>effect_Effect__rspack_import_8,
-        HttpApiBuilder: ()=>effect_unstable_httpapi__rspack_import_3.HttpApiBuilder,
-        HttpTraceContext: ()=>effect_unstable_http__rspack_import_2.HttpTraceContext,
-        Layer: ()=>effect_Layer__rspack_import_1,
-        Option: ()=>effect_Option__rspack_import_9,
-        Schema: ()=>effect_Schema__rspack_import_10,
-        createHttpApiHandler: ()=>createHttpApiHandler,
-        defineEffectBff: ()=>defineEffectBff,
-        defineEffectRpcBff: ()=>defineEffectRpcBff,
-        isValidatorAwareHandlerFactory: ()=>_entry_shape__rspack_import_6.isValidatorAwareHandlerFactory
+        Config: ()=>effect_Config__rspack_import_0,
+        EFFECT_VALIDATOR_AWARE_FACTORY: ()=>_entry_shape__rspack_import_8.EFFECT_VALIDATOR_AWARE_FACTORY,
+        Effect: ()=>effect_Effect__rspack_import_1,
+        HttpApiBuilder: ()=>effect_unstable_httpapi__rspack_import_6.HttpApiBuilder,
+        HttpTraceContext: ()=>effect_unstable_http__rspack_import_5.HttpTraceContext,
+        Layer: ()=>effect_Layer__rspack_import_2,
+        Option: ()=>effect_Option__rspack_import_3,
+        Schema: ()=>effect_Schema__rspack_import_4,
+        createHttpApiHandler: ()=>_handler_http__rspack_import_10.createHttpApiHandler,
+        defineEffectBff: ()=>_handler_definition__rspack_import_9.defineEffectBff,
+        defineEffectRpcBff: ()=>_handler_definition__rspack_import_9.defineEffectRpcBff,
+        isValidatorAwareHandlerFactory: ()=>_entry_shape__rspack_import_8.isValidatorAwareHandlerFactory
     });
 })();
 exports.Config = __webpack_exports__.Config;

package/dist/cjs/runtime/effect/rpcSerialization.js

@@ -0,0 +1,54 @@
+"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__, {
+    getRpcSerializationLayer: ()=>getRpcSerializationLayer
+});
+const rpc_namespaceObject = require("effect/unstable/rpc");
+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();
+    }
+}
+exports.getRpcSerializationLayer = __webpack_exports__.getRpcSerializationLayer;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getRpcSerializationLayer"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});