@uengage.io/platform-sdk 0.3.0 → 0.6.0

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,71 @@
+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 Bearer flow
+ *   - `oauthClientId` + `oauthClientSecret` for OAuth2 client_credentials
+ *   - `serviceId` + `serviceSecret` for HMAC service-to-service
+ *
+ * Mixing is allowed only when one is the user-facing Bearer and the
+ * other is the HMAC fallback for legacy endpoints (audit ingest).
+ * In that case `platform.business` uses Bearer; `platform.audit` uses
+ * HMAC. Without either, calls throw `ConfigError` on the first request.
+ */
+export interface ClientConfig {
+    baseUrl?: string;
+    /** Auth surface base; defaults to `${baseUrl}/auth/business`. Used only to bootstrap the first client_credentials mint — once a token exists, future auth calls follow the token's `iss`. */
+    authBaseUrl?: string;
+    accessToken?: string | (() => string | Promise<string>);
+    oauthClientId?: string;
+    oauthClientSecret?: string;
+    oauthScope?: string;
+    serviceId?: string;
+    serviceSecret?: 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`, `fetchFn`, and any HMAC fallback from this
+     * client; replaces the OAuth/static-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.
+ *
+ *   PLATFORM_BASE_URL              defaults to https://api.platform.uengage.io
+ *   PLATFORM_AUTH_TOKEN            Bearer token (overrides OAuth + HMAC)
+ *   PLATFORM_OAUTH_CLIENT_ID       OAuth2 client_credentials
+ *   PLATFORM_OAUTH_CLIENT_SECRET   OAuth2 client_credentials
+ *   PLATFORM_OAUTH_SCOPE           optional space-separated scope list
+ *   PLATFORM_SERVICE_ID            HMAC service-id (legacy / audit)
+ *   PLATFORM_SIGNING_SECRET        HMAC raw secret  (legacy / audit)
+ */
+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,152 @@
+"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 auth_1 = require("./auth");
+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 businessAuth = pickBusinessAuth(input, tokenSourceState);
+    const businessClient = (0, client_2.createBusinessClient)({
+        baseUrl,
+        fetchFn: input.fetchFn,
+        auth: businessAuth,
+    });
+    // Audit is HMAC-only on the server side, so always use the HMAC
+    // creds when present, regardless of any token-source overlay.
+    const auditAuth = input.serviceId && input.serviceSecret
+        ? { type: 'hmac', serviceId: input.serviceId, secret: input.serviceSecret }
+        : undefined;
+    const auditClient = (0, client_1.createAuditClient)({
+        baseUrl,
+        fetchFn: input.fetchFn,
+        auth: auditAuth,
+    });
+    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.
+                oauthClientId: undefined,
+                oauthClientSecret: undefined,
+                oauthScope: undefined,
+            });
+        },
+    };
+    return client;
+}
+function pickBusinessAuth(input, tokenSourceState) {
+    if (tokenSourceState)
+        return { type: 'token-source', state: tokenSourceState };
+    if (input.serviceId && input.serviceSecret) {
+        return { type: 'hmac', serviceId: input.serviceId, secret: input.serviceSecret };
+    }
+    return undefined;
+}
+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.oauthClientId && input.oauthClientSecret) {
+        return (0, token_source_1.makeTokenSourceState)({
+            kind: 'service-credentials',
+            clientId: input.oauthClientId,
+            clientSecret: input.oauthClientSecret,
+            authBaseUrl,
+            scope: input.oauthScope,
+        }, { 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 || config.oauthClientSecret) {
+        console.warn('[uengage-platform-sdk] service-side secrets 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.PLATFORM_BASE_URL,
+        authBaseUrl: e.PLATFORM_AUTH_BASE_URL,
+        accessToken: e.PLATFORM_AUTH_TOKEN,
+        oauthClientId: e.PLATFORM_OAUTH_CLIENT_ID,
+        oauthClientSecret: e.PLATFORM_OAUTH_CLIENT_SECRET,
+        oauthScope: e.PLATFORM_OAUTH_SCOPE,
+        serviceId: e.PLATFORM_SERVICE_ID,
+        serviceSecret: e.PLATFORM_SIGNING_SECRET,
+    };
+}
+/**
+ * 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.
+ *
+ *   PLATFORM_BASE_URL              defaults to https://api.platform.uengage.io
+ *   PLATFORM_AUTH_TOKEN            Bearer token (overrides OAuth + HMAC)
+ *   PLATFORM_OAUTH_CLIENT_ID       OAuth2 client_credentials
+ *   PLATFORM_OAUTH_CLIENT_SECRET   OAuth2 client_credentials
+ *   PLATFORM_OAUTH_SCOPE           optional space-separated scope list
+ *   PLATFORM_SERVICE_ID            HMAC service-id (legacy / audit)
+ *   PLATFORM_SIGNING_SECRET        HMAC raw secret  (legacy / audit)
+ */
+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 Bearer flow\n *   - `oauthClientId` + `oauthClientSecret` for OAuth2 client_credentials\n *   - `serviceId` + `serviceSecret` for HMAC service-to-service\n *\n * Mixing is allowed only when one is the user-facing Bearer and the\n * other is the HMAC fallback for legacy endpoints (audit ingest).\n * In that case `platform.business` uses Bearer; `platform.audit` uses\n * HMAC. Without either, calls throw `ConfigError` on the first request.\n */\nexport interface ClientConfig {\n  baseUrl?: string;\n  /** Auth surface base; defaults to `${baseUrl}/auth/business`. Used only to bootstrap the first client_credentials mint — once a token exists, future auth calls follow the token's `iss`. */\n  authBaseUrl?: string;\n  accessToken?: string | (() => string | Promise<string>);\n  oauthClientId?: string;\n  oauthClientSecret?: string;\n  oauthScope?: string;\n  serviceId?: string;\n  serviceSecret?: 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`, `fetchFn`, and any HMAC fallback from this\n   * client; replaces the OAuth/static-token source with the new one.\n   * Use case: BFF handlers that want to call the platform API as the\n   * 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\n  const businessAuth = pickBusinessAuth(input, tokenSourceState);\n  const businessClient = createBusinessClient({\n    baseUrl,\n    fetchFn: input.fetchFn,\n    auth: businessAuth,\n  });\n\n  // Audit is HMAC-only on the server side, so always use the HMAC\n  // creds when present, regardless of any token-source overlay.\n  const auditAuth: PlatformAuth | undefined =\n    input.serviceId && input.serviceSecret\n      ? { type: 'hmac', serviceId: input.serviceId, secret: input.serviceSecret }\n      : undefined;\n  const auditClient = createAuditClient({\n    baseUrl,\n    fetchFn: input.fetchFn,\n    auth: auditAuth,\n  });\n\n  const client: PlatformClient = {\n    business: businessClient,\n    audit: auditClient,\n    auth,\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        oauthClientId: undefined,\n        oauthClientSecret: undefined,\n        oauthScope: undefined,\n      });\n    },\n  };\n  return client;\n}\n\nfunction pickBusinessAuth(\n  input: ClientConfig,\n  tokenSourceState: TokenSourceState | undefined,\n): PlatformAuth | undefined {\n  if (tokenSourceState) return { type: 'token-source', state: tokenSourceState };\n  if (input.serviceId && input.serviceSecret) {\n    return { type: 'hmac', serviceId: input.serviceId, secret: input.serviceSecret };\n  }\n  return undefined;\n}\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.oauthClientId && input.oauthClientSecret) {\n    return makeTokenSourceState(\n      {\n        kind: 'service-credentials',\n        clientId: input.oauthClientId,\n        clientSecret: input.oauthClientSecret,\n        authBaseUrl,\n        scope: input.oauthScope,\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 || config.oauthClientSecret) {\n    console.warn(\n      '[uengage-platform-sdk] service-side secrets 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.PLATFORM_BASE_URL,\n    authBaseUrl: e.PLATFORM_AUTH_BASE_URL,\n    accessToken: e.PLATFORM_AUTH_TOKEN,\n    oauthClientId: e.PLATFORM_OAUTH_CLIENT_ID,\n    oauthClientSecret: e.PLATFORM_OAUTH_CLIENT_SECRET,\n    oauthScope: e.PLATFORM_OAUTH_SCOPE,\n    serviceId: e.PLATFORM_SERVICE_ID,\n    serviceSecret: e.PLATFORM_SIGNING_SECRET,\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 *   PLATFORM_BASE_URL              defaults to https://api.platform.uengage.io\n *   PLATFORM_AUTH_TOKEN            Bearer token (overrides OAuth + HMAC)\n *   PLATFORM_OAUTH_CLIENT_ID       OAuth2 client_credentials\n *   PLATFORM_OAUTH_CLIENT_SECRET   OAuth2 client_credentials\n *   PLATFORM_OAUTH_SCOPE           optional space-separated scope list\n *   PLATFORM_SERVICE_ID            HMAC service-id (legacy / audit)\n *   PLATFORM_SIGNING_SECRET        HMAC raw secret  (legacy / audit)\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,4 +1,5 @@
 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.
@@ -10,6 +11,9 @@ export type PlatformAuth = {
 } | {
     type: 'bearer';
     token: string;
+} | {
+    type: 'token-source';
+    state: TokenSourceState;
 };
 export interface PlatformConfig {
     baseUrl: string;

package/dist/config.js

@@ -81,4 +81,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,{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":";;;AA+CA,kCAMC;AAeD,sCAYC;AA7EY,QAAA,gBAAgB,GAAG,iCAAiC,CAAC;AAuClE;;;;GAIG;AACH,SAAgB,WAAW;IACzB,OAAO;QACL,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,iBAAiB,IAAI,wBAAgB;QAC1D,IAAI,EAAE,OAAO,EAAE;QACf,OAAO,EAAE,UAAU,CAAC,KAAqB;KAC1C,CAAC;AACJ,CAAC;AAED,SAAS,OAAO;IACd,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,uBAAuB,CAAC;IACnD,MAAM,SAAS,GAAG,OAAO,CAAC,GAAG,CAAC,mBAAmB,CAAC;IAClD,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,mBAAmB,CAAC;IAC9C,IAAI,KAAK;QAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;IAC5C,IAAI,MAAM,IAAI,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC;IACpE,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;GAGG;AACH,SAAgB,aAAa,CAAC,KAAuC;IACnE,IAAI,MAAM,IAAI,KAAK;QAAE,OAAO,KAAK,CAAC;IAClC,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;QAChB,IAAI,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,SAAS,EAAE,CAAC;YACpC,MAAM,IAAI,KAAK,CAAC,8DAA8D,CAAC,CAAC;QAClF,CAAC;QACD,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC;IAChD,CAAC;IACD,IAAI,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,SAAS,EAAE,CAAC;QACpC,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,CAAC,SAAS,EAAE,CAAC;IAC5E,CAAC;IACD,MAAM,IAAI,KAAK,CAAC,4DAA4D,CAAC,CAAC;AAChF,CAAC;AAED;;;;;GAKG;AACH,MAAa,WAAW;IACd,SAAS,GAAwB,EAAE,CAAC;IACpC,YAAY,CAA2B;IACvC,eAAe,GAAG,KAAK,CAAC;IAEhC,KAAK,CAAC,KAA0B;QAC9B,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS;YAAE,IAAI,CAAC,SAAS,CAAC,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;QACxE,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS;YAAE,IAAI,CAAC,SAAS,CAAC,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;QACxE,IAAI,KAAK,CAAC,MAAM,KAAK,SAAS;YAAE,IAAI,CAAC,SAAS,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;QACrE,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;YAC7B,IAAI,CAAC,YAAY,GAAG,aAAa,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YAC9C,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;QAC9B,CAAC;IACH,CAAC;IAED,OAAO,CAAC,KAAuC;QAC7C,IAAI,CAAC,YAAY,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC;QACzC,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;IAC9B,CAAC;IAED,OAAO;QACL,MAAM,GAAG,GAAG,WAAW,EAAE,CAAC;QAC1B,OAAO;YACL,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,IAAI,GAAG,CAAC,OAAO;YAC9C,IAAI,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI;YACzD,OAAO,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,IAAI,GAAG,CAAC,OAAO,CAAiB;YAChE,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,MAA4B;SACpD,CAAC;IACJ,CAAC;CACF;AA7BD,kCA6BC","sourcesContent":["import type { Logger } from '@uengage.io/js-logger';\nimport type { TokenSourceState } from './token-source';\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  | { type: 'token-source'; state: TokenSourceState };\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"]}

package/dist/errors.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Platform-SDK error hierarchy. Consumers should `instanceof`-check
+ * against `PlatformError` for the catch-all and the specific subclasses
+ * for the cases they care about. Status codes mirror the HTTP responses
+ * the platform API actually emits, so `error.status` is the simplest
+ * routing signal.
+ */
+export declare class PlatformError extends Error {
+    readonly status?: number;
+    readonly cause?: unknown;
+    constructor(message: string, opts?: {
+        status?: number;
+        cause?: unknown;
+    });
+}
+export declare class AuthenticationError extends PlatformError {
+    constructor(message?: string, opts?: {
+        cause?: unknown;
+    });
+}
+export declare class AuthorizationError extends PlatformError {
+    /** When the API returns a `requiredScope`, surface it for the consumer. */
+    readonly requiredScope?: string;
+    constructor(message?: string, opts?: {
+        requiredScope?: string;
+        cause?: unknown;
+    });
+}
+export declare class NotFoundError extends PlatformError {
+    constructor(message?: string, opts?: {
+        cause?: unknown;
+    });
+}
+export declare class ValidationError extends PlatformError {
+    /** Per-field issues in the platform's standard `issues` array shape. */
+    readonly issues?: unknown[];
+    constructor(message?: string, opts?: {
+        issues?: unknown[];
+        cause?: unknown;
+    });
+}
+export declare class RateLimitError extends PlatformError {
+    /** Seconds the consumer should back off (from `Retry-After`). */
+    readonly retryAfter?: number;
+    constructor(message?: string, opts?: {
+        retryAfter?: number;
+        cause?: unknown;
+    });
+}
+/**
+ * Thrown when the SDK detects an expired access token before the request
+ * is sent. Callers using a static externally-supplied token must update
+ * the config with a fresh one.
+ */
+export declare class TokenExpiredError extends PlatformError {
+    constructor(message?: string);
+}
+/** Thrown for missing / inconsistent SDK configuration. */
+export declare class ConfigError extends PlatformError {
+    constructor(message: string);
+}

package/dist/errors.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigError = exports.TokenExpiredError = exports.RateLimitError = exports.ValidationError = exports.NotFoundError = exports.AuthorizationError = exports.AuthenticationError = exports.PlatformError = void 0;
+/**
+ * Platform-SDK error hierarchy. Consumers should `instanceof`-check
+ * against `PlatformError` for the catch-all and the specific subclasses
+ * for the cases they care about. Status codes mirror the HTTP responses
+ * the platform API actually emits, so `error.status` is the simplest
+ * routing signal.
+ */
+class PlatformError extends Error {
+    status;
+    cause;
+    constructor(message, opts) {
+        super(message);
+        this.name = 'PlatformError';
+        this.status = opts?.status;
+        this.cause = opts?.cause;
+    }
+}
+exports.PlatformError = PlatformError;
+class AuthenticationError extends PlatformError {
+    constructor(message = 'authentication failed', opts) {
+        super(message, { status: 401, cause: opts?.cause });
+        this.name = 'AuthenticationError';
+    }
+}
+exports.AuthenticationError = AuthenticationError;
+class AuthorizationError extends PlatformError {
+    /** When the API returns a `requiredScope`, surface it for the consumer. */
+    requiredScope;
+    constructor(message = 'authorization failed', opts) {
+        super(message, { status: 403, cause: opts?.cause });
+        this.name = 'AuthorizationError';
+        this.requiredScope = opts?.requiredScope;
+    }
+}
+exports.AuthorizationError = AuthorizationError;
+class NotFoundError extends PlatformError {
+    constructor(message = 'not found', opts) {
+        super(message, { status: 404, cause: opts?.cause });
+        this.name = 'NotFoundError';
+    }
+}
+exports.NotFoundError = NotFoundError;
+class ValidationError extends PlatformError {
+    /** Per-field issues in the platform's standard `issues` array shape. */
+    issues;
+    constructor(message = 'validation failed', opts) {
+        super(message, { status: 422, cause: opts?.cause });
+        this.name = 'ValidationError';
+        this.issues = opts?.issues;
+    }
+}
+exports.ValidationError = ValidationError;
+class RateLimitError extends PlatformError {
+    /** Seconds the consumer should back off (from `Retry-After`). */
+    retryAfter;
+    constructor(message = 'rate limited', opts) {
+        super(message, { status: 429, cause: opts?.cause });
+        this.name = 'RateLimitError';
+        this.retryAfter = opts?.retryAfter;
+    }
+}
+exports.RateLimitError = RateLimitError;
+/**
+ * Thrown when the SDK detects an expired access token before the request
+ * is sent. Callers using a static externally-supplied token must update
+ * the config with a fresh one.
+ */
+class TokenExpiredError extends PlatformError {
+    constructor(message = 'access token has expired') {
+        super(message, { status: 401 });
+        this.name = 'TokenExpiredError';
+    }
+}
+exports.TokenExpiredError = TokenExpiredError;
+/** Thrown for missing / inconsistent SDK configuration. */
+class ConfigError extends PlatformError {
+    constructor(message) {
+        super(message);
+        this.name = 'ConfigError';
+    }
+}
+exports.ConfigError = ConfigError;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/http.d.ts

@@ -7,9 +7,14 @@ export interface SignedHeaderParams {
     body?: string;
 }
 /**
- * Build the headers required for a request to the platform API, given the
- * effective auth on `config`. With no auth configured we still return any
- * non-auth headers (e.g. content-type) - some endpoints accept anonymous
- * callers and the server decides whether to allow.
+ * Build the headers required for a request to the platform API, given
+ * the effective auth on `config`. Async because the `token-source`
+ * auth path may need to mint or refresh before returning.
+ *
+ * Adds three platform-wide headers automatically:
+ *   - `User-Agent` so the gateway can attribute traffic to SDK version
+ *   - `Idempotency-Key` (UUID v4) on mutating methods, so callers don't
+ *     have to generate one per call
+ *   - `content-type: application/json` when a body is supplied
  */
-export declare function buildHeaders(config: PlatformConfig, params: SignedHeaderParams): Record<string, string>;
+export declare function buildHeaders(config: PlatformConfig, params: SignedHeaderParams): Promise<Record<string, string>>;