@bleedingdev/modern-js-create-request 3.5.0-ultramodern.5 → 3.5.0-ultramodern.75

package/dist/esm/node.mjs

@@ -1,24 +1,10 @@
 import { storage } from "@modern-js/runtime-utils/node";
-import { compile } from "path-to-regexp";
-import { stringify } from "qs";
 import { handleRes } from "./handleRes.mjs";
-import { CrossOriginEnvelopePolicyError, IdentityBindingViolationError, OperationContractViolationError, ProducerClientNotInitializedError, ProducerDomainNotConfiguredError, TRACEPARENT_HEADER, attachOperationContextHeaders, buildEnvelopeHeaderValue, deleteHeader, extractPathParamNames, firstHeaderValue, isEmptyDomain, isSecuredRequestId, parseTraceparentValue, readHeader, resolveConfiguredRequest, toOrigin, writeHeader } from "./policyCore.mjs";
-import { executeWithResilience } from "./transport.mjs";
-import { BFF_DEFAULT_PROTECTED_IDENTITY_HEADERS, BFF_ENVELOPE_HEADER, BFF_OPERATION_CONTEXT_DETAIL_HEADER, BFF_OPERATION_CONTEXT_HEADER } from "./types.mjs";
-import { getUploadPayload } from "./utiles.mjs";
+import { CrossOriginEnvelopePolicyError, IdentityBindingViolationError, OperationContractViolationError, ProducerClientNotInitializedError, ProducerDomainNotConfiguredError, firstHeaderValue, toOrigin } from "./policyCore.mjs";
+import { createRequestFactory } from "./requestFactory.mjs";
 export * from "./requestContext.mjs";
 export * from "./traceparent.mjs";
 export * from "./types.mjs";
-const realRequest = new Map();
-const realAllowedHeaders = new Map();
-const realResolveHeaders = new Map();
-const realRequireEnvelope = new Map();
-const realAllowCrossOriginEnvelope = new Map();
-const realTransportResilience = new Map();
-const realIdentityBinding = new Map();
-const realOperationContract = new Map();
-const domainMap = new Map();
-const OPERATION_CONTEXT_DETAIL_HEADER = BFF_OPERATION_CONTEXT_DETAIL_HEADER;
 const resolveSourceOrigin = (headers)=>{
     const origin = toOrigin(firstHeaderValue(headers.origin));
     if (origin) return origin;
@@ -41,225 +27,15 @@ const originFetch = (...params)=>{
     if (init?.method?.toLowerCase() === 'get') init.body = void 0;
     return fetch(...params).then(handleRes);
 };
-const attachEnvelopeHeaderIfRequired = (headers, requestId, url, webRequestHeaders)=>{
-    const shouldRequireEnvelope = realRequireEnvelope.get(requestId) ?? isSecuredRequestId(requestId);
-    if (!shouldRequireEnvelope) return;
-    headers[BFF_ENVELOPE_HEADER] = buildEnvelopeHeaderValue({
-        requestId,
-        target: 'server',
-        sourceOrigin: resolveSourceOrigin(webRequestHeaders),
-        targetOrigin: toOrigin(url),
-        traceContext: parseTraceparentValue(readHeader(headers, TRACEPARENT_HEADER)),
-        allowCrossOriginEnvelope: realAllowCrossOriginEnvelope.get(requestId)
-    });
-};
-const attachSecuredOperationHeaders = (headers, requestId, method, path, operationContext)=>{
-    if (!isSecuredRequestId(requestId)) return;
-    attachOperationContextHeaders({
-        headers,
-        requestId,
-        target: 'server',
-        method,
-        path,
-        operationContext,
-        operationContract: realOperationContract.get(requestId),
-        operationContextHeader: BFF_OPERATION_CONTEXT_HEADER,
-        operationContextDetailHeader: OPERATION_CONTEXT_DETAIL_HEADER
-    });
-};
-const configure = (options)=>{
-    const { request, interceptor, allowedHeaders, resolveHeaders, transport, requireEnvelope, allowCrossOriginEnvelope, identityBinding, operationContract, setDomain, requestId = 'default' } = options;
-    const hasExistingDomain = domainMap.has(requestId);
-    if ('default' !== requestId && !setDomain && !hasExistingDomain) throw new ProducerDomainNotConfiguredError(requestId);
-    let configuredRequest = request || originFetch;
-    if (interceptor && !request) configuredRequest = interceptor(fetch);
-    if (Array.isArray(allowedHeaders)) realAllowedHeaders.set(requestId, allowedHeaders);
-    if ('function' == typeof resolveHeaders) realResolveHeaders.set(requestId, resolveHeaders);
-    if (transport && 'object' == typeof transport) realTransportResilience.set(requestId, transport);
-    if (identityBinding && 'object' == typeof identityBinding) realIdentityBinding.set(requestId, identityBinding);
-    if (operationContract && 'object' == typeof operationContract) realOperationContract.set(requestId, operationContract);
-    if ('boolean' == typeof requireEnvelope) realRequireEnvelope.set(requestId, requireEnvelope);
-    if ('boolean' == typeof allowCrossOriginEnvelope || 'function' == typeof allowCrossOriginEnvelope) realAllowCrossOriginEnvelope.set(requestId, allowCrossOriginEnvelope);
-    if (setDomain) {
-        const resolvedDomain = setDomain({
-            target: 'server',
-            requestId
-        });
-        if ('default' !== requestId && isEmptyDomain(resolvedDomain)) throw new ProducerDomainNotConfiguredError(requestId);
-        if ('string' == typeof resolvedDomain) domainMap.set(requestId, resolvedDomain);
-    }
-    realRequest.set(requestId, configuredRequest);
-};
-const normalizeRequestOptions = (...args)=>{
-    if ('object' == typeof args[0] && null !== args[0]) return args[0];
-    const [path, method, port, httpMethodDecider, fetch1, requestId, operationContext] = args;
-    return {
-        path,
-        method,
-        port,
-        httpMethodDecider,
-        fetch: fetch1,
-        requestId,
-        operationContext
-    };
-};
-const createRequest = (...args)=>{
-    const { path, method, port, httpMethodDecider = 'functionName', fetch: fetch1 = originFetch, requestId = 'default', operationContext } = normalizeRequestOptions(...args);
-    const getFinalPath = compile(path, {
-        encode: encodeURIComponent
-    });
-    const keyNames = extractPathParamNames(path);
-    const sender = (...args)=>{
-        const fetcher = resolveConfiguredRequest(realRequest, requestId, fetch1);
-        const webRequestHeaders = readIncomingWebHeaders();
-        let body;
-        let headers;
-        let url;
-        if ('inputParams' === httpMethodDecider) {
-            const configDomain = domainMap.get(requestId);
-            if ('default' !== requestId && isEmptyDomain(configDomain)) throw new ProducerDomainNotConfiguredError(requestId);
-            url = `${configDomain || `http://127.0.0.1:${port}`}${path}`;
-            body = args;
-            headers = {
-                'Content-Type': 'application/json'
-            };
-        } else {
-            const payload = 'object' == typeof args[args.length - 1] ? args[args.length - 1] : {};
-            payload.params = payload.params || {};
-            const requestParams = args[0];
-            if ('object' == typeof requestParams && requestParams.params) {
-                const { params } = requestParams;
-                keyNames.forEach((keyName)=>{
-                    payload.params[keyName] = params[keyName];
-                });
-            } else keyNames.forEach((keyName, index)=>{
-                payload.params[keyName] = args[index];
-            });
-            const plainPath = getFinalPath(payload.params);
-            const finalPath = payload.query ? `${plainPath}?${stringify(payload.query)}` : plainPath;
-            headers = payload.headers ? {
-                ...payload.headers
-            } : {};
-            const identityBinding = realIdentityBinding.get(requestId);
-            const identityBindingEnabled = identityBinding?.enabled ?? isSecuredRequestId(requestId);
-            const identityBindingStrict = identityBinding?.strict ?? isSecuredRequestId(requestId);
-            const protectedIdentityHeaders = (identityBinding?.protectedHeaders || BFF_DEFAULT_PROTECTED_IDENTITY_HEADERS).map((header)=>header.toLowerCase());
-            const targetAllowedHeaders = realAllowedHeaders.get(requestId) || [];
-            const forwardedHeaders = {};
-            for (const key of targetAllowedHeaders)if (void 0 !== webRequestHeaders[key]) forwardedHeaders[key] = webRequestHeaders[key];
-            if (identityBindingEnabled) {
-                const derivedIdentityHeaders = {};
-                for (const header of protectedIdentityHeaders){
-                    const incomingHeaderValue = readHeader(webRequestHeaders, header);
-                    if (void 0 !== incomingHeaderValue) writeHeader(derivedIdentityHeaders, header, incomingHeaderValue);
-                }
-                const customDerivedHeaders = identityBinding?.deriveHeaders?.({
-                    requestId,
-                    target: 'server',
-                    incomingHeaders: {
-                        ...webRequestHeaders
-                    },
-                    protectedHeaders: [
-                        ...protectedIdentityHeaders
-                    ]
-                });
-                if (customDerivedHeaders && 'object' == typeof customDerivedHeaders) for (const header of protectedIdentityHeaders){
-                    const customValue = readHeader(customDerivedHeaders, header);
-                    if (void 0 !== customValue) writeHeader(derivedIdentityHeaders, header, customValue);
-                }
-                for (const header of protectedIdentityHeaders){
-                    const attemptedValue = readHeader(headers, header);
-                    if (void 0 === attemptedValue) continue;
-                    const violation = {
-                        requestId,
-                        target: 'server',
-                        header,
-                        attemptedValue,
-                        derivedValue: readHeader(derivedIdentityHeaders, header),
-                        reason: identityBindingStrict ? 'client_override_rejected' : 'client_override_blocked'
-                    };
-                    identityBinding?.onViolation?.(violation);
-                    if (identityBindingStrict) throw new IdentityBindingViolationError(violation);
-                    deleteHeader(headers, header);
-                }
-                Object.keys(derivedIdentityHeaders).forEach((header)=>{
-                    writeHeader(forwardedHeaders, header, derivedIdentityHeaders[header]);
-                });
-            }
-            const resolveHeaders = realResolveHeaders.get(requestId);
-            if (resolveHeaders) {
-                const resolvedHeaders = resolveHeaders({
-                    requestId,
-                    allowedHeaders: targetAllowedHeaders,
-                    incomingHeaders: {
-                        ...forwardedHeaders
-                    }
-                });
-                if (resolvedHeaders && 'object' == typeof resolvedHeaders) {
-                    for (const key of targetAllowedHeaders)if (void 0 !== resolvedHeaders[key]) forwardedHeaders[key] = resolvedHeaders[key];
-                }
-            }
-            headers = {
-                ...headers,
-                ...forwardedHeaders
-            };
-            if (payload.data) {
-                headers['Content-Type'] = 'application/json';
-                body = 'object' == typeof payload.data ? JSON.stringify(payload.data) : payload.body;
-            } else if (payload.body) {
-                headers['Content-Type'] = 'text/plain';
-                body = payload.body;
-            } else if (payload.formData) body = payload.formData;
-            else if (payload.formUrlencoded) {
-                headers['Content-Type'] = 'application/x-www-form-urlencoded';
-                body = 'object' == typeof payload.formUrlencoded ? stringify(payload.formUrlencoded) : payload.formUrlencoded;
-            }
-            const configDomain = domainMap.get(requestId);
-            if ('default' !== requestId && isEmptyDomain(configDomain)) throw new ProducerDomainNotConfiguredError(requestId);
-            url = `${configDomain || `http://127.0.0.1:${port}`}${finalPath}`;
-        }
-        if (void 0 === readHeader(headers, TRACEPARENT_HEADER)) {
-            const incomingTraceparent = firstHeaderValue(readHeader(webRequestHeaders, TRACEPARENT_HEADER));
-            if ('string' == typeof incomingTraceparent) writeHeader(headers, TRACEPARENT_HEADER, incomingTraceparent);
-        }
-        if (void 0 === readHeader(headers, TRACEPARENT_HEADER) && operationContext?.traceparent) writeHeader(headers, TRACEPARENT_HEADER, operationContext.traceparent);
-        attachEnvelopeHeaderIfRequired(headers, requestId, url, webRequestHeaders);
-        attachSecuredOperationHeaders(headers, requestId, method, path, operationContext);
-        if ('get' === method.toLowerCase()) body = void 0;
-        headers.accept = "application/json,*/*;q=0.8";
-        return executeWithResilience({
-            requestId,
-            target: 'server',
-            method,
-            url,
-            init: {
-                method,
-                body,
-                headers
-            },
-            fetcher,
-            transport: realTransportResilience.get(requestId)
-        });
-    };
-    return sender;
-};
-const createUploader = ({ path, requestId = 'default', operationContext })=>{
-    const sender = (...args)=>{
-        const fetcher = resolveConfiguredRequest(realRequest, requestId, originFetch);
-        const { body, headers: uploadHeaders } = getUploadPayload(args);
-        const headers = {
-            ...uploadHeaders
-        };
-        const configDomain = domainMap.get(requestId);
-        const finalURL = `${configDomain || ''}${path}`;
-        attachEnvelopeHeaderIfRequired(headers, requestId, finalURL, readIncomingWebHeaders());
-        attachSecuredOperationHeaders(headers, requestId, 'POST', path, operationContext);
-        return fetcher(finalURL, {
-            method: 'POST',
-            body,
-            headers
-        });
-    };
-    return sender;
-};
+const requestFactory = createRequestFactory({
+    target: 'server',
+    getFetch: ()=>fetch,
+    originFetch: originFetch,
+    readIncomingHeaders: readIncomingWebHeaders,
+    resolveSourceOrigin: resolveSourceOrigin,
+    createInputParamsBody: (args)=>args,
+    resolveRequestUrl: ({ configDomain, path, port })=>`${configDomain || `http://127.0.0.1:${port}`}${path}`,
+    resolveUploadUrl: ({ configDomain, path })=>`${configDomain || ''}${path}`
+});
+const { configure: configure, createRequest: createRequest, createUploader: createUploader } = requestFactory;
 export { CrossOriginEnvelopePolicyError, IdentityBindingViolationError, OperationContractViolationError, ProducerClientNotInitializedError, ProducerDomainNotConfiguredError, configure, createRequest, createUploader };

package/dist/esm/policyCore.mjs

@@ -132,7 +132,7 @@ const resolveConfiguredRequest = (configuredRequests, requestId, fallback)=>{
 const buildEnvelopeHeaderValue = ({ requestId, target, sourceOrigin, targetOrigin, traceContext, allowCrossOriginEnvelope })=>{
     const isCrossOrigin = Boolean(sourceOrigin) && Boolean(targetOrigin) && sourceOrigin !== targetOrigin;
     if (isCrossOrigin) {
-        const isAllowed = 'function' == typeof allowCrossOriginEnvelope ? allowCrossOriginEnvelope({
+        const isAllowed = 'function' == typeof allowCrossOriginEnvelope ? true === allowCrossOriginEnvelope({
             requestId,
             sourceOrigin,
             targetOrigin,
@@ -171,4 +171,4 @@ const attachOperationContextHeaders = ({ headers, requestId, target, method, pat
     writeHeader(headers, operationContextDetailHeader, JSON.stringify(contextPayload));
     return contextPayload;
 };
-export { CrossOriginEnvelopePolicyError, IdentityBindingViolationError, OperationContractViolationError, ProducerClientNotInitializedError, ProducerDomainNotConfiguredError, TRACEPARENT_HEADER, attachOperationContextHeaders, buildEnvelopeHeaderValue, buildOperationContext, deleteHeader, extractPathParamNames, findHeaderKey, firstHeaderValue, isEmptyDomain, isSecuredRequestId, isStrictDefaultRequestIdEnabled, parseTraceparentValue, readHeader, resolveConfiguredRequest, toOrigin, validateOperationContract, writeHeader };
+export { CrossOriginEnvelopePolicyError, IdentityBindingViolationError, OperationContractViolationError, ProducerClientNotInitializedError, ProducerDomainNotConfiguredError, TRACEPARENT_HEADER, attachOperationContextHeaders, buildEnvelopeHeaderValue, buildOperationContext, deleteHeader, extractPathParamNames, findHeaderKey, firstHeaderValue, isEmptyDomain, isSecuredRequestId, parseTraceparentValue, readHeader, resolveConfiguredRequest, toOrigin, validateOperationContract, writeHeader };

package/dist/esm/requestFactory.mjs

@@ -0,0 +1,277 @@
+import { compile } from "path-to-regexp";
+import { stringify } from "qs";
+import { IdentityBindingViolationError, ProducerDomainNotConfiguredError, TRACEPARENT_HEADER, attachOperationContextHeaders, buildEnvelopeHeaderValue, deleteHeader, extractPathParamNames, firstHeaderValue, isEmptyDomain, isSecuredRequestId, parseTraceparentValue, readHeader, resolveConfiguredRequest, toOrigin, writeHeader } from "./policyCore.mjs";
+import { executeWithResilience } from "./transport.mjs";
+import { BFF_DEFAULT_PROTECTED_IDENTITY_HEADERS, BFF_ENVELOPE_HEADER, BFF_OPERATION_CONTEXT_DETAIL_HEADER, BFF_OPERATION_CONTEXT_HEADER } from "./types.mjs";
+import { getUploadPayload } from "./utiles.mjs";
+const OPERATION_CONTEXT_DETAIL_HEADER = BFF_OPERATION_CONTEXT_DETAIL_HEADER;
+const createRequestFactory = (environment)=>{
+    const isServerTarget = 'server' === environment.target;
+    const realRequest = new Map();
+    const realAllowedHeaders = new Map();
+    const realResolveHeaders = new Map();
+    const realRequireEnvelope = new Map();
+    const realAllowCrossOriginEnvelope = new Map();
+    const realTransportResilience = new Map();
+    const realIdentityBinding = new Map();
+    const realOperationContract = new Map();
+    const domainMap = new Map();
+    const attachEnvelopeHeaderIfRequired = (headers, requestId, url, incomingHeaders)=>{
+        const shouldRequireEnvelope = realRequireEnvelope.get(requestId) ?? isSecuredRequestId(requestId);
+        if (!shouldRequireEnvelope) return;
+        headers[BFF_ENVELOPE_HEADER] = buildEnvelopeHeaderValue({
+            requestId,
+            target: environment.target,
+            sourceOrigin: environment.resolveSourceOrigin(incomingHeaders),
+            targetOrigin: toOrigin(url),
+            traceContext: parseTraceparentValue(readHeader(headers, TRACEPARENT_HEADER)),
+            allowCrossOriginEnvelope: realAllowCrossOriginEnvelope.get(requestId)
+        });
+    };
+    const attachSecuredOperationHeaders = (headers, requestId, method, path, operationContext)=>{
+        if (!isSecuredRequestId(requestId)) return;
+        attachOperationContextHeaders({
+            headers,
+            requestId,
+            target: environment.target,
+            method,
+            path,
+            operationContext,
+            operationContract: realOperationContract.get(requestId),
+            operationContextHeader: BFF_OPERATION_CONTEXT_HEADER,
+            operationContextDetailHeader: OPERATION_CONTEXT_DETAIL_HEADER
+        });
+    };
+    const applyIdentityAndForwardedHeaders = (headers, requestId, incomingHeaders)=>{
+        const identityBinding = realIdentityBinding.get(requestId);
+        const identityBindingEnabled = identityBinding?.enabled ?? isSecuredRequestId(requestId);
+        const identityBindingStrict = identityBinding?.strict ?? isSecuredRequestId(requestId);
+        const protectedIdentityHeaders = (identityBinding?.protectedHeaders || BFF_DEFAULT_PROTECTED_IDENTITY_HEADERS).map((header)=>header.toLowerCase());
+        const targetAllowedHeaders = realAllowedHeaders.get(requestId) || [];
+        const forwardedHeaders = {};
+        if (isServerTarget) {
+            for (const key of targetAllowedHeaders)if (void 0 !== incomingHeaders[key]) forwardedHeaders[key] = incomingHeaders[key];
+        }
+        if (identityBindingEnabled) {
+            const derivedIdentityHeaders = {};
+            if (isServerTarget) for (const header of protectedIdentityHeaders){
+                const incomingHeaderValue = readHeader(incomingHeaders, header);
+                if (void 0 !== incomingHeaderValue) writeHeader(derivedIdentityHeaders, header, incomingHeaderValue);
+            }
+            const customDerivedHeaders = identityBinding?.deriveHeaders?.({
+                requestId,
+                target: environment.target,
+                incomingHeaders: isServerTarget ? {
+                    ...incomingHeaders
+                } : {},
+                protectedHeaders: [
+                    ...protectedIdentityHeaders
+                ]
+            });
+            if (customDerivedHeaders && 'object' == typeof customDerivedHeaders) for (const header of protectedIdentityHeaders){
+                const customValue = readHeader(customDerivedHeaders, header);
+                if (void 0 !== customValue) writeHeader(derivedIdentityHeaders, header, customValue);
+            }
+            for (const header of protectedIdentityHeaders){
+                const attemptedValue = readHeader(headers, header);
+                if (void 0 === attemptedValue) continue;
+                const violation = {
+                    requestId,
+                    target: environment.target,
+                    header,
+                    attemptedValue,
+                    derivedValue: readHeader(derivedIdentityHeaders, header),
+                    reason: 'client_override_blocked'
+                };
+                identityBinding?.onViolation?.(violation);
+                if (identityBindingStrict) throw new IdentityBindingViolationError(violation);
+                deleteHeader(headers, header);
+            }
+            Object.keys(derivedIdentityHeaders).forEach((header)=>{
+                isServerTarget ? writeHeader(forwardedHeaders, header, derivedIdentityHeaders[header]) : writeHeader(headers, header, derivedIdentityHeaders[header]);
+            });
+        }
+        if (isServerTarget) {
+            const resolveHeaders = realResolveHeaders.get(requestId);
+            if (resolveHeaders) {
+                const resolvedHeaders = resolveHeaders({
+                    requestId,
+                    allowedHeaders: targetAllowedHeaders,
+                    incomingHeaders: {
+                        ...forwardedHeaders
+                    }
+                });
+                if (resolvedHeaders && 'object' == typeof resolvedHeaders) {
+                    for (const key of targetAllowedHeaders)if (void 0 !== resolvedHeaders[key]) {
+                        if (identityBindingEnabled && protectedIdentityHeaders.includes(key.toLowerCase())) {
+                            writeHeader(forwardedHeaders, key.toLowerCase(), resolvedHeaders[key]);
+                            continue;
+                        }
+                        forwardedHeaders[key] = resolvedHeaders[key];
+                    }
+                }
+            }
+        }
+        if (isServerTarget) return {
+            ...headers,
+            ...forwardedHeaders
+        };
+        return headers;
+    };
+    const configure = (options)=>{
+        const { request, interceptor, allowedHeaders, resolveHeaders, transport, requireEnvelope, allowCrossOriginEnvelope, identityBinding, operationContract, setDomain, requestId = 'default' } = options;
+        const hasExistingDomain = domainMap.has(requestId);
+        if ('default' !== requestId && !setDomain && !hasExistingDomain) throw new ProducerDomainNotConfiguredError(requestId);
+        let configuredRequest = request || environment.originFetch;
+        if (interceptor && !request) configuredRequest = interceptor(environment.getFetch());
+        if (Array.isArray(allowedHeaders)) realAllowedHeaders.set(requestId, allowedHeaders);
+        if (isServerTarget && 'function' == typeof resolveHeaders) realResolveHeaders.set(requestId, resolveHeaders);
+        if (transport && 'object' == typeof transport) realTransportResilience.set(requestId, transport);
+        if (identityBinding && 'object' == typeof identityBinding) realIdentityBinding.set(requestId, identityBinding);
+        if (operationContract && 'object' == typeof operationContract) realOperationContract.set(requestId, operationContract);
+        if ('boolean' == typeof requireEnvelope) realRequireEnvelope.set(requestId, requireEnvelope);
+        if ('boolean' == typeof allowCrossOriginEnvelope || 'function' == typeof allowCrossOriginEnvelope) realAllowCrossOriginEnvelope.set(requestId, allowCrossOriginEnvelope);
+        if (setDomain) {
+            const resolvedDomain = setDomain({
+                target: environment.target,
+                requestId
+            });
+            if ('default' !== requestId && isEmptyDomain(resolvedDomain)) throw new ProducerDomainNotConfiguredError(requestId);
+            if ('string' == typeof resolvedDomain) domainMap.set(requestId, resolvedDomain);
+        }
+        realRequest.set(requestId, configuredRequest);
+    };
+    const createRequest = (...args)=>{
+        const options = 'object' == typeof args[0] && null !== args[0] ? args[0] : {
+            path: args[0],
+            method: args[1],
+            port: args[2],
+            httpMethodDecider: args[3],
+            fetch: args[4],
+            requestId: args[5],
+            operationContext: args[6]
+        };
+        const { path, method, port, httpMethodDecider = 'functionName', fetch = environment.originFetch, requestId = 'default', operationContext } = options;
+        const getFinalPath = compile(path, {
+            encode: encodeURIComponent
+        });
+        const keyNames = extractPathParamNames(path);
+        const send = (...senderArgs)=>{
+            const fetcher = resolveConfiguredRequest(realRequest, requestId, fetch);
+            const incomingHeaders = environment.readIncomingHeaders();
+            let body;
+            let headers;
+            let url;
+            if ('inputParams' === httpMethodDecider) {
+                const configDomain = domainMap.get(requestId);
+                if ('default' !== requestId && isEmptyDomain(configDomain)) throw new ProducerDomainNotConfiguredError(requestId);
+                url = environment.resolveRequestUrl({
+                    configDomain,
+                    port,
+                    path
+                });
+                body = environment.createInputParamsBody(senderArgs);
+                headers = {
+                    'Content-Type': 'application/json'
+                };
+            } else {
+                const payload = 'object' == typeof senderArgs[senderArgs.length - 1] ? senderArgs[senderArgs.length - 1] : {};
+                payload.params = payload.params || {};
+                const requestParams = senderArgs[0];
+                if ('object' == typeof requestParams && requestParams.params) {
+                    const { params } = requestParams;
+                    keyNames.forEach((keyName)=>{
+                        payload.params[keyName] = params[keyName];
+                    });
+                } else keyNames.forEach((keyName, index)=>{
+                    payload.params[keyName] = senderArgs[index];
+                });
+                const plainPath = getFinalPath(payload.params);
+                const finalPath = payload.query ? `${plainPath}?${stringify(payload.query)}` : plainPath;
+                headers = payload.headers ? {
+                    ...payload.headers
+                } : {};
+                headers = applyIdentityAndForwardedHeaders(headers, requestId, incomingHeaders);
+                if (payload.data) {
+                    headers['Content-Type'] = 'application/json';
+                    body = 'object' == typeof payload.data ? JSON.stringify(payload.data) : payload.body;
+                } else if (payload.body) {
+                    headers['Content-Type'] = 'text/plain';
+                    body = payload.body;
+                } else if (payload.formData) body = payload.formData;
+                else if (payload.formUrlencoded) {
+                    headers['Content-Type'] = 'application/x-www-form-urlencoded';
+                    body = !isServerTarget && "u" > typeof URLSearchParams && payload.formUrlencoded instanceof URLSearchParams ? payload.formUrlencoded : 'object' == typeof payload.formUrlencoded ? stringify(payload.formUrlencoded) : payload.formUrlencoded;
+                }
+                const configDomain = domainMap.get(requestId);
+                if ('default' !== requestId && isEmptyDomain(configDomain)) throw new ProducerDomainNotConfiguredError(requestId);
+                url = environment.resolveRequestUrl({
+                    configDomain,
+                    port,
+                    path: finalPath
+                });
+            }
+            if (!isServerTarget) writeHeader(headers, 'accept', "application/json,*/*;q=0.8");
+            if (isServerTarget) {
+                if (void 0 === readHeader(headers, TRACEPARENT_HEADER)) {
+                    const incomingTraceparent = firstHeaderValue(readHeader(incomingHeaders, TRACEPARENT_HEADER));
+                    if ('string' == typeof incomingTraceparent) writeHeader(headers, TRACEPARENT_HEADER, incomingTraceparent);
+                }
+                if (void 0 === readHeader(headers, TRACEPARENT_HEADER) && operationContext?.traceparent) writeHeader(headers, TRACEPARENT_HEADER, operationContext.traceparent);
+            }
+            attachEnvelopeHeaderIfRequired(headers, requestId, url, incomingHeaders);
+            attachSecuredOperationHeaders(headers, requestId, method, path, operationContext);
+            if ('get' === method.toLowerCase()) body = void 0;
+            if (isServerTarget) writeHeader(headers, 'accept', "application/json,*/*;q=0.8");
+            return executeWithResilience({
+                requestId,
+                target: environment.target,
+                method,
+                url,
+                init: {
+                    method,
+                    body,
+                    headers
+                },
+                fetcher: fetcher,
+                transport: realTransportResilience.get(requestId)
+            });
+        };
+        const sender = isServerTarget ? send : async (...senderArgs)=>send(...senderArgs);
+        return sender;
+    };
+    const createUploader = ({ path, domain, requestId = 'default', operationContext })=>{
+        const getUploadPath = isServerTarget ? void 0 : compile(path, {
+            encode: encodeURIComponent
+        });
+        const sender = (...args)=>{
+            const fetcher = resolveConfiguredRequest(realRequest, requestId, environment.originFetch);
+            const { body, headers: uploadHeaders, params } = getUploadPayload(args);
+            const headers = {
+                ...uploadHeaders
+            };
+            const finalPath = getUploadPath ? getUploadPath(params) : path;
+            const configDomain = domainMap.get(requestId);
+            const finalURL = environment.resolveUploadUrl({
+                configDomain,
+                domain,
+                path: finalPath
+            });
+            const incomingHeaders = environment.readIncomingHeaders();
+            attachEnvelopeHeaderIfRequired(headers, requestId, finalURL, incomingHeaders);
+            attachSecuredOperationHeaders(headers, requestId, 'POST', path, operationContext);
+            return fetcher(finalURL, {
+                method: 'POST',
+                body,
+                headers
+            });
+        };
+        return sender;
+    };
+    return {
+        configure,
+        createRequest,
+        createUploader
+    };
+};
+export { createRequestFactory };

package/dist/esm/transport.mjs

@@ -10,6 +10,14 @@ const DEFAULT_RETRYABLE_STATUS_CODES = [
 const DEFAULT_BASE_DELAY_MS = 100;
 const DEFAULT_MAX_DELAY_MS = 1000;
 const DEFAULT_JITTER_RATIO = 0.1;
+const DEFAULT_RETRYABLE_METHODS = new Set([
+    'DELETE',
+    'GET',
+    'HEAD',
+    'OPTIONS',
+    'PUT',
+    'TRACE'
+]);
 const createTimeoutError = (timeoutMs)=>{
     const error = new Error(`Request timed out after ${timeoutMs}ms`);
     error.name = 'TimeoutError';
@@ -29,7 +37,7 @@ const toStatusCode = (error)=>{
 const isRetryableNetworkError = (error)=>{
     if (!error || 'object' != typeof error) return false;
     const name = error.name;
-    if ('AbortError' === name || 'FetchError' === name || 'TimeoutError' === name || 'TypeError' === name) return true;
+    if ('FetchError' === name || 'TimeoutError' === name || 'TypeError' === name) return true;
     const code = error.code;
     return 'ECONNRESET' === code || 'ETIMEDOUT' === code || 'ECONNREFUSED' === code || 'EPIPE' === code;
 };
@@ -39,7 +47,8 @@ const normalizeJitterRatio = (value)=>{
     if ('number' != typeof value || !Number.isFinite(value)) return DEFAULT_JITTER_RATIO;
     return Math.max(0, Math.min(1, value));
 };
-const shouldRetryWithDefaults = (statusCode, error, retryableStatusCodes)=>{
+const shouldRetryWithDefaults = (method, statusCode, error, retryableStatusCodes)=>{
+    if (!DEFAULT_RETRYABLE_METHODS.has(method.toUpperCase())) return false;
     if ('number' == typeof statusCode) return retryableStatusCodes.includes(statusCode);
     return isRetryableNetworkError(error);
 };
@@ -49,7 +58,7 @@ const shouldRetry = (retryOptions, context, retryableStatusCodes)=>{
     } catch (error) {
         return false;
     }
-    return shouldRetryWithDefaults(context.statusCode, context.error, retryableStatusCodes);
+    return shouldRetryWithDefaults(context.method, context.statusCode, context.error, retryableStatusCodes);
 };
 const getBackoffMs = (retryOptions, attempt)=>{
     const baseDelayMs = normalizePositiveNumber(retryOptions?.baseDelayMs, DEFAULT_BASE_DELAY_MS);