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

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

@@ -0,0 +1,64 @@
+import "node:module";
+import { DEFAULT_DATA_ENVELOPE_HEADER, decodeRequestEnvelopeHeader, validateRequestEnvelope, validateSelectionPlan } from "../../data-platform/index.mjs";
+import { getExpectedEnvelopeOrigin } from "./routing.mjs";
+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
+    };
+}
+export { mergeDataPlatformOptions, validateDataPlatformRequestEnvelope };

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

@@ -0,0 +1,70 @@
+import "node:module";
+import { HttpRouter, HttpServer } from "effect/unstable/http";
+import { prepareJsonRequestBody } from "./batch.mjs";
+import { createDataPlatformBatchRequestHandler } from "./batch-handler.mjs";
+import { validateDataPlatformRequestEnvelope } from "./envelope.mjs";
+import { createOpenApiLayer } from "./openapi.mjs";
+import { getRequestPathname, isRpcRequest } from "./routing.mjs";
+import { createRpcApiHandler, normalizeRpcPath } from "./rpc.mjs";
+import { toEffectServiceContext } from "./types.mjs";
+import * as __rspack_external_effect_Layer_69c46453 from "effect/Layer";
+function createHttpApiHandler(options) {
+    const apiLayer = options.layer.pipe(__rspack_external_effect_Layer_69c46453.provide(HttpServer.layerServices));
+    const openApiLayer = createOpenApiLayer(options.api, options.openapi);
+    const mergedLayer = openApiLayer ? __rspack_external_effect_Layer_69c46453.mergeAll(apiLayer, openApiLayer) : apiLayer;
+    const httpApiHandler = HttpRouter.toWebHandler(mergedLayer);
+    const dispatchHttpApiRequest = async (request, context)=>{
+        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 withRequestPolicy = async (request, context)=>{
+        const policyDenial = options.validateRequest?.(request);
+        if (policyDenial) return policyDenial;
+        const next = ()=>dispatchHttpApiRequest(request, context);
+        return options.interceptRequest ? options.interceptRequest({
+            request,
+            next
+        }) : next();
+    };
+    const batchHandler = createDataPlatformBatchRequestHandler({
+        dataPlatform: options.dataPlatform,
+        handleItem: withRequestPolicy
+    });
+    const handleHttpApiRequest = async (request, context)=>{
+        const pathname = getRequestPathname(request);
+        if (batchHandler.enabled && pathname === batchHandler.path) return batchHandler.handle(request, context);
+        return withRequestPolicy(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;
+                const next = ()=>rpcHandler.handler(request, toEffectServiceContext(context));
+                return options.interceptRequest ? options.interceptRequest({
+                    request,
+                    next
+                }) : next();
+            }
+            return handleHttpApiRequest(request, context);
+        },
+        dispose: async ()=>{
+            await Promise.all([
+                httpApiHandler.dispose(),
+                rpcHandler.dispose()
+            ]);
+        }
+    };
+}
+export { createHttpApiHandler };

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

@@ -0,0 +1,21 @@
+import "node:module";
+import { HttpRouter, HttpServerResponse } from "effect/unstable/http";
+import { OpenApi } from "effect/unstable/httpapi";
+const DEFAULT_OPENAPI_PATH = '/openapi.json';
+function normalizeOpenApiPath(pathname) {
+    if (!pathname.startsWith('/')) return `/${pathname}`;
+    return pathname;
+}
+function getOpenApiOptions(openapi) {
+    if (false === openapi || void 0 === openapi) return;
+    const path = true === openapi ? DEFAULT_OPENAPI_PATH : openapi.path;
+    return {
+        path: normalizeOpenApiPath(path ?? DEFAULT_OPENAPI_PATH)
+    };
+}
+function createOpenApiLayer(api, openapi) {
+    const openApiOptions = getOpenApiOptions(openapi);
+    if (!openApiOptions) return null;
+    return HttpRouter.add('GET', openApiOptions.path, HttpServerResponse.jsonUnsafe(OpenApi.fromApi(api)));
+}
+export { createOpenApiLayer };

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

@@ -0,0 +1,51 @@
+import "node:module";
+import { isPlainObject } from "../../data-platform/index.mjs";
+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}/`);
+}
+export { getExpectedEnvelopeOrigin, getMountedPrefixFromContext, getRequestPathname, isRpcRequest, removeMountedPrefixFromBatchPath };

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

@@ -0,0 +1,23 @@
+import "node:module";
+import { HttpRouter } from "effect/unstable/http";
+import { RpcServer } from "effect/unstable/rpc";
+import { getRpcSerializationLayer } from "../rpcSerialization.mjs";
+import * as __rspack_external_effect_Layer_69c46453 from "effect/Layer";
+function normalizeRpcPath(pathname) {
+    if (!pathname || '/' === pathname) return '/rpc';
+    if (!pathname.startsWith('/')) return `/${pathname}`;
+    return pathname;
+}
+function createRpcApiHandler(options) {
+    const rpcPath = normalizeRpcPath(options.path);
+    const rpcLayer = __rspack_external_effect_Layer_69c46453.provide(RpcServer.layerHttp({
+        group: options.group,
+        path: rpcPath,
+        protocol: 'http',
+        disableTracing: options.disableTracing,
+        spanPrefix: options.spanPrefix,
+        spanAttributes: options.spanAttributes
+    }), __rspack_external_effect_Layer_69c46453.mergeAll(options.layer, getRpcSerializationLayer(options.serialization)));
+    return HttpRouter.toWebHandler(rpcLayer);
+}
+export { createRpcApiHandler, normalizeRpcPath };

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

@@ -0,0 +1,6 @@
+import "node:module";
+import * as __rspack_external_effect_Context_b3520bd3 from "effect/Context";
+const emptyEffectServiceContext = __rspack_external_effect_Context_b3520bd3.empty();
+const isEffectServiceContext = (context)=>'object' == typeof context && null !== context && 'mapUnsafe' in context;
+const toEffectServiceContext = (context)=>isEffectServiceContext(context) ? context : emptyEffectServiceContext;
+export { toEffectServiceContext };

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

@@ -0,0 +1,14 @@
+import "node:module";
+import * as __rspack_external_effect_Config_76cfa59d from "effect/Config";
+import * as __rspack_external_effect_Effect_41060786 from "effect/Effect";
+import * as __rspack_external_effect_Layer_69c46453 from "effect/Layer";
+import * as __rspack_external_effect_Option_0498e63a from "effect/Option";
+import * as __rspack_external_effect_Schema_6065f72d from "effect/Schema";
+export * from "effect/unstable/http";
+export * from "effect/unstable/httpapi";
+export * from "effect/unstable/rpc";
+export { HttpTraceContext } from "effect/unstable/http";
+export { HttpApiBuilder } from "effect/unstable/httpapi";
+export { defineEffectBff, defineEffectRpcBff } from "./handler/definition.mjs";
+export { createHttpApiHandler } from "./handler/http.mjs";
+export { __rspack_external_effect_Config_76cfa59d as Config, __rspack_external_effect_Effect_41060786 as Effect, __rspack_external_effect_Layer_69c46453 as Layer, __rspack_external_effect_Option_0498e63a as Option, __rspack_external_effect_Schema_6065f72d as Schema };

package/dist/esm-node/effect/index.mjs

@@ -0,0 +1,8 @@
+import "node:module";
+import * as __rspack_external__effect_opentelemetry_66324c75 from "@effect/opentelemetry";
+export * from "./endpoint-contracts.mjs";
+export * from "./handler.mjs";
+export { createEffectOperationContext, runWithEffectContext, useEffectContext, useOperationContext } from "./context.mjs";
+export { createEffectBffEdgeHandler, createEffectBffTestHandler, dispatchEffectBffRequest } from "./edge.mjs";
+export { resolveEffectBffModuleHandler } from "./module.mjs";
+export { __rspack_external__effect_opentelemetry_66324c75 as OpenTelemetry };

package/dist/esm-node/effect/module.mjs

@@ -0,0 +1,81 @@
+import "node:module";
+import { HttpApi } from "effect/unstable/httpapi";
+import { classifyEffectBffEntryModule, isValidatorAwareHandlerFactory, strictEffectApproachMessage } from "./entry-shape.mjs";
+import { createHttpApiHandler } from "./handler.mjs";
+function isRequestHandler(value) {
+    return 'function' == typeof value;
+}
+function shareDispose(dispose) {
+    let disposePromise;
+    return ()=>{
+        disposePromise ??= Promise.resolve().then(dispose);
+        return disposePromise;
+    };
+}
+function rejectLegacyEffectModuleShape(options, shape) {
+    options.onWarning?.(`${strictEffectApproachMessage} Rejected ${shape}.`);
+    return true;
+}
+function callEffectBffRequestHandler(handler, request, context) {
+    return void 0 === context ? handler(request) : handler(request, context);
+}
+function createLoadedHandler(webHandler) {
+    return {
+        handler: (request, context)=>callEffectBffRequestHandler(webHandler.handler, request, context),
+        dispose: shareDispose(webHandler.dispose)
+    };
+}
+function createLoadedHttpApiHandler(webHandler) {
+    return createLoadedHandler({
+        handler: webHandler.handler,
+        dispose: webHandler.dispose
+    });
+}
+function classifyEffectBffRuntimeEntryShape(module) {
+    return classifyEffectBffEntryModule(module, {
+        isRequestHandler: isRequestHandler,
+        isValidatorAwareHandlerFactory: isValidatorAwareHandlerFactory,
+        isHttpApi: HttpApi.isHttpApi
+    });
+}
+function resolveClassifiedEffectBffModuleHandler(facts, options = {}) {
+    if (!facts) return null;
+    if (facts.legacyShape) {
+        if (rejectLegacyEffectModuleShape(options, facts.legacyShape)) return null;
+    }
+    if ('function' == typeof facts.createHandler) {
+        if (facts.createHandlerValidatorAware) {
+            const factory = facts.createHandler;
+            const webHandler = factory({
+                openapi: options.openapi,
+                dataPlatform: options.dataPlatform,
+                validateRequest: options.validateRequest
+            });
+            return createLoadedHandler(webHandler);
+        }
+        if (void 0 === facts.api || !facts.hasRuntimeLayer) {
+            rejectLegacyEffectModuleShape(options, 'unbranded `createHandler` export');
+            return null;
+        }
+        options.onWarning?.(`${strictEffectApproachMessage} Ignored unbranded \`createHandler\` export and rebuilt the handler from its { api, layer } exports.`);
+    }
+    if (void 0 !== facts.api && facts.hasRuntimeLayer) {
+        if (void 0 === facts.createHandler) options.onWarning?.('[BFF][Effect] Detected { api, layer } export without createHandler. Prefer `defineEffectBff(...)` from @modern-js/bff-effect/effect to avoid module instance mismatch.');
+        const webHandler = createHttpApiHandler({
+            api: facts.api,
+            layer: facts.layer,
+            openapi: options.openapi,
+            dataPlatform: options.dataPlatform,
+            validateRequest: options.validateRequest
+        });
+        return createLoadedHttpApiHandler(webHandler);
+    }
+    return null;
+}
+function resolveNormalizedEffectBffModuleHandler(normalizedModule, options = {}) {
+    return resolveClassifiedEffectBffModuleHandler(classifyEffectBffRuntimeEntryShape(normalizedModule), options);
+}
+function resolveEffectBffModuleHandler(mod, options = {}) {
+    return Promise.resolve(resolveNormalizedEffectBffModuleHandler(mod, options));
+}
+export { resolveEffectBffModuleHandler };

package/dist/esm-node/effect/operation-context.mjs

@@ -0,0 +1,76 @@
+import "node:module";
+import { BFF_LOCALE_HEADER, BFF_OPERATION_CONTEXT_DETAIL_HEADER, BFF_OPERATION_CONTEXT_HEADER, BFF_TRACEPARENT_HEADER, parseTraceparent } from "@modern-js/create-request";
+const kEffectContextStorage = Symbol.for('modernjs.plugin-bff.effectContextStorage');
+const readHeader = (headers, header)=>{
+    const value = headers.get(header);
+    return value && value.length > 0 ? value : void 0;
+};
+const copyStringField = (target, details, key)=>{
+    const value = details[key];
+    if ('string' == typeof value && value.length > 0) target[key] = value;
+};
+const readOperationContextDetails = (request)=>{
+    const rawDetails = readHeader(request.headers, BFF_OPERATION_CONTEXT_DETAIL_HEADER);
+    if (!rawDetails) return {};
+    try {
+        const parsed = JSON.parse(rawDetails);
+        if (!parsed || 'object' != typeof parsed || Array.isArray(parsed)) return {};
+        const details = parsed;
+        const safeDetails = {};
+        copyStringField(safeDetails, details, 'requestId');
+        copyStringField(safeDetails, details, 'operationId');
+        copyStringField(safeDetails, details, 'schemaHash');
+        copyStringField(safeDetails, details, 'traceparent');
+        copyStringField(safeDetails, details, 'traceId');
+        copyStringField(safeDetails, details, 'spanId');
+        if ('number' == typeof details.operationVersion) safeDetails.operationVersion = details.operationVersion;
+        return safeDetails;
+    } catch  {
+        return {};
+    }
+};
+const createEffectOperationContext = ({ request, path, method })=>{
+    const details = readOperationContextDetails(request);
+    const operationDetails = {
+        ...details
+    };
+    delete operationDetails.traceparent;
+    delete operationDetails.traceId;
+    delete operationDetails.spanId;
+    const servicePath = new URL(request.url).pathname;
+    const headerTraceparent = readHeader(request.headers, BFF_TRACEPARENT_HEADER);
+    const headerTraceContext = parseTraceparent(headerTraceparent);
+    const detailTraceContext = parseTraceparent(details.traceparent);
+    const traceparent = headerTraceContext ? headerTraceparent : detailTraceContext ? details.traceparent : void 0;
+    const parsedTraceparent = headerTraceContext || detailTraceContext || (details.traceId && details.spanId ? {
+        traceId: details.traceId,
+        spanId: details.spanId
+    } : void 0);
+    const locale = readHeader(request.headers, BFF_LOCALE_HEADER);
+    const headerOperationId = readHeader(request.headers, BFF_OPERATION_CONTEXT_HEADER);
+    return {
+        ...operationDetails,
+        ...headerOperationId || details.operationId ? {
+            operationId: headerOperationId || details.operationId
+        } : {},
+        routePath: servicePath,
+        method: (method || request.method || 'GET').toUpperCase(),
+        source: 'effect-adapter',
+        ...path && path !== servicePath ? {
+            attributes: {
+                mountedPath: path
+            }
+        } : {},
+        ...locale ? {
+            locale
+        } : {},
+        ...traceparent ? {
+            traceparent
+        } : {},
+        ...parsedTraceparent ? {
+            traceId: parsedTraceparent.traceId,
+            spanId: parsedTraceparent.spanId
+        } : {}
+    };
+};
+export { createEffectOperationContext, kEffectContextStorage };

package/dist/esm-node/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/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/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/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 };