@webpieces/http-client-node 0.0.0-dev

package/README.md

@@ -0,0 +1,28 @@
+# @webpieces/http-client-node
+
+The server-side HTTP client. The client and the controller share ONE API contract, exactly like
+the Cloud Tasks twin — calling a method makes the HTTP request that contract describes.
+
+```ts
+// inject the factory (a framework singleton), then one client per contract
+const server2 = factory.createClient(Server2Api, new ClientConfig('server2'));
+const res = await server2.fetchValue(req);          // inside a RequestContext
+```
+
+- `svcName` is TYPICALLY the GCP Cloud Run service name, and MUST be when you omit `targetUrl`:
+  we look your service up in the same project and region and form the URL from the container's own
+  metadata, so you maintain no URL table. That works across demo/qa/prod as long as each
+  environment has its own projectId, which is typical.
+- `targetUrl` overrides the lookup for another region, another project, or a non-Cloud-Run host.
+  `svcName` is then used only for logging.
+
+`ClientHttpFactory` injects a `Provider<NodeProxyClient>` and calls `get()` per contract.
+`NodeProxyClient` is bound TRANSIENT, so each client gets its own — the provider caches nothing,
+the target's scope decides. (Bind the target `@provideFrameworkSingleton` instead and the very same
+provider yields a lazy singleton.)
+
+Calls made outside `RequestContext.run(...)` **throw**. An outbound call with no correlation id or
+request-id chain loses the trace, and finding that out in production is worse than a loud error. A
+top-level server filter normally establishes the scope for you.
+
+The browser twin is [@webpieces/http-client-browser](../http-client-browser).

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@webpieces/http-client-node",
+  "version": "0.0.0-dev",
+  "description": "Server-side HTTP client for webpieces: inversify-wired, reads RequestContext directly, mints OIDC/shared-secret delivery auth, resolves Cloud Run URLs from a service name",
+  "type": "commonjs",
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "author": "Dean Hiller",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/deanhiller/webpieces-ts.git",
+    "directory": "packages/http/http-client-node"
+  },
+  "keywords": [
+    "webpieces",
+    "http",
+    "client",
+    "node"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@webpieces/core-context": "workspace:*",
+    "@webpieces/core-util": "workspace:*",
+    "@webpieces/gcp-identity": "workspace:*",
+    "@webpieces/http-client-core": "workspace:*",
+    "inversify": "7.10.4",
+    "reflect-metadata": "0.2.2"
+  }
+}

package/src/ClientConfig.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Per-client STATE for a server-side HTTP client — nothing else. A plain class; it extends nothing
+ * and is unrelated to the browser package's ClientConfig, because the two answer "what URL?"
+ * differently and share nothing worth a base class.
+ *
+ * Collaborators (RequestContextHeaders, Secrets) are NOT config: they are dependencies of
+ * {@link NodeProxyClient} and are shared by every client the factory builds. This is the RPC twin
+ * of cloudtasks-client's TaskClientConfig, and takes the same two fields.
+ */
+export declare class ClientConfig {
+    /**
+     * TYPICALLY the GCP Cloud Run service name — and it MUST be the Cloud Run service name
+     * when you do not supply a `targetUrl`, because we derive the URL from it.
+     *
+     * We lookup your service in the same project, same region, and form the url from the
+     * container information unless you pass in a targetUrl, so you do not have to maintain
+     * targetUrls. This works across your demo, qa, prod environments as long as each
+     * environment is in its own projectId, which is typical.
+     *
+     * When you DO supply a `targetUrl`, svcName is used only for logging, so any readable
+     * name works.
+     */
+    readonly svcName: string;
+    /**
+     * Optional explicit base URL, for the cases lookup cannot describe: another region,
+     * another project, or a host that is not Cloud Run at all. It wins over `svcName`.
+     */
+    readonly targetUrl?: string | undefined;
+    constructor(
+    /**
+     * TYPICALLY the GCP Cloud Run service name — and it MUST be the Cloud Run service name
+     * when you do not supply a `targetUrl`, because we derive the URL from it.
+     *
+     * We lookup your service in the same project, same region, and form the url from the
+     * container information unless you pass in a targetUrl, so you do not have to maintain
+     * targetUrls. This works across your demo, qa, prod environments as long as each
+     * environment is in its own projectId, which is typical.
+     *
+     * When you DO supply a `targetUrl`, svcName is used only for logging, so any readable
+     * name works.
+     */
+    svcName: string, 
+    /**
+     * Optional explicit base URL, for the cases lookup cannot describe: another region,
+     * another project, or a host that is not Cloud Run at all. It wins over `svcName`.
+     */
+    targetUrl?: string | undefined);
+}

package/src/ClientConfig.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientConfig = void 0;
+/**
+ * Per-client STATE for a server-side HTTP client — nothing else. A plain class; it extends nothing
+ * and is unrelated to the browser package's ClientConfig, because the two answer "what URL?"
+ * differently and share nothing worth a base class.
+ *
+ * Collaborators (RequestContextHeaders, Secrets) are NOT config: they are dependencies of
+ * {@link NodeProxyClient} and are shared by every client the factory builds. This is the RPC twin
+ * of cloudtasks-client's TaskClientConfig, and takes the same two fields.
+ */
+class ClientConfig {
+    svcName;
+    targetUrl;
+    constructor(
+    /**
+     * TYPICALLY the GCP Cloud Run service name — and it MUST be the Cloud Run service name
+     * when you do not supply a `targetUrl`, because we derive the URL from it.
+     *
+     * We lookup your service in the same project, same region, and form the url from the
+     * container information unless you pass in a targetUrl, so you do not have to maintain
+     * targetUrls. This works across your demo, qa, prod environments as long as each
+     * environment is in its own projectId, which is typical.
+     *
+     * When you DO supply a `targetUrl`, svcName is used only for logging, so any readable
+     * name works.
+     */
+    svcName, 
+    /**
+     * Optional explicit base URL, for the cases lookup cannot describe: another region,
+     * another project, or a host that is not Cloud Run at all. It wins over `svcName`.
+     */
+    targetUrl) {
+        this.svcName = svcName;
+        this.targetUrl = targetUrl;
+    }
+}
+exports.ClientConfig = ClientConfig;
+//# sourceMappingURL=ClientConfig.js.map

package/src/ClientConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClientConfig.js","sourceRoot":"","sources":["../../../../../packages/http/http-client-node/src/ClientConfig.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;GAQG;AACH,MAAa,YAAY;IAcD;IAMA;IAnBpB;IACI;;;;;;;;;;;OAWG;IACa,OAAe;IAE/B;;;OAGG;IACa,SAAkB;QANlB,YAAO,GAAP,OAAO,CAAQ;QAMf,cAAS,GAAT,SAAS,CAAS;IACnC,CAAC;CACP;AAtBD,oCAsBC","sourcesContent":["/**\n * Per-client STATE for a server-side HTTP client — nothing else. A plain class; it extends nothing\n * and is unrelated to the browser package's ClientConfig, because the two answer \"what URL?\"\n * differently and share nothing worth a base class.\n *\n * Collaborators (RequestContextHeaders, Secrets) are NOT config: they are dependencies of\n * {@link NodeProxyClient} and are shared by every client the factory builds. This is the RPC twin\n * of cloudtasks-client's TaskClientConfig, and takes the same two fields.\n */\nexport class ClientConfig {\n    constructor(\n        /**\n         * TYPICALLY the GCP Cloud Run service name — and it MUST be the Cloud Run service name\n         * when you do not supply a `targetUrl`, because we derive the URL from it.\n         *\n         * We lookup your service in the same project, same region, and form the url from the\n         * container information unless you pass in a targetUrl, so you do not have to maintain\n         * targetUrls. This works across your demo, qa, prod environments as long as each\n         * environment is in its own projectId, which is typical.\n         *\n         * When you DO supply a `targetUrl`, svcName is used only for logging, so any readable\n         * name works.\n         */\n        public readonly svcName: string,\n\n        /**\n         * Optional explicit base URL, for the cases lookup cannot describe: another region,\n         * another project, or a host that is not Cloud Run at all. It wins over `svcName`.\n         */\n        public readonly targetUrl?: string,\n    ) {}\n}\n"]}

package/src/ClientHttpFactory.d.ts

@@ -0,0 +1,43 @@
+import { Provider } from '@webpieces/core-context';
+import type { ApiPrototype } from '@webpieces/http-client-core';
+import { ClientConfig } from './ClientConfig';
+import { NodeProxyClient } from './NodeProxyClient';
+/**
+ * ClientHttpFactory - builds type-safe HTTP clients from API prototypes carrying
+ * @ApiPath/@Endpoint decorators. The SERVER-side factory.
+ *
+ * This is the client-side equivalent of ApiRoutingFactory:
+ * - Server routing: ApiRoutingFactory reads decorators -> routes HTTP requests to controllers
+ * - Server client:  ClientHttpFactory reads decorators -> generates HTTP requests from method calls
+ *
+ * Inject it and ask for a typed client per contract:
+ * ```typescript
+ * // same project + region as this container; the URL is derived, you maintain nothing
+ * const server2 = factory.createClient(Server2Api, new ClientConfig('server2'));
+ *
+ * // or point somewhere lookup cannot describe (other region/project, non-Cloud-Run)
+ * const legacy = factory.createClient(LegacyApi, new ClientConfig('legacy', 'https://legacy.corp'));
+ *
+ * const response = await server2.fetchValue(req);   // inside a RequestContext
+ * ```
+ *
+ * Every client it builds shares one {@link NodeProxyClient} *shape* but never one instance: the
+ * injected `Provider<NodeProxyClient>` hands out a fresh one per contract, which `createClient`
+ * then `init`s. Their collaborators (RequestContextHeaders, Secrets) come from the container, so
+ * the whole dependency graph is visible in this package's design.html.
+ *
+ * Unlike @webpieces/http-client-browser this package is Node-only, so the factory IS the inversify
+ * entry point and the magic context is read straight from the RequestContext. A call made outside
+ * `RequestContext.run(...)` throws rather than silently dropping the trace.
+ */
+export declare class ClientHttpFactory {
+    private readonly proxyClientProvider;
+    constructor(proxyClientProvider: Provider<NodeProxyClient>);
+    /**
+     * Create a type-safe HTTP client for one API contract.
+     *
+     * @param apiPrototype - The API prototype class with @ApiPath/@Endpoint decorators
+     * @param config - This client's state (its svcName, and optionally an explicit targetUrl)
+     */
+    createClient<T extends object>(apiPrototype: ApiPrototype<T>, config: ClientConfig): T;
+}

package/src/ClientHttpFactory.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientHttpFactory = void 0;
+const tslib_1 = require("tslib");
+const inversify_1 = require("inversify");
+const core_util_1 = require("@webpieces/core-util");
+const core_context_1 = require("@webpieces/core-context");
+const http_client_core_1 = require("@webpieces/http-client-core");
+const NodeProxyClient_1 = require("./NodeProxyClient");
+// Teach the container how to hand out fresh NodeProxyClients. NodeProxyClient is bound TRANSIENT
+// (@provideFrameworkTransient), so each provider.get() constructs a new one.
+(0, core_context_1.bindFrameworkProvider)(NodeProxyClient_1.NODE_PROXY_CLIENT_PROVIDER, NodeProxyClient_1.NodeProxyClient);
+/**
+ * ClientHttpFactory - builds type-safe HTTP clients from API prototypes carrying
+ * @ApiPath/@Endpoint decorators. The SERVER-side factory.
+ *
+ * This is the client-side equivalent of ApiRoutingFactory:
+ * - Server routing: ApiRoutingFactory reads decorators -> routes HTTP requests to controllers
+ * - Server client:  ClientHttpFactory reads decorators -> generates HTTP requests from method calls
+ *
+ * Inject it and ask for a typed client per contract:
+ * ```typescript
+ * // same project + region as this container; the URL is derived, you maintain nothing
+ * const server2 = factory.createClient(Server2Api, new ClientConfig('server2'));
+ *
+ * // or point somewhere lookup cannot describe (other region/project, non-Cloud-Run)
+ * const legacy = factory.createClient(LegacyApi, new ClientConfig('legacy', 'https://legacy.corp'));
+ *
+ * const response = await server2.fetchValue(req);   // inside a RequestContext
+ * ```
+ *
+ * Every client it builds shares one {@link NodeProxyClient} *shape* but never one instance: the
+ * injected `Provider<NodeProxyClient>` hands out a fresh one per contract, which `createClient`
+ * then `init`s. Their collaborators (RequestContextHeaders, Secrets) come from the container, so
+ * the whole dependency graph is visible in this package's design.html.
+ *
+ * Unlike @webpieces/http-client-browser this package is Node-only, so the factory IS the inversify
+ * entry point and the magic context is read straight from the RequestContext. A call made outside
+ * `RequestContext.run(...)` throws rather than silently dropping the trace.
+ */
+let ClientHttpFactory = class ClientHttpFactory {
+    proxyClientProvider;
+    constructor(proxyClientProvider) {
+        this.proxyClientProvider = proxyClientProvider;
+    }
+    /**
+     * Create a type-safe HTTP client for one API contract.
+     *
+     * @param apiPrototype - The API prototype class with @ApiPath/@Endpoint decorators
+     * @param config - This client's state (its svcName, and optionally an explicit targetUrl)
+     */
+    createClient(apiPrototype, config) {
+        // Fresh instance per contract — NodeProxyClient is transient. init() binds it to this
+        // contract + target; the collaborators already came from the container.
+        const proxyClient = this.proxyClientProvider.get();
+        proxyClient.init(apiPrototype, config);
+        return (0, http_client_core_1.buildClientProxy)(apiPrototype, proxyClient);
+    }
+};
+exports.ClientHttpFactory = ClientHttpFactory;
+exports.ClientHttpFactory = ClientHttpFactory = tslib_1.__decorate([
+    (0, core_util_1.DocumentDesign)(),
+    (0, core_context_1.provideFrameworkSingleton)(),
+    (0, inversify_1.injectable)(),
+    tslib_1.__param(0, (0, inversify_1.inject)(NodeProxyClient_1.NODE_PROXY_CLIENT_PROVIDER)),
+    tslib_1.__metadata("design:paramtypes", [core_context_1.Provider])
+], ClientHttpFactory);
+//# sourceMappingURL=ClientHttpFactory.js.map

package/src/ClientHttpFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClientHttpFactory.js","sourceRoot":"","sources":["../../../../../packages/http/http-client-node/src/ClientHttpFactory.ts"],"names":[],"mappings":";;;;AAAA,yCAA+C;AAC/C,oDAAsD;AACtD,0DAAqG;AAErG,kEAA+D;AAE/D,uDAAgF;AAEhF,iGAAiG;AACjG,6EAA6E;AAC7E,IAAA,oCAAqB,EAAC,4CAA0B,EAAE,iCAAe,CAAC,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAII,IAAM,iBAAiB,GAAvB,MAAM,iBAAiB;IAE+B;IADzD,YACyD,mBAA8C;QAA9C,wBAAmB,GAAnB,mBAAmB,CAA2B;IACpG,CAAC;IAEJ;;;;;OAKG;IACH,YAAY,CAAmB,YAA6B,EAAE,MAAoB;QAC9E,sFAAsF;QACtF,wEAAwE;QACxE,MAAM,WAAW,GAAG,IAAI,CAAC,mBAAmB,CAAC,GAAG,EAAE,CAAC;QACnD,WAAW,CAAC,IAAI,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;QACvC,OAAO,IAAA,mCAAgB,EAAC,YAAY,EAAE,WAAW,CAAC,CAAC;IACvD,CAAC;CACJ,CAAA;AAlBY,8CAAiB;4BAAjB,iBAAiB;IAH7B,IAAA,0BAAc,GAAE;IAChB,IAAA,wCAAyB,GAAE;IAC3B,IAAA,sBAAU,GAAE;IAGJ,mBAAA,IAAA,kBAAM,EAAC,4CAA0B,CAAC,CAAA;6CAAuC,uBAAQ;GAF7E,iBAAiB,CAkB7B","sourcesContent":["import { inject, injectable } from 'inversify';\nimport { DocumentDesign } from '@webpieces/core-util';\nimport { Provider, bindFrameworkProvider, provideFrameworkSingleton } from '@webpieces/core-context';\nimport type { ApiPrototype } from '@webpieces/http-client-core';\nimport { buildClientProxy } from '@webpieces/http-client-core';\nimport { ClientConfig } from './ClientConfig';\nimport { NODE_PROXY_CLIENT_PROVIDER, NodeProxyClient } from './NodeProxyClient';\n\n// Teach the container how to hand out fresh NodeProxyClients. NodeProxyClient is bound TRANSIENT\n// (@provideFrameworkTransient), so each provider.get() constructs a new one.\nbindFrameworkProvider(NODE_PROXY_CLIENT_PROVIDER, NodeProxyClient);\n\n/**\n * ClientHttpFactory - builds type-safe HTTP clients from API prototypes carrying\n * @ApiPath/@Endpoint decorators. The SERVER-side factory.\n *\n * This is the client-side equivalent of ApiRoutingFactory:\n * - Server routing: ApiRoutingFactory reads decorators -> routes HTTP requests to controllers\n * - Server client:  ClientHttpFactory reads decorators -> generates HTTP requests from method calls\n *\n * Inject it and ask for a typed client per contract:\n * ```typescript\n * // same project + region as this container; the URL is derived, you maintain nothing\n * const server2 = factory.createClient(Server2Api, new ClientConfig('server2'));\n *\n * // or point somewhere lookup cannot describe (other region/project, non-Cloud-Run)\n * const legacy = factory.createClient(LegacyApi, new ClientConfig('legacy', 'https://legacy.corp'));\n *\n * const response = await server2.fetchValue(req);   // inside a RequestContext\n * ```\n *\n * Every client it builds shares one {@link NodeProxyClient} *shape* but never one instance: the\n * injected `Provider<NodeProxyClient>` hands out a fresh one per contract, which `createClient`\n * then `init`s. Their collaborators (RequestContextHeaders, Secrets) come from the container, so\n * the whole dependency graph is visible in this package's design.html.\n *\n * Unlike @webpieces/http-client-browser this package is Node-only, so the factory IS the inversify\n * entry point and the magic context is read straight from the RequestContext. A call made outside\n * `RequestContext.run(...)` throws rather than silently dropping the trace.\n */\n@DocumentDesign()\n@provideFrameworkSingleton()\n@injectable()\nexport class ClientHttpFactory {\n    constructor(\n        @inject(NODE_PROXY_CLIENT_PROVIDER) private readonly proxyClientProvider: Provider<NodeProxyClient>,\n    ) {}\n\n    /**\n     * Create a type-safe HTTP client for one API contract.\n     *\n     * @param apiPrototype - The API prototype class with @ApiPath/@Endpoint decorators\n     * @param config - This client's state (its svcName, and optionally an explicit targetUrl)\n     */\n    createClient<T extends object>(apiPrototype: ApiPrototype<T>, config: ClientConfig): T {\n        // Fresh instance per contract — NodeProxyClient is transient. init() binds it to this\n        // contract + target; the collaborators already came from the container.\n        const proxyClient = this.proxyClientProvider.get();\n        proxyClient.init(apiPrototype, config);\n        return buildClientProxy(apiPrototype, proxyClient);\n    }\n}\n"]}

package/src/NodeProxyClient.d.ts

@@ -0,0 +1,60 @@
+import { AuthMeta, RouteMetadata, Secrets } from '@webpieces/core-util';
+import { RequestContextHeaders } from '@webpieces/core-context';
+import { ApiPrototype, ProxyClient } from '@webpieces/http-client-core';
+import { ClientConfig } from './ClientConfig';
+/**
+ * The server-side {@link ProxyClient}. Everything a browser cannot do lives here: reading the
+ * ambient RequestContext, minting OIDC tokens, holding shared secrets, and recording test cases.
+ *
+ * TRANSIENT on purpose. Every `createClient(api, config)` needs its own instance, because `init()`
+ * binds one instance to exactly one API contract and one target. {@link ProxyClientProvider} hands
+ * them out — see its doc.
+ */
+export declare class NodeProxyClient extends ProxyClient {
+    private readonly headers;
+    private readonly secrets?;
+    private config;
+    constructor(headers: RequestContextHeaders, secrets?: Secrets | undefined);
+    /** Bind this client to one API contract + target. */
+    init(apiPrototype: ApiPrototype<object>, config: ClientConfig): void;
+    /**
+     * Resolved per call, never at construction, so building a client stays synchronous. Every GCP
+     * metadata read beneath resolveTargetUrl is memoized process-wide, so only the first call pays.
+     */
+    protected resolveBaseUrl(): Promise<string>;
+    /** Straight from the RequestContext. Throws when there is no active request scope. */
+    protected outboundHeaders(): Map<string, string>;
+    /**
+     * Attach the outbound credential for the endpoint's AuthMode: an @AuthOidc bearer minted as
+     * this caller's runtime SA (audience = the callee base URL — the server verifies the signature
+     * + caller allow-list), or the @AuthSharedSecret(key) value THIS client sends from its bound
+     * {@link Secrets}. Both ride in the ONE `Authorization` header under their own scheme —
+     * `Bearer <oidc>` / `Webpieces <secret>` — which is never a context key, so it cannot leak onto
+     * the next hop. Never reads process.env.
+     */
+    protected attachOutboundAuth(route: RouteMetadata, baseUrl: string, httpHeaders: Record<string, string>): Promise<void>;
+    /**
+     * Test-case recording hook (mirror of Java HttpsJsonClientInvokeHandler): if a recorder is
+     * travelling in the magic context, capture this outbound call + its result so it becomes a mock
+     * in the generated test. Absent a recorder this is exactly the base behavior.
+     */
+    protected execute(route: RouteMetadata, requestDto: unknown, method: () => Promise<unknown>): Promise<unknown>;
+    /**
+     * Execute the call while recording it (args + masked ctx snapshot + result).
+     *
+     * The snapshot is a FIXTURE field, not a log line, so it is built here rather than handed down
+     * from the call path — a logging backend stamps its own fields and never sees this.
+     */
+    private recordCall;
+    /** A server can satisfy every auth mode, so nothing is rejected at bind time. */
+    protected assertEndpointSupported(_authMeta: AuthMeta | undefined, _methodName: string): void;
+}
+/**
+ * DI token for the `Provider<NodeProxyClient>` that hands out RPC clients — one per API contract.
+ * `Provider<T>` is erased at runtime, so it cannot be its own token; this Symbol names T.
+ *
+ * Because NodeProxyClient is bound TRANSIENT, every `get()` constructs a new one. (Were it bound
+ * `@provideFrameworkSingleton`, the very same Provider would instead hand back one lazily-created
+ * instance — the provider caches nothing, so the target's scope decides.)
+ */
+export declare const NODE_PROXY_CLIENT_PROVIDER: unique symbol;

package/src/NodeProxyClient.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NODE_PROXY_CLIENT_PROVIDER = exports.NodeProxyClient = void 0;
+const tslib_1 = require("tslib");
+const inversify_1 = require("inversify");
+const core_util_1 = require("@webpieces/core-util");
+const core_context_1 = require("@webpieces/core-context");
+const gcp_identity_1 = require("@webpieces/gcp-identity");
+const http_client_core_1 = require("@webpieces/http-client-core");
+/**
+ * The server-side {@link ProxyClient}. Everything a browser cannot do lives here: reading the
+ * ambient RequestContext, minting OIDC tokens, holding shared secrets, and recording test cases.
+ *
+ * TRANSIENT on purpose. Every `createClient(api, config)` needs its own instance, because `init()`
+ * binds one instance to exactly one API contract and one target. {@link ProxyClientProvider} hands
+ * them out — see its doc.
+ */
+let NodeProxyClient = class NodeProxyClient extends http_client_core_1.ProxyClient {
+    headers;
+    secrets;
+    config;
+    constructor(headers, secrets) {
+        super();
+        this.headers = headers;
+        this.secrets = secrets;
+    }
+    /** Bind this client to one API contract + target. */
+    init(apiPrototype, config) {
+        this.config = config;
+        this.initRoutes(apiPrototype);
+    }
+    /**
+     * Resolved per call, never at construction, so building a client stays synchronous. Every GCP
+     * metadata read beneath resolveTargetUrl is memoized process-wide, so only the first call pays.
+     */
+    resolveBaseUrl() {
+        return (0, gcp_identity_1.resolveTargetUrl)(this.config.svcName, this.config.targetUrl);
+    }
+    /** Straight from the RequestContext. Throws when there is no active request scope. */
+    outboundHeaders() {
+        return this.headers.buildOutboundHeaders();
+    }
+    /**
+     * Attach the outbound credential for the endpoint's AuthMode: an @AuthOidc bearer minted as
+     * this caller's runtime SA (audience = the callee base URL — the server verifies the signature
+     * + caller allow-list), or the @AuthSharedSecret(key) value THIS client sends from its bound
+     * {@link Secrets}. Both ride in the ONE `Authorization` header under their own scheme —
+     * `Bearer <oidc>` / `Webpieces <secret>` — which is never a context key, so it cannot leak onto
+     * the next hop. Never reads process.env.
+     */
+    async attachOutboundAuth(route, baseUrl, httpHeaders) {
+        const mode = route.authMeta?.mode;
+        if (mode?.kind === 'oidc') {
+            httpHeaders['Authorization'] = `Bearer ${await (0, gcp_identity_1.mintIdToken)(baseUrl)}`;
+        }
+        else if (mode?.kind === 'shared-secret') {
+            const secret = this.secrets?.get(mode.secretKey);
+            if (!secret) {
+                throw new Error(`No shared secret configured for @AuthSharedSecret('${mode.secretKey}') endpoint ${route.methodName}`);
+            }
+            // Same header as a JWT/OIDC token, but its OWN scheme, so a secret can never be
+            // mistaken for a token nor accepted where one was expected.
+            httpHeaders['Authorization'] = `Webpieces ${secret}`;
+        }
+    }
+    /**
+     * Test-case recording hook (mirror of Java HttpsJsonClientInvokeHandler): if a recorder is
+     * travelling in the magic context, capture this outbound call + its result so it becomes a mock
+     * in the generated test. Absent a recorder this is exactly the base behavior.
+     */
+    // webpieces-disable no-any-unknown -- DTO types are erased at the proxy boundary
+    async execute(route, requestDto, 
+    // webpieces-disable no-any-unknown -- DTO types are erased at the proxy boundary
+    method) {
+        const recorder = this.headers.findRecorder();
+        if (!recorder) {
+            return super.execute(route, requestDto, method);
+        }
+        return this.recordCall(recorder, route, requestDto, method);
+    }
+    /**
+     * Execute the call while recording it (args + masked ctx snapshot + result).
+     *
+     * The snapshot is a FIXTURE field, not a log line, so it is built here rather than handed down
+     * from the call path — a logging backend stamps its own fields and never sees this.
+     */
+    // webpieces-disable no-any-unknown -- DTO types are erased at the proxy boundary
+    async recordCall(recorder, route, requestDto, 
+    // webpieces-disable no-any-unknown -- DTO types are erased at the proxy boundary
+    method) {
+        const ctxSnapshot = {};
+        for (const entry of core_context_1.RequestContext.buildLogFields().entries()) {
+            ctxSnapshot[entry[0]] = entry[1];
+        }
+        const recorded = new core_util_1.RecordedEndpoint(this.contractName(), route.methodName, [requestDto], ctxSnapshot);
+        recorder.addEndpointInfo(recorded);
+        // eslint-disable-next-line @webpieces/no-unmanaged-exceptions -- capture failure into the recording, then rethrow unchanged
+        try {
+            const response = await super.execute(route, requestDto, method);
+            recorded.successResponse = response;
+            return response;
+        }
+        catch (err) {
+            const error = (0, core_util_1.toError)(err);
+            recorded.failureResponse = new core_util_1.RecordedError(error.name, error.message);
+            throw err;
+        }
+    }
+    /** A server can satisfy every auth mode, so nothing is rejected at bind time. */
+    assertEndpointSupported(_authMeta, _methodName) { }
+};
+exports.NodeProxyClient = NodeProxyClient;
+exports.NodeProxyClient = NodeProxyClient = tslib_1.__decorate([
+    (0, core_context_1.provideFrameworkTransient)(),
+    (0, inversify_1.injectable)(),
+    tslib_1.__param(0, (0, inversify_1.inject)(core_context_1.RequestContextHeaders)),
+    tslib_1.__param(1, (0, inversify_1.optional)()),
+    tslib_1.__param(1, (0, inversify_1.inject)(core_util_1.Secrets)),
+    tslib_1.__metadata("design:paramtypes", [core_context_1.RequestContextHeaders,
+        core_util_1.Secrets])
+], NodeProxyClient);
+/**
+ * DI token for the `Provider<NodeProxyClient>` that hands out RPC clients — one per API contract.
+ * `Provider<T>` is erased at runtime, so it cannot be its own token; this Symbol names T.
+ *
+ * Because NodeProxyClient is bound TRANSIENT, every `get()` constructs a new one. (Were it bound
+ * `@provideFrameworkSingleton`, the very same Provider would instead hand back one lazily-created
+ * instance — the provider caches nothing, so the target's scope decides.)
+ */
+// webpieces-disable no-symbol-di-tokens -- Provider<T> is erased at runtime; the Symbol names T
+exports.NODE_PROXY_CLIENT_PROVIDER = Symbol.for('Provider<NodeProxyClient>');
+//# sourceMappingURL=NodeProxyClient.js.map

package/src/NodeProxyClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeProxyClient.js","sourceRoot":"","sources":["../../../../../packages/http/http-client-node/src/NodeProxyClient.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, injectable, optional } from 'inversify';\nimport {\n    AuthMeta,\n    RecordedEndpoint,\n    RecordedError,\n    RouteMetadata,\n    Secrets,\n    TestCaseRecorder,\n    toError,\n} from '@webpieces/core-util';\nimport { RequestContext, RequestContextHeaders, provideFrameworkTransient } from '@webpieces/core-context';\nimport { mintIdToken, resolveTargetUrl } from '@webpieces/gcp-identity';\nimport { ApiPrototype, ProxyClient } from '@webpieces/http-client-core';\nimport { ClientConfig } from './ClientConfig';\n\n/**\n * The server-side {@link ProxyClient}. Everything a browser cannot do lives here: reading the\n * ambient RequestContext, minting OIDC tokens, holding shared secrets, and recording test cases.\n *\n * TRANSIENT on purpose. Every `createClient(api, config)` needs its own instance, because `init()`\n * binds one instance to exactly one API contract and one target. {@link ProxyClientProvider} hands\n * them out — see its doc.\n */\n@provideFrameworkTransient()\n@injectable()\nexport class NodeProxyClient extends ProxyClient {\n    private config!: ClientConfig;\n\n    constructor(\n        @inject(RequestContextHeaders) private readonly headers: RequestContextHeaders,\n        // @optional: only @AuthSharedSecret endpoints need it; the client sends its bound value.\n        @optional() @inject(Secrets) private readonly secrets?: Secrets,\n    ) {\n        super();\n    }\n\n    /** Bind this client to one API contract + target. */\n    init(apiPrototype: ApiPrototype<object>, config: ClientConfig): void {\n        this.config = config;\n        this.initRoutes(apiPrototype);\n    }\n\n    /**\n     * Resolved per call, never at construction, so building a client stays synchronous. Every GCP\n     * metadata read beneath resolveTargetUrl is memoized process-wide, so only the first call pays.\n     */\n    protected override resolveBaseUrl(): Promise<string> {\n        return resolveTargetUrl(this.config.svcName, this.config.targetUrl);\n    }\n\n    /** Straight from the RequestContext. Throws when there is no active request scope. */\n    protected override outboundHeaders(): Map<string, string> {\n        return this.headers.buildOutboundHeaders();\n    }\n\n    /**\n     * Attach the outbound credential for the endpoint's AuthMode: an @AuthOidc bearer minted as\n     * this caller's runtime SA (audience = the callee base URL — the server verifies the signature\n     * + caller allow-list), or the @AuthSharedSecret(key) value THIS client sends from its bound\n     * {@link Secrets}. Both ride in the ONE `Authorization` header under their own scheme —\n     * `Bearer <oidc>` / `Webpieces <secret>` — which is never a context key, so it cannot leak onto\n     * the next hop. Never reads process.env.\n     */\n    protected override async attachOutboundAuth(\n        route: RouteMetadata,\n        baseUrl: string,\n        httpHeaders: Record<string, string>,\n    ): Promise<void> {\n        const mode = route.authMeta?.mode;\n        if (mode?.kind === 'oidc') {\n            httpHeaders['Authorization'] = `Bearer ${await mintIdToken(baseUrl)}`;\n        } else if (mode?.kind === 'shared-secret') {\n            const secret = this.secrets?.get(mode.secretKey);\n            if (!secret) {\n                throw new Error(\n                    `No shared secret configured for @AuthSharedSecret('${mode.secretKey}') endpoint ${route.methodName}`,\n                );\n            }\n            // Same header as a JWT/OIDC token, but its OWN scheme, so a secret can never be\n            // mistaken for a token nor accepted where one was expected.\n            httpHeaders['Authorization'] = `Webpieces ${secret}`;\n        }\n    }\n\n    /**\n     * Test-case recording hook (mirror of Java HttpsJsonClientInvokeHandler): if a recorder is\n     * travelling in the magic context, capture this outbound call + its result so it becomes a mock\n     * in the generated test. Absent a recorder this is exactly the base behavior.\n     */\n    // webpieces-disable no-any-unknown -- DTO types are erased at the proxy boundary\n    protected override async execute(\n        route: RouteMetadata,\n        requestDto: unknown,\n        // webpieces-disable no-any-unknown -- DTO types are erased at the proxy boundary\n        method: () => Promise<unknown>,\n        // webpieces-disable no-any-unknown -- DTO types are erased at the proxy boundary\n    ): Promise<unknown> {\n        const recorder = this.headers.findRecorder();\n        if (!recorder) {\n            return super.execute(route, requestDto, method);\n        }\n        return this.recordCall(recorder, route, requestDto, method);\n    }\n\n    /**\n     * Execute the call while recording it (args + masked ctx snapshot + result).\n     *\n     * The snapshot is a FIXTURE field, not a log line, so it is built here rather than handed down\n     * from the call path — a logging backend stamps its own fields and never sees this.\n     */\n    // webpieces-disable no-any-unknown -- DTO types are erased at the proxy boundary\n    private async recordCall(\n        recorder: TestCaseRecorder,\n        route: RouteMetadata,\n        requestDto: unknown,\n        // webpieces-disable no-any-unknown -- DTO types are erased at the proxy boundary\n        method: () => Promise<unknown>,\n        // webpieces-disable no-any-unknown -- DTO types are erased at the proxy boundary\n    ): Promise<unknown> {\n        const ctxSnapshot: Record<string, string> = {};\n        for (const entry of RequestContext.buildLogFields().entries()) {\n            ctxSnapshot[entry[0]] = entry[1];\n        }\n        const recorded = new RecordedEndpoint(this.contractName(), route.methodName, [requestDto], ctxSnapshot);\n        recorder.addEndpointInfo(recorded);\n\n        // eslint-disable-next-line @webpieces/no-unmanaged-exceptions -- capture failure into the recording, then rethrow unchanged\n        try {\n            const response = await super.execute(route, requestDto, method);\n            recorded.successResponse = response;\n            return response;\n        } catch (err: unknown) {\n            const error = toError(err);\n            recorded.failureResponse = new RecordedError(error.name, error.message);\n            throw err;\n        }\n    }\n\n    /** A server can satisfy every auth mode, so nothing is rejected at bind time. */\n    protected override assertEndpointSupported(_authMeta: AuthMeta | undefined, _methodName: string): void {}\n}\n\n/**\n * DI token for the `Provider<NodeProxyClient>` that hands out RPC clients — one per API contract.\n * `Provider<T>` is erased at runtime, so it cannot be its own token; this Symbol names T.\n *\n * Because NodeProxyClient is bound TRANSIENT, every `get()` constructs a new one. (Were it bound\n * `@provideFrameworkSingleton`, the very same Provider would instead hand back one lazily-created\n * instance — the provider caches nothing, so the target's scope decides.)\n */\n// webpieces-disable no-symbol-di-tokens -- Provider<T> is erased at runtime; the Symbol names T\nexport const NODE_PROXY_CLIENT_PROVIDER = Symbol.for('Provider<NodeProxyClient>');\n"]}

package/src/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @webpieces/http-client-node
+ *
+ * The SERVER-side HTTP client. Reads an API contract's decorators and generates type-safe HTTP
+ * clients from it — the same contract the callee's controller implements.
+ *
+ * Node-only, so unlike @webpieces/http-client-browser it is fully inversify-wired and reads the
+ * magic context straight out of the AsyncLocalStorage-backed RequestContext. There is no
+ * ContextReader indirection, because a server has exactly one right answer, and a call made
+ * OUTSIDE `RequestContext.run(...)` throws instead of silently dropping the trace.
+ *
+ * Usage:
+ * ```typescript
+ * import { ClientHttpFactory, ClientConfig } from '@webpieces/http-client-node';
+ *
+ * // inject the factory, then one client per contract
+ * const server2 = factory.createClient(Server2Api, new ClientConfig('server2'));
+ * const response = await server2.fetchValue(req);
+ * ```
+ */
+export { ClientHttpFactory } from './ClientHttpFactory';
+export { NodeProxyClient, NODE_PROXY_CLIENT_PROVIDER } from './NodeProxyClient';
+export { ClientConfig } from './ClientConfig';
+export { ProxyClient, ClientErrorTranslator } from '@webpieces/http-client-core';
+export type { ApiPrototype } from '@webpieces/http-client-core';

package/src/index.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * @webpieces/http-client-node
+ *
+ * The SERVER-side HTTP client. Reads an API contract's decorators and generates type-safe HTTP
+ * clients from it — the same contract the callee's controller implements.
+ *
+ * Node-only, so unlike @webpieces/http-client-browser it is fully inversify-wired and reads the
+ * magic context straight out of the AsyncLocalStorage-backed RequestContext. There is no
+ * ContextReader indirection, because a server has exactly one right answer, and a call made
+ * OUTSIDE `RequestContext.run(...)` throws instead of silently dropping the trace.
+ *
+ * Usage:
+ * ```typescript
+ * import { ClientHttpFactory, ClientConfig } from '@webpieces/http-client-node';
+ *
+ * // inject the factory, then one client per contract
+ * const server2 = factory.createClient(Server2Api, new ClientConfig('server2'));
+ * const response = await server2.fetchValue(req);
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientErrorTranslator = exports.ProxyClient = exports.ClientConfig = exports.NODE_PROXY_CLIENT_PROVIDER = exports.NodeProxyClient = exports.ClientHttpFactory = void 0;
+var ClientHttpFactory_1 = require("./ClientHttpFactory");
+Object.defineProperty(exports, "ClientHttpFactory", { enumerable: true, get: function () { return ClientHttpFactory_1.ClientHttpFactory; } });
+var NodeProxyClient_1 = require("./NodeProxyClient");
+Object.defineProperty(exports, "NodeProxyClient", { enumerable: true, get: function () { return NodeProxyClient_1.NodeProxyClient; } });
+Object.defineProperty(exports, "NODE_PROXY_CLIENT_PROVIDER", { enumerable: true, get: function () { return NodeProxyClient_1.NODE_PROXY_CLIENT_PROVIDER; } });
+var ClientConfig_1 = require("./ClientConfig");
+Object.defineProperty(exports, "ClientConfig", { enumerable: true, get: function () { return ClientConfig_1.ClientConfig; } });
+// The isomorphic engine, re-exported so a server app needs one import.
+var http_client_core_1 = require("@webpieces/http-client-core");
+Object.defineProperty(exports, "ProxyClient", { enumerable: true, get: function () { return http_client_core_1.ProxyClient; } });
+Object.defineProperty(exports, "ClientErrorTranslator", { enumerable: true, get: function () { return http_client_core_1.ClientErrorTranslator; } });
+//# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../packages/http/http-client-node/src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;GAmBG;;;AAEH,yDAAwD;AAA/C,sHAAA,iBAAiB,OAAA;AAC1B,qDAAgF;AAAvE,kHAAA,eAAe,OAAA;AAAE,6HAAA,0BAA0B,OAAA;AACpD,+CAA8C;AAArC,4GAAA,YAAY,OAAA;AAErB,uEAAuE;AACvE,gEAAiF;AAAxE,+GAAA,WAAW,OAAA;AAAE,yHAAA,qBAAqB,OAAA","sourcesContent":["/**\n * @webpieces/http-client-node\n *\n * The SERVER-side HTTP client. Reads an API contract's decorators and generates type-safe HTTP\n * clients from it — the same contract the callee's controller implements.\n *\n * Node-only, so unlike @webpieces/http-client-browser it is fully inversify-wired and reads the\n * magic context straight out of the AsyncLocalStorage-backed RequestContext. There is no\n * ContextReader indirection, because a server has exactly one right answer, and a call made\n * OUTSIDE `RequestContext.run(...)` throws instead of silently dropping the trace.\n *\n * Usage:\n * ```typescript\n * import { ClientHttpFactory, ClientConfig } from '@webpieces/http-client-node';\n *\n * // inject the factory, then one client per contract\n * const server2 = factory.createClient(Server2Api, new ClientConfig('server2'));\n * const response = await server2.fetchValue(req);\n * ```\n */\n\nexport { ClientHttpFactory } from './ClientHttpFactory';\nexport { NodeProxyClient, NODE_PROXY_CLIENT_PROVIDER } from './NodeProxyClient';\nexport { ClientConfig } from './ClientConfig';\n\n// The isomorphic engine, re-exported so a server app needs one import.\nexport { ProxyClient, ClientErrorTranslator } from '@webpieces/http-client-core';\nexport type { ApiPrototype } from '@webpieces/http-client-core';\n"]}