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

package/dist/cjs/requestFactory.js

@@ -0,0 +1,316 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createRequestFactory: ()=>createRequestFactory
+});
+const external_path_to_regexp_namespaceObject = require("path-to-regexp");
+const external_qs_namespaceObject = require("qs");
+const external_policyCore_js_namespaceObject = require("./policyCore.js");
+const external_transport_js_namespaceObject = require("./transport.js");
+const external_types_js_namespaceObject = require("./types.js");
+const external_utiles_js_namespaceObject = require("./utiles.js");
+const OPERATION_CONTEXT_DETAIL_HEADER = external_types_js_namespaceObject.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) ?? (0, external_policyCore_js_namespaceObject.isSecuredRequestId)(requestId);
+        if (!shouldRequireEnvelope) return;
+        headers[external_types_js_namespaceObject.BFF_ENVELOPE_HEADER] = (0, external_policyCore_js_namespaceObject.buildEnvelopeHeaderValue)({
+            requestId,
+            target: environment.target,
+            sourceOrigin: environment.resolveSourceOrigin(incomingHeaders),
+            targetOrigin: (0, external_policyCore_js_namespaceObject.toOrigin)(url),
+            traceContext: (0, external_policyCore_js_namespaceObject.parseTraceparentValue)((0, external_policyCore_js_namespaceObject.readHeader)(headers, external_policyCore_js_namespaceObject.TRACEPARENT_HEADER)),
+            allowCrossOriginEnvelope: realAllowCrossOriginEnvelope.get(requestId)
+        });
+    };
+    const attachSecuredOperationHeaders = (headers, requestId, method, path, operationContext)=>{
+        if (!(0, external_policyCore_js_namespaceObject.isSecuredRequestId)(requestId)) return;
+        (0, external_policyCore_js_namespaceObject.attachOperationContextHeaders)({
+            headers,
+            requestId,
+            target: environment.target,
+            method,
+            path,
+            operationContext,
+            operationContract: realOperationContract.get(requestId),
+            operationContextHeader: external_types_js_namespaceObject.BFF_OPERATION_CONTEXT_HEADER,
+            operationContextDetailHeader: OPERATION_CONTEXT_DETAIL_HEADER
+        });
+    };
+    const applyIdentityAndForwardedHeaders = (headers, requestId, incomingHeaders)=>{
+        const identityBinding = realIdentityBinding.get(requestId);
+        const identityBindingEnabled = identityBinding?.enabled ?? (0, external_policyCore_js_namespaceObject.isSecuredRequestId)(requestId);
+        const identityBindingStrict = identityBinding?.strict ?? (0, external_policyCore_js_namespaceObject.isSecuredRequestId)(requestId);
+        const protectedIdentityHeaders = (identityBinding?.protectedHeaders || external_types_js_namespaceObject.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 = (0, external_policyCore_js_namespaceObject.readHeader)(incomingHeaders, header);
+                if (void 0 !== incomingHeaderValue) (0, external_policyCore_js_namespaceObject.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 = (0, external_policyCore_js_namespaceObject.readHeader)(customDerivedHeaders, header);
+                if (void 0 !== customValue) (0, external_policyCore_js_namespaceObject.writeHeader)(derivedIdentityHeaders, header, customValue);
+            }
+            for (const header of protectedIdentityHeaders){
+                const attemptedValue = (0, external_policyCore_js_namespaceObject.readHeader)(headers, header);
+                if (void 0 === attemptedValue) continue;
+                const violation = {
+                    requestId,
+                    target: environment.target,
+                    header,
+                    attemptedValue,
+                    derivedValue: (0, external_policyCore_js_namespaceObject.readHeader)(derivedIdentityHeaders, header),
+                    reason: 'client_override_blocked'
+                };
+                identityBinding?.onViolation?.(violation);
+                if (identityBindingStrict) throw new external_policyCore_js_namespaceObject.IdentityBindingViolationError(violation);
+                (0, external_policyCore_js_namespaceObject.deleteHeader)(headers, header);
+            }
+            Object.keys(derivedIdentityHeaders).forEach((header)=>{
+                if (isServerTarget) (0, external_policyCore_js_namespaceObject.writeHeader)(forwardedHeaders, header, derivedIdentityHeaders[header]);
+                else (0, external_policyCore_js_namespaceObject.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())) {
+                            (0, external_policyCore_js_namespaceObject.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 external_policyCore_js_namespaceObject.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 && (0, external_policyCore_js_namespaceObject.isEmptyDomain)(resolvedDomain)) throw new external_policyCore_js_namespaceObject.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 = (0, external_path_to_regexp_namespaceObject.compile)(path, {
+            encode: encodeURIComponent
+        });
+        const keyNames = (0, external_policyCore_js_namespaceObject.extractPathParamNames)(path);
+        const send = (...senderArgs)=>{
+            const fetcher = (0, external_policyCore_js_namespaceObject.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 && (0, external_policyCore_js_namespaceObject.isEmptyDomain)(configDomain)) throw new external_policyCore_js_namespaceObject.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}?${(0, external_qs_namespaceObject.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 ? (0, external_qs_namespaceObject.stringify)(payload.formUrlencoded) : payload.formUrlencoded;
+                }
+                const configDomain = domainMap.get(requestId);
+                if ('default' !== requestId && (0, external_policyCore_js_namespaceObject.isEmptyDomain)(configDomain)) throw new external_policyCore_js_namespaceObject.ProducerDomainNotConfiguredError(requestId);
+                url = environment.resolveRequestUrl({
+                    configDomain,
+                    port,
+                    path: finalPath
+                });
+            }
+            if (!isServerTarget) (0, external_policyCore_js_namespaceObject.writeHeader)(headers, 'accept', "application/json,*/*;q=0.8");
+            if (isServerTarget) {
+                if (void 0 === (0, external_policyCore_js_namespaceObject.readHeader)(headers, external_policyCore_js_namespaceObject.TRACEPARENT_HEADER)) {
+                    const incomingTraceparent = (0, external_policyCore_js_namespaceObject.firstHeaderValue)((0, external_policyCore_js_namespaceObject.readHeader)(incomingHeaders, external_policyCore_js_namespaceObject.TRACEPARENT_HEADER));
+                    if ('string' == typeof incomingTraceparent) (0, external_policyCore_js_namespaceObject.writeHeader)(headers, external_policyCore_js_namespaceObject.TRACEPARENT_HEADER, incomingTraceparent);
+                }
+                if (void 0 === (0, external_policyCore_js_namespaceObject.readHeader)(headers, external_policyCore_js_namespaceObject.TRACEPARENT_HEADER) && operationContext?.traceparent) (0, external_policyCore_js_namespaceObject.writeHeader)(headers, external_policyCore_js_namespaceObject.TRACEPARENT_HEADER, operationContext.traceparent);
+            }
+            attachEnvelopeHeaderIfRequired(headers, requestId, url, incomingHeaders);
+            attachSecuredOperationHeaders(headers, requestId, method, path, operationContext);
+            if ('get' === method.toLowerCase()) body = void 0;
+            if (isServerTarget) (0, external_policyCore_js_namespaceObject.writeHeader)(headers, 'accept', "application/json,*/*;q=0.8");
+            return (0, external_transport_js_namespaceObject.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 : (0, external_path_to_regexp_namespaceObject.compile)(path, {
+            encode: encodeURIComponent
+        });
+        const sender = (...args)=>{
+            const fetcher = (0, external_policyCore_js_namespaceObject.resolveConfiguredRequest)(realRequest, requestId, environment.originFetch);
+            const { body, headers: uploadHeaders, params } = (0, external_utiles_js_namespaceObject.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
+    };
+};
+exports.createRequestFactory = __webpack_exports__.createRequestFactory;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRequestFactory"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/transport.js

@@ -39,6 +39,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';
@@ -58,7 +66,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;
 };
@@ -68,7 +76,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);
 };
@@ -78,7 +87,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);

package/dist/esm/browser.mjs

@@ -1,218 +1,26 @@
-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, 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 { 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 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 resolveBrowserOrigin = ()=>"u" > typeof window ? window.location.origin : void 0;
 const originFetch = (...params)=>{
     const [url, init] = params;
     if (init?.method?.toLowerCase() === 'get') init.body = void 0;
     return fetch(url, init).then(handleRes);
 };
-const attachEnvelopeHeaderIfRequired = (headers, requestId, finalURL)=>{
-    const shouldRequireEnvelope = realRequireEnvelope.get(requestId) ?? isSecuredRequestId(requestId);
-    if (!shouldRequireEnvelope) return;
-    headers[BFF_ENVELOPE_HEADER] = buildEnvelopeHeaderValue({
-        requestId,
-        target: 'browser',
-        sourceOrigin: resolveBrowserOrigin(),
-        targetOrigin: toOrigin(finalURL),
-        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: 'browser',
-        method,
-        path,
-        operationContext,
-        operationContract: realOperationContract.get(requestId),
-        operationContextHeader: BFF_OPERATION_CONTEXT_HEADER,
-        operationContextDetailHeader: OPERATION_CONTEXT_DETAIL_HEADER
-    });
-};
-const configure = (options)=>{
-    const { request, interceptor, allowedHeaders, 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 (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: 'browser',
-            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, domain, requestId = 'default', operationContext } = normalizeRequestOptions(...args);
-    const getFinalPath = compile(path, {
-        encode: encodeURIComponent
-    });
-    const keyNames = extractPathParamNames(path);
-    const sender = async (...args)=>{
-        const fetcher = resolveConfiguredRequest(realRequest, requestId, fetch1);
-        let body;
-        let finalURL;
-        let headers;
-        if ('inputParams' === httpMethodDecider) {
-            finalURL = path;
-            body = JSON.stringify({
-                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 finalPath = getFinalPath(payload.params);
-            finalURL = payload.query ? `${finalPath}?${stringify(payload.query)}` : finalPath;
-            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());
-            if (identityBindingEnabled) {
-                const derivedIdentityHeaders = {};
-                const customDerivedHeaders = identityBinding?.deriveHeaders?.({
-                    requestId,
-                    target: 'browser',
-                    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: 'browser',
-                        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(headers, header, derivedIdentityHeaders[header]);
-                });
-            }
-            body = payload.data && 'object' == typeof payload.data ? JSON.stringify(payload.data) : payload.body;
-            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 || payload.formUrlencoded instanceof URLSearchParams ? payload.formUrlencoded : stringify(payload.formUrlencoded);
-            }
-        }
-        headers.accept = "application/json,*/*;q=0.8";
-        const configDomain = domainMap.get(requestId);
-        if ('default' !== requestId && isEmptyDomain(configDomain)) throw new ProducerDomainNotConfiguredError(requestId);
-        finalURL = `${configDomain || ''}${finalURL}`;
-        attachEnvelopeHeaderIfRequired(headers, requestId, finalURL);
-        attachSecuredOperationHeaders(headers, requestId, method, path, operationContext);
-        return executeWithResilience({
-            requestId,
-            target: 'browser',
-            method,
-            url: finalURL,
-            init: {
-                method,
-                body,
-                headers
-            },
-            fetcher,
-            transport: realTransportResilience.get(requestId)
-        });
-    };
-    return sender;
-};
-const createUploader = ({ path, domain, requestId = 'default', operationContext })=>{
-    const getFinalPath = compile(path, {
-        encode: encodeURIComponent
-    });
-    const sender = (...args)=>{
-        const fetcher = resolveConfiguredRequest(realRequest, requestId, originFetch);
-        const { body, headers: uploadHeaders, params } = getUploadPayload(args);
-        const headers = {
-            ...uploadHeaders
-        };
-        const finalPath = getFinalPath(params);
-        const configDomain = domainMap.get(requestId);
-        const finalURL = `${configDomain || domain || ''}${finalPath}`;
-        attachEnvelopeHeaderIfRequired(headers, requestId, finalURL);
-        attachSecuredOperationHeaders(headers, requestId, 'POST', path, operationContext);
-        return fetcher(finalURL, {
-            method: 'POST',
-            body,
-            headers
-        });
-    };
-    return sender;
-};
-export { CrossOriginEnvelopePolicyError, IdentityBindingViolationError, OperationContractViolationError, ProducerClientNotInitializedError, ProducerDomainNotConfiguredError, configure, createRequest, createUploader };
+const requestFactory = createRequestFactory({
+    target: 'browser',
+    getFetch: ()=>fetch,
+    originFetch: originFetch,
+    readIncomingHeaders: ()=>({}),
+    resolveSourceOrigin: resolveBrowserOrigin,
+    createInputParamsBody: (args)=>JSON.stringify({
+            args
+        }),
+    resolveRequestUrl: ({ configDomain, path })=>`${configDomain || ''}${path}`,
+    resolveUploadUrl: ({ configDomain, domain, path })=>`${configDomain || domain || ''}${path}`
+});
+const { configure: configure, createRequest: createRequest, createUploader: createUploader } = requestFactory;
+export { CrossOriginEnvelopePolicyError, IdentityBindingViolationError, OperationContractViolationError, ProducerClientNotInitializedError, ProducerDomainNotConfiguredError } from "./policyCore.mjs";
+export { configure, createRequest, createUploader };