@webpieces/core-context 0.3.263 → 0.3.265

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webpieces/core-context",
-  "version": "0.3.263",
+  "version": "0.3.265",
   "description": "AsyncLocalStorage-based context management for request-scoped data",
   "type": "commonjs",
   "main": "./src/index.js",
@@ -22,6 +22,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@webpieces/core-util": "0.3.263"
+    "@webpieces/core-util": "0.3.265",
+    "@inversifyjs/binding-decorators": "1.1.5",
+    "inversify": "7.10.4",
+    "reflect-metadata": "0.2.2"
   }
 }

package/src/ContextMgr.d.ts

@@ -0,0 +1,76 @@
+import { ContextReader, HeaderMethods, HeaderRegistry } from '@webpieces/core-util';
+/**
+ * ContextMgr - Manages context reader + header registry for HTTP clients.
+ *
+ * Passed to createApiClient() via ClientConfig.contextMgr to enable automatic
+ * header propagation: every header in the registry with isWantTransferred=true
+ * is read from the ContextReader and added to outbound requests.
+ *
+ * BREAKING (migration from the PlatformHeader[] constructor):
+ *   new ContextMgr(reader, headerArray)
+ * becomes
+ *   new ContextMgr(reader, new HeaderRegistry([new PlatformHeadersExtension(headerArray)]))
+ *
+ * Example usage:
+ * ```typescript
+ * // Node.js server-side (reads the magic context from RequestContext):
+ * const contextMgr = new ContextMgr(new RequestContextReader(), registry);
+ *
+ * // Browser client-side (app-managed store, no AsyncLocalStorage):
+ * const store = new MutableContextStore();
+ * const contextMgr = new ContextMgr(store, registry);
+ *
+ * // Both cases:
+ * const config = new ClientConfig('http://api.example.com', contextMgr);
+ * const client = createApiClient(SaveApi, config);
+ * ```
+ */
+export declare class ContextMgr {
+    /**
+     * The context reader that provides header values.
+     * Different implementations for Node.js vs browser.
+     */
+    readonly contextReader: ContextReader;
+    /**
+     * The single source of truth for which headers exist and how they behave
+     * (transferred/secured/MDC). Shared with the server-side filters.
+     */
+    readonly registry: HeaderRegistry;
+    /**
+     * When true (default), outbound calls send the current x-request-id as
+     * x-previous-request-id (and drop x-request-id) so each hop in a
+     * distributed trace gets its own id chained to its caller's.
+     */
+    readonly chainRequestIds: boolean;
+    private chainProcessor;
+    constructor(
+    /**
+     * The context reader that provides header values.
+     * Different implementations for Node.js vs browser.
+     */
+    contextReader: ContextReader, 
+    /**
+     * The single source of truth for which headers exist and how they behave
+     * (transferred/secured/MDC). Shared with the server-side filters.
+     */
+    registry: HeaderRegistry, 
+    /**
+     * When true (default), outbound calls send the current x-request-id as
+     * x-previous-request-id (and drop x-request-id) so each hop in a
+     * distributed trace gets its own id chained to its caller's.
+     */
+    chainRequestIds?: boolean);
+    /**
+     * Build the headers to send on an outbound request: every transferred
+     * header (isWantTransferred=true) with a non-empty value in the context,
+     * then request-id chaining applied (unless opted out).
+     *
+     * Values are RAW (unmasked) - this map goes on the wire, not in logs.
+     */
+    buildOutboundHeaders(): Map<string, string>;
+    /**
+     * Build the header map for LOGGING: secured header values are masked,
+     * and headers are keyed by loggerMdcKey when defined.
+     */
+    buildHeadersForLogging(headerMethods: HeaderMethods): Map<string, string>;
+}

package/src/ContextMgr.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextMgr = void 0;
+const RequestIdChainProcessor_1 = require("./RequestIdChainProcessor");
+/**
+ * ContextMgr - Manages context reader + header registry for HTTP clients.
+ *
+ * Passed to createApiClient() via ClientConfig.contextMgr to enable automatic
+ * header propagation: every header in the registry with isWantTransferred=true
+ * is read from the ContextReader and added to outbound requests.
+ *
+ * BREAKING (migration from the PlatformHeader[] constructor):
+ *   new ContextMgr(reader, headerArray)
+ * becomes
+ *   new ContextMgr(reader, new HeaderRegistry([new PlatformHeadersExtension(headerArray)]))
+ *
+ * Example usage:
+ * ```typescript
+ * // Node.js server-side (reads the magic context from RequestContext):
+ * const contextMgr = new ContextMgr(new RequestContextReader(), registry);
+ *
+ * // Browser client-side (app-managed store, no AsyncLocalStorage):
+ * const store = new MutableContextStore();
+ * const contextMgr = new ContextMgr(store, registry);
+ *
+ * // Both cases:
+ * const config = new ClientConfig('http://api.example.com', contextMgr);
+ * const client = createApiClient(SaveApi, config);
+ * ```
+ */
+class ContextMgr {
+    contextReader;
+    registry;
+    chainRequestIds;
+    chainProcessor;
+    constructor(
+    /**
+     * The context reader that provides header values.
+     * Different implementations for Node.js vs browser.
+     */
+    contextReader, 
+    /**
+     * The single source of truth for which headers exist and how they behave
+     * (transferred/secured/MDC). Shared with the server-side filters.
+     */
+    registry, 
+    /**
+     * When true (default), outbound calls send the current x-request-id as
+     * x-previous-request-id (and drop x-request-id) so each hop in a
+     * distributed trace gets its own id chained to its caller's.
+     */
+    chainRequestIds = true) {
+        this.contextReader = contextReader;
+        this.registry = registry;
+        this.chainRequestIds = chainRequestIds;
+        this.chainProcessor = new RequestIdChainProcessor_1.RequestIdChainProcessor();
+    }
+    /**
+     * Build the headers to send on an outbound request: every transferred
+     * header (isWantTransferred=true) with a non-empty value in the context,
+     * then request-id chaining applied (unless opted out).
+     *
+     * Values are RAW (unmasked) - this map goes on the wire, not in logs.
+     */
+    buildOutboundHeaders() {
+        const outbound = new Map();
+        for (const header of this.registry.getTransferredHeaders()) {
+            const value = this.contextReader.read(header);
+            if (value !== undefined && value !== null && value !== '') {
+                outbound.set(header.headerName, value);
+            }
+        }
+        if (this.chainRequestIds) {
+            this.chainProcessor.process(outbound);
+        }
+        return outbound;
+    }
+    /**
+     * Build the header map for LOGGING: secured header values are masked,
+     * and headers are keyed by loggerMdcKey when defined.
+     */
+    buildHeadersForLogging(headerMethods) {
+        return headerMethods.buildSecureMapForLogs(this.registry.getHeaders(), this.contextReader);
+    }
+}
+exports.ContextMgr = ContextMgr;
+//# sourceMappingURL=ContextMgr.js.map

package/src/ContextMgr.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContextMgr.js","sourceRoot":"","sources":["../../../../../packages/core/core-context/src/ContextMgr.ts"],"names":[],"mappings":";;;AACA,uEAAoE;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAa,UAAU;IAQC;IAMA;IAOA;IApBZ,cAAc,CAA0B;IAEhD;IACI;;;OAGG;IACa,aAA4B;IAE5C;;;OAGG;IACa,QAAwB;IAExC;;;;OAIG;IACa,kBAA2B,IAAI;QAb/B,kBAAa,GAAb,aAAa,CAAe;QAM5B,aAAQ,GAAR,QAAQ,CAAgB;QAOxB,oBAAe,GAAf,eAAe,CAAgB;QAE/C,IAAI,CAAC,cAAc,GAAG,IAAI,iDAAuB,EAAE,CAAC;IACxD,CAAC;IAED;;;;;;OAMG;IACH,oBAAoB;QAChB,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAkB,CAAC;QAE3C,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,QAAQ,CAAC,qBAAqB,EAAE,EAAE,CAAC;YACzD,MAAM,KAAK,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YAC9C,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,EAAE,EAAE,CAAC;gBACxD,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;YAC3C,CAAC;QACL,CAAC;QAED,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;YACvB,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QAC1C,CAAC;QAED,OAAO,QAAQ,CAAC;IACpB,CAAC;IAED;;;OAGG;IACH,sBAAsB,CAAC,aAA4B;QAC/C,OAAO,aAAa,CAAC,qBAAqB,CAAC,IAAI,CAAC,QAAQ,CAAC,UAAU,EAAE,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;IAC/F,CAAC;CACJ;AAzDD,gCAyDC","sourcesContent":["import { ContextReader, HeaderMethods, HeaderRegistry } from '@webpieces/core-util';\nimport { RequestIdChainProcessor } from './RequestIdChainProcessor';\n\n/**\n * ContextMgr - Manages context reader + header registry for HTTP clients.\n *\n * Passed to createApiClient() via ClientConfig.contextMgr to enable automatic\n * header propagation: every header in the registry with isWantTransferred=true\n * is read from the ContextReader and added to outbound requests.\n *\n * BREAKING (migration from the PlatformHeader[] constructor):\n *   new ContextMgr(reader, headerArray)\n * becomes\n *   new ContextMgr(reader, new HeaderRegistry([new PlatformHeadersExtension(headerArray)]))\n *\n * Example usage:\n * ```typescript\n * // Node.js server-side (reads the magic context from RequestContext):\n * const contextMgr = new ContextMgr(new RequestContextReader(), registry);\n *\n * // Browser client-side (app-managed store, no AsyncLocalStorage):\n * const store = new MutableContextStore();\n * const contextMgr = new ContextMgr(store, registry);\n *\n * // Both cases:\n * const config = new ClientConfig('http://api.example.com', contextMgr);\n * const client = createApiClient(SaveApi, config);\n * ```\n */\nexport class ContextMgr {\n    private chainProcessor: RequestIdChainProcessor;\n\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 single source of truth for which headers exist and how they behave\n         * (transferred/secured/MDC). Shared with the server-side filters.\n         */\n        public readonly registry: HeaderRegistry,\n\n        /**\n         * When true (default), outbound calls send the current x-request-id as\n         * x-previous-request-id (and drop x-request-id) so each hop in a\n         * distributed trace gets its own id chained to its caller's.\n         */\n        public readonly chainRequestIds: boolean = true,\n    ) {\n        this.chainProcessor = new RequestIdChainProcessor();\n    }\n\n    /**\n     * Build the headers to send on an outbound request: every transferred\n     * header (isWantTransferred=true) with a non-empty value in the context,\n     * then request-id chaining applied (unless opted out).\n     *\n     * Values are RAW (unmasked) - this map goes on the wire, not in logs.\n     */\n    buildOutboundHeaders(): Map<string, string> {\n        const outbound = new Map<string, string>();\n\n        for (const header of this.registry.getTransferredHeaders()) {\n            const value = this.contextReader.read(header);\n            if (value !== undefined && value !== null && value !== '') {\n                outbound.set(header.headerName, value);\n            }\n        }\n\n        if (this.chainRequestIds) {\n            this.chainProcessor.process(outbound);\n        }\n\n        return outbound;\n    }\n\n    /**\n     * Build the header map for LOGGING: secured header values are masked,\n     * and headers are keyed by loggerMdcKey when defined.\n     */\n    buildHeadersForLogging(headerMethods: HeaderMethods): Map<string, string> {\n        return headerMethods.buildSecureMapForLogs(this.registry.getHeaders(), this.contextReader);\n    }\n}\n"]}

package/src/RequestContextReader.d.ts

@@ -0,0 +1,29 @@
+import { PlatformHeader, ContextReader } from '@webpieces/core-util';
+import { ContextKey } from '@webpieces/core-util';
+/**
+ * RequestContextReader - Reads headers from Node.js RequestContext.
+ *
+ * Only works in Node.js with active AsyncLocalStorage context.
+ * This is a server-side only implementation.
+ *
+ * Lives in @webpieces/core-context (Node.js only) alongside the RequestContext
+ * (AsyncLocalStorage) it reads from, so libraries can build a context-propagating
+ * ContextMgr without pulling in @webpieces/http-routing.
+ *
+ * For browser environments, use StaticContextReader from @webpieces/http-client.
+ */
+export declare class RequestContextReader implements ContextReader {
+    /**
+     * Read a header value from the active RequestContext.
+     *
+     * @param header - The platform header to read
+     * @returns The header value, or undefined if not in context
+     */
+    read(header: PlatformHeader): string | undefined;
+    /**
+     * Read a non-header context value (e.g. the active TestCaseRecorder under
+     * RecorderKeys.RECORDER). Lets the isomorphic http-client find server-side
+     * context without importing core-context itself.
+     */
+    readValue(key: ContextKey): unknown;
+}

package/src/RequestContextReader.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestContextReader = void 0;
+const RequestContext_1 = require("./RequestContext");
+/**
+ * RequestContextReader - Reads headers from Node.js RequestContext.
+ *
+ * Only works in Node.js with active AsyncLocalStorage context.
+ * This is a server-side only implementation.
+ *
+ * Lives in @webpieces/core-context (Node.js only) alongside the RequestContext
+ * (AsyncLocalStorage) it reads from, so libraries can build a context-propagating
+ * ContextMgr without pulling in @webpieces/http-routing.
+ *
+ * For browser environments, use StaticContextReader from @webpieces/http-client.
+ */
+class RequestContextReader {
+    /**
+     * Read a header value from the active RequestContext.
+     *
+     * @param header - The platform header to read
+     * @returns The header value, or undefined if not in context
+     */
+    read(header) {
+        // Use RequestContext.getHeader() which calls header.getHeaderName()
+        return RequestContext_1.RequestContext.getHeader(header);
+    }
+    /**
+     * Read a non-header context value (e.g. the active TestCaseRecorder under
+     * RecorderKeys.RECORDER). Lets the isomorphic http-client find server-side
+     * context without importing core-context itself.
+     */
+    // webpieces-disable no-any-unknown -- context values are heterogeneous (recorder, meta objects)
+    readValue(key) {
+        return RequestContext_1.RequestContext.getHeader(key);
+    }
+}
+exports.RequestContextReader = RequestContextReader;
+//# sourceMappingURL=RequestContextReader.js.map

package/src/RequestContextReader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RequestContextReader.js","sourceRoot":"","sources":["../../../../../packages/core/core-context/src/RequestContextReader.ts"],"names":[],"mappings":";;;AAEA,qDAAkD;AAElD;;;;;;;;;;;GAWG;AACH,MAAa,oBAAoB;IAC7B;;;;;OAKG;IACH,IAAI,CAAC,MAAsB;QACvB,oEAAoE;QACpE,OAAO,+BAAc,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;IAC5C,CAAC;IAED;;;;OAIG;IACH,gGAAgG;IAChG,SAAS,CAAC,GAAe;QACrB,OAAO,+BAAc,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;IACzC,CAAC;CACJ;AArBD,oDAqBC","sourcesContent":["import { PlatformHeader, ContextReader } from '@webpieces/core-util';\nimport { ContextKey } from '@webpieces/core-util';\nimport { RequestContext } from './RequestContext';\n\n/**\n * RequestContextReader - Reads headers from Node.js RequestContext.\n *\n * Only works in Node.js with active AsyncLocalStorage context.\n * This is a server-side only implementation.\n *\n * Lives in @webpieces/core-context (Node.js only) alongside the RequestContext\n * (AsyncLocalStorage) it reads from, so libraries can build a context-propagating\n * ContextMgr without pulling in @webpieces/http-routing.\n *\n * For browser environments, use StaticContextReader from @webpieces/http-client.\n */\nexport class RequestContextReader implements ContextReader {\n    /**\n     * Read a header value from the active RequestContext.\n     *\n     * @param header - The platform header to read\n     * @returns The header value, or undefined if not in context\n     */\n    read(header: PlatformHeader): string | undefined {\n        // Use RequestContext.getHeader() which calls header.getHeaderName()\n        return RequestContext.getHeader(header);\n    }\n\n    /**\n     * Read a non-header context value (e.g. the active TestCaseRecorder under\n     * RecorderKeys.RECORDER). Lets the isomorphic http-client find server-side\n     * context without importing core-context itself.\n     */\n    // webpieces-disable no-any-unknown -- context values are heterogeneous (recorder, meta objects)\n    readValue(key: ContextKey): unknown {\n        return RequestContext.getHeader(key);\n    }\n}\n"]}

package/src/RequestIdChainProcessor.d.ts

@@ -0,0 +1,20 @@
+/**
+ * RequestIdChainProcessor - Builds the per-hop distributed-trace chain.
+ *
+ * TS equivalent of the Java MicroSvcHeader REQUEST_ID/PREVIOUS_REQUEST_ID flow:
+ * when a server makes an outbound call, its CURRENT request id is sent to the
+ * downstream service as x-previous-request-id, and x-request-id is NOT sent -
+ * the downstream ContextFilter then generates a fresh id for its own hop.
+ * Result: every hop has its own id plus a pointer to its caller's id, forming
+ * a trace tree.
+ *
+ * Invoked by ContextMgr.buildOutboundHeaders() after the transferred headers
+ * are collected. Opt out via `new ContextMgr(reader, registry, false)` if you
+ * want raw pass-through of x-request-id instead.
+ */
+export declare class RequestIdChainProcessor {
+    /**
+     * Rewrite the outbound header map in place: x-request-id -> x-previous-request-id.
+     */
+    process(outboundHeaders: Map<string, string>): void;
+}

package/src/RequestIdChainProcessor.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestIdChainProcessor = void 0;
+const core_util_1 = require("@webpieces/core-util");
+/**
+ * RequestIdChainProcessor - Builds the per-hop distributed-trace chain.
+ *
+ * TS equivalent of the Java MicroSvcHeader REQUEST_ID/PREVIOUS_REQUEST_ID flow:
+ * when a server makes an outbound call, its CURRENT request id is sent to the
+ * downstream service as x-previous-request-id, and x-request-id is NOT sent -
+ * the downstream ContextFilter then generates a fresh id for its own hop.
+ * Result: every hop has its own id plus a pointer to its caller's id, forming
+ * a trace tree.
+ *
+ * Invoked by ContextMgr.buildOutboundHeaders() after the transferred headers
+ * are collected. Opt out via `new ContextMgr(reader, registry, false)` if you
+ * want raw pass-through of x-request-id instead.
+ */
+class RequestIdChainProcessor {
+    /**
+     * Rewrite the outbound header map in place: x-request-id -> x-previous-request-id.
+     */
+    process(outboundHeaders) {
+        const requestIdName = core_util_1.WebpiecesCoreHeaders.REQUEST_ID.headerName;
+        const previousIdName = core_util_1.WebpiecesCoreHeaders.PREVIOUS_REQUEST_ID.headerName;
+        const currentRequestId = outboundHeaders.get(requestIdName);
+        if (currentRequestId === undefined) {
+            return;
+        }
+        outboundHeaders.set(previousIdName, currentRequestId);
+        outboundHeaders.delete(requestIdName);
+    }
+}
+exports.RequestIdChainProcessor = RequestIdChainProcessor;
+//# sourceMappingURL=RequestIdChainProcessor.js.map

package/src/RequestIdChainProcessor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RequestIdChainProcessor.js","sourceRoot":"","sources":["../../../../../packages/core/core-context/src/RequestIdChainProcessor.ts"],"names":[],"mappings":";;;AAAA,oDAA4D;AAE5D;;;;;;;;;;;;;GAaG;AACH,MAAa,uBAAuB;IAChC;;OAEG;IACH,OAAO,CAAC,eAAoC;QACxC,MAAM,aAAa,GAAG,gCAAoB,CAAC,UAAU,CAAC,UAAU,CAAC;QACjE,MAAM,cAAc,GAAG,gCAAoB,CAAC,mBAAmB,CAAC,UAAU,CAAC;QAE3E,MAAM,gBAAgB,GAAG,eAAe,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;QAC5D,IAAI,gBAAgB,KAAK,SAAS,EAAE,CAAC;YACjC,OAAO;QACX,CAAC;QAED,eAAe,CAAC,GAAG,CAAC,cAAc,EAAE,gBAAgB,CAAC,CAAC;QACtD,eAAe,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;IAC1C,CAAC;CACJ;AAhBD,0DAgBC","sourcesContent":["import { WebpiecesCoreHeaders } from '@webpieces/core-util';\n\n/**\n * RequestIdChainProcessor - Builds the per-hop distributed-trace chain.\n *\n * TS equivalent of the Java MicroSvcHeader REQUEST_ID/PREVIOUS_REQUEST_ID flow:\n * when a server makes an outbound call, its CURRENT request id is sent to the\n * downstream service as x-previous-request-id, and x-request-id is NOT sent -\n * the downstream ContextFilter then generates a fresh id for its own hop.\n * Result: every hop has its own id plus a pointer to its caller's id, forming\n * a trace tree.\n *\n * Invoked by ContextMgr.buildOutboundHeaders() after the transferred headers\n * are collected. Opt out via `new ContextMgr(reader, registry, false)` if you\n * want raw pass-through of x-request-id instead.\n */\nexport class RequestIdChainProcessor {\n    /**\n     * Rewrite the outbound header map in place: x-request-id -> x-previous-request-id.\n     */\n    process(outboundHeaders: Map<string, string>): void {\n        const requestIdName = WebpiecesCoreHeaders.REQUEST_ID.headerName;\n        const previousIdName = WebpiecesCoreHeaders.PREVIOUS_REQUEST_ID.headerName;\n\n        const currentRequestId = outboundHeaders.get(requestIdName);\n        if (currentRequestId === undefined) {\n            return;\n        }\n\n        outboundHeaders.set(previousIdName, currentRequestId);\n        outboundHeaders.delete(requestIdName);\n    }\n}\n"]}

package/src/index.d.ts

@@ -1 +1,5 @@
 export { RequestContext } from './RequestContext';
+export { provideSingleton, provideSingletonAs, provideTransient } from './provide';
+export { ContextMgr } from './ContextMgr';
+export { RequestIdChainProcessor } from './RequestIdChainProcessor';
+export { RequestContextReader } from './RequestContextReader';

package/src/index.js

@@ -1,7 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RequestContext = void 0;
+exports.RequestContextReader = exports.RequestIdChainProcessor = exports.ContextMgr = exports.provideTransient = exports.provideSingletonAs = exports.provideSingleton = exports.RequestContext = void 0;
 // Context management with AsyncLocalStorage
 var RequestContext_1 = require("./RequestContext");
 Object.defineProperty(exports, "RequestContext", { enumerable: true, get: function () { return RequestContext_1.RequestContext; } });
+// DI provider decorators (shared DI seam; http-routing re-exports for back-compat)
+var provide_1 = require("./provide");
+Object.defineProperty(exports, "provideSingleton", { enumerable: true, get: function () { return provide_1.provideSingleton; } });
+Object.defineProperty(exports, "provideSingletonAs", { enumerable: true, get: function () { return provide_1.provideSingletonAs; } });
+Object.defineProperty(exports, "provideTransient", { enumerable: true, get: function () { return provide_1.provideTransient; } });
+// Outbound-header machinery (request-context -> outbound HTTP headers)
+var ContextMgr_1 = require("./ContextMgr");
+Object.defineProperty(exports, "ContextMgr", { enumerable: true, get: function () { return ContextMgr_1.ContextMgr; } });
+var RequestIdChainProcessor_1 = require("./RequestIdChainProcessor");
+Object.defineProperty(exports, "RequestIdChainProcessor", { enumerable: true, get: function () { return RequestIdChainProcessor_1.RequestIdChainProcessor; } });
+var RequestContextReader_1 = require("./RequestContextReader");
+Object.defineProperty(exports, "RequestContextReader", { enumerable: true, get: function () { return RequestContextReader_1.RequestContextReader; } });
 //# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../packages/core/core-context/src/index.ts"],"names":[],"mappings":";;;AAAA,4CAA4C;AAC5C,mDAAkD;AAAzC,gHAAA,cAAc,OAAA","sourcesContent":["// Context management with AsyncLocalStorage\nexport { RequestContext } from './RequestContext';\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../packages/core/core-context/src/index.ts"],"names":[],"mappings":";;;AAAA,4CAA4C;AAC5C,mDAAkD;AAAzC,gHAAA,cAAc,OAAA;AAEvB,mFAAmF;AACnF,qCAAmF;AAA1E,2GAAA,gBAAgB,OAAA;AAAE,6GAAA,kBAAkB,OAAA;AAAE,2GAAA,gBAAgB,OAAA;AAE/D,uEAAuE;AACvE,2CAA0C;AAAjC,wGAAA,UAAU,OAAA;AACnB,qEAAoE;AAA3D,kIAAA,uBAAuB,OAAA;AAChC,+DAA8D;AAArD,4HAAA,oBAAoB,OAAA","sourcesContent":["// Context management with AsyncLocalStorage\nexport { RequestContext } from './RequestContext';\n\n// DI provider decorators (shared DI seam; http-routing re-exports for back-compat)\nexport { provideSingleton, provideSingletonAs, provideTransient } from './provide';\n\n// Outbound-header machinery (request-context -> outbound HTTP headers)\nexport { ContextMgr } from './ContextMgr';\nexport { RequestIdChainProcessor } from './RequestIdChainProcessor';\nexport { RequestContextReader } from './RequestContextReader';\n"]}

package/src/provide.d.ts

@@ -0,0 +1,49 @@
+import 'reflect-metadata';
+import type { ServiceIdentifier } from 'inversify';
+/**
+ * DI provider decorators (the lightweight DI seam shared across webpieces).
+ *
+ * These live in @webpieces/core-context — the lowest package that already owns
+ * request-scoped context — so libraries (cloudtasks-client, http-client, …) can
+ * register singletons WITHOUT depending on the server-side @webpieces/http-routing
+ * package. http-routing re-exports them for back-compat.
+ */
+/**
+ * Provides a singleton-scoped dependency.
+ * When called without arguments, the decorated class binds to itself.
+ *
+ * Usage:
+ * ```typescript
+ * @provideSingleton()
+ * export class SaveController {
+ *   // ...
+ * }
+ * ```
+ */
+export declare function provideSingleton(): ClassDecorator;
+/**
+ * Provides a singleton-scoped dependency bound to a specific token (Symbol or abstract class).
+ * Use this in libraries/apis-external/** to bind an impl to the Symbol defined in libraries/apis/**.
+ *
+ * Usage:
+ * ```typescript
+ * import { SOME_API_TOKEN } from '@myorg/some-api';
+ *
+ * @provideSingletonAs(SOME_API_TOKEN)
+ * export class SomeApiImpl { ... }
+ * ```
+ */
+export declare function provideSingletonAs<T>(serviceIdentifier: ServiceIdentifier<T>): ClassDecorator;
+/**
+ * Provides a transient-scoped dependency (new instance every time).
+ * When called without arguments, the decorated class binds to itself.
+ *
+ * Usage:
+ * ```typescript
+ * @provideTransient()
+ * export class TransientController {
+ *   // ...
+ * }
+ * ```
+ */
+export declare function provideTransient(): ClassDecorator;

package/src/provide.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.provideSingleton = provideSingleton;
+exports.provideSingletonAs = provideSingletonAs;
+exports.provideTransient = provideTransient;
+require("reflect-metadata");
+const binding_decorators_1 = require("@inversifyjs/binding-decorators");
+/**
+ * DI provider decorators (the lightweight DI seam shared across webpieces).
+ *
+ * These live in @webpieces/core-context — the lowest package that already owns
+ * request-scoped context — so libraries (cloudtasks-client, http-client, …) can
+ * register singletons WITHOUT depending on the server-side @webpieces/http-routing
+ * package. http-routing re-exports them for back-compat.
+ */
+/**
+ * Provides a singleton-scoped dependency.
+ * When called without arguments, the decorated class binds to itself.
+ *
+ * Usage:
+ * ```typescript
+ * @provideSingleton()
+ * export class SaveController {
+ *   // ...
+ * }
+ * ```
+ */
+function provideSingleton() {
+    // webpieces-disable no-any-unknown -- decorator target is any class constructor
+    return (target) => {
+        return (0, binding_decorators_1.provide)(target, (bind) => bind.inSingletonScope())(target);
+    };
+}
+/**
+ * Provides a singleton-scoped dependency bound to a specific token (Symbol or abstract class).
+ * Use this in libraries/apis-external/** to bind an impl to the Symbol defined in libraries/apis/**.
+ *
+ * Usage:
+ * ```typescript
+ * import { SOME_API_TOKEN } from '@myorg/some-api';
+ *
+ * @provideSingletonAs(SOME_API_TOKEN)
+ * export class SomeApiImpl { ... }
+ * ```
+ */
+function provideSingletonAs(serviceIdentifier) {
+    return (0, binding_decorators_1.provide)(serviceIdentifier, (bind) => bind.inSingletonScope());
+}
+/**
+ * Provides a transient-scoped dependency (new instance every time).
+ * When called without arguments, the decorated class binds to itself.
+ *
+ * Usage:
+ * ```typescript
+ * @provideTransient()
+ * export class TransientController {
+ *   // ...
+ * }
+ * ```
+ */
+function provideTransient() {
+    // webpieces-disable no-any-unknown -- decorator target is any class constructor
+    return (target) => {
+        return (0, binding_decorators_1.provide)(target)(target);
+    };
+}
+//# sourceMappingURL=provide.js.map

package/src/provide.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"provide.js","sourceRoot":"","sources":["../../../../../packages/core/core-context/src/provide.ts"],"names":[],"mappings":";;AAyBA,4CAKC;AAcD,gDAEC;AAcD,4CAKC;AAjED,4BAA0B;AAC1B,wEAA0D;AAG1D;;;;;;;GAOG;AAEH;;;;;;;;;;;GAWG;AACH,SAAgB,gBAAgB;IAC5B,gFAAgF;IAChF,OAAO,CAAC,MAAW,EAAE,EAAE;QACnB,OAAO,IAAA,4BAAO,EAAC,MAAM,EAAE,CAAC,IAAuC,EAAE,EAAE,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC;IACzG,CAAC,CAAC;AACN,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAgB,kBAAkB,CAAI,iBAAuC;IACzE,OAAO,IAAA,4BAAO,EAAC,iBAAiB,EAAE,CAAC,IAAiC,EAAE,EAAE,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC;AACtG,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAgB,gBAAgB;IAC5B,gFAAgF;IAChF,OAAO,CAAC,MAAW,EAAE,EAAE;QACnB,OAAO,IAAA,4BAAO,EAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC;IACnC,CAAC,CAAC;AACN,CAAC","sourcesContent":["import 'reflect-metadata';\nimport { provide } from '@inversifyjs/binding-decorators';\nimport type { BindInWhenOnFluentSyntax, ServiceIdentifier } from 'inversify';\n\n/**\n * DI provider decorators (the lightweight DI seam shared across webpieces).\n *\n * These live in @webpieces/core-context — the lowest package that already owns\n * request-scoped context — so libraries (cloudtasks-client, http-client, …) can\n * register singletons WITHOUT depending on the server-side @webpieces/http-routing\n * package. http-routing re-exports them for back-compat.\n */\n\n/**\n * Provides a singleton-scoped dependency.\n * When called without arguments, the decorated class binds to itself.\n *\n * Usage:\n * ```typescript\n * @provideSingleton()\n * export class SaveController {\n *   // ...\n * }\n * ```\n */\nexport function provideSingleton(): ClassDecorator {\n    // webpieces-disable no-any-unknown -- decorator target is any class constructor\n    return (target: any) => {\n        return provide(target, (bind: BindInWhenOnFluentSyntax<unknown>) => bind.inSingletonScope())(target);\n    };\n}\n\n/**\n * Provides a singleton-scoped dependency bound to a specific token (Symbol or abstract class).\n * Use this in libraries/apis-external/** to bind an impl to the Symbol defined in libraries/apis/**.\n *\n * Usage:\n * ```typescript\n * import { SOME_API_TOKEN } from '@myorg/some-api';\n *\n * @provideSingletonAs(SOME_API_TOKEN)\n * export class SomeApiImpl { ... }\n * ```\n */\nexport function provideSingletonAs<T>(serviceIdentifier: ServiceIdentifier<T>): ClassDecorator {\n    return provide(serviceIdentifier, (bind: BindInWhenOnFluentSyntax<T>) => bind.inSingletonScope());\n}\n\n/**\n * Provides a transient-scoped dependency (new instance every time).\n * When called without arguments, the decorated class binds to itself.\n *\n * Usage:\n * ```typescript\n * @provideTransient()\n * export class TransientController {\n *   // ...\n * }\n * ```\n */\nexport function provideTransient(): ClassDecorator {\n    // webpieces-disable no-any-unknown -- decorator target is any class constructor\n    return (target: any) => {\n        return provide(target)(target);\n    };\n}\n"]}