@webpieces/http-client-browser 0.0.0-dev

package/README.md

@@ -0,0 +1,25 @@
+# @webpieces/http-client-browser
+
+The browser HTTP client. The client and the server share ONE API contract; calling a method on the
+client makes the HTTP request the server's controller answers.
+
+DI-free on purpose — this may be bundled by React or Angular, so it ships no inversify and no
+`@webpieces/core-context`. Browsers have no ambient request scope, so the app holds a
+`MutableContextStore` and sets values as they become known; every outbound call transfers them.
+
+```ts
+HeaderRegistry.configure(AppHeaders.getAllHeaders(), CompanyHeaders.getAllHeaders(), true);
+
+const store = new MutableContextStore();
+const factory = new ClientHttpBrowserFactory(store);
+const saveApi = factory.createClient(SaveApi, new ClientConfig(env.apiBaseUrl));
+
+const res = await saveApi.save({ query: 'test' });   // type-safe
+
+// later, after login — every subsequent call carries these
+store.set(WebpiecesCoreHeaders.AUTHORIZATION, token);
+store.set(CompanyHeaders.TENANT_ID, tenantId);
+```
+
+A browser cannot hold service credentials, so a contract with an `@AuthOidc` endpoint fails fast at
+`createClient`. The server twin is [@webpieces/http-client-node](../http-client-node).

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@webpieces/http-client-browser",
+  "version": "0.0.0-dev",
+  "description": "Browser HTTP client for webpieces: DI-free (React or Angular), app-managed context store, no AsyncLocalStorage",
+  "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-browser"
+  },
+  "keywords": [
+    "webpieces",
+    "http",
+    "client",
+    "browser"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@webpieces/core-util": "workspace:*",
+    "@webpieces/http-client-core": "workspace:*"
+  }
+}

package/src/BrowserProxyClient.d.ts

@@ -0,0 +1,28 @@
+import { AuthMeta, ContextMgr } from '@webpieces/core-util';
+import { ApiPrototype, ProxyClient } from '@webpieces/http-client-core';
+import { ClientConfig } from './ClientConfig';
+/**
+ * The browser {@link ProxyClient}. Reads context from the app-held store (via {@link ContextMgr}),
+ * because a browser has no ambient request scope.
+ *
+ * It attaches NO outbound credential and does NO recording — both inherit the base's no-ops. A
+ * browser cannot mint an OIDC token and must never hold a shared secret; the user's JWT travels as
+ * an ordinary transferred context key, set on the store at login.
+ *
+ * This is the ONLY class in webpieces that names ContextMgr.
+ */
+export declare class BrowserProxyClient extends ProxyClient {
+    private readonly contextMgr;
+    private config;
+    constructor(contextMgr: ContextMgr);
+    /** Bind this client to one API contract + base URL. */
+    init(apiPrototype: ApiPrototype<object>, config: ClientConfig): void;
+    protected resolveBaseUrl(): Promise<string>;
+    protected outboundHeaders(): Map<string, string>;
+    /**
+     * Reject a contract this browser cannot satisfy, at bind time rather than on the first call.
+     * Both service-to-service modes need credentials only a server has: @AuthOidc needs a runtime
+     * service account to mint a token, @AuthSharedSecret needs a secret no browser may ship.
+     */
+    protected assertEndpointSupported(authMeta: AuthMeta | undefined, methodName: string): void;
+}

package/src/BrowserProxyClient.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserProxyClient = void 0;
+const http_client_core_1 = require("@webpieces/http-client-core");
+/**
+ * The browser {@link ProxyClient}. Reads context from the app-held store (via {@link ContextMgr}),
+ * because a browser has no ambient request scope.
+ *
+ * It attaches NO outbound credential and does NO recording — both inherit the base's no-ops. A
+ * browser cannot mint an OIDC token and must never hold a shared secret; the user's JWT travels as
+ * an ordinary transferred context key, set on the store at login.
+ *
+ * This is the ONLY class in webpieces that names ContextMgr.
+ */
+class BrowserProxyClient extends http_client_core_1.ProxyClient {
+    contextMgr;
+    config;
+    constructor(contextMgr) {
+        super();
+        this.contextMgr = contextMgr;
+    }
+    /** Bind this client to one API contract + base URL. */
+    init(apiPrototype, config) {
+        this.config = config;
+        this.initRoutes(apiPrototype);
+    }
+    resolveBaseUrl() {
+        return Promise.resolve(this.config.baseUrl);
+    }
+    outboundHeaders() {
+        return this.contextMgr.buildOutboundHeaders();
+    }
+    /**
+     * Reject a contract this browser cannot satisfy, at bind time rather than on the first call.
+     * Both service-to-service modes need credentials only a server has: @AuthOidc needs a runtime
+     * service account to mint a token, @AuthSharedSecret needs a secret no browser may ship.
+     */
+    assertEndpointSupported(authMeta, methodName) {
+        const kind = authMeta?.mode.kind;
+        if (kind !== 'oidc' && kind !== 'shared-secret') {
+            return;
+        }
+        throw new Error(`Endpoint ${methodName} is @${kind === 'oidc' ? 'AuthOidc' : 'AuthSharedSecret'} — a browser cannot ` +
+            `hold service credentials. Call it server-side with ClientHttpFactory from @webpieces/http-client-node.`);
+    }
+}
+exports.BrowserProxyClient = BrowserProxyClient;
+//# sourceMappingURL=BrowserProxyClient.js.map

package/src/BrowserProxyClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BrowserProxyClient.js","sourceRoot":"","sources":["../../../../../packages/http/http-client-browser/src/BrowserProxyClient.ts"],"names":[],"mappings":";;;AACA,kEAAwE;AAGxE;;;;;;;;;GASG;AACH,MAAa,kBAAmB,SAAQ,8BAAW;IAGlB;IAFrB,MAAM,CAAgB;IAE9B,YAA6B,UAAsB;QAC/C,KAAK,EAAE,CAAC;QADiB,eAAU,GAAV,UAAU,CAAY;IAEnD,CAAC;IAED,uDAAuD;IACvD,IAAI,CAAC,YAAkC,EAAE,MAAoB;QACzD,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;IAClC,CAAC;IAEkB,cAAc;QAC7B,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAChD,CAAC;IAEkB,eAAe;QAC9B,OAAO,IAAI,CAAC,UAAU,CAAC,oBAAoB,EAAE,CAAC;IAClD,CAAC;IAED;;;;OAIG;IACgB,uBAAuB,CAAC,QAA8B,EAAE,UAAkB;QACzF,MAAM,IAAI,GAAG,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC;QACjC,IAAI,IAAI,KAAK,MAAM,IAAI,IAAI,KAAK,eAAe,EAAE,CAAC;YAC9C,OAAO;QACX,CAAC;QACD,MAAM,IAAI,KAAK,CACX,YAAY,UAAU,QAAQ,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,kBAAkB,sBAAsB;YACrG,wGAAwG,CAC3G,CAAC;IACN,CAAC;CACJ;AApCD,gDAoCC","sourcesContent":["import { AuthMeta, ContextMgr } from '@webpieces/core-util';\nimport { ApiPrototype, ProxyClient } from '@webpieces/http-client-core';\nimport { ClientConfig } from './ClientConfig';\n\n/**\n * The browser {@link ProxyClient}. Reads context from the app-held store (via {@link ContextMgr}),\n * because a browser has no ambient request scope.\n *\n * It attaches NO outbound credential and does NO recording — both inherit the base's no-ops. A\n * browser cannot mint an OIDC token and must never hold a shared secret; the user's JWT travels as\n * an ordinary transferred context key, set on the store at login.\n *\n * This is the ONLY class in webpieces that names ContextMgr.\n */\nexport class BrowserProxyClient extends ProxyClient {\n    private config!: ClientConfig;\n\n    constructor(private readonly contextMgr: ContextMgr) {\n        super();\n    }\n\n    /** Bind this client to one API contract + base URL. */\n    init(apiPrototype: ApiPrototype<object>, config: ClientConfig): void {\n        this.config = config;\n        this.initRoutes(apiPrototype);\n    }\n\n    protected override resolveBaseUrl(): Promise<string> {\n        return Promise.resolve(this.config.baseUrl);\n    }\n\n    protected override outboundHeaders(): Map<string, string> {\n        return this.contextMgr.buildOutboundHeaders();\n    }\n\n    /**\n     * Reject a contract this browser cannot satisfy, at bind time rather than on the first call.\n     * Both service-to-service modes need credentials only a server has: @AuthOidc needs a runtime\n     * service account to mint a token, @AuthSharedSecret needs a secret no browser may ship.\n     */\n    protected override assertEndpointSupported(authMeta: AuthMeta | undefined, methodName: string): void {\n        const kind = authMeta?.mode.kind;\n        if (kind !== 'oidc' && kind !== 'shared-secret') {\n            return;\n        }\n        throw new Error(\n            `Endpoint ${methodName} is @${kind === 'oidc' ? 'AuthOidc' : 'AuthSharedSecret'} — a browser cannot ` +\n            `hold service credentials. Call it server-side with ClientHttpFactory from @webpieces/http-client-node.`,\n        );\n    }\n}\n"]}

package/src/ClientConfig.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Per-client STATE for a browser HTTP client — nothing else. A plain class; it extends nothing and
+ * is unrelated to the server package's ClientConfig.
+ *
+ * A browser is simply handed the base URL of the API it calls (usually from an environment config),
+ * because it has no container metadata to derive one from. That is the only difference from
+ * http-client-node's ClientConfig, which names a Cloud Run service and resolves the URL from it.
+ *
+ * The context store is NOT config: it is a dependency of {@link ClientHttpBrowserFactory}, shared
+ * by every client it builds.
+ */
+export declare class ClientConfig {
+    /** Base URL for all requests (e.g., 'http://localhost:3000') */
+    readonly baseUrl: string;
+    /** The callee's name for logging. Defaults to the baseUrl. */
+    readonly svcName: string;
+    constructor(
+    /** Base URL for all requests (e.g., 'http://localhost:3000') */
+    baseUrl: string, 
+    /** The callee's name for logging. Defaults to the baseUrl. */
+    svcName?: string);
+}

package/src/ClientConfig.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientConfig = void 0;
+/**
+ * Per-client STATE for a browser HTTP client — nothing else. A plain class; it extends nothing and
+ * is unrelated to the server package's ClientConfig.
+ *
+ * A browser is simply handed the base URL of the API it calls (usually from an environment config),
+ * because it has no container metadata to derive one from. That is the only difference from
+ * http-client-node's ClientConfig, which names a Cloud Run service and resolves the URL from it.
+ *
+ * The context store is NOT config: it is a dependency of {@link ClientHttpBrowserFactory}, shared
+ * by every client it builds.
+ */
+class ClientConfig {
+    baseUrl;
+    svcName;
+    constructor(
+    /** Base URL for all requests (e.g., 'http://localhost:3000') */
+    baseUrl, 
+    /** The callee's name for logging. Defaults to the baseUrl. */
+    svcName = baseUrl) {
+        this.baseUrl = baseUrl;
+        this.svcName = svcName;
+    }
+}
+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-browser/src/ClientConfig.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;GAUG;AACH,MAAa,YAAY;IAGD;IAGA;IALpB;IACI,gEAAgE;IAChD,OAAe;IAE/B,8DAA8D;IAC9C,UAAkB,OAAO;QAHzB,YAAO,GAAP,OAAO,CAAQ;QAGf,YAAO,GAAP,OAAO,CAAkB;IAC1C,CAAC;CACP;AARD,oCAQC","sourcesContent":["/**\n * Per-client STATE for a browser HTTP client — nothing else. A plain class; it extends nothing and\n * is unrelated to the server package's ClientConfig.\n *\n * A browser is simply handed the base URL of the API it calls (usually from an environment config),\n * because it has no container metadata to derive one from. That is the only difference from\n * http-client-node's ClientConfig, which names a Cloud Run service and resolves the URL from it.\n *\n * The context store is NOT config: it is a dependency of {@link ClientHttpBrowserFactory}, shared\n * by every client it builds.\n */\nexport class ClientConfig {\n    constructor(\n        /** Base URL for all requests (e.g., 'http://localhost:3000') */\n        public readonly baseUrl: string,\n\n        /** The callee's name for logging. Defaults to the baseUrl. */\n        public readonly svcName: string = baseUrl,\n    ) {}\n}\n"]}

package/src/ClientHttpBrowserFactory.d.ts

@@ -0,0 +1,42 @@
+import { ApiPrototype } from '@webpieces/http-client-core';
+import { ClientConfig } from './ClientConfig';
+import { MutableContextStore } from './MutableContextStore';
+/**
+ * ClientHttpBrowserFactory - builds type-safe HTTP clients for a BROWSER from API prototypes
+ * carrying @ApiPath/@Endpoint decorators.
+ *
+ * Deliberately a plain class with NO decorators and NO inversify: this package may be bundled by
+ * React just as easily as by Angular, and neither should be forced to adopt a Node DI container.
+ * The app provides it through whatever DI it already has — Angular's `useFactory`, a React context,
+ * or a module-level `const`.
+ *
+ * The factory holds the ONE collaborator every browser client shares (the app's
+ * {@link MutableContextStore}); each {@link ClientConfig} holds only that one client's base URL.
+ *
+ * ```typescript
+ * // once, at startup (after HeaderRegistry.configure(...)):
+ * const store = new MutableContextStore();
+ * const factory = new ClientHttpBrowserFactory(store);
+ *
+ * const saveApi = factory.createClient(SaveApi, new ClientConfig(env.apiBaseUrl));
+ * const response = await saveApi.save({ query: 'test' }); // type-safe
+ *
+ * // later, when the user logs in / picks a tenant — every subsequent call carries them:
+ * store.set(AppHeaders.AUTHORIZATION, token);   // an app-defined key, if it wants auto-attach
+ * store.set(CompanyHeaders.TENANT_ID, tenantId);
+ * ```
+ *
+ * A browser cannot hold service credentials, so a contract with an @AuthOidc or @AuthSharedSecret
+ * endpoint throws in `createClient`, not on the first call.
+ */
+export declare class ClientHttpBrowserFactory {
+    private readonly contextMgr;
+    constructor(store: MutableContextStore);
+    /**
+     * 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 baseUrl)
+     */
+    createClient<T extends object>(apiPrototype: ApiPrototype<T>, config: ClientConfig): T;
+}

package/src/ClientHttpBrowserFactory.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientHttpBrowserFactory = void 0;
+const tslib_1 = require("tslib");
+const core_util_1 = require("@webpieces/core-util");
+const http_client_core_1 = require("@webpieces/http-client-core");
+const BrowserProxyClient_1 = require("./BrowserProxyClient");
+const MutableContextStore_1 = require("./MutableContextStore");
+/**
+ * ClientHttpBrowserFactory - builds type-safe HTTP clients for a BROWSER from API prototypes
+ * carrying @ApiPath/@Endpoint decorators.
+ *
+ * Deliberately a plain class with NO decorators and NO inversify: this package may be bundled by
+ * React just as easily as by Angular, and neither should be forced to adopt a Node DI container.
+ * The app provides it through whatever DI it already has — Angular's `useFactory`, a React context,
+ * or a module-level `const`.
+ *
+ * The factory holds the ONE collaborator every browser client shares (the app's
+ * {@link MutableContextStore}); each {@link ClientConfig} holds only that one client's base URL.
+ *
+ * ```typescript
+ * // once, at startup (after HeaderRegistry.configure(...)):
+ * const store = new MutableContextStore();
+ * const factory = new ClientHttpBrowserFactory(store);
+ *
+ * const saveApi = factory.createClient(SaveApi, new ClientConfig(env.apiBaseUrl));
+ * const response = await saveApi.save({ query: 'test' }); // type-safe
+ *
+ * // later, when the user logs in / picks a tenant — every subsequent call carries them:
+ * store.set(AppHeaders.AUTHORIZATION, token);   // an app-defined key, if it wants auto-attach
+ * store.set(CompanyHeaders.TENANT_ID, tenantId);
+ * ```
+ *
+ * A browser cannot hold service credentials, so a contract with an @AuthOidc or @AuthSharedSecret
+ * endpoint throws in `createClient`, not on the first call.
+ */
+let ClientHttpBrowserFactory = class ClientHttpBrowserFactory {
+    contextMgr;
+    constructor(store) {
+        this.contextMgr = new core_util_1.ContextMgr(store);
+    }
+    /**
+     * 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 baseUrl)
+     */
+    createClient(apiPrototype, config) {
+        const proxyClient = new BrowserProxyClient_1.BrowserProxyClient(this.contextMgr);
+        proxyClient.init(apiPrototype, config);
+        return (0, http_client_core_1.buildClientProxy)(apiPrototype, proxyClient);
+    }
+};
+exports.ClientHttpBrowserFactory = ClientHttpBrowserFactory;
+exports.ClientHttpBrowserFactory = ClientHttpBrowserFactory = tslib_1.__decorate([
+    (0, core_util_1.DocumentDesign)(),
+    tslib_1.__metadata("design:paramtypes", [MutableContextStore_1.MutableContextStore])
+], ClientHttpBrowserFactory);
+//# sourceMappingURL=ClientHttpBrowserFactory.js.map

package/src/ClientHttpBrowserFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClientHttpBrowserFactory.js","sourceRoot":"","sources":["../../../../../packages/http/http-client-browser/src/ClientHttpBrowserFactory.ts"],"names":[],"mappings":";;;;AAAA,oDAAkE;AAClE,kEAA6E;AAC7E,6DAA0D;AAE1D,+DAA4D;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEI,IAAM,wBAAwB,GAA9B,MAAM,wBAAwB;IAChB,UAAU,CAAa;IAExC,YAAY,KAA0B;QAClC,IAAI,CAAC,UAAU,GAAG,IAAI,sBAAU,CAAC,KAAK,CAAC,CAAC;IAC5C,CAAC;IAED;;;;;OAKG;IACH,YAAY,CAAmB,YAA6B,EAAE,MAAoB;QAC9E,MAAM,WAAW,GAAG,IAAI,uCAAkB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAC5D,WAAW,CAAC,IAAI,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;QACvC,OAAO,IAAA,mCAAgB,EAAC,YAAY,EAAE,WAAW,CAAC,CAAC;IACvD,CAAC;CACJ,CAAA;AAlBY,4DAAwB;mCAAxB,wBAAwB;IADpC,IAAA,0BAAc,GAAE;6CAIM,yCAAmB;GAH7B,wBAAwB,CAkBpC","sourcesContent":["import { ContextMgr, DocumentDesign } from '@webpieces/core-util';\nimport { ApiPrototype, buildClientProxy } from '@webpieces/http-client-core';\nimport { BrowserProxyClient } from './BrowserProxyClient';\nimport { ClientConfig } from './ClientConfig';\nimport { MutableContextStore } from './MutableContextStore';\n\n/**\n * ClientHttpBrowserFactory - builds type-safe HTTP clients for a BROWSER from API prototypes\n * carrying @ApiPath/@Endpoint decorators.\n *\n * Deliberately a plain class with NO decorators and NO inversify: this package may be bundled by\n * React just as easily as by Angular, and neither should be forced to adopt a Node DI container.\n * The app provides it through whatever DI it already has — Angular's `useFactory`, a React context,\n * or a module-level `const`.\n *\n * The factory holds the ONE collaborator every browser client shares (the app's\n * {@link MutableContextStore}); each {@link ClientConfig} holds only that one client's base URL.\n *\n * ```typescript\n * // once, at startup (after HeaderRegistry.configure(...)):\n * const store = new MutableContextStore();\n * const factory = new ClientHttpBrowserFactory(store);\n *\n * const saveApi = factory.createClient(SaveApi, new ClientConfig(env.apiBaseUrl));\n * const response = await saveApi.save({ query: 'test' }); // type-safe\n *\n * // later, when the user logs in / picks a tenant — every subsequent call carries them:\n * store.set(AppHeaders.AUTHORIZATION, token);   // an app-defined key, if it wants auto-attach\n * store.set(CompanyHeaders.TENANT_ID, tenantId);\n * ```\n *\n * A browser cannot hold service credentials, so a contract with an @AuthOidc or @AuthSharedSecret\n * endpoint throws in `createClient`, not on the first call.\n */\n@DocumentDesign()\nexport class ClientHttpBrowserFactory {\n    private readonly contextMgr: ContextMgr;\n\n    constructor(store: MutableContextStore) {\n        this.contextMgr = new ContextMgr(store);\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 baseUrl)\n     */\n    createClient<T extends object>(apiPrototype: ApiPrototype<T>, config: ClientConfig): T {\n        const proxyClient = new BrowserProxyClient(this.contextMgr);\n        proxyClient.init(apiPrototype, config);\n        return buildClientProxy(apiPrototype, proxyClient);\n    }\n}\n"]}

package/src/MutableContextStore.d.ts

@@ -0,0 +1,32 @@
+import { ContextKey, ContextReader } from '@webpieces/core-util';
+/**
+ * MutableContextStore - the BROWSER ContextReader.
+ *
+ * Browsers have no AsyncLocalStorage, so apps (Angular/React) hold one of these
+ * (e.g. as an Angular service / React context value) and set values as they become
+ * known (login token, selected tenant, ...). The ContextMgr then reads from it on
+ * every outbound request.
+ *
+ * Example (Angular):
+ * ```typescript
+ * const store = new MutableContextStore();
+ * // startup:
+ * HeaderRegistry.configure(AppHeaders.getAllHeaders(), CompanyHeaders.getAllHeaders(), true);
+ * const factory = new ClientHttpFactory(new ContextMgr(store));
+ * const client = factory.createClient(SaveApi, new ClientConfig(baseUrl));
+ *
+ * // later, when the user logs in / picks a tenant:
+ * store.set(AppHeaders.AUTHORIZATION, token);   // an app-defined key, if it wants auto-attach
+ * store.set(CompanyHeaders.TENANT_ID, tenantId);
+ * ```
+ */
+export declare class MutableContextStore implements ContextReader {
+    private values;
+    /** Set (or overwrite) the current value for a context key. */
+    set(key: ContextKey, value: string): void;
+    /** Remove the current value for a context key (e.g. on logout). */
+    remove(key: ContextKey): void;
+    /** Clear all stored values. */
+    clear(): void;
+    read(key: ContextKey): string | undefined;
+}

package/src/MutableContextStore.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MutableContextStore = void 0;
+/**
+ * MutableContextStore - the BROWSER ContextReader.
+ *
+ * Browsers have no AsyncLocalStorage, so apps (Angular/React) hold one of these
+ * (e.g. as an Angular service / React context value) and set values as they become
+ * known (login token, selected tenant, ...). The ContextMgr then reads from it on
+ * every outbound request.
+ *
+ * Example (Angular):
+ * ```typescript
+ * const store = new MutableContextStore();
+ * // startup:
+ * HeaderRegistry.configure(AppHeaders.getAllHeaders(), CompanyHeaders.getAllHeaders(), true);
+ * const factory = new ClientHttpFactory(new ContextMgr(store));
+ * const client = factory.createClient(SaveApi, new ClientConfig(baseUrl));
+ *
+ * // later, when the user logs in / picks a tenant:
+ * store.set(AppHeaders.AUTHORIZATION, token);   // an app-defined key, if it wants auto-attach
+ * store.set(CompanyHeaders.TENANT_ID, tenantId);
+ * ```
+ */
+class MutableContextStore {
+    values = new Map();
+    /** Set (or overwrite) the current value for a context key. */
+    set(key, value) {
+        this.values.set(key.name, value);
+    }
+    /** Remove the current value for a context key (e.g. on logout). */
+    remove(key) {
+        this.values.delete(key.name);
+    }
+    /** Clear all stored values. */
+    clear() {
+        this.values.clear();
+    }
+    read(key) {
+        return this.values.get(key.name);
+    }
+}
+exports.MutableContextStore = MutableContextStore;
+//# sourceMappingURL=MutableContextStore.js.map

package/src/MutableContextStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MutableContextStore.js","sourceRoot":"","sources":["../../../../../packages/http/http-client-browser/src/MutableContextStore.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAa,mBAAmB;IACpB,MAAM,GAAwB,IAAI,GAAG,EAAE,CAAC;IAEhD,8DAA8D;IAC9D,GAAG,CAAC,GAAe,EAAE,KAAa;QAC9B,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACrC,CAAC;IAED,mEAAmE;IACnE,MAAM,CAAC,GAAe;QAClB,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACjC,CAAC;IAED,+BAA+B;IAC/B,KAAK;QACD,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;IACxB,CAAC;IAED,IAAI,CAAC,GAAe;QAChB,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACrC,CAAC;CACJ;AArBD,kDAqBC","sourcesContent":["import { ContextKey, ContextReader } from '@webpieces/core-util';\n\n/**\n * MutableContextStore - the BROWSER ContextReader.\n *\n * Browsers have no AsyncLocalStorage, so apps (Angular/React) hold one of these\n * (e.g. as an Angular service / React context value) and set values as they become\n * known (login token, selected tenant, ...). The ContextMgr then reads from it on\n * every outbound request.\n *\n * Example (Angular):\n * ```typescript\n * const store = new MutableContextStore();\n * // startup:\n * HeaderRegistry.configure(AppHeaders.getAllHeaders(), CompanyHeaders.getAllHeaders(), true);\n * const factory = new ClientHttpFactory(new ContextMgr(store));\n * const client = factory.createClient(SaveApi, new ClientConfig(baseUrl));\n *\n * // later, when the user logs in / picks a tenant:\n * store.set(AppHeaders.AUTHORIZATION, token);   // an app-defined key, if it wants auto-attach\n * store.set(CompanyHeaders.TENANT_ID, tenantId);\n * ```\n */\nexport class MutableContextStore implements ContextReader {\n    private values: Map<string, string> = new Map();\n\n    /** Set (or overwrite) the current value for a context key. */\n    set(key: ContextKey, value: string): void {\n        this.values.set(key.name, value);\n    }\n\n    /** Remove the current value for a context key (e.g. on logout). */\n    remove(key: ContextKey): void {\n        this.values.delete(key.name);\n    }\n\n    /** Clear all stored values. */\n    clear(): void {\n        this.values.clear();\n    }\n\n    read(key: ContextKey): string | undefined {\n        return this.values.get(key.name);\n    }\n}\n"]}

package/src/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @webpieces/http-client-browser
+ *
+ * The BROWSER HTTP client. Reads an API contract's decorators and generates type-safe HTTP
+ * clients from it — the same contract the server implements.
+ *
+ * DI-free on purpose: this may be bundled by React or Angular, so it ships no inversify and no
+ * @webpieces/core-context (which is AsyncLocalStorage-backed and Node-only). Browsers have no
+ * ambient request scope, so the app holds a {@link MutableContextStore} and sets context values
+ * as they become known; every outbound call then transfers them as headers.
+ *
+ * Usage:
+ * ```typescript
+ * import { ClientHttpBrowserFactory, ClientConfig, MutableContextStore } from '@webpieces/http-client-browser';
+ *
+ * HeaderRegistry.configure(AppHeaders.getAllHeaders(), CompanyHeaders.getAllHeaders(), true);
+ * const store = new MutableContextStore();
+ * const factory = new ClientHttpBrowserFactory(store);
+ *
+ * const client = factory.createClient(SaveApi, new ClientConfig('http://localhost:3000'));
+ * const response = await client.save({ query: 'test' });
+ * ```
+ *
+ * The server twin is @webpieces/http-client-node.
+ */
+export { ClientHttpBrowserFactory } from './ClientHttpBrowserFactory';
+export { BrowserProxyClient } from './BrowserProxyClient';
+export { ClientConfig } from './ClientConfig';
+export { MutableContextStore } from './MutableContextStore';
+export { ProxyClient, ClientErrorTranslator } from '@webpieces/http-client-core';
+export type { ApiPrototype } from '@webpieces/http-client-core';
+export { ContextMgr } from '@webpieces/core-util';
+export { ContextReader, ContextKey, HeaderRegistry, WebpiecesCoreHeaders, } from '@webpieces/core-util';
+export { ApiPath, Endpoint, Authentication, AuthenticationConfig, Public, AuthJwt, AuthOidc, AuthSharedSecret, Rpc, PubSub, Queue, ValidateImplementation, } from '@webpieces/core-util';

package/src/index.js

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * @webpieces/http-client-browser
+ *
+ * The BROWSER HTTP client. Reads an API contract's decorators and generates type-safe HTTP
+ * clients from it — the same contract the server implements.
+ *
+ * DI-free on purpose: this may be bundled by React or Angular, so it ships no inversify and no
+ * @webpieces/core-context (which is AsyncLocalStorage-backed and Node-only). Browsers have no
+ * ambient request scope, so the app holds a {@link MutableContextStore} and sets context values
+ * as they become known; every outbound call then transfers them as headers.
+ *
+ * Usage:
+ * ```typescript
+ * import { ClientHttpBrowserFactory, ClientConfig, MutableContextStore } from '@webpieces/http-client-browser';
+ *
+ * HeaderRegistry.configure(AppHeaders.getAllHeaders(), CompanyHeaders.getAllHeaders(), true);
+ * const store = new MutableContextStore();
+ * const factory = new ClientHttpBrowserFactory(store);
+ *
+ * const client = factory.createClient(SaveApi, new ClientConfig('http://localhost:3000'));
+ * const response = await client.save({ query: 'test' });
+ * ```
+ *
+ * The server twin is @webpieces/http-client-node.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Queue = exports.PubSub = exports.Rpc = exports.AuthSharedSecret = exports.AuthOidc = exports.AuthJwt = exports.Public = exports.AuthenticationConfig = exports.Authentication = exports.Endpoint = exports.ApiPath = exports.WebpiecesCoreHeaders = exports.HeaderRegistry = exports.ContextKey = exports.ContextMgr = exports.ClientErrorTranslator = exports.ProxyClient = exports.MutableContextStore = exports.ClientConfig = exports.BrowserProxyClient = exports.ClientHttpBrowserFactory = void 0;
+var ClientHttpBrowserFactory_1 = require("./ClientHttpBrowserFactory");
+Object.defineProperty(exports, "ClientHttpBrowserFactory", { enumerable: true, get: function () { return ClientHttpBrowserFactory_1.ClientHttpBrowserFactory; } });
+var BrowserProxyClient_1 = require("./BrowserProxyClient");
+Object.defineProperty(exports, "BrowserProxyClient", { enumerable: true, get: function () { return BrowserProxyClient_1.BrowserProxyClient; } });
+var ClientConfig_1 = require("./ClientConfig");
+Object.defineProperty(exports, "ClientConfig", { enumerable: true, get: function () { return ClientConfig_1.ClientConfig; } });
+var MutableContextStore_1 = require("./MutableContextStore");
+Object.defineProperty(exports, "MutableContextStore", { enumerable: true, get: function () { return MutableContextStore_1.MutableContextStore; } });
+// The isomorphic engine, re-exported so a browser 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; } });
+// ContextMgr is the BROWSER's outbound-header propagation. This is the only package that may use
+// it; the server reads RequestContext directly (RequestContextHeaders in @webpieces/core-context).
+var core_util_1 = require("@webpieces/core-util");
+Object.defineProperty(exports, "ContextMgr", { enumerable: true, get: function () { return core_util_1.ContextMgr; } });
+// Re-export the context-key contract from core-util for convenience (browser one-import)
+var core_util_2 = require("@webpieces/core-util");
+Object.defineProperty(exports, "ContextKey", { enumerable: true, get: function () { return core_util_2.ContextKey; } });
+Object.defineProperty(exports, "HeaderRegistry", { enumerable: true, get: function () { return core_util_2.HeaderRegistry; } });
+Object.defineProperty(exports, "WebpiecesCoreHeaders", { enumerable: true, get: function () { return core_util_2.WebpiecesCoreHeaders; } });
+// Re-export API decorators for convenience (same as http-routing does)
+var core_util_3 = require("@webpieces/core-util");
+Object.defineProperty(exports, "ApiPath", { enumerable: true, get: function () { return core_util_3.ApiPath; } });
+Object.defineProperty(exports, "Endpoint", { enumerable: true, get: function () { return core_util_3.Endpoint; } });
+Object.defineProperty(exports, "Authentication", { enumerable: true, get: function () { return core_util_3.Authentication; } });
+Object.defineProperty(exports, "AuthenticationConfig", { enumerable: true, get: function () { return core_util_3.AuthenticationConfig; } });
+Object.defineProperty(exports, "Public", { enumerable: true, get: function () { return core_util_3.Public; } });
+Object.defineProperty(exports, "AuthJwt", { enumerable: true, get: function () { return core_util_3.AuthJwt; } });
+Object.defineProperty(exports, "AuthOidc", { enumerable: true, get: function () { return core_util_3.AuthOidc; } });
+Object.defineProperty(exports, "AuthSharedSecret", { enumerable: true, get: function () { return core_util_3.AuthSharedSecret; } });
+Object.defineProperty(exports, "Rpc", { enumerable: true, get: function () { return core_util_3.Rpc; } });
+Object.defineProperty(exports, "PubSub", { enumerable: true, get: function () { return core_util_3.PubSub; } });
+Object.defineProperty(exports, "Queue", { enumerable: true, get: function () { return core_util_3.Queue; } });
+//# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../packages/http/http-client-browser/src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;;;AAEH,uEAAsE;AAA7D,oIAAA,wBAAwB,OAAA;AACjC,2DAA0D;AAAjD,wHAAA,kBAAkB,OAAA;AAC3B,+CAA8C;AAArC,4GAAA,YAAY,OAAA;AACrB,6DAA4D;AAAnD,0HAAA,mBAAmB,OAAA;AAE5B,wEAAwE;AACxE,gEAAiF;AAAxE,+GAAA,WAAW,OAAA;AAAE,yHAAA,qBAAqB,OAAA;AAG3C,iGAAiG;AACjG,mGAAmG;AACnG,kDAAkD;AAAzC,uGAAA,UAAU,OAAA;AAEnB,yFAAyF;AACzF,kDAK8B;AAH1B,uGAAA,UAAU,OAAA;AACV,2GAAA,cAAc,OAAA;AACd,iHAAA,oBAAoB,OAAA;AAGxB,uEAAuE;AACvE,kDAa8B;AAZ1B,oGAAA,OAAO,OAAA;AACP,qGAAA,QAAQ,OAAA;AACR,2GAAA,cAAc,OAAA;AACd,iHAAA,oBAAoB,OAAA;AACpB,mGAAA,MAAM,OAAA;AACN,oGAAA,OAAO,OAAA;AACP,qGAAA,QAAQ,OAAA;AACR,6GAAA,gBAAgB,OAAA;AAChB,gGAAA,GAAG,OAAA;AACH,mGAAA,MAAM,OAAA;AACN,kGAAA,KAAK,OAAA","sourcesContent":["/**\n * @webpieces/http-client-browser\n *\n * The BROWSER HTTP client. Reads an API contract's decorators and generates type-safe HTTP\n * clients from it — the same contract the server implements.\n *\n * DI-free on purpose: this may be bundled by React or Angular, so it ships no inversify and no\n * @webpieces/core-context (which is AsyncLocalStorage-backed and Node-only). Browsers have no\n * ambient request scope, so the app holds a {@link MutableContextStore} and sets context values\n * as they become known; every outbound call then transfers them as headers.\n *\n * Usage:\n * ```typescript\n * import { ClientHttpBrowserFactory, ClientConfig, MutableContextStore } from '@webpieces/http-client-browser';\n *\n * HeaderRegistry.configure(AppHeaders.getAllHeaders(), CompanyHeaders.getAllHeaders(), true);\n * const store = new MutableContextStore();\n * const factory = new ClientHttpBrowserFactory(store);\n *\n * const client = factory.createClient(SaveApi, new ClientConfig('http://localhost:3000'));\n * const response = await client.save({ query: 'test' });\n * ```\n *\n * The server twin is @webpieces/http-client-node.\n */\n\nexport { ClientHttpBrowserFactory } from './ClientHttpBrowserFactory';\nexport { BrowserProxyClient } from './BrowserProxyClient';\nexport { ClientConfig } from './ClientConfig';\nexport { MutableContextStore } from './MutableContextStore';\n\n// The isomorphic engine, re-exported so a browser app needs one import.\nexport { ProxyClient, ClientErrorTranslator } from '@webpieces/http-client-core';\nexport type { ApiPrototype } from '@webpieces/http-client-core';\n\n// ContextMgr is the BROWSER's outbound-header propagation. This is the only package that may use\n// it; the server reads RequestContext directly (RequestContextHeaders in @webpieces/core-context).\nexport { ContextMgr } from '@webpieces/core-util';\n\n// Re-export the context-key contract from core-util for convenience (browser one-import)\nexport {\n    ContextReader,\n    ContextKey,\n    HeaderRegistry,\n    WebpiecesCoreHeaders,\n} from '@webpieces/core-util';\n\n// Re-export API decorators for convenience (same as http-routing does)\nexport {\n    ApiPath,\n    Endpoint,\n    Authentication,\n    AuthenticationConfig,\n    Public,\n    AuthJwt,\n    AuthOidc,\n    AuthSharedSecret,\n    Rpc,\n    PubSub,\n    Queue,\n    ValidateImplementation,\n} from '@webpieces/core-util';\n"]}