@bleedingdev/modern-js-plugin-bff 3.5.0-ultramodern.6 → 3.5.0-ultramodern.75

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 };

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

@@ -1,17 +1,18 @@
 import "node:module";
 import { createRequestContextHeaders } from "@modern-js/create-request";
-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_Effect_41060786 from "effect/Effect";
+import * as __rspack_external_effect_Layer_69c46453 from "effect/Layer";
 import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http";
 import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
 import { Rpc, RpcClient, RpcGroup, RpcSchema, RpcSerialization } from "effect/unstable/rpc";
-import * as __rspack_external_effect_Schema_f8472650 from "effect/Schema";
-import * as __rspack_external_effect_unstable_http_HttpClientError_b9ead235 from "effect/unstable/http/HttpClientError";
-import * as __rspack_external_effect_Data_7c33fca9 from "effect/Data";
-import * as __rspack_external_effect_Exit_a10cfb96 from "effect/Exit";
-import * as __rspack_external_effect_ManagedRuntime_94dd2709 from "effect/ManagedRuntime";
-import * as __rspack_external_effect_Scope_3211a2d6 from "effect/Scope";
-class EffectRpcClientError extends __rspack_external_effect_Data_7c33fca9.TaggedError('EffectRpcClientError') {
+import { getRpcSerializationLayer } from "../effect/rpcSerialization.mjs";
+import * as __rspack_external_effect_Schema_6065f72d from "effect/Schema";
+import * as __rspack_external_effect_unstable_http_HttpClientError_4b9eaee6 from "effect/unstable/http/HttpClientError";
+import * as __rspack_external_effect_Data_2b3f4efb from "effect/Data";
+import * as __rspack_external_effect_Exit_1ca64b33 from "effect/Exit";
+import * as __rspack_external_effect_ManagedRuntime_bfe218e3 from "effect/ManagedRuntime";
+import * as __rspack_external_effect_Scope_f87b0bd6 from "effect/Scope";
+class EffectRpcClientError extends __rspack_external_effect_Data_2b3f4efb.TaggedError('EffectRpcClientError') {
 }
 function isRecord(value) {
     return 'object' == typeof value && null !== value && !Array.isArray(value);
@@ -21,7 +22,10 @@ function applySelection(value, selection) {
     if (Array.isArray(value)) return value.map((item)=>applySelection(item, selection));
     if (!isRecord(value) || !isRecord(selection)) return value;
     const masked = {};
-    for (const key of Object.keys(selection))if (key in value) masked[key] = applySelection(value[key], selection[key]);
+    for (const key of Object.keys(selection)){
+        const selected = selection[key];
+        if (void 0 !== selected && key in value && (true === selected || isRecord(selected))) masked[key] = applySelection(value[key], selected);
+    }
     return masked;
 }
 function view() {
@@ -35,20 +39,6 @@ function runEffectView(request, selection) {
         request.then((value)=>resolve(mask(value, selection)), (reason)=>reject(reason));
     });
 }
-function getRpcSerializationLayer(serialization) {
-    switch(serialization){
-        case 'ndjson':
-            return RpcSerialization.layerNdjson;
-        case 'jsonRpc':
-            return RpcSerialization.layerJsonRpc();
-        case 'ndJsonRpc':
-            return RpcSerialization.layerNdJsonRpc();
-        case 'msgPack':
-            return RpcSerialization.layerMsgPack;
-        default:
-            return RpcSerialization.layerJsonRpc();
-    }
-}
 function makeEffectHttpApiClient(api, options) {
     const requestContextHeaders = createRequestContextHeaders(options?.requestContext);
     const transformClient = (client)=>{
@@ -63,28 +53,28 @@ function makeEffectHttpApiClient(api, options) {
         baseUrl: options?.baseUrl,
         transformClient,
         transformResponse: options?.transformResponse
-    }).pipe(__rspack_external_effect_Effect_194ac36c.provide(FetchHttpClient.layer));
+    }).pipe(__rspack_external_effect_Effect_41060786.provide(FetchHttpClient.layer));
 }
 function makeEffectRpcClient(group, options) {
-    const protocolLayer = __rspack_external_effect_Layer_16f7a8fc.provide(RpcClient.layerProtocolHttp({
+    const protocolLayer = __rspack_external_effect_Layer_69c46453.provide(RpcClient.layerProtocolHttp({
         url: options.url
-    }), __rspack_external_effect_Layer_16f7a8fc.mergeAll(getRpcSerializationLayer(options.serialization), FetchHttpClient.layer));
-    const middlewareLayer = options.middlewareLayer ?? __rspack_external_effect_Layer_16f7a8fc.empty;
-    const runtimeLayer = __rspack_external_effect_Layer_16f7a8fc.mergeAll(protocolLayer, middlewareLayer);
-    return __rspack_external_effect_Effect_194ac36c.tryPromise({
+    }), __rspack_external_effect_Layer_69c46453.mergeAll(getRpcSerializationLayer(options.serialization), FetchHttpClient.layer));
+    const middlewareLayer = options.middlewareLayer ?? __rspack_external_effect_Layer_69c46453.empty;
+    const runtimeLayer = __rspack_external_effect_Layer_69c46453.mergeAll(protocolLayer, middlewareLayer);
+    return __rspack_external_effect_Effect_41060786.tryPromise({
         try: async ()=>{
-            const runtime = __rspack_external_effect_ManagedRuntime_94dd2709.make(runtimeLayer);
-            const scope = await runtime.runPromise(__rspack_external_effect_Scope_3211a2d6.make());
+            const runtime = __rspack_external_effect_ManagedRuntime_bfe218e3.make(runtimeLayer);
+            const scope = await runtime.runPromise(__rspack_external_effect_Scope_f87b0bd6.make());
             try {
                 const client = await runtime.runPromise(RpcClient.make(group, {
                     flatten: options.flatten
-                }).pipe(__rspack_external_effect_Effect_194ac36c.provideService(__rspack_external_effect_Scope_3211a2d6.Scope, scope)));
+                }).pipe(__rspack_external_effect_Effect_41060786.provideService(__rspack_external_effect_Scope_f87b0bd6.Scope, scope)));
                 let disposed = false;
                 const clientWithDispose = Object.assign(client, {
                     dispose: async ()=>{
                         if (!disposed) {
                             disposed = true;
-                            await runtime.runPromise(__rspack_external_effect_Scope_3211a2d6.close(scope, __rspack_external_effect_Exit_a10cfb96["void"]));
+                            await runtime.runPromise(__rspack_external_effect_Scope_f87b0bd6.close(scope, __rspack_external_effect_Exit_1ca64b33["void"]));
                         }
                         await runtime.dispose();
                     }
@@ -92,7 +82,7 @@ function makeEffectRpcClient(group, options) {
                 return clientWithDispose;
             } catch (error) {
                 try {
-                    await runtime.runPromise(__rspack_external_effect_Scope_3211a2d6.close(scope, __rspack_external_effect_Exit_a10cfb96["void"]));
+                    await runtime.runPromise(__rspack_external_effect_Scope_f87b0bd6.close(scope, __rspack_external_effect_Exit_1ca64b33["void"]));
                 } catch  {}
                 try {
                     await runtime.dispose();
@@ -105,5 +95,5 @@ function makeEffectRpcClient(group, options) {
             })
     });
 }
-const runEffectRequest = __rspack_external_effect_Effect_194ac36c.runPromise;
-export { EffectRpcClientError, HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, Rpc, RpcClient, RpcGroup, RpcSchema, RpcSerialization, __rspack_external_effect_Effect_194ac36c as Effect, __rspack_external_effect_Layer_16f7a8fc as Layer, __rspack_external_effect_Schema_f8472650 as Schema, __rspack_external_effect_unstable_http_HttpClientError_b9ead235 as HttpClientError, makeEffectHttpApiClient, makeEffectRpcClient, mask, runEffectRequest, runEffectView, view };
+const runEffectRequest = __rspack_external_effect_Effect_41060786.runPromise;
+export { EffectRpcClientError, HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, Rpc, RpcClient, RpcGroup, RpcSchema, RpcSerialization, __rspack_external_effect_Effect_41060786 as Effect, __rspack_external_effect_Layer_69c46453 as Layer, __rspack_external_effect_Schema_6065f72d as Schema, __rspack_external_effect_unstable_http_HttpClientError_4b9eaee6 as HttpClientError, makeEffectHttpApiClient, makeEffectRpcClient, mask, runEffectRequest, runEffectView, view };

package/dist/esm-node/runtime/effect-client/request-context.mjs

@@ -0,0 +1,24 @@
+import "node:module";
+import { isRecord } from "./guards.mjs";
+const createEffectRequestContext = (createRequestContextHeaders, requestContext)=>{
+    if (!isRecord(requestContext)) return {};
+    const headers = createRequestContextHeaders ? createRequestContextHeaders(requestContext) : {};
+    return {
+        ...requestContext,
+        headers
+    };
+};
+const applyRequestContext = (normalizedRequest, request, createRequestContext)=>{
+    if (!isRecord(request) || !isRecord(request.requestContext)) return normalizedRequest;
+    const requestContext = createRequestContext(request.requestContext);
+    const requestHeaders = isRecord(requestContext.headers) ? requestContext.headers : {};
+    if (0 === Object.keys(requestHeaders).length) return normalizedRequest;
+    return {
+        ...normalizedRequest,
+        headers: {
+            ...isRecord(normalizedRequest.headers) ? normalizedRequest.headers : {},
+            ...requestHeaders
+        }
+    };
+};
+export { applyRequestContext, createEffectRequestContext };

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

@@ -0,0 +1,29 @@
+import "node:module";
+import { isRecord } from "./guards.mjs";
+const METHODS_WITHOUT_BODY = new Set([
+    'GET',
+    'DELETE',
+    'HEAD',
+    'OPTIONS'
+]);
+const normalizeRequest = (method, request)=>{
+    if (!isRecord(request)) return {};
+    const payload = {
+        ...request
+    };
+    if (isRecord(request.path) && !isRecord(payload.params)) payload.params = request.path;
+    if (isRecord(request.urlParams) && !isRecord(payload.query)) payload.query = request.urlParams;
+    if (isRecord(request.headers) && !isRecord(payload.headers)) payload.headers = request.headers;
+    if ('payload' in request && void 0 !== request.payload) if ("u" > typeof FormData && request.payload instanceof FormData && !('formData' in payload)) payload.formData = request.payload;
+    else if (METHODS_WITHOUT_BODY.has(method)) {
+        if (isRecord(request.payload)) payload.query = isRecord(payload.query) ? {
+            ...payload.query,
+            ...request.payload
+        } : request.payload;
+        else if (!('body' in payload)) payload.body = request.payload;
+    } else if (!isRecord(request.payload) || 'data' in payload) {
+        if (!('body' in payload)) payload.body = request.payload;
+    } else payload.data = request.payload;
+    return payload;
+};
+export { normalizeRequest };

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

@@ -1,187 +1,15 @@
 import "node:module";
-import { DEFAULT_DATA_BATCH_HEADER, DEFAULT_DATA_ENVELOPE_HEADER, createDataBatchTransport, createRequestEnvelope, encodeRequestEnvelopeHeader } from "../data-platform/index.mjs";
-const METHODS_WITHOUT_BODY = new Set([
-    'GET',
-    'DELETE',
-    'HEAD',
-    'OPTIONS'
-]);
-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 isRecord = (value)=>'object' == typeof value && null !== value;
-const stringOrUndefined = (value)=>'string' == typeof value && value.length > 0 ? value : void 0;
-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 resolveRuntimeFetch = ()=>'function' == typeof fetch ? fetch.bind(globalThis) : void 0;
-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 normalizeRequest = (method, request)=>{
-    if (!isRecord(request)) return {};
-    const payload = {
-        ...request
-    };
-    if (isRecord(request.path) && !isRecord(payload.params)) payload.params = request.path;
-    if (isRecord(request.urlParams) && !isRecord(payload.query)) payload.query = request.urlParams;
-    if (isRecord(request.headers) && !isRecord(payload.headers)) payload.headers = request.headers;
-    if ('payload' in request && void 0 !== request.payload) if ("u" > typeof FormData && request.payload instanceof FormData && !('formData' in payload)) payload.formData = request.payload;
-    else if (METHODS_WITHOUT_BODY.has(method)) {
-        if (isRecord(request.payload)) payload.query = isRecord(payload.query) ? {
-            ...payload.query,
-            ...request.payload
-        } : request.payload;
-        else if (!('body' in payload)) payload.body = request.payload;
-    } else if (!isRecord(request.payload) || 'data' in payload) {
-        if (!('body' in payload)) payload.body = request.payload;
-    } else payload.data = request.payload;
-    return payload;
-};
-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;
-};
+import { configureGeneratedEffectClientRuntime } from "./batch.mjs";
+import { prepareEffectRequest } from "./envelope.mjs";
+import { createEffectRequestContext as external_request_context_mjs_createEffectRequestContext } from "./request-context.mjs";
 const createGeneratedEffectClient = (manifest, config, requestRuntime)=>{
     const createRequest = requestRuntime.createRequest;
     const configureRequest = 'function' == typeof requestRuntime.configure ? requestRuntime.configure : void 0;
     const createRequestContextHeaders = 'function' == typeof requestRuntime.createRequestContextHeaders ? requestRuntime.createRequestContextHeaders : void 0;
-    const defaultOrigin = config.defaultOrigin;
     const httpMethodDecider = config.httpMethodDecider || 'functionName';
     const port = config.useEnvPort && "u" > typeof process && process.env && process.env.PORT ? process.env.PORT : config.port;
-    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);
-    }
-    const createEffectRequestContext = (requestContext)=>{
-        if (!isRecord(requestContext)) return {};
-        const headers = createRequestContextHeaders ? createRequestContextHeaders(requestContext) : {};
-        return {
-            ...requestContext,
-            headers
-        };
-    };
-    const applyRequestContext = (normalizedRequest, request)=>{
-        if (!isRecord(request) || !isRecord(request.requestContext)) return normalizedRequest;
-        const requestContext = createEffectRequestContext(request.requestContext);
-        const requestHeaders = isRecord(requestContext.headers) ? requestContext.headers : {};
-        if (0 === Object.keys(requestHeaders).length) return normalizedRequest;
-        return {
-            ...normalizedRequest,
-            headers: {
-                ...requestHeaders,
-                ...isRecord(normalizedRequest.headers) ? normalizedRequest.headers : {}
-            }
-        };
-    };
-    const prepareEffectRequest = (endpoint, operation, request)=>{
-        const normalizedRequest = applyRequestContext(normalizeRequest(endpoint.method, request), request);
-        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;
-        }
-    };
+    configureGeneratedEffectClientRuntime(config, configureRequest);
+    const createEffectRequestContext = (requestContext)=>external_request_context_mjs_createEffectRequestContext(createRequestContextHeaders, requestContext);
     const client = {};
     const operationManifest = {};
     for (const endpoint of manifest.endpoints){
@@ -214,7 +42,13 @@ const createGeneratedEffectClient = (manifest, config, requestRuntime)=>{
                 requestId: config.requestId
             } : {}
         });
-        const call = (request = {})=>sender(prepareEffectRequest(endpoint, operation, request));
+        const call = (request = {})=>sender(prepareEffectRequest({
+                endpoint,
+                operation,
+                request,
+                config,
+                createEffectRequestContext
+            }));
         client[endpoint.group] ??= {};
         client[endpoint.group][endpoint.endpoint] = call;
         operationManifest[endpoint.group] ??= {};

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

@@ -0,0 +1 @@
+import "node:module";

package/dist/esm-node/runtime/safe-failure.mjs

@@ -7,6 +7,7 @@ const SAFE_FAILURE_CODES = {
     500: 'INTERNAL_SERVER_ERROR',
     503: 'SERVICE_UNAVAILABLE'
 };
+const INVALID_HTTP_HEADER_VALUE = /[\0-\x08\x0a-\x1f\x7f]/u;
 const readErrorProperty = (error, key)=>{
     if ('object' != typeof error || null === error || !(key in error)) return;
     return error[key];
@@ -19,7 +20,7 @@ const normalizeRetryAfter = (value)=>{
     if ('number' == typeof value && Number.isFinite(value) && value >= 0) return String(Math.ceil(value));
     if ('string' == typeof value) {
         const trimmed = value.trim();
-        return trimmed.length > 0 ? trimmed : void 0;
+        return trimmed.length > 0 && !INVALID_HTTP_HEADER_VALUE.test(trimmed) ? trimmed : void 0;
     }
     if (value instanceof Date) return value.toUTCString();
 };

package/dist/esm-node/utils/client-generator/files.mjs

@@ -0,0 +1,69 @@
+import "node:module";
+import { fs } from "@modern-js/utils";
+import path from "path";
+const API_DIR = 'api';
+const PLUGIN_DIR = 'plugin';
+const RUNTIME_DIR = 'runtime';
+const CLIENT_DIR = 'client';
+const EXPORT_PREFIX = `./${API_DIR}/`;
+const TYPE_PREFIX = `${API_DIR}/`;
+const GENERATED_RUNTIME_DIRS = [
+    CLIENT_DIR,
+    PLUGIN_DIR,
+    RUNTIME_DIR
+];
+const toPosixPath = (p)=>p.replace(/\\/g, '/');
+const posixJoin = (...args)=>toPosixPath(path.join(...args));
+function createFileDetails(options) {
+    const { appDirectory, baseDirectory, resourcePath, source, relativeDistPath } = options;
+    const relativePath = path.relative(baseDirectory, resourcePath);
+    const parsedPath = path.parse(relativePath);
+    const targetDir = posixJoin(`./${relativeDistPath}/${CLIENT_DIR}`, parsedPath.dir, `${parsedPath.name}.js`);
+    const absTargetDir = path.resolve(targetDir);
+    const relativePathFromAppDirectory = path.relative(appDirectory, path.dirname(resourcePath));
+    const typesFilePath = posixJoin(`./${relativeDistPath}`, relativePathFromAppDirectory, `${parsedPath.name}.d.ts`);
+    return {
+        resourcePath,
+        source,
+        targetDir,
+        name: parsedPath.name,
+        absTargetDir,
+        relativeTargetDistDir: `./${typesFilePath}`,
+        exportKey: toPosixPath(path.join(parsedPath.dir, parsedPath.name))
+    };
+}
+async function readDirectoryFiles(appDirectory, directory, relativeDistPath) {
+    const filesList = [];
+    async function readFiles(currentPath) {
+        const entries = await fs.readdir(currentPath, {
+            withFileTypes: true
+        });
+        for (const entry of entries){
+            if ('_app.ts' === entry.name) continue;
+            const resourcePath = path.join(currentPath, entry.name);
+            if (entry.isDirectory()) await readFiles(resourcePath);
+            else {
+                const source = await fs.readFile(resourcePath, 'utf8');
+                filesList.push(createFileDetails({
+                    appDirectory,
+                    baseDirectory: directory,
+                    resourcePath,
+                    source,
+                    relativeDistPath
+                }));
+            }
+        }
+    }
+    await readFiles(directory);
+    return filesList;
+}
+async function writeTargetFile(absTargetDir, content) {
+    await fs.mkdir(path.dirname(absTargetDir), {
+        recursive: true
+    });
+    await fs.writeFile(absTargetDir, content);
+}
+async function copyFiles(from, to) {
+    if (await fs.pathExists(from)) await fs.copy(toPosixPath(from), toPosixPath(to));
+}
+export { API_DIR, CLIENT_DIR, EXPORT_PREFIX, GENERATED_RUNTIME_DIRS, PLUGIN_DIR, RUNTIME_DIR, TYPE_PREFIX, copyFiles, createFileDetails, posixJoin, readDirectoryFiles, toPosixPath, writeTargetFile };