@webpieces/http-client 0.2.16 → 0.2.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webpieces/http-client",
-  "version": "0.2.16",
+  "version": "0.2.21",
   "description": "HTTP client for WebPieces framework",
   "type": "commonjs",
   "main": "./src/index.js",
@@ -21,6 +21,6 @@
     "access": "public"
   },
   "dependencies": {
-    "@webpieces/http-api": "0.2.16"
+    "@webpieces/http-api": "0.2.21"
   }
 }

package/src/ClientErrorTranslator.d.ts

@@ -0,0 +1,37 @@
+import { ProtocolError } from '@webpieces/http-api';
+/**
+ * ClientErrorTranslator - Translates HTTP error responses to HttpError exceptions.
+ *
+ * This is the CLIENT-SIDE reverse of ExpressWrapper.handleError() on the server.
+ * It reconstructs typed HttpError exceptions from ProtocolError JSON responses.
+ *
+ * Architecture:
+ * - Server: HttpError → ExpressWrapper.handleError() → ProtocolError JSON
+ * - Client: ProtocolError JSON → ClientErrorTranslator.translateError() → HttpError
+ *
+ * This achieves symmetric error handling - server throws typed exceptions,
+ * client receives typed exceptions.
+ */
+export declare class ClientErrorTranslator {
+    /**
+     * Parse error response and reconstruct appropriate HttpError subclass.
+     *
+     * Maps HTTP status codes to error types (symmetric with server):
+     * - 400 → HttpBadRequestError (with field, guiAlertMessage)
+     * - 266 → HttpUserError (with errorCode) - 2xx code for user validation
+     * - 401 → HttpUnauthorizedError
+     * - 403 → HttpForbiddenError
+     * - 404 → HttpNotFoundError
+     * - 408 → HttpTimeoutError
+     * - 500 → HttpInternalServerError
+     * - 502 → HttpBadGatewayError
+     * - 504 → HttpGatewayTimeoutError
+     * - 598 → HttpVendorError (with waitSeconds) - custom status code
+     * - other → generic HttpError
+     *
+     * @param response - Fetch Response object
+     * @param protocolError - Parsed ProtocolError from response body
+     * @returns HttpError subclass instance
+     */
+    static translateError(response: Response, protocolError: ProtocolError): Error;
+}

package/src/ClientErrorTranslator.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientErrorTranslator = void 0;
+const http_api_1 = require("@webpieces/http-api");
+/**
+ * ClientErrorTranslator - Translates HTTP error responses to HttpError exceptions.
+ *
+ * This is the CLIENT-SIDE reverse of ExpressWrapper.handleError() on the server.
+ * It reconstructs typed HttpError exceptions from ProtocolError JSON responses.
+ *
+ * Architecture:
+ * - Server: HttpError → ExpressWrapper.handleError() → ProtocolError JSON
+ * - Client: ProtocolError JSON → ClientErrorTranslator.translateError() → HttpError
+ *
+ * This achieves symmetric error handling - server throws typed exceptions,
+ * client receives typed exceptions.
+ */
+class ClientErrorTranslator {
+    /**
+     * Parse error response and reconstruct appropriate HttpError subclass.
+     *
+     * Maps HTTP status codes to error types (symmetric with server):
+     * - 400 → HttpBadRequestError (with field, guiAlertMessage)
+     * - 266 → HttpUserError (with errorCode) - 2xx code for user validation
+     * - 401 → HttpUnauthorizedError
+     * - 403 → HttpForbiddenError
+     * - 404 → HttpNotFoundError
+     * - 408 → HttpTimeoutError
+     * - 500 → HttpInternalServerError
+     * - 502 → HttpBadGatewayError
+     * - 504 → HttpGatewayTimeoutError
+     * - 598 → HttpVendorError (with waitSeconds) - custom status code
+     * - other → generic HttpError
+     *
+     * @param response - Fetch Response object
+     * @param protocolError - Parsed ProtocolError from response body
+     * @returns HttpError subclass instance
+     */
+    static translateError(response, protocolError) {
+        const statusCode = response.status;
+        const message = protocolError.message || response.statusText || 'Unknown error';
+        const subType = protocolError.subType;
+        // Map status codes to error types (symmetric with server's ExpressWrapper.handleError())
+        switch (statusCode) {
+            case 400:
+                return new http_api_1.HttpBadRequestError(message, protocolError.field, protocolError.guiAlertMessage);
+            case 266: // HttpUserError - 2xx code for user validation errors
+                return new http_api_1.HttpUserError(message, protocolError.errorCode);
+            case 401:
+                return new http_api_1.HttpUnauthorizedError(message, subType);
+            case 403:
+                return new http_api_1.HttpForbiddenError(message);
+            case 404:
+                return new http_api_1.HttpNotFoundError(message);
+            case 408:
+                return new http_api_1.HttpTimeoutError(message);
+            case 500:
+                return new http_api_1.HttpInternalServerError(message);
+            case 502:
+                return new http_api_1.HttpBadGatewayError(message);
+            case 504:
+                return new http_api_1.HttpGatewayTimeoutError(message);
+            case 598: // HttpVendorError - custom status code for vendor/external service errors
+                return new http_api_1.HttpVendorError(message, protocolError.waitSeconds);
+            default:
+                // Unknown status code - return generic HttpError
+                return new Error(` could not translate statusCode=${statusCode}`);
+        }
+    }
+}
+exports.ClientErrorTranslator = ClientErrorTranslator;
+//# sourceMappingURL=ClientErrorTranslator.js.map

package/src/ClientErrorTranslator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClientErrorTranslator.js","sourceRoot":"","sources":["../../../../../packages/http/http-client/src/ClientErrorTranslator.ts"],"names":[],"mappings":";;;AAAA,kDAa6B;AAE7B;;;;;;;;;;;;GAYG;AACH,MAAa,qBAAqB;IAC9B;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,CAAC,cAAc,CAAC,QAAkB,EAAE,aAA4B;QAClE,MAAM,UAAU,GAAG,QAAQ,CAAC,MAAM,CAAC;QACnC,MAAM,OAAO,GAAG,aAAa,CAAC,OAAO,IAAI,QAAQ,CAAC,UAAU,IAAI,eAAe,CAAC;QAChF,MAAM,OAAO,GAAG,aAAa,CAAC,OAAO,CAAC;QAEtC,yFAAyF;QACzF,QAAQ,UAAU,EAAE,CAAC;YACjB,KAAK,GAAG;gBACJ,OAAO,IAAI,8BAAmB,CAC1B,OAAO,EACP,aAAa,CAAC,KAAK,EACnB,aAAa,CAAC,eAAe,CAChC,CAAC;YAEN,KAAK,GAAG,EAAE,sDAAsD;gBAC5D,OAAO,IAAI,wBAAa,CAAC,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,CAAC;YAE/D,KAAK,GAAG;gBACJ,OAAO,IAAI,gCAAqB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;YAEvD,KAAK,GAAG;gBACJ,OAAO,IAAI,6BAAkB,CAAC,OAAO,CAAC,CAAC;YAE3C,KAAK,GAAG;gBACJ,OAAO,IAAI,4BAAiB,CAAC,OAAO,CAAC,CAAC;YAE1C,KAAK,GAAG;gBACJ,OAAO,IAAI,2BAAgB,CAAC,OAAO,CAAC,CAAC;YAEzC,KAAK,GAAG;gBACJ,OAAO,IAAI,kCAAuB,CAAC,OAAO,CAAC,CAAC;YAEhD,KAAK,GAAG;gBACJ,OAAO,IAAI,8BAAmB,CAAC,OAAO,CAAC,CAAC;YAE5C,KAAK,GAAG;gBACJ,OAAO,IAAI,kCAAuB,CAAC,OAAO,CAAC,CAAC;YAEhD,KAAK,GAAG,EAAE,0EAA0E;gBAChF,OAAO,IAAI,0BAAe,CAAC,OAAO,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC;YAEnE;gBACI,iDAAiD;gBACjD,OAAO,IAAI,KAAK,CAAC,mCAAmC,UAAU,EAAE,CAAC,CAAC;QAC1E,CAAC;IACL,CAAC;CACJ;AAnED,sDAmEC","sourcesContent":["import {\n    ProtocolError,\n    HttpError,\n    HttpBadRequestError,\n    HttpUserError,\n    HttpVendorError,\n    HttpUnauthorizedError,\n    HttpForbiddenError,\n    HttpNotFoundError,\n    HttpTimeoutError,\n    HttpInternalServerError,\n    HttpBadGatewayError,\n    HttpGatewayTimeoutError,\n} from '@webpieces/http-api';\n\n/**\n * ClientErrorTranslator - Translates HTTP error responses to HttpError exceptions.\n *\n * This is the CLIENT-SIDE reverse of ExpressWrapper.handleError() on the server.\n * It reconstructs typed HttpError exceptions from ProtocolError JSON responses.\n *\n * Architecture:\n * - Server: HttpError → ExpressWrapper.handleError() → ProtocolError JSON\n * - Client: ProtocolError JSON → ClientErrorTranslator.translateError() → HttpError\n *\n * This achieves symmetric error handling - server throws typed exceptions,\n * client receives typed exceptions.\n */\nexport class ClientErrorTranslator {\n    /**\n     * Parse error response and reconstruct appropriate HttpError subclass.\n     *\n     * Maps HTTP status codes to error types (symmetric with server):\n     * - 400 → HttpBadRequestError (with field, guiAlertMessage)\n     * - 266 → HttpUserError (with errorCode) - 2xx code for user validation\n     * - 401 → HttpUnauthorizedError\n     * - 403 → HttpForbiddenError\n     * - 404 → HttpNotFoundError\n     * - 408 → HttpTimeoutError\n     * - 500 → HttpInternalServerError\n     * - 502 → HttpBadGatewayError\n     * - 504 → HttpGatewayTimeoutError\n     * - 598 → HttpVendorError (with waitSeconds) - custom status code\n     * - other → generic HttpError\n     *\n     * @param response - Fetch Response object\n     * @param protocolError - Parsed ProtocolError from response body\n     * @returns HttpError subclass instance\n     */\n    static translateError(response: Response, protocolError: ProtocolError): Error {\n        const statusCode = response.status;\n        const message = protocolError.message || response.statusText || 'Unknown error';\n        const subType = protocolError.subType;\n\n        // Map status codes to error types (symmetric with server's ExpressWrapper.handleError())\n        switch (statusCode) {\n            case 400:\n                return new HttpBadRequestError(\n                    message,\n                    protocolError.field,\n                    protocolError.guiAlertMessage,\n                );\n\n            case 266: // HttpUserError - 2xx code for user validation errors\n                return new HttpUserError(message, protocolError.errorCode);\n\n            case 401:\n                return new HttpUnauthorizedError(message, subType);\n\n            case 403:\n                return new HttpForbiddenError(message);\n\n            case 404:\n                return new HttpNotFoundError(message);\n\n            case 408:\n                return new HttpTimeoutError(message);\n\n            case 500:\n                return new HttpInternalServerError(message);\n\n            case 502:\n                return new HttpBadGatewayError(message);\n\n            case 504:\n                return new HttpGatewayTimeoutError(message);\n\n            case 598: // HttpVendorError - custom status code for vendor/external service errors\n                return new HttpVendorError(message, protocolError.waitSeconds);\n\n            default:\n                // Unknown status code - return generic HttpError\n                return new Error(` could not translate statusCode=${statusCode}`);\n        }\n    }\n}\n"]}

package/src/ClientFactory.d.ts

@@ -1,10 +1,17 @@
+import { RouteMetadata, HeaderMethods, LogApiCall } from '@webpieces/http-api';
+import { ContextMgr } from './ContextMgr';
 /**
  * Configuration options for HTTP client.
  */
 export declare class ClientConfig {
     /** Base URL for all requests (e.g., 'http://localhost:3000') */
     baseUrl: string;
-    constructor(baseUrl: string);
+    /**
+     * Optional context manager for automatic header propagation.
+     * When provided, headers will be read from the ContextReader and added to requests.
+     */
+    contextMgr?: ContextMgr;
+    constructor(baseUrl: string, contextMgr?: ContextMgr);
 }
 /**
  * Creates a type-safe HTTP client from an API interface prototype.
@@ -22,8 +29,56 @@ export declare class ClientConfig {
  *
  * @param apiPrototype - The API prototype class with decorators (e.g., SaveApiPrototype)
  * @param config - Client configuration with baseUrl
+ * @param logApiCall - Optional LogApiCall instance (creates new one if not provided)
  * @returns A proxy object that implements the API interface
  */
 export declare function createClient<T extends object>(apiPrototype: Function & {
     prototype: T;
-}, config: ClientConfig): T;
+}, config: ClientConfig, contextMgr?: ContextMgr): T;
+/**
+ * ProxyClient - HTTP client implementation with logging.
+ *
+ * This class handles:
+ * - Making HTTP requests based on route metadata
+ * - Header propagation via ContextMgr
+ * - Logging via LogApiCall
+ * - Error translation via ClientErrorTranslator
+ *
+ * LogApiCall is injected for consistent logging across the framework.
+ */
+export declare class ProxyClient {
+    private config;
+    private logApiCall;
+    private headerMethods;
+    private contextMgr?;
+    private routeMap;
+    constructor(config: ClientConfig, logApiCall: LogApiCall, headerMethods: HeaderMethods, routes: RouteMetadata[], contextMgr?: ContextMgr | undefined);
+    /**
+     * Get route metadata for a method name.
+     * @throws Error if no route found
+     */
+    getRoute(methodName: string): RouteMetadata;
+    /**
+     * Make an HTTP request based on route metadata and arguments.
+     *
+     * Uses plain JSON.stringify/parse - no serialization library needed!
+     *
+     * Error handling:
+     * - Server: Throws HttpError → translates to ProtocolError JSON
+     * - Client: Receives ProtocolError JSON → reconstructs HttpError
+     *
+     * Automatic header propagation via ContextMgr:
+     * - If config.contextMgr is provided, reads headers from ContextReader
+     * - Adds headers to request before fetch()
+     *
+     * Logging via LogApiCall.execute():
+     * - [API-CLIENT-req] logs outgoing requests with headers (secure ones masked)
+     * - [API-CLIENT-resp-SUCCESS] logs successful responses
+     * - [API-CLIENT-resp-FAIL] logs failed responses
+     */
+    makeRequest(route: RouteMetadata, args: any[]): Promise<any>;
+    /**
+     * Execute the fetch request and handle response.
+     */
+    private executeFetch;
+}

package/src/ClientFactory.js

@@ -1,14 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClientConfig = void 0;
+exports.ProxyClient = exports.ClientConfig = void 0;
 exports.createClient = createClient;
 const http_api_1 = require("@webpieces/http-api");
+const ClientErrorTranslator_1 = require("./ClientErrorTranslator");
 /**
  * Configuration options for HTTP client.
  */
 class ClientConfig {
-    constructor(baseUrl) {
+    constructor(baseUrl, contextMgr) {
         this.baseUrl = baseUrl;
+        this.contextMgr = contextMgr;
     }
 }
 exports.ClientConfig = ClientConfig;
@@ -28,9 +30,10 @@ exports.ClientConfig = ClientConfig;
  *
  * @param apiPrototype - The API prototype class with decorators (e.g., SaveApiPrototype)
  * @param config - Client configuration with baseUrl
+ * @param logApiCall - Optional LogApiCall instance (creates new one if not provided)
  * @returns A proxy object that implements the API interface
  */
-function createClient(apiPrototype, config) {
+function createClient(apiPrototype, config, contextMgr) {
     // Validate that the API prototype is marked with @ApiInterface
     if (!(0, http_api_1.isApiInterface)(apiPrototype)) {
         const className = apiPrototype.name || 'Unknown';
@@ -38,11 +41,9 @@ function createClient(apiPrototype, config) {
     }
     // Get all routes from the API prototype
     const routes = (0, http_api_1.getRoutes)(apiPrototype);
-    // Create a map of method name -> route metadata for fast lookup
-    const routeMap = new Map();
-    for (const route of routes) {
-        routeMap.set(route.methodName, route);
-    }
+    // Create ProxyClient with injected LogApiCall (or create new one)
+    //CRAP our own little DI going on here as angular and nodejs are using 2 different DI systems!!! fuck!!
+    const proxyClient = new ProxyClient(config, new http_api_1.LogApiCall(), new http_api_1.HeaderMethods(), routes, contextMgr);
     // Create a proxy that intercepts method calls and makes HTTP requests
     return new Proxy({}, {
         get(target, prop) {
@@ -51,45 +52,119 @@ function createClient(apiPrototype, config) {
                 return undefined;
             }
             // Get the route metadata for this method
-            const route = routeMap.get(prop);
-            if (!route) {
-                throw new Error(`No route found for method ${prop}`);
-            }
+            const route = proxyClient.getRoute(prop);
             // Return a function that makes the HTTP request
             return async (...args) => {
-                return makeRequest(config, route, args);
+                return proxyClient.makeRequest(route, args);
             };
         },
     });
 }
 /**
- * Make an HTTP request based on route metadata and arguments.
+ * ProxyClient - HTTP client implementation with logging.
+ *
+ * This class handles:
+ * - Making HTTP requests based on route metadata
+ * - Header propagation via ContextMgr
+ * - Logging via LogApiCall
+ * - Error translation via ClientErrorTranslator
+ *
+ * LogApiCall is injected for consistent logging across the framework.
  */
-async function makeRequest(config, route, args) {
-    const { httpMethod, path } = route;
-    // Build the full URL
-    const url = `${config.baseUrl}${path}`;
-    // Build headers
-    const headers = {
-        'Content-Type': 'application/json',
-    };
-    // Build request options
-    const options = {
-        method: httpMethod,
-        headers,
-    };
-    // For POST/PUT/PATCH, include the body (first argument)
-    if (['POST', 'PUT', 'PATCH'].includes(httpMethod) && args.length > 0) {
-        options.body = JSON.stringify(args[0]);
+class ProxyClient {
+    constructor(config, logApiCall, headerMethods, routes, contextMgr) {
+        this.config = config;
+        this.logApiCall = logApiCall;
+        this.headerMethods = headerMethods;
+        this.contextMgr = contextMgr;
+        // Create a map of method name -> route metadata for fast lookup
+        this.routeMap = new Map();
+        for (const route of routes) {
+            this.routeMap.set(route.methodName, route);
+        }
+    }
+    /**
+     * Get route metadata for a method name.
+     * @throws Error if no route found
+     */
+    getRoute(methodName) {
+        const route = this.routeMap.get(methodName);
+        if (!route) {
+            throw new Error(`No route found for method ${methodName}`);
+        }
+        return route;
+    }
+    /**
+     * Make an HTTP request based on route metadata and arguments.
+     *
+     * Uses plain JSON.stringify/parse - no serialization library needed!
+     *
+     * Error handling:
+     * - Server: Throws HttpError → translates to ProtocolError JSON
+     * - Client: Receives ProtocolError JSON → reconstructs HttpError
+     *
+     * Automatic header propagation via ContextMgr:
+     * - If config.contextMgr is provided, reads headers from ContextReader
+     * - Adds headers to request before fetch()
+     *
+     * Logging via LogApiCall.execute():
+     * - [API-CLIENT-req] logs outgoing requests with headers (secure ones masked)
+     * - [API-CLIENT-resp-SUCCESS] logs successful responses
+     * - [API-CLIENT-resp-FAIL] logs failed responses
+     */
+    async makeRequest(route, args) {
+        const { httpMethod, path } = route;
+        // Build the full URL
+        const url = `${this.config.baseUrl}${path}`;
+        // Build base headers for the HTTP request
+        const httpHeaders = {
+            'Content-Type': 'application/json',
+        };
+        // Add context headers to httpHeaders (unmasked, for actual HTTP request)
+        if (this.contextMgr) {
+            for (const header of this.contextMgr.headerSet) {
+                const value = this.contextMgr.contextReader.read(header);
+                if (value) {
+                    httpHeaders[header.headerName] = value;
+                }
+            }
+        }
+        // Build masked headers map for logging
+        const headersForLogging = this.contextMgr
+            ? this.headerMethods.buildSecureMapForLogs(this.contextMgr.headerSet, this.contextMgr.contextReader)
+            : new Map();
+        // Build request options
+        const options = {
+            method: httpMethod,
+            headers: httpHeaders,
+        };
+        // For POST/PUT/PATCH, include the body (first argument) as JSON
+        let requestDto;
+        if (['POST', 'PUT', 'PATCH'].includes(httpMethod) && args.length > 0) {
+            requestDto = args[0];
+            // Plain JSON stringify - works with plain objects and our DateTimeDto classes
+            options.body = JSON.stringify(requestDto);
+        }
+        // Wrap fetch in a method for LogApiCall.execute
+        const method = async () => {
+            return this.executeFetch(url, options);
+        };
+        return await this.logApiCall.execute("CLIENT", route, requestDto, headersForLogging, method);
     }
-    // Make the HTTP request
-    const response = await fetch(url, options);
-    // Check for HTTP errors
-    if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(`HTTP ${response.status}: ${response.statusText}. ${errorText}`);
+    /**
+     * Execute the fetch request and handle response.
+     */
+    async executeFetch(url, options) {
+        const response = await fetch(url, options);
+        if (response.ok) {
+            return await response.json();
+        }
+        // Handle errors (non-2xx responses)
+        // Try to parse ProtocolError from response body
+        const protocolError = (await response.json());
+        // Reconstruct appropriate HttpError subclass and throw
+        throw ClientErrorTranslator_1.ClientErrorTranslator.translateError(response, protocolError);
     }
-    // Parse and return the JSON response
-    return response.json();
 }
+exports.ProxyClient = ProxyClient;
 //# sourceMappingURL=ClientFactory.js.map

package/src/ClientFactory.js.map

@@ -1 +1 @@
-{"version":3,"file":"ClientFactory.js","sourceRoot":"","sources":["../../../../../packages/http/http-client/src/ClientFactory.ts"],"names":[],"mappings":";;;AAgCA,oCAuCC;AAvED,kDAA+E;AAE/E;;GAEG;AACH,MAAa,YAAY;IAIrB,YAAY,OAAe;QACvB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IAC3B,CAAC;CACJ;AAPD,oCAOC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,SAAgB,YAAY,CACxB,YAAyC,EACzC,MAAoB;IAEpB,+DAA+D;IAC/D,IAAI,CAAC,IAAA,yBAAc,EAAC,YAAY,CAAC,EAAE,CAAC;QAChC,MAAM,SAAS,GAAG,YAAY,CAAC,IAAI,IAAI,SAAS,CAAC;QACjD,MAAM,IAAI,KAAK,CAAC,SAAS,SAAS,yCAAyC,CAAC,CAAC;IACjF,CAAC;IAED,wCAAwC;IACxC,MAAM,MAAM,GAAG,IAAA,oBAAS,EAAC,YAAY,CAAC,CAAC;IAEvC,gEAAgE;IAChE,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAyB,CAAC;IAClD,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QACzB,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;IAC1C,CAAC;IAED,sEAAsE;IACtE,OAAO,IAAI,KAAK,CAAC,EAAO,EAAE;QACtB,GAAG,CAAC,MAAM,EAAE,IAAqB;YAC7B,+CAA+C;YAC/C,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;gBAC3B,OAAO,SAAS,CAAC;YACrB,CAAC;YAED,yCAAyC;YACzC,MAAM,KAAK,GAAG,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YACjC,IAAI,CAAC,KAAK,EAAE,CAAC;gBACT,MAAM,IAAI,KAAK,CAAC,6BAA6B,IAAI,EAAE,CAAC,CAAC;YACzD,CAAC;YAED,gDAAgD;YAChD,OAAO,KAAK,EAAE,GAAG,IAAW,EAAE,EAAE;gBAC5B,OAAO,WAAW,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;YAC5C,CAAC,CAAC;QACN,CAAC;KACJ,CAAC,CAAC;AACP,CAAC;AAED;;GAEG;AACH,KAAK,UAAU,WAAW,CAAC,MAAoB,EAAE,KAAoB,EAAE,IAAW;IAC9E,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,GAAG,KAAK,CAAC;IAEnC,qBAAqB;IACrB,MAAM,GAAG,GAAG,GAAG,MAAM,CAAC,OAAO,GAAG,IAAI,EAAE,CAAC;IAEvC,gBAAgB;IAChB,MAAM,OAAO,GAA2B;QACpC,cAAc,EAAE,kBAAkB;KACrC,CAAC;IAEF,wBAAwB;IACxB,MAAM,OAAO,GAAgB;QACzB,MAAM,EAAE,UAAU;QAClB,OAAO;KACV,CAAC;IAEF,wDAAwD;IACxD,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACnE,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3C,CAAC;IAED,wBAAwB;IACxB,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;IAE3C,wBAAwB;IACxB,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;QACf,MAAM,SAAS,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC;QACxC,MAAM,IAAI,KAAK,CAAC,QAAQ,QAAQ,CAAC,MAAM,KAAK,QAAQ,CAAC,UAAU,KAAK,SAAS,EAAE,CAAC,CAAC;IACrF,CAAC;IAED,qCAAqC;IACrC,OAAO,QAAQ,CAAC,IAAI,EAAE,CAAC;AAC3B,CAAC","sourcesContent":["import { getRoutes, isApiInterface, RouteMetadata } from '@webpieces/http-api';\n\n/**\n * Configuration options for HTTP client.\n */\nexport class ClientConfig {\n    /** Base URL for all requests (e.g., 'http://localhost:3000') */\n    baseUrl: string;\n\n    constructor(baseUrl: string) {\n        this.baseUrl = baseUrl;\n    }\n}\n\n/**\n * Creates a type-safe HTTP client from an API interface prototype.\n *\n * This is the client-side equivalent of RESTApiRoutes.\n * - Server: RESTApiRoutes reads decorators → routes HTTP requests to controllers\n * - Client: createClient reads decorators → generates HTTP requests from method calls\n *\n * Usage:\n * ```typescript\n * const config = new ClientConfig('http://localhost:3000');\n * const client = createClient(SaveApiPrototype, config);\n * const response = await client.save({ query: 'test' }); // Type-safe!\n * ```\n *\n * @param apiPrototype - The API prototype class with decorators (e.g., SaveApiPrototype)\n * @param config - Client configuration with baseUrl\n * @returns A proxy object that implements the API interface\n */\nexport function createClient<T extends object>(\n    apiPrototype: Function & { prototype: T },\n    config: ClientConfig,\n): T {\n    // Validate that the API prototype is marked with @ApiInterface\n    if (!isApiInterface(apiPrototype)) {\n        const className = apiPrototype.name || 'Unknown';\n        throw new Error(`Class ${className} must be decorated with @ApiInterface()`);\n    }\n\n    // Get all routes from the API prototype\n    const routes = getRoutes(apiPrototype);\n\n    // Create a map of method name -> route metadata for fast lookup\n    const routeMap = new Map<string, RouteMetadata>();\n    for (const route of routes) {\n        routeMap.set(route.methodName, route);\n    }\n\n    // Create a proxy that intercepts method calls and makes HTTP requests\n    return new Proxy({} as T, {\n        get(target, prop: string | symbol) {\n            // Only handle string properties (method names)\n            if (typeof prop !== 'string') {\n                return undefined;\n            }\n\n            // Get the route metadata for this method\n            const route = routeMap.get(prop);\n            if (!route) {\n                throw new Error(`No route found for method ${prop}`);\n            }\n\n            // Return a function that makes the HTTP request\n            return async (...args: any[]) => {\n                return makeRequest(config, route, args);\n            };\n        },\n    });\n}\n\n/**\n * Make an HTTP request based on route metadata and arguments.\n */\nasync function makeRequest(config: ClientConfig, route: RouteMetadata, args: any[]): Promise<any> {\n    const { httpMethod, path } = route;\n\n    // Build the full URL\n    const url = `${config.baseUrl}${path}`;\n\n    // Build headers\n    const headers: Record<string, string> = {\n        'Content-Type': 'application/json',\n    };\n\n    // Build request options\n    const options: RequestInit = {\n        method: httpMethod,\n        headers,\n    };\n\n    // For POST/PUT/PATCH, include the body (first argument)\n    if (['POST', 'PUT', 'PATCH'].includes(httpMethod) && args.length > 0) {\n        options.body = JSON.stringify(args[0]);\n    }\n\n    // Make the HTTP request\n    const response = await fetch(url, options);\n\n    // Check for HTTP errors\n    if (!response.ok) {\n        const errorText = await response.text();\n        throw new Error(`HTTP ${response.status}: ${response.statusText}. ${errorText}`);\n    }\n\n    // Parse and return the JSON response\n    return response.json();\n}\n"]}
+{"version":3,"file":"ClientFactory.js","sourceRoot":"","sources":["../../../../../packages/http/http-client/src/ClientFactory.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    getRoutes,\n    isApiInterface,\n    RouteMetadata,\n    ProtocolError,\n    HeaderMethods,\n    LogApiCall,\n} from '@webpieces/http-api';\nimport { ClientErrorTranslator } from './ClientErrorTranslator';\nimport { ContextMgr } from './ContextMgr';\n\n/**\n * Configuration options for HTTP client.\n */\nexport class ClientConfig {\n    /** Base URL for all requests (e.g., 'http://localhost:3000') */\n    baseUrl: string;\n\n    /**\n     * Optional context manager for automatic header propagation.\n     * When provided, headers will be read from the ContextReader and added to requests.\n     */\n    contextMgr?: ContextMgr;\n\n    constructor(baseUrl: string, contextMgr?: ContextMgr) {\n        this.baseUrl = baseUrl;\n        this.contextMgr = contextMgr;\n    }\n}\n\n/**\n * Creates a type-safe HTTP client from an API interface prototype.\n *\n * This is the client-side equivalent of RESTApiRoutes.\n * - Server: RESTApiRoutes reads decorators → routes HTTP requests to controllers\n * - Client: createClient reads decorators → generates HTTP requests from method calls\n *\n * Usage:\n * ```typescript\n * const config = new ClientConfig('http://localhost:3000');\n * const client = createClient(SaveApiPrototype, config);\n * const response = await client.save({ query: 'test' }); // Type-safe!\n * ```\n *\n * @param apiPrototype - The API prototype class with decorators (e.g., SaveApiPrototype)\n * @param config - Client configuration with baseUrl\n * @param logApiCall - Optional LogApiCall instance (creates new one if not provided)\n * @returns A proxy object that implements the API interface\n */\nexport function createClient<T extends object>(\n    apiPrototype: Function & { prototype: T },\n    config: ClientConfig,\n    contextMgr?: ContextMgr\n): T {\n    // Validate that the API prototype is marked with @ApiInterface\n    if (!isApiInterface(apiPrototype)) {\n        const className = apiPrototype.name || 'Unknown';\n        throw new Error(`Class ${className} must be decorated with @ApiInterface()`);\n    }\n\n    // Get all routes from the API prototype\n    const routes = getRoutes(apiPrototype);\n\n    // Create ProxyClient with injected LogApiCall (or create new one)\n    //CRAP our own little DI going on here as angular and nodejs are using 2 different DI systems!!! fuck!!\n    const proxyClient = new ProxyClient(\n        config, new LogApiCall(), new HeaderMethods(), routes, contextMgr);\n\n    // Create a proxy that intercepts method calls and makes HTTP requests\n    return new Proxy({} as T, {\n        get(target, prop: string | symbol) {\n            // Only handle string properties (method names)\n            if (typeof prop !== 'string') {\n                return undefined;\n            }\n\n            // Get the route metadata for this method\n            const route = proxyClient.getRoute(prop);\n\n            // Return a function that makes the HTTP request\n            return async (...args: any[]) => {\n                return proxyClient.makeRequest(route, args);\n            };\n        },\n    });\n}\n\n/**\n * ProxyClient - HTTP client implementation with logging.\n *\n * This class handles:\n * - Making HTTP requests based on route metadata\n * - Header propagation via ContextMgr\n * - Logging via LogApiCall\n * - Error translation via ClientErrorTranslator\n *\n * LogApiCall is injected for consistent logging across the framework.\n */\nexport class ProxyClient {\n    private routeMap: Map<string, RouteMetadata>;\n\n    constructor(\n        private config: ClientConfig,\n        private logApiCall: LogApiCall,\n        private headerMethods: HeaderMethods,\n        routes: RouteMetadata[],\n        private contextMgr?: ContextMgr,\n    ) {\n        // Create a map of method name -> route metadata for fast lookup\n        this.routeMap = new Map<string, RouteMetadata>();\n        for (const route of routes) {\n            this.routeMap.set(route.methodName, route);\n        }\n    }\n\n    /**\n     * Get route metadata for a method name.\n     * @throws Error if no route found\n     */\n    getRoute(methodName: string): RouteMetadata {\n        const route = this.routeMap.get(methodName);\n        if (!route) {\n            throw new Error(`No route found for method ${methodName}`);\n        }\n        return route;\n    }\n\n    /**\n     * Make an HTTP request based on route metadata and arguments.\n     *\n     * Uses plain JSON.stringify/parse - no serialization library needed!\n     *\n     * Error handling:\n     * - Server: Throws HttpError → translates to ProtocolError JSON\n     * - Client: Receives ProtocolError JSON → reconstructs HttpError\n     *\n     * Automatic header propagation via ContextMgr:\n     * - If config.contextMgr is provided, reads headers from ContextReader\n     * - Adds headers to request before fetch()\n     *\n     * Logging via LogApiCall.execute():\n     * - [API-CLIENT-req] logs outgoing requests with headers (secure ones masked)\n     * - [API-CLIENT-resp-SUCCESS] logs successful responses\n     * - [API-CLIENT-resp-FAIL] logs failed responses\n     */\n    async makeRequest(route: RouteMetadata, args: any[]): Promise<any> {\n        const { httpMethod, path } = route;\n\n        // Build the full URL\n        const url = `${this.config.baseUrl}${path}`;\n\n\n        // Build base headers for the HTTP request\n        const httpHeaders: Record<string, string> = {\n            'Content-Type': 'application/json',\n        };\n\n        // Add context headers to httpHeaders (unmasked, for actual HTTP request)\n        if (this.contextMgr) {\n            for (const header of this.contextMgr.headerSet) {\n                const value = this.contextMgr.contextReader.read(header);\n                if (value) {\n                    httpHeaders[header.headerName] = value;\n                }\n            }\n        }\n\n        // Build masked headers map for logging\n        const headersForLogging = this.contextMgr\n            ? this.headerMethods.buildSecureMapForLogs(this.contextMgr.headerSet, this.contextMgr.contextReader)\n            : new Map<string, any>();\n\n        // Build request options\n        const options: RequestInit = {\n            method: httpMethod,\n            headers: httpHeaders,\n        };\n\n        // For POST/PUT/PATCH, include the body (first argument) as JSON\n        let requestDto: unknown;\n        if (['POST', 'PUT', 'PATCH'].includes(httpMethod) && args.length > 0) {\n            requestDto = args[0];\n            // Plain JSON stringify - works with plain objects and our DateTimeDto classes\n            options.body = JSON.stringify(requestDto);\n        }\n\n        // Wrap fetch in a method for LogApiCall.execute\n        const method = async (): Promise<unknown> => {\n            return this.executeFetch(url, options);\n        };\n\n        return await this.logApiCall.execute(\"CLIENT\", route, requestDto, headersForLogging, method);\n    }\n\n    /**\n     * Execute the fetch request and handle response.\n     */\n    private async executeFetch(url: string, options: RequestInit): Promise<unknown> {\n        const response = await fetch(url, options);\n\n        if (response.ok) {\n            return await response.json();\n        }\n\n        // Handle errors (non-2xx responses)\n        // Try to parse ProtocolError from response body\n        const protocolError = (await response.json()) as ProtocolError;\n\n        // Reconstruct appropriate HttpError subclass and throw\n        throw ClientErrorTranslator.translateError(response, protocolError);\n    }\n}\n"]}

package/src/ContextMgr.d.ts

@@ -0,0 +1,66 @@
+import { PlatformHeader, ContextReader } from '@webpieces/http-api';
+/**
+ * ContextMgr - Manages context reader and header set for HTTP clients.
+ *
+ * Passed to createClient() via ClientConfig to enable automatic header propagation.
+ * Combines a ContextReader (how to read header values) with a header set
+ * (which headers to propagate).
+ *
+ * Example usage:
+ * ```typescript
+ * // Node.js server-side (reads from RequestContext)
+ * const contextMgr = new ContextMgr(
+ *     new RequestContextReader(),
+ *     [...WebpiecesCoreHeaders.getAllHeaders(), ...CompanyHeaders.getAllHeaders()]
+ * );
+ *
+ * // Browser client-side (reads from static map)
+ * const headers = new Map([['Authorization', getToken()]]);
+ * const contextMgr = new ContextMgr(
+ *     new StaticContextReader(headers),
+ *     [WebpiecesCoreHeaders.REQUEST_ID]
+ * );
+ *
+ * // Both cases
+ * const config = new ClientConfig('http://api.example.com', contextMgr);
+ * const client = createClient(SaveApiPrototype, config);
+ * ```
+ */
+export declare class ContextMgr {
+    /**
+     * The context reader that provides header values.
+     * Different implementations for Node.js vs browser.
+     */
+    readonly contextReader: ContextReader;
+    /**
+     * The set of platform headers to read and propagate.
+     * Only headers in this set will be added to requests.
+     */
+    readonly headerSet: PlatformHeader[];
+    constructor(
+    /**
+     * The context reader that provides header values.
+     * Different implementations for Node.js vs browser.
+     */
+    contextReader: ContextReader, 
+    /**
+     * The set of platform headers to read and propagate.
+     * Only headers in this set will be added to requests.
+     */
+    headerSet: PlatformHeader[]);
+    /**
+     * Read a single header value by header name.
+     *
+     * Returns undefined if:
+     * - Header name not found in headerSet
+     * - Header has isWantTransferred=false
+     * - contextReader returns undefined/null/empty string
+     *
+     * This method is called by ClientFactory for each header in the headerSet,
+     * allowing a single loop instead of the previous double-loop pattern.
+     *
+     * @param headerName - The HTTP header name (e.g., 'x-request-id')
+     * @returns The header value, or undefined if not available/transferable
+     */
+    read(headerName: string): string | undefined;
+}

package/src/ContextMgr.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextMgr = void 0;
+/**
+ * ContextMgr - Manages context reader and header set for HTTP clients.
+ *
+ * Passed to createClient() via ClientConfig to enable automatic header propagation.
+ * Combines a ContextReader (how to read header values) with a header set
+ * (which headers to propagate).
+ *
+ * Example usage:
+ * ```typescript
+ * // Node.js server-side (reads from RequestContext)
+ * const contextMgr = new ContextMgr(
+ *     new RequestContextReader(),
+ *     [...WebpiecesCoreHeaders.getAllHeaders(), ...CompanyHeaders.getAllHeaders()]
+ * );
+ *
+ * // Browser client-side (reads from static map)
+ * const headers = new Map([['Authorization', getToken()]]);
+ * const contextMgr = new ContextMgr(
+ *     new StaticContextReader(headers),
+ *     [WebpiecesCoreHeaders.REQUEST_ID]
+ * );
+ *
+ * // Both cases
+ * const config = new ClientConfig('http://api.example.com', contextMgr);
+ * const client = createClient(SaveApiPrototype, config);
+ * ```
+ */
+class ContextMgr {
+    constructor(
+    /**
+     * The context reader that provides header values.
+     * Different implementations for Node.js vs browser.
+     */
+    contextReader, 
+    /**
+     * The set of platform headers to read and propagate.
+     * Only headers in this set will be added to requests.
+     */
+    headerSet) {
+        this.contextReader = contextReader;
+        this.headerSet = headerSet;
+    }
+    /**
+     * Read a single header value by header name.
+     *
+     * Returns undefined if:
+     * - Header name not found in headerSet
+     * - Header has isWantTransferred=false
+     * - contextReader returns undefined/null/empty string
+     *
+     * This method is called by ClientFactory for each header in the headerSet,
+     * allowing a single loop instead of the previous double-loop pattern.
+     *
+     * @param headerName - The HTTP header name (e.g., 'x-request-id')
+     * @returns The header value, or undefined if not available/transferable
+     */
+    read(headerName) {
+        // Find the header definition in our set
+        const header = this.headerSet.find(h => h.headerName === headerName);
+        // Not in our header set - don't transfer
+        if (!header) {
+            return undefined;
+        }
+        // Header not marked for transfer - don't transfer
+        if (!header.isWantTransferred) {
+            return undefined;
+        }
+        // Read value from context reader
+        const value = this.contextReader.read(header);
+        // Only return non-empty values
+        if (value !== undefined && value !== null && value !== '') {
+            return value;
+        }
+        return undefined;
+    }
+}
+exports.ContextMgr = ContextMgr;
+//# sourceMappingURL=ContextMgr.js.map

package/src/ContextMgr.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContextMgr.js","sourceRoot":"","sources":["../../../../../packages/http/http-client/src/ContextMgr.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAa,UAAU;IACnB;IACI;;;OAGG;IACa,aAA4B;IAE5C;;;OAGG;IACa,SAA2B;QAN3B,kBAAa,GAAb,aAAa,CAAe;QAM5B,cAAS,GAAT,SAAS,CAAkB;IAC5C,CAAC;IAEJ;;;;;;;;;;;;;OAaG;IACH,IAAI,CAAC,UAAkB;QACnB,wCAAwC;QACxC,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,UAAU,KAAK,UAAU,CAAC,CAAC;QAErE,yCAAyC;QACzC,IAAI,CAAC,MAAM,EAAE,CAAC;YACV,OAAO,SAAS,CAAC;QACrB,CAAC;QAED,kDAAkD;QAClD,IAAI,CAAC,MAAM,CAAC,iBAAiB,EAAE,CAAC;YAC5B,OAAO,SAAS,CAAC;QACrB,CAAC;QAED,iCAAiC;QACjC,MAAM,KAAK,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAE9C,+BAA+B;QAC/B,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,EAAE,EAAE,CAAC;YACxD,OAAO,KAAK,CAAC;QACjB,CAAC;QAED,OAAO,SAAS,CAAC;IACrB,CAAC;CACJ;AArDD,gCAqDC","sourcesContent":["import { PlatformHeader, ContextReader } from '@webpieces/http-api';\n\n/**\n * ContextMgr - Manages context reader and header set for HTTP clients.\n *\n * Passed to createClient() via ClientConfig to enable automatic header propagation.\n * Combines a ContextReader (how to read header values) with a header set\n * (which headers to propagate).\n *\n * Example usage:\n * ```typescript\n * // Node.js server-side (reads from RequestContext)\n * const contextMgr = new ContextMgr(\n *     new RequestContextReader(),\n *     [...WebpiecesCoreHeaders.getAllHeaders(), ...CompanyHeaders.getAllHeaders()]\n * );\n *\n * // Browser client-side (reads from static map)\n * const headers = new Map([['Authorization', getToken()]]);\n * const contextMgr = new ContextMgr(\n *     new StaticContextReader(headers),\n *     [WebpiecesCoreHeaders.REQUEST_ID]\n * );\n *\n * // Both cases\n * const config = new ClientConfig('http://api.example.com', contextMgr);\n * const client = createClient(SaveApiPrototype, config);\n * ```\n */\nexport class ContextMgr {\n    constructor(\n        /**\n         * The context reader that provides header values.\n         * Different implementations for Node.js vs browser.\n         */\n        public readonly contextReader: ContextReader,\n\n        /**\n         * The set of platform headers to read and propagate.\n         * Only headers in this set will be added to requests.\n         */\n        public readonly headerSet: PlatformHeader[]\n    ) {}\n\n    /**\n     * Read a single header value by header name.\n     *\n     * Returns undefined if:\n     * - Header name not found in headerSet\n     * - Header has isWantTransferred=false\n     * - contextReader returns undefined/null/empty string\n     *\n     * This method is called by ClientFactory for each header in the headerSet,\n     * allowing a single loop instead of the previous double-loop pattern.\n     *\n     * @param headerName - The HTTP header name (e.g., 'x-request-id')\n     * @returns The header value, or undefined if not available/transferable\n     */\n    read(headerName: string): string | undefined {\n        // Find the header definition in our set\n        const header = this.headerSet.find(h => h.headerName === headerName);\n\n        // Not in our header set - don't transfer\n        if (!header) {\n            return undefined;\n        }\n\n        // Header not marked for transfer - don't transfer\n        if (!header.isWantTransferred) {\n            return undefined;\n        }\n\n        // Read value from context reader\n        const value = this.contextReader.read(header);\n\n        // Only return non-empty values\n        if (value !== undefined && value !== null && value !== '') {\n            return value;\n        }\n\n        return undefined;\n    }\n}\n"]}

package/src/ContextReader.d.ts

@@ -0,0 +1,44 @@
+import { PlatformHeader, ContextReader } from '@webpieces/http-api';
+/**
+ * StaticContextReader - Returns static header values from a Map.
+ *
+ * Useful for:
+ * - Browser environments where headers are manually managed
+ * - Testing with fixed header values
+ * - Angular services that read from localStorage/sessionStorage
+ *
+ * Example:
+ * ```typescript
+ * const headers = new Map<string, string>();
+ * headers.set('x-api-version', 'v1');
+ * headers.set('Authorization', getAuthToken());
+ * const reader = new StaticContextReader(headers);
+ * ```
+ */
+export declare class StaticContextReader implements ContextReader {
+    private headers;
+    constructor(headers: Map<string, string>);
+    read(header: PlatformHeader): string | undefined;
+}
+/**
+ * CompositeContextReader - Tries multiple readers in order.
+ *
+ * Later readers override earlier ones (last one wins).
+ * Useful for layered header sources:
+ * 1. RequestContext (base layer, from incoming request)
+ * 2. Config headers (middle layer, from ClientConfig)
+ * 3. Dynamic headers (top layer, runtime-computed values)
+ *
+ * Example:
+ * ```typescript
+ * const reader = new CompositeContextReader([
+ *     new RequestContextReader(),      // Try context first
+ *     new StaticContextReader(config), // Fall back to config
+ * ]);
+ * ```
+ */
+export declare class CompositeContextReader implements ContextReader {
+    private readers;
+    constructor(readers: ContextReader[]);
+    read(header: PlatformHeader): string | undefined;
+}

package/src/ContextReader.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompositeContextReader = exports.StaticContextReader = void 0;
+/**
+ * StaticContextReader - Returns static header values from a Map.
+ *
+ * Useful for:
+ * - Browser environments where headers are manually managed
+ * - Testing with fixed header values
+ * - Angular services that read from localStorage/sessionStorage
+ *
+ * Example:
+ * ```typescript
+ * const headers = new Map<string, string>();
+ * headers.set('x-api-version', 'v1');
+ * headers.set('Authorization', getAuthToken());
+ * const reader = new StaticContextReader(headers);
+ * ```
+ */
+class StaticContextReader {
+    constructor(headers) {
+        this.headers = headers;
+    }
+    read(header) {
+        return this.headers.get(header.headerName);
+    }
+}
+exports.StaticContextReader = StaticContextReader;
+/**
+ * CompositeContextReader - Tries multiple readers in order.
+ *
+ * Later readers override earlier ones (last one wins).
+ * Useful for layered header sources:
+ * 1. RequestContext (base layer, from incoming request)
+ * 2. Config headers (middle layer, from ClientConfig)
+ * 3. Dynamic headers (top layer, runtime-computed values)
+ *
+ * Example:
+ * ```typescript
+ * const reader = new CompositeContextReader([
+ *     new RequestContextReader(),      // Try context first
+ *     new StaticContextReader(config), // Fall back to config
+ * ]);
+ * ```
+ */
+class CompositeContextReader {
+    constructor(readers) {
+        this.readers = readers;
+    }
+    read(header) {
+        // Try readers in reverse order (last one wins/overrides)
+        for (let i = this.readers.length - 1; i >= 0; i--) {
+            const value = this.readers[i].read(header);
+            if (value !== undefined) {
+                return value;
+            }
+        }
+        return undefined;
+    }
+}
+exports.CompositeContextReader = CompositeContextReader;
+//# sourceMappingURL=ContextReader.js.map

package/src/ContextReader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContextReader.js","sourceRoot":"","sources":["../../../../../packages/http/http-client/src/ContextReader.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;;;;GAeG;AACH,MAAa,mBAAmB;IAC5B,YAAoB,OAA4B;QAA5B,YAAO,GAAP,OAAO,CAAqB;IAAG,CAAC;IAEpD,IAAI,CAAC,MAAsB;QACvB,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;IAC/C,CAAC;CACJ;AAND,kDAMC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAa,sBAAsB;IAC/B,YAAoB,OAAwB;QAAxB,YAAO,GAAP,OAAO,CAAiB;IAAG,CAAC;IAEhD,IAAI,CAAC,MAAsB;QACvB,yDAAyD;QACzD,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YAChD,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YAC3C,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;gBACtB,OAAO,KAAK,CAAC;YACjB,CAAC;QACL,CAAC;QACD,OAAO,SAAS,CAAC;IACrB,CAAC;CACJ;AAbD,wDAaC","sourcesContent":["import { PlatformHeader, ContextReader } from '@webpieces/http-api';\n\n/**\n * StaticContextReader - Returns static header values from a Map.\n *\n * Useful for:\n * - Browser environments where headers are manually managed\n * - Testing with fixed header values\n * - Angular services that read from localStorage/sessionStorage\n *\n * Example:\n * ```typescript\n * const headers = new Map<string, string>();\n * headers.set('x-api-version', 'v1');\n * headers.set('Authorization', getAuthToken());\n * const reader = new StaticContextReader(headers);\n * ```\n */\nexport class StaticContextReader implements ContextReader {\n    constructor(private headers: Map<string, string>) {}\n\n    read(header: PlatformHeader): string | undefined {\n        return this.headers.get(header.headerName);\n    }\n}\n\n/**\n * CompositeContextReader - Tries multiple readers in order.\n *\n * Later readers override earlier ones (last one wins).\n * Useful for layered header sources:\n * 1. RequestContext (base layer, from incoming request)\n * 2. Config headers (middle layer, from ClientConfig)\n * 3. Dynamic headers (top layer, runtime-computed values)\n *\n * Example:\n * ```typescript\n * const reader = new CompositeContextReader([\n *     new RequestContextReader(),      // Try context first\n *     new StaticContextReader(config), // Fall back to config\n * ]);\n * ```\n */\nexport class CompositeContextReader implements ContextReader {\n    constructor(private readers: ContextReader[]) {}\n\n    read(header: PlatformHeader): string | undefined {\n        // Try readers in reverse order (last one wins/overrides)\n        for (let i = this.readers.length - 1; i >= 0; i--) {\n            const value = this.readers[i].read(header);\n            if (value !== undefined) {\n                return value;\n            }\n        }\n        return undefined;\n    }\n}\n"]}

package/src/index.d.ts

@@ -30,4 +30,8 @@
  * ```
  */
 export { createClient, ClientConfig } from './ClientFactory';
+export { ClientErrorTranslator } from './ClientErrorTranslator';
+export { StaticContextReader, CompositeContextReader } from './ContextReader';
+export { ContextMgr } from './ContextMgr';
+export { ContextReader } from '@webpieces/http-api';
 export { ApiInterface, Get, Post, Put, Delete, Patch, Path, ValidateImplementation, } from '@webpieces/http-api';

package/src/index.js

@@ -31,10 +31,18 @@
  * ```
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Path = exports.Patch = exports.Delete = exports.Put = exports.Post = exports.Get = exports.ApiInterface = exports.ClientConfig = exports.createClient = void 0;
+exports.Path = exports.Patch = exports.Delete = exports.Put = exports.Post = exports.Get = exports.ApiInterface = exports.ContextMgr = exports.CompositeContextReader = exports.StaticContextReader = exports.ClientErrorTranslator = exports.ClientConfig = exports.createClient = void 0;
 var ClientFactory_1 = require("./ClientFactory");
 Object.defineProperty(exports, "createClient", { enumerable: true, get: function () { return ClientFactory_1.createClient; } });
 Object.defineProperty(exports, "ClientConfig", { enumerable: true, get: function () { return ClientFactory_1.ClientConfig; } });
+var ClientErrorTranslator_1 = require("./ClientErrorTranslator");
+Object.defineProperty(exports, "ClientErrorTranslator", { enumerable: true, get: function () { return ClientErrorTranslator_1.ClientErrorTranslator; } });
+// Context management for header propagation
+var ContextReader_1 = require("./ContextReader");
+Object.defineProperty(exports, "StaticContextReader", { enumerable: true, get: function () { return ContextReader_1.StaticContextReader; } });
+Object.defineProperty(exports, "CompositeContextReader", { enumerable: true, get: function () { return ContextReader_1.CompositeContextReader; } });
+var ContextMgr_1 = require("./ContextMgr");
+Object.defineProperty(exports, "ContextMgr", { enumerable: true, get: function () { return ContextMgr_1.ContextMgr; } });
 // Re-export API decorators for convenience (same as http-routing does)
 var http_api_1 = require("@webpieces/http-api");
 Object.defineProperty(exports, "ApiInterface", { enumerable: true, get: function () { return http_api_1.ApiInterface; } });

package/src/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../packages/http/http-client/src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;;;AAEH,iDAA6D;AAApD,6GAAA,YAAY,OAAA;AAAE,6GAAA,YAAY,OAAA;AAEnC,uEAAuE;AACvE,gDAS6B;AARzB,wGAAA,YAAY,OAAA;AACZ,+FAAA,GAAG,OAAA;AACH,gGAAA,IAAI,OAAA;AACJ,+FAAA,GAAG,OAAA;AACH,kGAAA,MAAM,OAAA;AACN,iGAAA,KAAK,OAAA;AACL,gGAAA,IAAI,OAAA","sourcesContent":["/**\n * @webpieces/http-client\n *\n * Client-side HTTP client generation package.\n * Reads API decorators and generates type-safe HTTP clients.\n *\n * This is the client-side counterpart to @webpieces/http-routing:\n * - Server (@webpieces/http-routing): API decorators → route HTTP to controllers\n * - Client (@webpieces/http-client): API decorators → generate HTTP from method calls\n *\n * Both packages depend on @webpieces/http-api for shared decorator definitions.\n *\n * Architecture:\n * ```\n * http-api (defines the contract)\n *    ↑\n *    ├── http-routing (server: contract → handlers)\n *    └── http-client (client: contract → HTTP requests)  ← YOU ARE HERE\n * ```\n *\n * Usage:\n * ```typescript\n * import { createClient, ClientConfig } from '@webpieces/http-client';\n * import { SaveApiPrototype } from './api/SaveApi';\n *\n * const config = new ClientConfig('http://localhost:3000');\n * const client = createClient(SaveApiPrototype, config);\n *\n * const response = await client.save({ query: 'test' });\n * ```\n */\n\nexport { createClient, ClientConfig } from './ClientFactory';\n\n// Re-export API decorators for convenience (same as http-routing does)\nexport {\n    ApiInterface,\n    Get,\n    Post,\n    Put,\n    Delete,\n    Patch,\n    Path,\n    ValidateImplementation,\n} from '@webpieces/http-api';\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../packages/http/http-client/src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;;;AAEH,iDAA6D;AAApD,6GAAA,YAAY,OAAA;AAAE,6GAAA,YAAY,OAAA;AACnC,iEAAgE;AAAvD,8HAAA,qBAAqB,OAAA;AAE9B,4CAA4C;AAC5C,iDAA8E;AAArE,oHAAA,mBAAmB,OAAA;AAAE,uHAAA,sBAAsB,OAAA;AACpD,2CAA0C;AAAjC,wGAAA,UAAU,OAAA;AAKnB,uEAAuE;AACvE,gDAS6B;AARzB,wGAAA,YAAY,OAAA;AACZ,+FAAA,GAAG,OAAA;AACH,gGAAA,IAAI,OAAA;AACJ,+FAAA,GAAG,OAAA;AACH,kGAAA,MAAM,OAAA;AACN,iGAAA,KAAK,OAAA;AACL,gGAAA,IAAI,OAAA","sourcesContent":["/**\n * @webpieces/http-client\n *\n * Client-side HTTP client generation package.\n * Reads API decorators and generates type-safe HTTP clients.\n *\n * This is the client-side counterpart to @webpieces/http-routing:\n * - Server (@webpieces/http-routing): API decorators → route HTTP to controllers\n * - Client (@webpieces/http-client): API decorators → generate HTTP from method calls\n *\n * Both packages depend on @webpieces/http-api for shared decorator definitions.\n *\n * Architecture:\n * ```\n * http-api (defines the contract)\n *    ↑\n *    ├── http-routing (server: contract → handlers)\n *    └── http-client (client: contract → HTTP requests)  ← YOU ARE HERE\n * ```\n *\n * Usage:\n * ```typescript\n * import { createClient, ClientConfig } from '@webpieces/http-client';\n * import { SaveApiPrototype } from './api/SaveApi';\n *\n * const config = new ClientConfig('http://localhost:3000');\n * const client = createClient(SaveApiPrototype, config);\n *\n * const response = await client.save({ query: 'test' });\n * ```\n */\n\nexport { createClient, ClientConfig } from './ClientFactory';\nexport { ClientErrorTranslator } from './ClientErrorTranslator';\n\n// Context management for header propagation\nexport { StaticContextReader, CompositeContextReader } from './ContextReader';\nexport { ContextMgr } from './ContextMgr';\n\n// Re-export ContextReader interface from http-api for convenience\nexport { ContextReader } from '@webpieces/http-api';\n\n// Re-export API decorators for convenience (same as http-routing does)\nexport {\n    ApiInterface,\n    Get,\n    Post,\n    Put,\n    Delete,\n    Patch,\n    Path,\n    ValidateImplementation,\n} from '@webpieces/http-api';\n"]}