@bleedingdev/modern-js-create-request 3.5.0-ultramodern.6 → 3.5.0-ultramodern.76

package/dist/esm-node/requestFactory.mjs

@@ -0,0 +1,278 @@
+import "node:module";
+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-node/transport.mjs

@@ -11,6 +11,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';
@@ -30,7 +38,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;
 };
@@ -40,7 +48,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);
 };
@@ -50,7 +59,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/types/browser.d.ts

@@ -1,8 +1,5 @@
-import type { IOptions, RequestCreator, UploadCreator } from './types';
 export { CrossOriginEnvelopePolicyError, IdentityBindingViolationError, OperationContractViolationError, ProducerClientNotInitializedError, ProducerDomainNotConfiguredError, } from './policyCore';
-export declare const configure: (options: IOptions) => void;
-export declare const createRequest: RequestCreator;
-export declare const createUploader: UploadCreator;
+export declare const configure: (options: import("./types").IOptions<typeof fetch>) => void, createRequest: import("./types").RequestCreator<typeof fetch>, createUploader: import("./types").UploadCreator;
 export * from './requestContext';
 export * from './traceparent';
 export * from './types';

package/dist/types/node.d.ts

@@ -1,9 +1,5 @@
-import type { IOptions, RequestCreator, UploadCreator } from './types';
 export { CrossOriginEnvelopePolicyError, IdentityBindingViolationError, OperationContractViolationError, ProducerClientNotInitializedError, ProducerDomainNotConfiguredError, } from './policyCore';
-type Fetch = typeof fetch;
-export declare const configure: (options: IOptions<Fetch>) => void;
-export declare const createRequest: RequestCreator<Fetch>;
-export declare const createUploader: UploadCreator;
+export declare const configure: (options: import("./types").IOptions<typeof fetch>) => void, createRequest: import("./types").RequestCreator<typeof fetch>, createUploader: import("./types").UploadCreator;
 export * from './requestContext';
 export * from './traceparent';
 export * from './types';

package/dist/types/policyCore.d.ts

@@ -1,6 +1,5 @@
 import type { IdentityBindingViolation, OperationContext, OperationContractOptions, OperationContractViolation, TransportTarget } from './types';
 export declare const TRACEPARENT_HEADER = "traceparent";
-export declare const isStrictDefaultRequestIdEnabled: () => boolean;
 export declare const isSecuredRequestId: (requestId: string) => boolean;
 export declare const isEmptyDomain: (domain?: string) => boolean;
 export declare const firstHeaderValue: (value: unknown) => any;
@@ -28,7 +27,7 @@ export declare const buildOperationContext: ({ requestId, method, path, operatio
     traceId?: string | undefined;
     spanId?: string | undefined;
 };
-export type OperationContextPayload = ReturnType<typeof buildOperationContext>;
+type OperationContextPayload = ReturnType<typeof buildOperationContext>;
 export declare class ProducerClientNotInitializedError extends Error {
     readonly code = "BFF_PRODUCER_CLIENT_NOT_INITIALIZED";
     constructor(requestId: string);
@@ -106,3 +105,4 @@ export declare const attachOperationContextHeaders: ({ headers, requestId, targe
     traceId?: string | undefined;
     spanId?: string | undefined;
 };
+export {};

package/dist/types/requestFactory.d.ts

@@ -0,0 +1,28 @@
+import type { IOptions, RequestCreator, TransportTarget, UploadCreator } from './types';
+type HeaderMap = Record<string, any>;
+type RequestUrlOptions = {
+    configDomain: string | undefined;
+    path: string;
+    port: number;
+};
+type UploadUrlOptions = {
+    configDomain: string | undefined;
+    domain: string | undefined;
+    path: string;
+};
+type RequestFactoryEnvironment<F> = {
+    target: TransportTarget;
+    getFetch: () => F;
+    originFetch: F;
+    readIncomingHeaders: () => HeaderMap;
+    resolveSourceOrigin: (incomingHeaders: HeaderMap) => string | undefined;
+    createInputParamsBody: (args: any[]) => any;
+    resolveRequestUrl: (options: RequestUrlOptions) => string;
+    resolveUploadUrl: (options: UploadUrlOptions) => string;
+};
+export declare const createRequestFactory: <F>(environment: RequestFactoryEnvironment<F>) => {
+    configure: (options: IOptions<F>) => void;
+    createRequest: RequestCreator<F>;
+    createUploader: UploadCreator;
+};
+export {};

package/dist/types/types.d.ts

@@ -1,4 +1,3 @@
-import type { HttpMethodDecider } from '@modern-js/types';
 export declare const BFF_ENVELOPE_HEADER = "x-modernjs-bff-envelope";
 export declare const BFF_OPERATION_CONTEXT_HEADER = "x-operation-id";
 export declare const BFF_OPERATION_CONTEXT_DETAIL_HEADER = "x-modernjs-bff-operation-context";
@@ -17,6 +16,7 @@ export type BFFRequestPayload = {
 export type Sender<F = typeof fetch> = ((...args: any[]) => Promise<any>) & {
     fetch?: F;
 };
+export type HttpMethodDecider = 'functionName' | 'inputParams';
 export type ResolveHeadersOptions = {
     requestId: string;
     allowedHeaders: string[];

package/package.json

@@ -17,7 +17,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "3.5.0-ultramodern.6",
+  "version": "3.5.0-ultramodern.76",
   "modern:source": "./src/node.ts",
   "types": "./dist/types/browser.d.ts",
   "main": "./dist/cjs/node.js",
@@ -28,18 +28,15 @@
   "exports": {
     ".": {
       "types": "./dist/types/browser.d.ts",
-      "modern:source": "./src/browser.ts",
       "node": "./dist/esm/node.mjs",
       "default": "./dist/esm/browser.mjs"
     },
     "./client": {
       "types": "./dist/types/browser.d.ts",
-      "modern:source": "./src/browser.ts",
       "default": "./dist/esm/browser.mjs"
     },
     "./server": {
       "types": "./dist/types/node.d.ts",
-      "modern:source": "./src/node.ts",
       "require": "./dist/cjs/node.js",
       "default": "./dist/esm/node.mjs"
     }
@@ -58,27 +55,25 @@
     }
   },
   "dependencies": {
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.5.0-ultramodern.76",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.5.0-ultramodern.76",
     "@swc/helpers": "^0.5.23",
     "encoding": "^0.1.13",
     "path-to-regexp": "^8.4.2",
-    "qs": "^6.15.3",
-    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.5.0-ultramodern.6",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.5.0-ultramodern.6"
+    "qs": "^6.15.3"
   },
   "devDependencies": {
-    "@rslib/core": "0.23.1",
-    "@types/node": "^26.0.1",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.5.0-ultramodern.76",
+    "@rslib/core": "0.23.2",
+    "@scripts/rstest-config": "2.66.0",
+    "@types/node": "^26.1.1",
     "@types/qs": "^6.15.1",
-    "@typescript/native-preview": "7.0.0-dev.20260628.1",
-    "happy-dom": "^20.10.6",
+    "@typescript/native-preview": "7.0.0-dev.20260707.2",
     "nock": "^14.0.16",
-    "typescript": "^6.0.3",
-    "@scripts/rstest-config": "2.66.0",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.5.0-ultramodern.6"
+    "typescript": "^7.0.2"
   },
   "sideEffects": false,
   "publishConfig": {
-    "registry": "https://registry.npmjs.org/",
     "access": "public"
   },
   "scripts": {