@bleedingdev/modern-js-bff-effect 3.8.3-ultramodern.2

package/dist/cjs/effect/handler/batch-handler.js

@@ -0,0 +1,270 @@
+"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__, {
+    createDataPlatformBatchRequestHandler: ()=>createDataPlatformBatchRequestHandler
+});
+const index_js_namespaceObject = require("../../data-platform/index.js");
+const protocol_js_namespaceObject = require("../../data-platform/batch/protocol.js");
+const external_batch_js_namespaceObject = require("./batch.js");
+const external_routing_js_namespaceObject = require("./routing.js");
+const HOP_BY_HOP_BATCH_ITEM_HEADERS = new Set([
+    'connection',
+    'keep-alive',
+    'proxy-authenticate',
+    'proxy-authorization',
+    'proxy-connection',
+    'te',
+    'trailer',
+    'transfer-encoding',
+    'upgrade'
+]);
+const OUTER_BOUND_BATCH_ITEM_HEADERS = new Set([
+    'authorization',
+    'cookie',
+    'forwarded',
+    'origin',
+    'referer',
+    'sec-fetch-dest',
+    'sec-fetch-mode',
+    'sec-fetch-site',
+    'sec-fetch-user',
+    'x-forwarded-client-cert',
+    'x-forwarded-for',
+    'x-forwarded-host',
+    'x-forwarded-port',
+    'x-forwarded-proto',
+    'x-real-ip',
+    'x-subject-id',
+    'x-tenant-id',
+    'x-user-id',
+    'x-verified-producer'
+]);
+const TRANSPORT_CONTROLLED_BATCH_ITEM_HEADERS = new Set([
+    'content-length',
+    'host',
+    ...HOP_BY_HOP_BATCH_ITEM_HEADERS
+]);
+async function readRequestTextWithinLimit(request, maxBytes) {
+    const contentLength = request.headers.get('content-length');
+    if (null !== contentLength) {
+        if (!/^\d+$/.test(contentLength)) return {
+            status: 'invalid-content-length'
+        };
+        if (BigInt(contentLength) > BigInt(maxBytes)) return {
+            status: 'too-large'
+        };
+    }
+    if (null === request.body) return {
+        status: 'ok',
+        text: ''
+    };
+    const reader = request.body.getReader();
+    const decoder = new TextDecoder();
+    const text = [];
+    let bytesRead = 0;
+    try {
+        while(true){
+            const chunk = await reader.read();
+            if (chunk.done) {
+                text.push(decoder.decode());
+                return {
+                    status: 'ok',
+                    text: text.join('')
+                };
+            }
+            bytesRead += chunk.value.byteLength;
+            if (bytesRead > maxBytes) {
+                await reader.cancel('batch-payload-too-large');
+                return {
+                    status: 'too-large'
+                };
+            }
+            text.push(decoder.decode(chunk.value, {
+                stream: true
+            }));
+        }
+    } catch  {
+        return {
+            status: 'read-error'
+        };
+    } finally{
+        reader.releaseLock();
+    }
+}
+function createDataPlatformBatchRequestHandler(options) {
+    const dataPlatformBatchOptions = options.dataPlatform?.batch;
+    const batchEnabled = dataPlatformBatchOptions?.enabled !== false;
+    const batchPath = (0, external_batch_js_namespaceObject.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 = (0, external_batch_js_namespaceObject.normalizeBatchAllowedMethods)(dataPlatformBatchOptions?.allowedMethods);
+    const envelopeHeader = options.dataPlatform?.envelopeHeader || index_js_namespaceObject.DEFAULT_DATA_ENVELOPE_HEADER;
+    const normalizedEnvelopeHeader = envelopeHeader.toLowerCase();
+    const handle = async (request, context)=>{
+        const mountedPrefix = (0, external_routing_js_namespaceObject.getMountedPrefixFromContext)(request, context);
+        const method = (0, index_js_namespaceObject.normalizeMethod)(request.method);
+        if ('POST' !== method) return (0, external_batch_js_namespaceObject.createBatchValidationResponse)('Batch endpoint only supports POST requests', 405);
+        const contentType = request.headers.get('content-type') || '';
+        if (!contentType.includes('application/json')) return (0, external_batch_js_namespaceObject.createBatchValidationResponse)('Batch endpoint requires application/json content-type', 415);
+        const bodyResult = await readRequestTextWithinLimit(request, batchMaxBytes);
+        if ('too-large' === bodyResult.status) return (0, external_batch_js_namespaceObject.createBatchValidationResponse)(`Batch payload exceeds max size (${String(batchMaxBytes)} bytes)`, 413);
+        if ('invalid-content-length' === bodyResult.status) return (0, external_batch_js_namespaceObject.createBatchValidationResponse)('Batch payload has invalid content-length');
+        if ('read-error' === bodyResult.status) return (0, external_batch_js_namespaceObject.createBatchValidationResponse)('Unable to read batch payload');
+        const payloadText = bodyResult.text;
+        let payload;
+        try {
+            payload = JSON.parse(payloadText);
+        } catch  {
+            return (0, external_batch_js_namespaceObject.createBatchValidationResponse)('Invalid batch payload JSON');
+        }
+        if (!(0, external_batch_js_namespaceObject.isBatchRequestPayload)(payload)) return (0, external_batch_js_namespaceObject.createBatchValidationResponse)('Invalid batch payload shape');
+        if (0 === payload.items.length) return (0, external_batch_js_namespaceObject.createBatchValidationResponse)('Batch payload items cannot be empty');
+        if (payload.items.length > batchMaxSize) return (0, external_batch_js_namespaceObject.createBatchValidationResponse)(`Batch item count exceeds max size (${String(batchMaxSize)})`, 413);
+        const batchRequestOrigin = new URL(request.url).origin;
+        const responseItems = await (0, external_batch_js_namespaceObject.mapWithConcurrency)(payload.items, batchConcurrency, async (rawItem, index)=>{
+            const fallbackId = `item_${String(index)}`;
+            const itemId = (0, index_js_namespaceObject.isPlainObject)(rawItem) && 'string' == typeof rawItem.id ? rawItem.id : fallbackId;
+            if (!(0, index_js_namespaceObject.isPlainObject)(rawItem)) return (0, external_batch_js_namespaceObject.toBatchItemError)(itemId, 400, 'Invalid batch item; expected object');
+            if ('string' != typeof rawItem.path || 0 === rawItem.path.length) return (0, external_batch_js_namespaceObject.toBatchItemError)(itemId, 400, 'Invalid batch item path');
+            if (!rawItem.path.startsWith('/')) return (0, external_batch_js_namespaceObject.toBatchItemError)(itemId, 400, 'Batch item path must start with "/"');
+            const normalizedItemPath = (0, external_routing_js_namespaceObject.removeMountedPrefixFromBatchPath)(rawItem.path, mountedPrefix);
+            const itemPathname = normalizedItemPath.split('?')[0] || normalizedItemPath;
+            if (itemPathname === batchPath || itemPathname.startsWith(`${batchPath}/`)) return (0, external_batch_js_namespaceObject.toBatchItemError)(itemId, 400, 'Batch item path cannot target batch endpoint');
+            const itemMethod = (0, index_js_namespaceObject.normalizeMethod)('string' == typeof rawItem.method ? rawItem.method : void 0);
+            if (!batchAllowedMethods.has(itemMethod)) return (0, external_batch_js_namespaceObject.toBatchItemError)(itemId, 405, `Batch item method ${itemMethod} is not allowed`);
+            if (void 0 !== rawItem.body && !(0, protocol_js_namespaceObject.isBatchBody)(rawItem.body)) return (0, external_batch_js_namespaceObject.toBatchItemError)(itemId, 400, 'Batch item body must use the base64 body protocol');
+            if (('GET' === itemMethod || 'HEAD' === itemMethod) && void 0 !== rawItem.body) return (0, external_batch_js_namespaceObject.toBatchItemError)(itemId, 400, `${itemMethod} batch item cannot include body`);
+            const normalizedHeaders = {};
+            if (void 0 !== rawItem.headers) {
+                if (!(0, index_js_namespaceObject.isPlainObject)(rawItem.headers)) return (0, external_batch_js_namespaceObject.toBatchItemError)(itemId, 400, 'Batch item headers must be an object');
+                for (const [key, value] of Object.entries(rawItem.headers)){
+                    if ('string' != typeof value) return (0, external_batch_js_namespaceObject.toBatchItemError)(itemId, 400, `Invalid header "${key}" for batch item`);
+                    normalizedHeaders[key.toLowerCase()] = value;
+                }
+            }
+            const connectionScopedHeaders = new Set((normalizedHeaders.connection || '').split(',').map((header)=>header.trim().toLowerCase()).filter(Boolean));
+            for (const header of Object.keys(normalizedHeaders))if (TRANSPORT_CONTROLLED_BATCH_ITEM_HEADERS.has(header) || OUTER_BOUND_BATCH_ITEM_HEADERS.has(header) || connectionScopedHeaders.has(header)) delete normalizedHeaders[header];
+            if (!normalizedHeaders.traceparent) {
+                const encodedEnvelope = normalizedHeaders[normalizedEnvelopeHeader];
+                if ('string' == typeof encodedEnvelope) {
+                    const envelope = (0, index_js_namespaceObject.decodeRequestEnvelopeHeader)(encodedEnvelope);
+                    if (envelope?.traceparent) normalizedHeaders.traceparent = envelope.traceparent;
+                }
+            }
+            for (const header of OUTER_BOUND_BATCH_ITEM_HEADERS){
+                const value = request.headers.get(header);
+                if (null !== value) normalizedHeaders[header] = value;
+            }
+            if (!normalizedHeaders.traceparent) {
+                const requestTraceparent = request.headers.get('traceparent');
+                if (requestTraceparent) normalizedHeaders.traceparent = requestTraceparent;
+            }
+            const targetUrl = new URL(normalizedItemPath, request.url);
+            if (targetUrl.origin !== batchRequestOrigin) return (0, external_batch_js_namespaceObject.toBatchItemError)(itemId, 400, 'Batch item path must stay on the same origin');
+            let requestHeaders;
+            try {
+                requestHeaders = new Headers(normalizedHeaders);
+            } catch  {
+                return (0, external_batch_js_namespaceObject.toBatchItemError)(itemId, 400, 'Invalid batch item headers');
+            }
+            const body = 'GET' === itemMethod || 'HEAD' === itemMethod ? void 0 : void 0 === rawItem.body ? void 0 : (0, protocol_js_namespaceObject.decodeBatchBody)(rawItem.body);
+            if (void 0 === body) requestHeaders.delete('content-type');
+            const itemAbortController = new AbortController();
+            const abortFromBatchRequest = ()=>itemAbortController.abort(request.signal.reason);
+            if (request.signal.aborted) abortFromBatchRequest();
+            else request.signal.addEventListener('abort', abortFromBatchRequest, {
+                once: true
+            });
+            const itemRequest = new Request(targetUrl.toString(), {
+                method: itemMethod,
+                headers: requestHeaders,
+                body,
+                signal: itemAbortController.signal
+            });
+            try {
+                const itemResponse = await (0, external_batch_js_namespaceObject.promiseWithTimeout)(options.handleItem(itemRequest, context), batchItemTimeoutMs, (error)=>itemAbortController.abort(error));
+                if (!(itemResponse instanceof Response)) return (0, external_batch_js_namespaceObject.toBatchItemError)(itemId, 500, 'Invalid response returned by batch item handler');
+                return (0, protocol_js_namespaceObject.toBatchResponseItem)(itemId, itemResponse, 'HEAD' === itemMethod);
+            } catch (error) {
+                if (error instanceof external_batch_js_namespaceObject.BatchItemTimeoutError) {
+                    console.error({
+                        event: 'bff.batch.item.timeout',
+                        batchId: payload.batchId,
+                        itemId,
+                        method: itemMethod,
+                        path: itemPathname,
+                        errorName: error.name
+                    });
+                    return (0, external_batch_js_namespaceObject.toBatchItemError)(itemId, 504, 'Batch item request timed out');
+                }
+                if (error instanceof Response) return (0, protocol_js_namespaceObject.toBatchResponseItem)(itemId, error, 'HEAD' === itemMethod);
+                console.error({
+                    event: 'bff.batch.item.failure',
+                    batchId: payload.batchId,
+                    itemId,
+                    method: itemMethod,
+                    path: itemPathname,
+                    errorName: error instanceof Error ? error.name : 'UnknownError'
+                });
+                return (0, external_batch_js_namespaceObject.toBatchItemError)(itemId, 500, 'Internal Server Error');
+            } finally{
+                request.signal.removeEventListener('abort', abortFromBatchRequest);
+            }
+        });
+        const responsePayload = {
+            protocolVersion: 2,
+            batchId: payload.batchId,
+            receivedAt: Date.now(),
+            items: responseItems
+        };
+        return new Response(JSON.stringify(responsePayload), {
+            status: 200,
+            headers: {
+                'content-type': 'application/json; charset=utf-8',
+                [index_js_namespaceObject.DEFAULT_DATA_BATCH_HEADER]: '2',
+                'x-modernjs-data-batch-id': payload.batchId
+            }
+        });
+    };
+    return {
+        enabled: batchEnabled,
+        path: batchPath,
+        handle
+    };
+}
+exports.createDataPlatformBatchRequestHandler = __webpack_exports__.createDataPlatformBatchRequestHandler;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createDataPlatformBatchRequestHandler"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,170 @@
+"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__, {
+    BatchItemTimeoutError: ()=>BatchItemTimeoutError,
+    createBatchValidationResponse: ()=>createBatchValidationResponse,
+    isBatchRequestPayload: ()=>isBatchRequestPayload,
+    mapWithConcurrency: ()=>mapWithConcurrency,
+    normalizeBatchAllowedMethods: ()=>normalizeBatchAllowedMethods,
+    normalizeBatchPath: ()=>normalizeBatchPath,
+    prepareJsonRequestBody: ()=>prepareJsonRequestBody,
+    promiseWithTimeout: ()=>promiseWithTimeout,
+    toBatchItemError: ()=>toBatchItemError,
+    toHeaderRecord: ()=>external_headers_js_namespaceObject.toHeaderRecord
+});
+const index_js_namespaceObject = require("../../data-platform/index.js");
+const protocol_js_namespaceObject = require("../../data-platform/batch/protocol.js");
+const external_headers_js_namespaceObject = require("../../headers.js");
+function normalizeBatchPath(pathname) {
+    if (!pathname || '/' === pathname) return index_js_namespaceObject.DEFAULT_DATA_BATCH_ENDPOINT;
+    if (!pathname.startsWith('/')) return `/${pathname}`;
+    return pathname;
+}
+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 (0, index_js_namespaceObject.isPlainObject)(value) && 2 === 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 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 = (0, index_js_namespaceObject.normalizeMethod)(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 createBatchValidationResponse('Invalid JSON request body');
+    }
+    return request;
+}
+function toBatchItemError(id, status, message) {
+    return {
+        id,
+        status,
+        headers: [
+            [
+                'content-type',
+                'application/json; charset=utf-8'
+            ]
+        ],
+        body: (0, protocol_js_namespaceObject.encodeBatchText)(JSON.stringify({
+            message
+        }))
+    };
+}
+class BatchItemTimeoutError extends Error {
+}
+function promiseWithTimeout(effect, timeoutMs, onTimeout) {
+    if (timeoutMs <= 0) return effect;
+    return new Promise((resolve, reject)=>{
+        const timer = setTimeout(()=>{
+            const error = new BatchItemTimeoutError(`Batch item timeout after ${String(timeoutMs)}ms`);
+            onTimeout?.(error);
+            reject(error);
+        }, 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;
+}
+exports.BatchItemTimeoutError = __webpack_exports__.BatchItemTimeoutError;
+exports.createBatchValidationResponse = __webpack_exports__.createBatchValidationResponse;
+exports.isBatchRequestPayload = __webpack_exports__.isBatchRequestPayload;
+exports.mapWithConcurrency = __webpack_exports__.mapWithConcurrency;
+exports.normalizeBatchAllowedMethods = __webpack_exports__.normalizeBatchAllowedMethods;
+exports.normalizeBatchPath = __webpack_exports__.normalizeBatchPath;
+exports.prepareJsonRequestBody = __webpack_exports__.prepareJsonRequestBody;
+exports.promiseWithTimeout = __webpack_exports__.promiseWithTimeout;
+exports.toBatchItemError = __webpack_exports__.toBatchItemError;
+exports.toHeaderRecord = __webpack_exports__.toHeaderRecord;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "BatchItemTimeoutError",
+    "createBatchValidationResponse",
+    "isBatchRequestPayload",
+    "mapWithConcurrency",
+    "normalizeBatchAllowedMethods",
+    "normalizeBatchPath",
+    "prepareJsonRequestBody",
+    "promiseWithTimeout",
+    "toBatchItemError",
+    "toHeaderRecord"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,99 @@
+"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__, {
+    defineEffectBff: ()=>defineEffectBff,
+    defineEffectRpcBff: ()=>defineEffectRpcBff
+});
+const external_entry_shape_js_namespaceObject = require("../entry-shape.js");
+const external_envelope_js_namespaceObject = require("./envelope.js");
+const external_http_js_namespaceObject = require("./http.js");
+const external_rpc_js_namespaceObject = require("./rpc.js");
+function defineEffectBff(definition) {
+    const createHandler = (0, external_entry_shape_js_namespaceObject.registerValidatorAwareHandlerFactory)((options)=>{
+        const rpcDefinition = definition.rpc;
+        let mergedRpcOptions = rpcDefinition;
+        if (rpcDefinition && options?.rpc) mergedRpcOptions = {
+            ...rpcDefinition,
+            ...options.rpc
+        };
+        return (0, external_http_js_namespaceObject.createHttpApiHandler)({
+            api: definition.api,
+            layer: definition.layer,
+            openapi: options?.openapi,
+            rpc: mergedRpcOptions,
+            dataPlatform: (0, external_envelope_js_namespaceObject.mergeDataPlatformOptions)(definition.dataPlatform, options?.dataPlatform),
+            interceptRequest: definition.interceptRequest,
+            validateRequest: options?.validateRequest
+        });
+    });
+    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)=>(0, external_rpc_js_namespaceObject.createRpcApiHandler)({
+            ...definition,
+            ...options
+        });
+    return {
+        ...definition,
+        createHandler
+    };
+}
+exports.defineEffectBff = __webpack_exports__.defineEffectBff;
+exports.defineEffectRpcBff = __webpack_exports__.defineEffectRpcBff;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "defineEffectBff",
+    "defineEffectRpcBff"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,104 @@
+"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__, {
+    mergeDataPlatformOptions: ()=>mergeDataPlatformOptions,
+    validateDataPlatformRequestEnvelope: ()=>validateDataPlatformRequestEnvelope
+});
+const index_js_namespaceObject = require("../../data-platform/index.js");
+const external_routing_js_namespaceObject = require("./routing.js");
+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 || index_js_namespaceObject.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, index_js_namespaceObject.decodeRequestEnvelopeHeader)(encodedEnvelope);
+    if (!envelope) return createInvalidEnvelopeResponse(`Invalid data envelope header format: ${envelopeHeader}`);
+    const validation = (0, index_js_namespaceObject.validateRequestEnvelope)(envelope, {
+        expectedProtocolVersion: 1,
+        expectedNamespace: options?.expectedNamespace,
+        expectedOrigin: options?.validateOrigin === false ? void 0 : (0, external_routing_js_namespaceObject.getExpectedEnvelopeOrigin)(request),
+        requireTraceContext: options?.requireTraceContext
+    });
+    if (!validation.ok) return createInvalidEnvelopeResponse('Invalid data envelope', validation.errors);
+    if (envelope.selectionPlan) {
+        const selectionValidation = (0, index_js_namespaceObject.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
+    };
+}
+exports.mergeDataPlatformOptions = __webpack_exports__.mergeDataPlatformOptions;
+exports.validateDataPlatformRequestEnvelope = __webpack_exports__.validateDataPlatformRequestEnvelope;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "mergeDataPlatformOptions",
+    "validateDataPlatformRequestEnvelope"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});