@bleedingdev/modern-js-create-request 3.8.3-ultramodern.6 → 3.9.0-ultramodern.10

package/dist/esm/requestFactory.mjs

@@ -1,150 +1,53 @@
 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 { readHeader, writeHeader } from "./headers.mjs";
 import { getUploadPayload } from "./utiles.mjs";
-const OPERATION_CONTEXT_DETAIL_HEADER = BFF_OPERATION_CONTEXT_DETAIL_HEADER;
+const extractPathParamNames = (path)=>Array.from(path.matchAll(/:([A-Za-z0-9_]+)/g)).flatMap(([, key])=>key ? [
+            key
+        ] : []);
 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({
+    const startRequest = (requestId, hooks)=>{
+        const context = {
             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
-        });
+            incomingHeaders: environment.readIncomingHeaders(),
+            configured: realRequest.has(requestId),
+            configuredDomain: domainMap.get(requestId)
+        };
+        hooks?.onStart?.(context);
+        return context;
     };
-    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 prepareHeaders = (headers, context, hooks)=>{
+        const allowedHeaders = realAllowedHeaders.get(context.requestId) || [];
         const forwardedHeaders = {};
-        if (isServerTarget) for (const key of targetAllowedHeaders){
-            const incomingValue = readHeader(incomingHeaders, key);
-            if (void 0 !== incomingValue) writeHeader(forwardedHeaders, key, incomingValue);
-        }
-        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){
-                    const resolvedValue = readHeader(resolvedHeaders, key);
-                    if (void 0 !== resolvedValue) {
-                        if (identityBindingEnabled && protectedIdentityHeaders.includes(key.toLowerCase())) {
-                            writeHeader(forwardedHeaders, key.toLowerCase(), resolvedValue);
-                            continue;
-                        }
-                        writeHeader(forwardedHeaders, key, resolvedValue);
-                    }
-                }
-            }
+        if (isServerTarget) for (const key of allowedHeaders){
+            const value = readHeader(context.incomingHeaders, key);
+            if (void 0 !== value) writeHeader(forwardedHeaders, key, value);
         }
+        hooks?.prepareHeaders?.({
+            ...context,
+            headers,
+            forwardedHeaders,
+            allowedHeaders
+        });
         if (isServerTarget) for (const [header, value] of Object.entries(forwardedHeaders))writeHeader(headers, header, value);
         return headers;
     };
+    const dispatch = (context, hooks)=>hooks?.dispatch ? hooks.dispatch(context) : context.fetcher(context.url, context.init);
     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);
+        const { request, interceptor, allowedHeaders, setDomain, requestId = 'default' } = options;
         let configuredRequest = request || environment.originFetch;
         if (interceptor && !request) configuredRequest = interceptor(environment.getFetch());
-        let resolvedDomain;
-        if (setDomain) {
-            resolvedDomain = setDomain({
-                target: environment.target,
-                requestId
-            });
-            if ('default' !== requestId && isEmptyDomain(resolvedDomain)) throw new ProducerDomainNotConfiguredError(requestId);
-        }
+        const resolvedDomain = setDomain?.({
+            target: environment.target,
+            requestId
+        });
         realAllowedHeaders.delete(requestId);
-        realResolveHeaders.delete(requestId);
-        realTransportResilience.delete(requestId);
-        realIdentityBinding.delete(requestId);
-        realOperationContract.delete(requestId);
-        realRequireEnvelope.delete(requestId);
-        realAllowCrossOriginEnvelope.delete(requestId);
         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 ('string' == typeof resolvedDomain) domainMap.set(requestId, resolvedDomain);
         realRequest.set(requestId, configuredRequest);
     };
@@ -156,22 +59,21 @@ const createRequestFactory = (environment)=>{
             httpMethodDecider: args[3],
             fetch: args[4],
             requestId: args[5],
-            operationContext: args[6]
+            hooks: args[6]
         };
-        const { path, method, port, httpMethodDecider = 'functionName', fetch = environment.originFetch, domain, requestId = 'default', operationContext } = options;
+        const { path, method, port, httpMethodDecider = 'functionName', fetch = environment.originFetch, domain, requestId = 'default', hooks } = options;
         const getFinalPath = compile(path, {
             encode: encodeURIComponent
         });
         const keyNames = extractPathParamNames(path);
         const send = (...senderArgs)=>{
-            const fetcher = resolveConfiguredRequest(realRequest, requestId, fetch);
-            const incomingHeaders = environment.readIncomingHeaders();
+            const context = startRequest(requestId, hooks);
+            const fetcher = realRequest.get(requestId) || fetch;
             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,
                     domain,
@@ -182,7 +84,7 @@ const createRequestFactory = (environment)=>{
                 headers = {
                     'Content-Type': 'application/json'
                 };
-                headers = applyIdentityAndForwardedHeaders(headers, requestId, incomingHeaders);
+                headers = prepareHeaders(headers, context, hooks);
             } else {
                 const payload = 'object' == typeof senderArgs[senderArgs.length - 1] ? senderArgs[senderArgs.length - 1] : {};
                 payload.params = payload.params || {};
@@ -200,7 +102,7 @@ const createRequestFactory = (environment)=>{
                 headers = payload.headers ? {
                     ...payload.headers
                 } : {};
-                headers = applyIdentityAndForwardedHeaders(headers, requestId, incomingHeaders);
+                headers = prepareHeaders(headers, context, hooks);
                 if (payload.data) {
                     headers['Content-Type'] = 'application/json';
                     body = 'object' == typeof payload.data ? JSON.stringify(payload.data) : payload.body;
@@ -213,7 +115,6 @@ const createRequestFactory = (environment)=>{
                     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,
                     domain,
@@ -222,20 +123,12 @@ const createRequestFactory = (environment)=>{
                 });
             }
             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({
+            return dispatch({
+                ...context,
+                path,
                 requestId,
-                target: environment.target,
                 method,
                 url,
                 init: {
@@ -243,19 +136,19 @@ const createRequestFactory = (environment)=>{
                     body,
                     headers
                 },
-                fetcher: fetcher,
-                transport: realTransportResilience.get(requestId)
-            });
+                fetcher: fetcher
+            }, hooks);
         };
         const sender = isServerTarget ? send : async (...senderArgs)=>send(...senderArgs);
         return sender;
     };
-    const createUploader = ({ path, domain, requestId = 'default', operationContext })=>{
+    const createUploader = ({ path, domain, requestId = 'default', hooks })=>{
         const getUploadPath = isServerTarget ? void 0 : compile(path, {
             encode: encodeURIComponent
         });
         const sender = (...args)=>{
-            const fetcher = resolveConfiguredRequest(realRequest, requestId, environment.originFetch);
+            const context = startRequest(requestId, hooks);
+            const fetcher = realRequest.get(requestId) || environment.originFetch;
             const { body, headers: uploadHeaders, params } = getUploadPayload(args);
             let headers = {
                 ...uploadHeaders
@@ -267,13 +160,11 @@ const createRequestFactory = (environment)=>{
                 domain,
                 path: finalPath
             });
-            const incomingHeaders = environment.readIncomingHeaders();
-            headers = applyIdentityAndForwardedHeaders(headers, requestId, incomingHeaders);
-            attachEnvelopeHeaderIfRequired(headers, requestId, finalURL, incomingHeaders);
-            attachSecuredOperationHeaders(headers, requestId, 'POST', path, operationContext);
-            return executeWithResilience({
+            headers = prepareHeaders(headers, context, hooks);
+            return dispatch({
+                ...context,
+                path,
                 requestId,
-                target: environment.target,
                 method: 'POST',
                 url: finalURL,
                 init: {
@@ -281,9 +172,8 @@ const createRequestFactory = (environment)=>{
                     body,
                     headers
                 },
-                fetcher: fetcher,
-                transport: realTransportResilience.get(requestId)
-            });
+                fetcher: fetcher
+            }, hooks);
         };
         return sender;
     };
@@ -293,4 +183,4 @@ const createRequestFactory = (environment)=>{
         createUploader
     };
 };
-export { createRequestFactory };
+export { createRequestFactory, extractPathParamNames };

package/dist/esm/types.mjs

@@ -1,10 +0,0 @@
-const BFF_ENVELOPE_HEADER = 'x-modernjs-bff-envelope';
-const BFF_OPERATION_CONTEXT_HEADER = 'x-operation-id';
-const BFF_OPERATION_CONTEXT_DETAIL_HEADER = 'x-modernjs-bff-operation-context';
-const BFF_DEFAULT_PROTECTED_IDENTITY_HEADERS = [
-    'x-tenant-id',
-    'x-subject-id',
-    'x-user-id',
-    BFF_OPERATION_CONTEXT_HEADER
-];
-export { BFF_DEFAULT_PROTECTED_IDENTITY_HEADERS, BFF_ENVELOPE_HEADER, BFF_OPERATION_CONTEXT_DETAIL_HEADER, BFF_OPERATION_CONTEXT_HEADER };

package/dist/esm-node/browser.mjs

@@ -1,27 +1,22 @@
 import "node:module";
 import { handleRes } from "./handleRes.mjs";
 import { createRequestFactory } from "./requestFactory.mjs";
-export * from "./requestContext.mjs";
-export * from "./traceparent.mjs";
 export * from "./types.mjs";
-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 requestFactory = createRequestFactory({
-    target: 'browser',
-    getFetch: ()=>fetch,
-    originFetch: originFetch,
-    readIncomingHeaders: ()=>({}),
-    resolveSourceOrigin: resolveBrowserOrigin,
-    createInputParamsBody: (args)=>JSON.stringify({
-            args
-        }),
-    resolveRequestUrl: ({ configDomain, domain, path })=>`${configDomain || domain || ''}${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 };
+const createClient = ()=>createRequestFactory({
+        target: 'browser',
+        getFetch: ()=>fetch,
+        originFetch: originFetch,
+        readIncomingHeaders: ()=>({}),
+        createInputParamsBody: (args)=>JSON.stringify({
+                args
+            }),
+        resolveRequestUrl: ({ configDomain, domain, path })=>`${configDomain || domain || ''}${path}`,
+        resolveUploadUrl: ({ configDomain, domain, path })=>`${configDomain || domain || ''}${path}`
+    });
+const { configure: configure, createRequest: createRequest, createUploader: createUploader } = createClient();
+export { configure, createClient, createRequest, createUploader };

package/dist/esm-node/headers.mjs

@@ -0,0 +1,16 @@
+import "node:module";
+const findHeaderKey = (headers, header)=>{
+    const normalized = header.toLowerCase();
+    return Object.keys(headers).find((key)=>key.toLowerCase() === normalized);
+};
+const readHeader = (headers, header)=>{
+    const key = findHeaderKey(headers, header);
+    return 'string' == typeof key ? headers[key] : void 0;
+};
+const writeHeader = (headers, header, value)=>{
+    if (void 0 === value) return;
+    const key = findHeaderKey(headers, header);
+    if ('string' == typeof key && key !== header) delete headers[key];
+    headers[header] = value;
+};
+export { findHeaderKey, readHeader, writeHeader };

package/dist/esm-node/node.mjs

@@ -1,21 +1,8 @@
 import "node:module";
 import { storage } from "@modern-js/runtime-utils/node";
 import { handleRes } from "./handleRes.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 resolveSourceOrigin = (headers)=>{
-    const origin = toOrigin(firstHeaderValue(headers.origin));
-    if (origin) return origin;
-    const referer = toOrigin(firstHeaderValue(headers.referer));
-    if (referer) return referer;
-    const host = firstHeaderValue(headers.host);
-    if (!host) return;
-    const proto = firstHeaderValue(headers['x-forwarded-proto']) || 'http';
-    return `${proto}://${host}`;
-};
 const readIncomingWebHeaders = ()=>{
     try {
         return storage.useContext().headers || {};
@@ -28,15 +15,14 @@ const originFetch = (...params)=>{
     if (init?.method?.toLowerCase() === 'get') init.body = void 0;
     return fetch(...params).then(handleRes);
 };
-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 };
+const createClient = ()=>createRequestFactory({
+        target: 'server',
+        getFetch: ()=>fetch,
+        originFetch: originFetch,
+        readIncomingHeaders: readIncomingWebHeaders,
+        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 } = createClient();
+export { configure, createClient, createRequest, createUploader };