@uengage.io/platform-sdk 0.3.0 → 0.7.0

package/dist/auth/verify.js

@@ -0,0 +1,93 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyAccessToken = verifyAccessToken;
+exports._resetJwksCache = _resetJwksCache;
+const errors_1 = require("../errors");
+const issuer_1 = require("./issuer");
+/**
+ * Cache of JWKS documents keyed by issuer URL. Lambda-style: cleared
+ * on cold start, reused for the lifetime of the process. 5-minute
+ * staleness is plenty: when a key is rotated the auth server keeps
+ * publishing both old + new for the access-token TTL window, so the
+ * SDK's slightly stale view never causes a verification miss.
+ */
+const jwksCache = new Map();
+const JWKS_TTL_MS = 5 * 60 * 1000;
+async function getJwks(issuer) {
+    const cached = jwksCache.get(issuer);
+    if (cached && Date.now() - cached.cachedAt < JWKS_TTL_MS)
+        return cached.doc;
+    const res = await fetch(`${issuer}/jwks.json`);
+    if (!res.ok)
+        throw new errors_1.PlatformError(`JWKS fetch failed: HTTP ${res.status}`, { status: res.status });
+    const doc = (await res.json());
+    jwksCache.set(issuer, { doc, cachedAt: Date.now() });
+    return doc;
+}
+/**
+ * Verify an access token: fetches JWKS based on the token's `iss`,
+ * verifies the RSA signature, and returns the claims. Throws on any
+ * failure so callers can `try/catch` once instead of branching on a
+ * boolean.
+ *
+ * The verification itself happens via `jose`'s `jwtVerify`, but to
+ * keep this module lightweight (and to avoid pulling jose into the
+ * Browser bundle when consumers only want the URL helpers) we
+ * dynamic-import it. Tree-shakers will drop the import for code paths
+ * that never call `verifyAccessToken`.
+ */
+async function verifyAccessToken(token, options) {
+    const issuer = (0, issuer_1.getIssuer)(token);
+    if (!issuer)
+        throw new errors_1.ConfigError('access token has no `iss` claim');
+    const { jwtVerify, createLocalJWKSet } = await Promise.resolve().then(() => __importStar(require('jose')));
+    const jwks = createLocalJWKSet({ keys: (await getJwks(issuer)).keys });
+    try {
+        const { payload } = await jwtVerify(token, jwks, {
+            issuer,
+            audience: options?.audience,
+        });
+        return payload;
+    }
+    catch (err) {
+        throw new errors_1.AuthenticationError('access token verification failed', { cause: err });
+    }
+}
+/** Test-only: clear the JWKS cache. */
+function _resetJwksCache() {
+    jwksCache.clear();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/business/client.js

@@ -4,6 +4,7 @@ exports.BusinessApiError = void 0;
 exports.createBusinessClient = createBusinessClient;
 const config_1 = require("../config");
 const http_1 = require("../http");
+const token_source_1 = require("../token-source");
 class BusinessApiError extends Error {
     status;
     body;
@@ -34,10 +35,10 @@ function createBusinessClient(input = {}) {
             const path = `/v1/businesses/${id}`;
             const query = opts.groups?.length ? `?groups=${opts.groups.join(',')}` : '';
             const config = state.resolve();
-            const headers = (0, http_1.buildHeaders)(config, { method: 'GET', path });
-            const res = await config.fetchFn(`${config.baseUrl}${path}${query}`, {
+            const res = await sendWithAuthRetry(config, {
                 method: 'GET',
-                headers,
+                path,
+                url: `${config.baseUrl}${path}${query}`,
             });
             if (!res.ok) {
                 throw new BusinessApiError(res.status, await res.text());
@@ -58,10 +59,10 @@ function createBusinessClient(input = {}) {
             if (opts.groups?.length)
                 params.set('groups', opts.groups.join(','));
             const config = state.resolve();
-            const headers = (0, http_1.buildHeaders)(config, { method: 'GET', path });
-            const res = await config.fetchFn(`${config.baseUrl}${path}?${params.toString()}`, {
+            const res = await sendWithAuthRetry(config, {
                 method: 'GET',
-                headers,
+                path,
+                url: `${config.baseUrl}${path}?${params.toString()}`,
             });
             if (!res.ok) {
                 throw new BusinessApiError(res.status, await res.text());
@@ -71,4 +72,36 @@ function createBusinessClient(input = {}) {
     };
     return client;
 }
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * Send a request with the SDK's standard 401-retry-once behaviour.
+ * Only retries when auth is `token-source`, since that's the case
+ * where the cached token may have expired server-side; HMAC and
+ * static bearer 401s mean the auth is misconfigured and a retry
+ * would just fail again.
+ */
+async function sendWithAuthRetry(config, params) {
+    const headers = await (0, http_1.buildHeaders)(config, {
+        method: params.method,
+        path: params.path,
+        body: params.body,
+    });
+    const res = await config.fetchFn(params.url, {
+        method: params.method,
+        headers,
+        body: params.body,
+    });
+    if (res.status !== 401 || config.auth?.type !== 'token-source')
+        return res;
+    (0, token_source_1.invalidateToken)(config.auth.state);
+    const retryHeaders = await (0, http_1.buildHeaders)(config, {
+        method: params.method,
+        path: params.path,
+        body: params.body,
+    });
+    return config.fetchFn(params.url, {
+        method: params.method,
+        headers: retryHeaders,
+        body: params.body,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client.js","sourceRoot":"","sources":["../../src/business/client.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ConfigState,\n  type PlatformAuth,\n  type PlatformAuthInput,\n  type PlatformConfig,\n  type PlatformConfigInput,\n} from '../config';\nimport { buildHeaders } from '../http';\nimport { invalidateToken } from '../token-source';\nimport type { BusinessGroupName, BusinessRecord } from './schema';\n\nexport interface BusinessGetOptions {\n  groups?: readonly BusinessGroupName[];\n}\n\nexport interface BusinessClient {\n  config(input: PlatformConfigInput): BusinessClient;\n  auth(input: PlatformAuthInput | PlatformAuth): BusinessClient;\n  /** GET /v1/businesses/:id - returns the record or throws BusinessApiError. */\n  get(id: number, opts?: BusinessGetOptions): Promise<BusinessRecord>;\n  /** GET /v1/businesses?ids= - returns matched records (missing ids dropped). */\n  bulk(ids: readonly number[], opts?: BusinessGetOptions): Promise<BusinessRecord[]>;\n}\n\nexport class BusinessApiError extends Error {\n  readonly status: number;\n  readonly body: string;\n\n  constructor(status: number, body: string) {\n    super(`business API ${status}: ${body}`);\n    this.name = 'BusinessApiError';\n    this.status = status;\n    this.body = body;\n  }\n}\n\nexport function createBusinessClient(input: PlatformConfigInput = {}): BusinessClient {\n  const state = new ConfigState();\n  state.apply(input);\n\n  const client: BusinessClient = {\n    config(opts) {\n      state.apply(opts);\n      return client;\n    },\n    auth(opts) {\n      state.setAuth(opts);\n      return client;\n    },\n    async get(id, opts = {}) {\n      if (!Number.isInteger(id) || id <= 0) {\n        throw new Error(`business.get: id must be a positive integer (got ${id})`);\n      }\n      const path = `/v1/businesses/${id}`;\n      const query = opts.groups?.length ? `?groups=${opts.groups.join(',')}` : '';\n      const config = state.resolve();\n      const res = await sendWithAuthRetry(config, {\n        method: 'GET',\n        path,\n        url: `${config.baseUrl}${path}${query}`,\n      });\n      if (!res.ok) {\n        throw new BusinessApiError(res.status, await res.text());\n      }\n      return (await res.json()) as BusinessRecord;\n    },\n    async bulk(ids, opts = {}) {\n      if (ids.length === 0) {\n        throw new Error('business.bulk: ids must not be empty');\n      }\n      for (const n of ids) {\n        if (!Number.isInteger(n) || n <= 0) {\n          throw new Error(`business.bulk: every id must be a positive integer (got ${n})`);\n        }\n      }\n      const path = '/v1/businesses';\n      const params = new URLSearchParams({ ids: ids.join(',') });\n      if (opts.groups?.length) params.set('groups', opts.groups.join(','));\n      const config = state.resolve();\n      const res = await sendWithAuthRetry(config, {\n        method: 'GET',\n        path,\n        url: `${config.baseUrl}${path}?${params.toString()}`,\n      });\n      if (!res.ok) {\n        throw new BusinessApiError(res.status, await res.text());\n      }\n      return (await res.json()) as BusinessRecord[];\n    },\n  };\n\n  return client;\n}\n\n/**\n * Send a request with the SDK's standard 401-retry-once behaviour.\n * Only retries when auth is `token-source`, since that's the case\n * where the cached token may have expired server-side; HMAC and\n * static bearer 401s mean the auth is misconfigured and a retry\n * would just fail again.\n */\nasync function sendWithAuthRetry(\n  config: PlatformConfig,\n  params: { method: string; path: string; url: string; body?: string },\n): Promise<Response> {\n  const headers = await buildHeaders(config, {\n    method: params.method,\n    path: params.path,\n    body: params.body,\n  });\n  const res = await config.fetchFn(params.url, {\n    method: params.method,\n    headers,\n    body: params.body,\n  });\n  if (res.status !== 401 || config.auth?.type !== 'token-source') return res;\n  invalidateToken(config.auth.state);\n  const retryHeaders = await buildHeaders(config, {\n    method: params.method,\n    path: params.path,\n    body: params.body,\n  });\n  return config.fetchFn(params.url, {\n    method: params.method,\n    headers: retryHeaders,\n    body: params.body,\n  });\n}\n"]}

package/dist/client.d.ts

@@ -0,0 +1,74 @@
+import { type AuditClient } from './audit/client';
+import { type BusinessClient } from './business/client';
+import { auth } from './auth';
+/**
+ * Caller-facing config for the unified `createClient(...)` factory and
+ * the `platform` singleton.
+ *
+ * Pick exactly one of:
+ *   - `accessToken` (string or callback) for the static Bearer flow
+ *   - `serviceId` + `serviceSecret` for OAuth2 client_credentials
+ *
+ * Without either, calls throw `ConfigError` on the first request.
+ */
+export interface ClientConfig {
+    baseUrl?: string;
+    /**
+     * Auth surface base used to bootstrap the first client_credentials
+     * mint. Defaults to `${baseUrl}/auth/business`. Once a token exists,
+     * future auth calls follow the token's `iss` claim.
+     */
+    authBaseUrl?: string;
+    accessToken?: string | (() => string | Promise<string>);
+    serviceId?: string;
+    serviceSecret?: string;
+    /** Space-separated scope list to request when minting via client_credentials. */
+    scope?: string;
+    /**
+     * Service identifier the audit client should stamp into `actor.via`
+     * on emitted events. Defaults to `serviceId` when set; otherwise
+     * audit `record()` calls log an error and drop the event.
+     */
+    actorVia?: string;
+    expiryBufferMs?: number;
+    fetchFn?: typeof fetch;
+}
+export interface PlatformClient {
+    business: BusinessClient;
+    audit: AuditClient;
+    auth: typeof auth;
+    /**
+     * Return a derived client bound to the supplied access token.
+     * Inherits `baseUrl` and `fetchFn`; replaces the token source with
+     * the new one. Use case: BFF handlers that want to call the
+     * platform API as the end user instead of as the service.
+     */
+    withToken(token: string | (() => string | Promise<string>)): PlatformClient;
+}
+/**
+ * Build a fresh, isolated client from explicit config. Each call
+ * gets its own TokenSource state — concurrent `createClient(...)` use
+ * does not stampede the cache.
+ */
+export declare function createClient(input?: ClientConfig): PlatformClient;
+/**
+ * Default client. Reads config from environment variables on first
+ * property access (so test setups that mutate `process.env` after
+ * import work). Use `createClient(...)` when you need an isolated
+ * instance with explicit config.
+ *
+ *   UENGAGE_BASE_URL         defaults to https://api.platform.uengage.io
+ *   UENGAGE_AUTH_BASE_URL    auth surface override (default ${baseUrl}/auth/business)
+ *   UENGAGE_AUTH_TOKEN       static Bearer token (overrides client_credentials)
+ *   UENGAGE_SERVICE_ID       OAuth2 client_credentials clientId
+ *   UENGAGE_SERVICE_SECRET   OAuth2 client_credentials clientSecret
+ *   UENGAGE_SERVICE_SCOPE    optional space-separated scope list
+ */
+export declare const platform: PlatformClient;
+/** Test-only: drop the singleton cache between cases. */
+export declare function _resetPlatformSingleton(): void;
+/**
+ * Convenience: shorthand for `platform.withToken(token)`.
+ * BFF handlers commonly call this once per request.
+ */
+export declare function withToken(token: string | (() => string | Promise<string>)): PlatformClient;

package/dist/client.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.platform = void 0;
+exports.createClient = createClient;
+exports._resetPlatformSingleton = _resetPlatformSingleton;
+exports.withToken = withToken;
+const client_1 = require("./audit/client");
+const client_2 = require("./business/client");
+const token_source_1 = require("./token-source");
+const DEFAULT_BASE_URL = 'https://api.platform.uengage.io';
+/**
+ * Build a fresh, isolated client from explicit config. Each call
+ * gets its own TokenSource state — concurrent `createClient(...)` use
+ * does not stampede the cache.
+ */
+function createClient(input = {}) {
+    warnIfBrowserSecret(input);
+    return buildClient(input);
+}
+function buildClient(input) {
+    const baseUrl = input.baseUrl ?? DEFAULT_BASE_URL;
+    const tokenSourceState = resolveTokenSource(input, baseUrl);
+    const auth = tokenSourceState
+        ? { type: 'token-source', state: tokenSourceState }
+        : undefined;
+    const businessClient = (0, client_2.createBusinessClient)({ baseUrl, fetchFn: input.fetchFn, auth });
+    const auditClient = (0, client_1.createAuditClient)({
+        baseUrl,
+        fetchFn: input.fetchFn,
+        auth,
+        actorVia: input.actorVia ?? input.serviceId,
+    });
+    const client = {
+        business: businessClient,
+        audit: auditClient,
+        auth: auth_1.auth,
+        withToken(token) {
+            return buildClient({
+                ...input,
+                accessToken: token,
+                // The new client should not also try to mint via
+                // client_credentials on top of the supplied user token.
+                serviceId: undefined,
+                serviceSecret: undefined,
+                scope: undefined,
+            });
+        },
+    };
+    return client;
+}
+const auth_1 = require("./auth");
+function resolveTokenSource(input, baseUrl) {
+    const authBaseUrl = input.authBaseUrl ?? `${baseUrl}/auth/business`;
+    if (input.accessToken !== undefined) {
+        if (typeof input.accessToken === 'string') {
+            return (0, token_source_1.makeTokenSourceState)({ kind: 'static-string', token: input.accessToken }, { expiryBufferMs: input.expiryBufferMs, fetchFn: input.fetchFn });
+        }
+        return (0, token_source_1.makeTokenSourceState)({ kind: 'callback', getToken: input.accessToken }, { expiryBufferMs: input.expiryBufferMs, fetchFn: input.fetchFn });
+    }
+    if (input.serviceId && input.serviceSecret) {
+        return (0, token_source_1.makeTokenSourceState)({
+            kind: 'service-credentials',
+            clientId: input.serviceId,
+            clientSecret: input.serviceSecret,
+            authBaseUrl,
+            scope: input.scope,
+        }, { expiryBufferMs: input.expiryBufferMs, fetchFn: input.fetchFn });
+    }
+    return undefined;
+}
+function warnIfBrowserSecret(config) {
+    const g = globalThis;
+    const inBrowser = typeof g.window !== 'undefined' && typeof g.window.document !== 'undefined';
+    if (!inBrowser)
+        return;
+    if (config.serviceSecret) {
+        console.warn('[uengage-platform-sdk] serviceSecret should not be used in browser environments. ' +
+            'Service credentials in browser bundles are publicly visible. ' +
+            'Use `accessToken` with a token obtained via OAuth (or `withToken(...)` on a server-built client) instead.');
+    }
+}
+// ─── Default singleton ─────────────────────────────────────────────────────
+//
+// Resolved lazily on first property access (Proxy) so consumers that
+// mutate `process.env` after import still pick up the right values.
+let cachedSingleton;
+function singleton() {
+    if (!cachedSingleton)
+        cachedSingleton = buildClient(envClientConfig());
+    return cachedSingleton;
+}
+function envClientConfig() {
+    if (typeof process === 'undefined')
+        return {};
+    const e = process.env ?? {};
+    return {
+        baseUrl: e.UENGAGE_BASE_URL,
+        authBaseUrl: e.UENGAGE_AUTH_BASE_URL,
+        accessToken: e.UENGAGE_AUTH_TOKEN,
+        serviceId: e.UENGAGE_SERVICE_ID,
+        serviceSecret: e.UENGAGE_SERVICE_SECRET,
+        scope: e.UENGAGE_SERVICE_SCOPE,
+    };
+}
+/**
+ * Default client. Reads config from environment variables on first
+ * property access (so test setups that mutate `process.env` after
+ * import work). Use `createClient(...)` when you need an isolated
+ * instance with explicit config.
+ *
+ *   UENGAGE_BASE_URL         defaults to https://api.platform.uengage.io
+ *   UENGAGE_AUTH_BASE_URL    auth surface override (default ${baseUrl}/auth/business)
+ *   UENGAGE_AUTH_TOKEN       static Bearer token (overrides client_credentials)
+ *   UENGAGE_SERVICE_ID       OAuth2 client_credentials clientId
+ *   UENGAGE_SERVICE_SECRET   OAuth2 client_credentials clientSecret
+ *   UENGAGE_SERVICE_SCOPE    optional space-separated scope list
+ */
+exports.platform = new Proxy({}, {
+    get(_, prop) {
+        const s = singleton();
+        return s[prop];
+    },
+});
+/** Test-only: drop the singleton cache between cases. */
+function _resetPlatformSingleton() {
+    cachedSingleton = undefined;
+}
+/**
+ * Convenience: shorthand for `platform.withToken(token)`.
+ * BFF handlers commonly call this once per request.
+ */
+function withToken(token) {
+    return singleton().withToken(token);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client.js","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"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","sourcesContent":["import { createAuditClient, type AuditClient } from './audit/client';\nimport { createBusinessClient, type BusinessClient } from './business/client';\nimport { auth } from './auth';\nimport { makeTokenSourceState, type TokenSourceState } from './token-source';\nimport type { PlatformAuth } from './config';\n\n/**\n * Caller-facing config for the unified `createClient(...)` factory and\n * the `platform` singleton.\n *\n * Pick exactly one of:\n *   - `accessToken` (string or callback) for the static Bearer flow\n *   - `serviceId` + `serviceSecret` for OAuth2 client_credentials\n *\n * Without either, calls throw `ConfigError` on the first request.\n */\nexport interface ClientConfig {\n  baseUrl?: string;\n  /**\n   * Auth surface base used to bootstrap the first client_credentials\n   * mint. Defaults to `${baseUrl}/auth/business`. Once a token exists,\n   * future auth calls follow the token's `iss` claim.\n   */\n  authBaseUrl?: string;\n  accessToken?: string | (() => string | Promise<string>);\n  serviceId?: string;\n  serviceSecret?: string;\n  /** Space-separated scope list to request when minting via client_credentials. */\n  scope?: string;\n  /**\n   * Service identifier the audit client should stamp into `actor.via`\n   * on emitted events. Defaults to `serviceId` when set; otherwise\n   * audit `record()` calls log an error and drop the event.\n   */\n  actorVia?: string;\n  expiryBufferMs?: number;\n  fetchFn?: typeof fetch;\n}\n\nexport interface PlatformClient {\n  business: BusinessClient;\n  audit: AuditClient;\n  auth: typeof auth;\n  /**\n   * Return a derived client bound to the supplied access token.\n   * Inherits `baseUrl` and `fetchFn`; replaces the token source with\n   * the new one. Use case: BFF handlers that want to call the\n   * platform API as the end user instead of as the service.\n   */\n  withToken(token: string | (() => string | Promise<string>)): PlatformClient;\n}\n\nconst DEFAULT_BASE_URL = 'https://api.platform.uengage.io';\n\n/**\n * Build a fresh, isolated client from explicit config. Each call\n * gets its own TokenSource state — concurrent `createClient(...)` use\n * does not stampede the cache.\n */\nexport function createClient(input: ClientConfig = {}): PlatformClient {\n  warnIfBrowserSecret(input);\n  return buildClient(input);\n}\n\nfunction buildClient(input: ClientConfig): PlatformClient {\n  const baseUrl = input.baseUrl ?? DEFAULT_BASE_URL;\n  const tokenSourceState = resolveTokenSource(input, baseUrl);\n  const auth: PlatformAuth | undefined = tokenSourceState\n    ? { type: 'token-source', state: tokenSourceState }\n    : undefined;\n\n  const businessClient = createBusinessClient({ baseUrl, fetchFn: input.fetchFn, auth });\n  const auditClient = createAuditClient({\n    baseUrl,\n    fetchFn: input.fetchFn,\n    auth,\n    actorVia: input.actorVia ?? input.serviceId,\n  });\n\n  const client: PlatformClient = {\n    business: businessClient,\n    audit: auditClient,\n    auth: authNamespace,\n    withToken(token) {\n      return buildClient({\n        ...input,\n        accessToken: token,\n        // The new client should not also try to mint via\n        // client_credentials on top of the supplied user token.\n        serviceId: undefined,\n        serviceSecret: undefined,\n        scope: undefined,\n      });\n    },\n  };\n  return client;\n}\n\nimport { auth as authNamespace } from './auth';\n\nfunction resolveTokenSource(input: ClientConfig, baseUrl: string): TokenSourceState | undefined {\n  const authBaseUrl = input.authBaseUrl ?? `${baseUrl}/auth/business`;\n  if (input.accessToken !== undefined) {\n    if (typeof input.accessToken === 'string') {\n      return makeTokenSourceState(\n        { kind: 'static-string', token: input.accessToken },\n        { expiryBufferMs: input.expiryBufferMs, fetchFn: input.fetchFn },\n      );\n    }\n    return makeTokenSourceState(\n      { kind: 'callback', getToken: input.accessToken },\n      { expiryBufferMs: input.expiryBufferMs, fetchFn: input.fetchFn },\n    );\n  }\n  if (input.serviceId && input.serviceSecret) {\n    return makeTokenSourceState(\n      {\n        kind: 'service-credentials',\n        clientId: input.serviceId,\n        clientSecret: input.serviceSecret,\n        authBaseUrl,\n        scope: input.scope,\n      },\n      { expiryBufferMs: input.expiryBufferMs, fetchFn: input.fetchFn },\n    );\n  }\n  return undefined;\n}\n\nfunction warnIfBrowserSecret(config: ClientConfig): void {\n  const g = globalThis as { window?: { document?: unknown } };\n  const inBrowser = typeof g.window !== 'undefined' && typeof g.window.document !== 'undefined';\n  if (!inBrowser) return;\n  if (config.serviceSecret) {\n    console.warn(\n      '[uengage-platform-sdk] serviceSecret should not be used in browser environments. ' +\n        'Service credentials in browser bundles are publicly visible. ' +\n        'Use `accessToken` with a token obtained via OAuth (or `withToken(...)` on a server-built client) instead.',\n    );\n  }\n}\n\n// ─── Default singleton ─────────────────────────────────────────────────────\n//\n// Resolved lazily on first property access (Proxy) so consumers that\n// mutate `process.env` after import still pick up the right values.\n\nlet cachedSingleton: PlatformClient | undefined;\nfunction singleton(): PlatformClient {\n  if (!cachedSingleton) cachedSingleton = buildClient(envClientConfig());\n  return cachedSingleton;\n}\n\nfunction envClientConfig(): ClientConfig {\n  if (typeof process === 'undefined') return {};\n  const e = (process as { env?: Record<string, string | undefined> }).env ?? {};\n  return {\n    baseUrl: e.UENGAGE_BASE_URL,\n    authBaseUrl: e.UENGAGE_AUTH_BASE_URL,\n    accessToken: e.UENGAGE_AUTH_TOKEN,\n    serviceId: e.UENGAGE_SERVICE_ID,\n    serviceSecret: e.UENGAGE_SERVICE_SECRET,\n    scope: e.UENGAGE_SERVICE_SCOPE,\n  };\n}\n\n/**\n * Default client. Reads config from environment variables on first\n * property access (so test setups that mutate `process.env` after\n * import work). Use `createClient(...)` when you need an isolated\n * instance with explicit config.\n *\n *   UENGAGE_BASE_URL         defaults to https://api.platform.uengage.io\n *   UENGAGE_AUTH_BASE_URL    auth surface override (default ${baseUrl}/auth/business)\n *   UENGAGE_AUTH_TOKEN       static Bearer token (overrides client_credentials)\n *   UENGAGE_SERVICE_ID       OAuth2 client_credentials clientId\n *   UENGAGE_SERVICE_SECRET   OAuth2 client_credentials clientSecret\n *   UENGAGE_SERVICE_SCOPE    optional space-separated scope list\n */\nexport const platform: PlatformClient = new Proxy({} as PlatformClient, {\n  get(_, prop) {\n    const s = singleton() as unknown as Record<PropertyKey, unknown>;\n    return s[prop];\n  },\n});\n\n/** Test-only: drop the singleton cache between cases. */\nexport function _resetPlatformSingleton(): void {\n  cachedSingleton = undefined;\n}\n\n/**\n * Convenience: shorthand for `platform.withToken(token)`.\n * BFF handlers commonly call this once per request.\n */\nexport function withToken(token: string | (() => string | Promise<string>)): PlatformClient {\n  return singleton().withToken(token);\n}\n"]}

package/dist/config.d.ts

@@ -1,15 +1,15 @@
 import type { Logger } from '@uengage.io/js-logger';
+import type { TokenSourceState } from './token-source';
 export declare const DEFAULT_BASE_URL = "https://api.platform.uengage.io";
 /**
  * Resolved auth state. Discriminated by `type` so consumers can narrow.
  */
 export type PlatformAuth = {
-    type: 'hmac';
-    secret: string;
-    serviceId: string;
-} | {
     type: 'bearer';
     token: string;
+} | {
+    type: 'token-source';
+    state: TokenSourceState;
 };
 export interface PlatformConfig {
     baseUrl: string;
@@ -17,11 +17,6 @@ export interface PlatformConfig {
     fetchFn: typeof fetch;
     logger?: Logger;
 }
-/**
- * Caller-facing input shape. `auth` accepts either a discriminated
- * PlatformAuth or the looser PlatformAuthInput - the looser form is
- * also what `.auth()` accepts.
- */
 export interface PlatformConfigInput {
     baseUrl?: string;
     auth?: PlatformAuthInput | PlatformAuth;
@@ -29,13 +24,12 @@ export interface PlatformConfigInput {
     logger?: Logger;
 }
 /**
- * `.auth()` shape. Pass either `{token}` (Bearer) or `{secret, serviceId}`
- * (HMAC). Mixing both throws.
+ * `.auth()` shape. Pass `{token}` for a static Bearer access token.
+ * OAuth2 client_credentials live at `createClient()` config-time
+ * (`serviceId` + `serviceSecret` fields), not via `.auth()`.
  */
 export interface PlatformAuthInput {
     token?: string;
-    secret?: string;
-    serviceId?: string;
 }
 /**
  * Resolve env-defaulted config. Re-read on every call so that callers can
@@ -44,8 +38,13 @@ export interface PlatformAuthInput {
  */
 export declare function envDefaults(): PlatformConfig;
 /**
- * Coerce `.auth()` input or `config({auth})` input into a typed PlatformAuth.
- * Throws if the input has no usable credentials or mixes HMAC + Bearer.
+ * Coerce `.auth()` input or `config({auth})` input into a typed
+ * PlatformAuth. Throws when the input has no usable credentials.
+ *
+ * Today this only accepts `{token}` or a pre-shaped `PlatformAuth`.
+ * For OAuth2 client_credentials use `createClient({serviceId, serviceSecret})`
+ * instead — that builds a TokenSource which mints + caches Bearer
+ * tokens.
  */
 export declare function normalizeAuth(input: PlatformAuthInput | PlatformAuth): PlatformAuth;
 /**

package/dist/config.js

@@ -11,38 +11,33 @@ exports.DEFAULT_BASE_URL = 'https://api.platform.uengage.io';
  */
 function envDefaults() {
     return {
-        baseUrl: process.env.PLATFORM_BASE_URL ?? exports.DEFAULT_BASE_URL,
+        baseUrl: process.env.UENGAGE_BASE_URL ?? exports.DEFAULT_BASE_URL,
         auth: envAuth(),
         fetchFn: globalThis.fetch,
     };
 }
 function envAuth() {
-    const secret = process.env.PLATFORM_SIGNING_SECRET;
-    const serviceId = process.env.PLATFORM_SERVICE_ID;
-    const token = process.env.PLATFORM_AUTH_TOKEN;
+    const token = process.env.UENGAGE_AUTH_TOKEN;
     if (token)
         return { type: 'bearer', token };
-    if (secret && serviceId)
-        return { type: 'hmac', secret, serviceId };
     return undefined;
 }
 /**
- * Coerce `.auth()` input or `config({auth})` input into a typed PlatformAuth.
- * Throws if the input has no usable credentials or mixes HMAC + Bearer.
+ * Coerce `.auth()` input or `config({auth})` input into a typed
+ * PlatformAuth. Throws when the input has no usable credentials.
+ *
+ * Today this only accepts `{token}` or a pre-shaped `PlatformAuth`.
+ * For OAuth2 client_credentials use `createClient({serviceId, serviceSecret})`
+ * instead — that builds a TokenSource which mints + caches Bearer
+ * tokens.
  */
 function normalizeAuth(input) {
     if ('type' in input)
         return input;
     if (input.token) {
-        if (input.secret || input.serviceId) {
-            throw new Error('auth(): pass either {token} or {secret, serviceId}, not both');
-        }
         return { type: 'bearer', token: input.token };
     }
-    if (input.secret && input.serviceId) {
-        return { type: 'hmac', secret: input.secret, serviceId: input.serviceId };
-    }
-    throw new Error('auth(): must provide either {token} or {secret, serviceId}');
+    throw new Error('auth(): pass {token} for a static Bearer access token, or use createClient({serviceId, serviceSecret}) for OAuth2 client_credentials');
 }
 /**
  * Mutable config shared by clients. `apply()` and `setAuth()` are how the
@@ -81,4 +76,4 @@ class ConfigState {
     }
 }
 exports.ConfigState = ConfigState;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Logger } from '@uengage.io/js-logger';\n\nexport const DEFAULT_BASE_URL = 'https://api.platform.uengage.io';\n\n/**\n * Resolved auth state. Discriminated by `type` so consumers can narrow.\n */\nexport type PlatformAuth =\n  | { type: 'hmac'; secret: string; serviceId: string }\n  | { type: 'bearer'; token: string };\n\nexport interface PlatformConfig {\n  baseUrl: string;\n  auth?: PlatformAuth;\n  fetchFn: typeof fetch;\n  logger?: Logger;\n}\n\n/**\n * Caller-facing input shape. `auth` accepts either a discriminated\n * PlatformAuth or the looser PlatformAuthInput - the looser form is\n * also what `.auth()` accepts.\n */\nexport interface PlatformConfigInput {\n  baseUrl?: string;\n  auth?: PlatformAuthInput | PlatformAuth;\n  fetchFn?: typeof fetch;\n  logger?: Logger;\n}\n\n/**\n * `.auth()` shape. Pass either `{token}` (Bearer) or `{secret, serviceId}`\n * (HMAC). Mixing both throws.\n */\nexport interface PlatformAuthInput {\n  token?: string;\n  secret?: string;\n  serviceId?: string;\n}\n\n/**\n * Resolve env-defaulted config. Re-read on every call so that callers can\n * set env vars after the SDK has been imported and still pick them up on\n * the next request.\n */\nexport function envDefaults(): PlatformConfig {\n  return {\n    baseUrl: process.env.PLATFORM_BASE_URL ?? DEFAULT_BASE_URL,\n    auth: envAuth(),\n    fetchFn: globalThis.fetch as typeof fetch,\n  };\n}\n\nfunction envAuth(): PlatformAuth | undefined {\n  const secret = process.env.PLATFORM_SIGNING_SECRET;\n  const serviceId = process.env.PLATFORM_SERVICE_ID;\n  const token = process.env.PLATFORM_AUTH_TOKEN;\n  if (token) return { type: 'bearer', token };\n  if (secret && serviceId) return { type: 'hmac', secret, serviceId };\n  return undefined;\n}\n\n/**\n * Coerce `.auth()` input or `config({auth})` input into a typed PlatformAuth.\n * Throws if the input has no usable credentials or mixes HMAC + Bearer.\n */\nexport function normalizeAuth(input: PlatformAuthInput | PlatformAuth): PlatformAuth {\n  if ('type' in input) return input;\n  if (input.token) {\n    if (input.secret || input.serviceId) {\n      throw new Error('auth(): pass either {token} or {secret, serviceId}, not both');\n    }\n    return { type: 'bearer', token: input.token };\n  }\n  if (input.secret && input.serviceId) {\n    return { type: 'hmac', secret: input.secret, serviceId: input.serviceId };\n  }\n  throw new Error('auth(): must provide either {token} or {secret, serviceId}');\n}\n\n/**\n * Mutable config shared by clients. `apply()` and `setAuth()` are how the\n * chainable `.config()` / `.auth()` methods write back. `resolve()` produces\n * the effective config for one request, falling back to current env state\n * for fields the caller hasn't pinned.\n */\nexport class ConfigState {\n  private overrides: PlatformConfigInput = {};\n  private explicitAuth: PlatformAuth | undefined;\n  private hasExplicitAuth = false;\n\n  apply(input: PlatformConfigInput): void {\n    if (input.baseUrl !== undefined) this.overrides.baseUrl = input.baseUrl;\n    if (input.fetchFn !== undefined) this.overrides.fetchFn = input.fetchFn;\n    if (input.logger !== undefined) this.overrides.logger = input.logger;\n    if (input.auth !== undefined) {\n      this.explicitAuth = normalizeAuth(input.auth);\n      this.hasExplicitAuth = true;\n    }\n  }\n\n  setAuth(input: PlatformAuthInput | PlatformAuth): void {\n    this.explicitAuth = normalizeAuth(input);\n    this.hasExplicitAuth = true;\n  }\n\n  resolve(): PlatformConfig {\n    const env = envDefaults();\n    return {\n      baseUrl: this.overrides.baseUrl ?? env.baseUrl,\n      auth: this.hasExplicitAuth ? this.explicitAuth : env.auth,\n      fetchFn: (this.overrides.fetchFn ?? env.fetchFn) as typeof fetch,\n      logger: this.overrides.logger as Logger | undefined,\n    };\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,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