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

package/dist/esm-node/runtime/effect/handler.mjs

@@ -1,507 +1,15 @@
 import "node:module";
-import * as __rspack_external_effect_Layer_16f7a8fc from "effect/Layer";
-import { HttpRouter, HttpServer, 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 { EFFECT_VALIDATOR_AWARE_FACTORY, isValidatorAwareHandlerFactory } from "./entry-shape.mjs";
 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_Layer_16f7a8fc from "effect/Layer";
 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";
-import * as __rspack_external_effect_Context_f1289ca3 from "effect/Context";
-const emptyEffectServiceContext = __rspack_external_effect_Context_f1289ca3.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 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 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),
-            validateRequest: options?.validateRequest
-        });
-    };
-    Object.defineProperty(createHandler, 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(__rspack_external_effect_Layer_16f7a8fc.provide(HttpServer.layerServices));
-    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 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 = 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)) {
-                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()
-            ]);
-        }
-    };
-}
-export { EFFECT_VALIDATOR_AWARE_FACTORY, HttpApiBuilder, HttpTraceContext, __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, isValidatorAwareHandlerFactory };
+export { HttpTraceContext } from "effect/unstable/http";
+export { HttpApiBuilder } from "effect/unstable/httpapi";
+export { EFFECT_VALIDATOR_AWARE_FACTORY, isValidatorAwareHandlerFactory } from "./entry-shape.mjs";
+export { defineEffectBff, defineEffectRpcBff } from "./handler/definition.mjs";
+export { createHttpApiHandler } from "./handler/http.mjs";
+export { __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 };

package/dist/esm-node/runtime/effect/rpcSerialization.mjs

@@ -0,0 +1,17 @@
+import "node:module";
+import { RpcSerialization } from "effect/unstable/rpc";
+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();
+    }
+}
+export { getRpcSerializationLayer };

package/dist/esm-node/runtime/effect-client/batch.mjs

@@ -0,0 +1,36 @@
+import "node:module";
+import { createDataBatchTransport } from "../data-platform/index.mjs";
+import { resolveOrigin } from "./envelope.mjs";
+const resolveRuntimeFetch = ()=>'function' == typeof fetch ? fetch.bind(globalThis) : void 0;
+const configureGeneratedEffectClientRuntime = (config, configureRequest)=>{
+    const defaultOrigin = config.defaultOrigin;
+    if (config.requestId && configureRequest) {
+        const configurePayload = {
+            requestId: config.requestId,
+            requireEnvelope: true,
+            identityBinding: {
+                enabled: true,
+                strict: true
+            },
+            operationContract: {
+                enabled: true,
+                strict: true,
+                requireSchemaHash: true,
+                requireOperationVersion: true
+            },
+            setDomain: ()=>resolveOrigin(defaultOrigin)
+        };
+        const runtimeFetch = resolveRuntimeFetch();
+        if (false !== config.batch.enabled && runtimeFetch) configurePayload.request = createDataBatchTransport({
+            fetch: runtimeFetch,
+            endpoint: config.batch.endpoint,
+            flushIntervalMs: config.batch.flushIntervalMs,
+            maxBatchSize: config.batch.maxBatchSize,
+            maxBatchBytes: config.batch.maxBatchBytes,
+            requestTimeoutMs: config.batch.requestTimeoutMs,
+            allowedMethods: config.batch.allowedMethods
+        });
+        configureRequest(configurePayload);
+    }
+};
+export { configureGeneratedEffectClientRuntime };

package/dist/esm-node/runtime/effect-client/envelope.mjs

@@ -0,0 +1,105 @@
+import "node:module";
+import { DEFAULT_DATA_BATCH_HEADER, DEFAULT_DATA_ENVELOPE_HEADER, createRequestEnvelope, encodeRequestEnvelopeHeader } from "../data-platform/index.mjs";
+import { isRecord, stringOrUndefined } from "./guards.mjs";
+import { normalizeRequest } from "./request.mjs";
+import { applyRequestContext } from "./request-context.mjs";
+const DATA_REQUEST_MODES = new Set([
+    'cache-first',
+    'stale-while-revalidate',
+    'network-only'
+]);
+const DATA_MUTATION_MODES = new Set([
+    'optimistic',
+    'pessimistic',
+    'fire-and-forget'
+]);
+const isDataRequestMode = (value)=>'string' == typeof value && DATA_REQUEST_MODES.has(value);
+const isDataMutationMode = (value)=>'string' == typeof value && DATA_MUTATION_MODES.has(value);
+const normalizeOrigin = (value)=>{
+    if ('string' != typeof value || 0 === value.length) return;
+    try {
+        return new URL(value).origin;
+    } catch  {
+        return;
+    }
+};
+const resolveOrigin = (defaultOrigin)=>{
+    if ("u" > typeof window && window.location && 'string' == typeof window.location.origin && window.location.origin) return window.location.origin;
+    const globalLocation = globalThis?.location;
+    if (globalLocation && 'string' == typeof globalLocation.origin && globalLocation.origin) return globalLocation.origin;
+    return defaultOrigin;
+};
+const resolveTargetOrigin = (dataPlatform, defaultOrigin)=>{
+    const explicitTargetOrigin = stringOrUndefined(dataPlatform.targetOrigin) || stringOrUndefined(dataPlatform.endpointOrigin);
+    if (explicitTargetOrigin) return explicitTargetOrigin;
+    return defaultOrigin;
+};
+const shouldAttachEnvelopeHeader = (dataPlatform, defaultOrigin)=>{
+    if (true === dataPlatform.allowCrossOriginEnvelope) return true;
+    const currentOrigin = normalizeOrigin(resolveOrigin(defaultOrigin));
+    const targetOrigin = normalizeOrigin(resolveTargetOrigin(dataPlatform, defaultOrigin));
+    if (!currentOrigin || !targetOrigin) return true;
+    return currentOrigin === targetOrigin;
+};
+const toEnvelopeInput = (normalizedRequest)=>{
+    const payload = {};
+    if (isRecord(normalizedRequest.params)) payload.path = normalizedRequest.params;
+    if (isRecord(normalizedRequest.query)) payload.query = normalizedRequest.query;
+    if ('data' in normalizedRequest && void 0 !== normalizedRequest.data) payload.data = normalizedRequest.data;
+    if ('body' in normalizedRequest && void 0 !== normalizedRequest.body) payload.body = normalizedRequest.body;
+    if ("u" > typeof FormData && normalizedRequest.formData instanceof FormData) payload.formData = Array.from(normalizedRequest.formData.entries()).map(([key, value])=>[
+            key,
+            String(value)
+        ]);
+    if ("u" > typeof URLSearchParams && normalizedRequest.formUrlencoded instanceof URLSearchParams) payload.formUrlencoded = normalizedRequest.formUrlencoded.toString();
+    return payload;
+};
+const prepareEffectRequest = (options)=>{
+    const { endpoint, operation, request, config, createEffectRequestContext } = options;
+    const defaultOrigin = config.defaultOrigin;
+    const normalizedRequest = applyRequestContext(normalizeRequest(endpoint.method, request), request, createEffectRequestContext);
+    const dataPlatform = isRecord(request) && isRecord(request.dataPlatform) ? request.dataPlatform : {};
+    const strictEnvelope = true === dataPlatform.requireEnvelope || true === dataPlatform.strict;
+    if (!strictEnvelope && !shouldAttachEnvelopeHeader(dataPlatform, defaultOrigin)) return normalizedRequest;
+    try {
+        const namespace = stringOrUndefined(dataPlatform.appNamespace) || config.appNamespace;
+        const origin = stringOrUndefined(dataPlatform.origin) || resolveOrigin(defaultOrigin);
+        const envelope = createRequestEnvelope({
+            operation: {
+                ...operation,
+                appNamespace: namespace
+            },
+            scope: {
+                appNamespace: namespace,
+                origin,
+                tenantId: stringOrUndefined(dataPlatform.tenantId),
+                userId: stringOrUndefined(dataPlatform.userId),
+                sessionId: stringOrUndefined(dataPlatform.sessionId)
+            },
+            requestInput: {
+                method: endpoint.method,
+                routePath: endpoint.routePath,
+                payload: toEnvelopeInput(normalizedRequest)
+            },
+            requestMode: isDataRequestMode(dataPlatform.requestMode) ? dataPlatform.requestMode : void 0,
+            mutationMode: isDataMutationMode(dataPlatform.mutationMode) ? dataPlatform.mutationMode : void 0,
+            selectionPlan: isRecord(dataPlatform.selectionPlan) ? dataPlatform.selectionPlan : void 0,
+            traceContext: isRecord(dataPlatform.traceContext) ? dataPlatform.traceContext : void 0,
+            requireTraceContext: true === dataPlatform.requireTraceContext
+        });
+        const headerName = stringOrUndefined(dataPlatform.envelopeHeader) || DEFAULT_DATA_ENVELOPE_HEADER;
+        const headers = isRecord(normalizedRequest.headers) ? {
+            ...normalizedRequest.headers
+        } : {};
+        if (false === dataPlatform.batch) headers[DEFAULT_DATA_BATCH_HEADER] = 'off';
+        headers[headerName] = encodeRequestEnvelopeHeader(envelope);
+        return {
+            ...normalizedRequest,
+            headers
+        };
+    } catch (error) {
+        if (strictEnvelope) throw error;
+        return normalizedRequest;
+    }
+};
+export { prepareEffectRequest, resolveOrigin };

package/dist/esm-node/runtime/effect-client/guards.mjs

@@ -0,0 +1,4 @@
+import "node:module";
+const isRecord = (value)=>'object' == typeof value && null !== value;
+const stringOrUndefined = (value)=>'string' == typeof value && value.length > 0 ? value : void 0;
+export { isRecord, stringOrUndefined };