@uengage.io/platform-sdk 0.8.0 → 0.12.0

package/dist/client.js

@@ -1,54 +1,23 @@
 "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.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 client_3 = require("./zones/client");
+const auth_1 = require("./auth");
 const token_source_1 = require("./token-source");
+const errors_1 = require("./errors");
 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.
+ * Build a fresh, isolated client. With no args, reads `UENGAGE_*`
+ * env vars; explicit fields override per call. Each call gets its own
+ * TokenSource state — concurrent `createClient(...)` use does not
+ * stampede the cache.
  */
 function createClient(input = {}) {
-    warnIfBrowserSecret(input);
-    return buildClient(input);
+    const merged = mergeWithEnv(input);
+    warnIfBrowserSecret(merged);
+    return buildClient(merged);
 }
 function buildClient(input) {
     const baseUrl = input.baseUrl ?? DEFAULT_BASE_URL;
@@ -63,72 +32,181 @@ function buildClient(input) {
         auth,
         actorVia: input.actorVia ?? input.serviceId,
     });
-    const client = {
+    const zonesClient = (0, client_3.createZonesClient)({ baseUrl, fetchFn: input.fetchFn, auth });
+    return {
         business: businessClient,
         audit: auditClient,
+        zones: zonesClient,
         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,
-            });
-        },
-        withSessionToken(sessionToken) {
-            const customerAuthBaseUrl = input.customerAuthBaseUrl ?? `${baseUrl}/auth/customer`;
-            const fetchFn = input.fetchFn ?? globalThis.fetch;
-            // Wrap the customer-side session-exchange in a callback-style
-            // TokenSource. The existing dedup + cache + 401-retry machinery
-            // does the rest.
-            return buildClient({
-                ...input,
-                accessToken: () => exchangeSessionToken(sessionToken, customerAuthBaseUrl, fetchFn),
-                serviceId: undefined,
-                serviceSecret: undefined,
-                scope: undefined,
-            });
+        getAccessToken: async () => {
+            if (!tokenSourceState) {
+                throw new errors_1.ConfigError('getAccessToken: no auth mode configured. Pass {serviceId, serviceSecret} | {authToken} | {session}.');
+            }
+            return (0, token_source_1.getAccessToken)(tokenSourceState);
         },
     };
-    return client;
+}
+const AUTH_MODE_FIELDS = [
+    'serviceId',
+    'serviceSecret',
+    'scope',
+    'authToken',
+    'session',
+    'tokens',
+];
+/**
+ * Merge env-derived defaults with the caller's explicit input. Any
+ * explicit auth-mode field suppresses *all* env-derived auth defaults,
+ * so an explicit `{authToken}` override doesn't accidentally inherit
+ * `serviceId`/`serviceSecret` from env. Non-auth fields fall through
+ * normally (caller `baseUrl` overrides env baseUrl; absent input keeps
+ * env baseUrl).
+ */
+function mergeWithEnv(input) {
+    const env = readEnvDefaults();
+    const inputHasAuth = inputHasAuthMode(input);
+    const envForMerge = inputHasAuth ? withoutAuthFields(env) : env;
+    const merged = {
+        baseUrl: input.baseUrl ?? envForMerge.baseUrl,
+        authBaseUrl: input.authBaseUrl ?? envForMerge.authBaseUrl,
+        customerAuthBaseUrl: input.customerAuthBaseUrl ?? envForMerge.customerAuthBaseUrl,
+        serviceId: input.serviceId ?? envForMerge.serviceId,
+        serviceSecret: input.serviceSecret ?? envForMerge.serviceSecret,
+        scope: input.scope ?? envForMerge.scope,
+        authToken: input.authToken ?? envForMerge.authToken,
+        session: input.session ?? envForMerge.session,
+        tokens: input.tokens,
+        actorVia: input.actorVia ?? envForMerge.actorVia,
+        expiryBufferMs: input.expiryBufferMs ?? envForMerge.expiryBufferMs,
+        fetchFn: input.fetchFn,
+    };
+    assertExactlyOneAuthMode(merged);
+    return merged;
+}
+function readEnvDefaults() {
+    if (typeof process === 'undefined')
+        return {};
+    const e = process.env ?? {};
+    const expiry = e.UENGAGE_EXPIRY_BUFFER_MS ? Number(e.UENGAGE_EXPIRY_BUFFER_MS) : undefined;
+    // UENGAGE_SESSION_ID + UENGAGE_SESSION_TOKEN must be paired; either alone is ignored
+    // so an env-only setup never produces a half-configured session.
+    const session = e.UENGAGE_SESSION_ID && e.UENGAGE_SESSION_TOKEN
+        ? { id: e.UENGAGE_SESSION_ID, token: e.UENGAGE_SESSION_TOKEN }
+        : undefined;
+    return {
+        baseUrl: e.UENGAGE_BASE_URL,
+        authBaseUrl: e.UENGAGE_AUTH_BASE_URL,
+        customerAuthBaseUrl: e.UENGAGE_CUSTOMER_AUTH_BASE_URL,
+        serviceId: e.UENGAGE_SERVICE_ID,
+        serviceSecret: e.UENGAGE_SERVICE_SECRET,
+        scope: e.UENGAGE_SCOPE,
+        authToken: e.UENGAGE_AUTH_TOKEN,
+        session,
+        actorVia: e.UENGAGE_ACTOR_VIA,
+        expiryBufferMs: Number.isFinite(expiry) ? expiry : undefined,
+    };
+}
+function inputHasAuthMode(input) {
+    return AUTH_MODE_FIELDS.some((f) => input[f] !== undefined);
+}
+function withoutAuthFields(c) {
+    return {
+        ...c,
+        serviceId: undefined,
+        serviceSecret: undefined,
+        scope: undefined,
+        authToken: undefined,
+        session: undefined,
+        tokens: undefined,
+    };
+}
+function assertExactlyOneAuthMode(input) {
+    const modes = [];
+    if (input.authToken !== undefined)
+        modes.push('authToken');
+    if (input.session !== undefined)
+        modes.push('session');
+    if (input.tokens !== undefined)
+        modes.push('tokens');
+    if (input.serviceId !== undefined || input.serviceSecret !== undefined) {
+        modes.push('serviceId+serviceSecret');
+    }
+    if (modes.length > 1) {
+        throw new errors_1.ConfigError(`createClient: pick exactly one auth mode. Got ${modes.join(', ')}. ` +
+            'Use one of {serviceId, serviceSecret} | {authToken} | {session} | {tokens}.');
+    }
+    // Zero modes is allowed — caller may want a fully-anonymous client for
+    // public endpoints. The first request that needs auth will surface a
+    // ConfigError downstream.
 }
 /**
- * POST to the customer auth surface to exchange a legacy session
- * token for a fresh access token. Internal to `withSessionToken`;
- * callers don't see this directly.
+ * Probe the business `legacy_session` grant first, fall back to customer
+ * on `invalid_grant`. Either surface mints a JWT — the SDK doesn't care
+ * which side answered.
+ *
+ * Why probe both: `id` (numeric) overlaps users.userId vs
+ * addo_contacts_mapping.id/contactId. Callers usually don't know which
+ * table their (id, token) pair belongs to.
  */
-async function exchangeSessionToken(sessionToken, customerAuthBaseUrl, fetchFn) {
-    const res = await fetchFn(`${customerAuthBaseUrl}/oauth/token`, {
+async function exchangeLegacySession(session, authBaseUrl, customerAuthBaseUrl, fetchFn) {
+    const body = new URLSearchParams({
+        grant_type: 'legacy_session',
+        id: String(session.id),
+        token: session.token,
+    }).toString();
+    const businessRes = await fetchFn(`${authBaseUrl}/oauth/token`, {
         method: 'POST',
         headers: { 'content-type': 'application/x-www-form-urlencoded' },
-        body: new URLSearchParams({
-            grant_type: 'session_token',
-            session_token: sessionToken,
-        }).toString(),
+        body,
     });
-    if (!res.ok) {
-        const text = await res.text().catch(() => '');
-        const { AuthenticationError } = await Promise.resolve().then(() => __importStar(require('./errors')));
-        throw new AuthenticationError(`session-token exchange failed: HTTP ${res.status} ${text}`);
+    if (businessRes.ok) {
+        return parseAccessToken(businessRes);
     }
+    if (await isInvalidGrant(businessRes)) {
+        const customerRes = await fetchFn(`${customerAuthBaseUrl}/oauth/token`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/x-www-form-urlencoded' },
+            body,
+        });
+        if (customerRes.ok) {
+            return parseAccessToken(customerRes);
+        }
+        const text = await customerRes.text().catch(() => '');
+        throw new errors_1.AuthenticationError(`legacy_session exchange failed on both surfaces: customer HTTP ${customerRes.status} ${text}`);
+    }
+    const text = await businessRes.text().catch(() => '');
+    throw new errors_1.AuthenticationError(`legacy_session exchange failed: HTTP ${businessRes.status} ${text}`);
+}
+async function isInvalidGrant(res) {
+    if (res.status !== 400)
+        return false;
+    const cloned = res.clone();
+    const json = (await cloned.json().catch(() => ({})));
+    return json.error === 'invalid_grant';
+}
+async function parseAccessToken(res) {
     const json = (await res.json());
     if (!json.access_token) {
-        const { ConfigError } = await Promise.resolve().then(() => __importStar(require('./errors')));
-        throw new ConfigError('session-token exchange response missing access_token');
+        throw new errors_1.ConfigError('legacy_session exchange response missing access_token');
     }
     return json.access_token;
 }
-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 });
+    const fetchFn = input.fetchFn ?? globalThis.fetch;
+    if (input.authToken !== undefined) {
+        if (typeof input.authToken === 'string') {
+            return (0, token_source_1.makeTokenSourceState)({ kind: 'static-string', token: input.authToken }, { expiryBufferMs: input.expiryBufferMs, fetchFn: input.fetchFn });
         }
-        return (0, token_source_1.makeTokenSourceState)({ kind: 'callback', getToken: input.accessToken }, { expiryBufferMs: input.expiryBufferMs, fetchFn: input.fetchFn });
+        return (0, token_source_1.makeTokenSourceState)({ kind: 'callback', getToken: input.authToken }, { expiryBufferMs: input.expiryBufferMs, fetchFn: input.fetchFn });
+    }
+    if (input.session !== undefined) {
+        const customerAuthBaseUrl = input.customerAuthBaseUrl ?? `${baseUrl}/auth/customer`;
+        const session = input.session;
+        return (0, token_source_1.makeTokenSourceState)({
+            kind: 'callback',
+            getToken: () => exchangeLegacySession(session, authBaseUrl, customerAuthBaseUrl, fetchFn),
+        }, { expiryBufferMs: input.expiryBufferMs, fetchFn: input.fetchFn });
     }
     if (input.serviceId && input.serviceSecret) {
         return (0, token_source_1.makeTokenSourceState)({
@@ -139,6 +217,16 @@ function resolveTokenSource(input, baseUrl) {
             scope: input.scope,
         }, { expiryBufferMs: input.expiryBufferMs, fetchFn: input.fetchFn });
     }
+    if (input.tokens) {
+        return (0, token_source_1.makeTokenSourceState)({
+            kind: 'access-refresh-pair',
+            accessToken: input.tokens.accessToken,
+            refreshToken: input.tokens.refreshToken,
+            expiresAt: Date.now() + input.tokens.expiresIn * 1000,
+            clientId: input.tokens.clientId,
+            onRotate: input.tokens.onRotate,
+        }, { expiryBufferMs: input.expiryBufferMs, fetchFn: input.fetchFn });
+    }
     return undefined;
 }
 function warnIfBrowserSecret(config) {
@@ -149,60 +237,7 @@ function warnIfBrowserSecret(config) {
     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.');
+            'Use `authToken` (a Bearer obtained via OAuth) or `sessionToken` 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  /**\n   * Customer auth surface base used by `withSessionToken`. Defaults\n   * to `${baseUrl}/auth/customer`.\n   */\n  customerAuthBaseUrl?: 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   * Return a derived client that exchanges a legacy customer session\n   * token (from `addo_contacts_mapping.token`) for a Bearer JWT\n   * transparently on each call. The session token is the persistent\n   * credential — exchanges happen lazily on token-cache miss and on\n   * 401 retries. When the legacy session is revoked, the next\n   * exchange returns 401 and surfaces as `AuthenticationError`.\n   */\n  withSessionToken(sessionToken: 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    withSessionToken(sessionToken) {\n      const customerAuthBaseUrl = input.customerAuthBaseUrl ?? `${baseUrl}/auth/customer`;\n      const fetchFn = input.fetchFn ?? (globalThis.fetch as typeof fetch);\n      // Wrap the customer-side session-exchange in a callback-style\n      // TokenSource. The existing dedup + cache + 401-retry machinery\n      // does the rest.\n      return buildClient({\n        ...input,\n        accessToken: () => exchangeSessionToken(sessionToken, customerAuthBaseUrl, fetchFn),\n        serviceId: undefined,\n        serviceSecret: undefined,\n        scope: undefined,\n      });\n    },\n  };\n  return client;\n}\n\n/**\n * POST to the customer auth surface to exchange a legacy session\n * token for a fresh access token. Internal to `withSessionToken`;\n * callers don't see this directly.\n */\nasync function exchangeSessionToken(\n  sessionToken: string,\n  customerAuthBaseUrl: string,\n  fetchFn: typeof fetch,\n): Promise<string> {\n  const res = await fetchFn(`${customerAuthBaseUrl}/oauth/token`, {\n    method: 'POST',\n    headers: { 'content-type': 'application/x-www-form-urlencoded' },\n    body: new URLSearchParams({\n      grant_type: 'session_token',\n      session_token: sessionToken,\n    }).toString(),\n  });\n  if (!res.ok) {\n    const text = await res.text().catch(() => '');\n    const { AuthenticationError } = await import('./errors');\n    throw new AuthenticationError(`session-token exchange failed: HTTP ${res.status} ${text}`);\n  }\n  const json = (await res.json()) as { access_token?: string };\n  if (!json.access_token) {\n    const { ConfigError } = await import('./errors');\n    throw new ConfigError('session-token exchange response missing access_token');\n  }\n  return json.access_token;\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"]}
+//# 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 { createZonesClient, type ZonesClient } from './zones/client';\nimport { auth as authNamespace } from './auth';\nimport {\n  getAccessToken as resolveAccessToken,\n  makeTokenSourceState,\n  type TokenSourceState,\n} from './token-source';\nimport { ConfigError, AuthenticationError } from './errors';\nimport type { PlatformAuth } from './config';\n\n/**\n * Caller-facing config for `createClient(...)`.\n *\n * `createClient()` (no args) reads everything from the standard\n * `UENGAGE_*` environment variables — convenient for Lambdas that\n * already have their config injected by the deploy stack. Any field\n * passed explicitly overrides the matching env default for that one\n * call only (no shared mutable state, no singleton).\n *\n * Auth-mode fields are mutually exclusive. Pick one:\n *   - `serviceId` + `serviceSecret`  OAuth2 client_credentials.\n *   - `authToken`                    static Bearer token, or async\n *                                    callback that returns one.\n *   - `session: {id, token}`         legacy uEngage (id, apiToken) /\n *                                    (id, addo_contacts_mapping.token)\n *                                    pair. The SDK probes the business\n *                                    surface (users) first, falls back\n *                                    to the customer surface\n *                                    (addo_contacts_mapping) if the\n *                                    business probe returns\n *                                    `invalid_grant`, and caches the\n *                                    resulting JWT.\n *\n * Passing more than one explicitly is a `ConfigError`. Passing any one\n * of them suppresses every env-derived auth default, so a caller's\n * explicit override is never silently merged with env credentials of\n * a different mode.\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`.\n   */\n  authBaseUrl?: string;\n  /**\n   * Customer auth surface base used by `session` exchanges. Defaults to\n   * `${baseUrl}/auth/customer`.\n   */\n  customerAuthBaseUrl?: string;\n\n  // ─── Auth modes (mutually exclusive) ────────────────────────────────────\n  /** OAuth2 `client_credentials` clientId. Pair with `serviceSecret`. */\n  serviceId?: string;\n  /** OAuth2 `client_credentials` clientSecret. Pair with `serviceId`. */\n  serviceSecret?: string;\n  /** Space-separated scope list to request when minting via client_credentials. */\n  scope?: string;\n  /** Static Bearer JWT, or async callback that returns one. */\n  authToken?: string | (() => string | Promise<string>);\n  /**\n   * Legacy uEngage (id, token) pair. `id` is `users.userId` for staff\n   * users (matched via the business surface) or\n   * `addo_contacts_mapping.id`/`contactId` for customers (matched via\n   * the customer surface). The SDK probes the business surface first\n   * and falls back to customer on `invalid_grant`.\n   */\n  session?: { id: string | number; token: string };\n  /**\n   * `(accessToken, refreshToken)` pair from a finished login flow\n   * (`auth.loginWithPassword(...)`, `auth.verifyOtp(...)`, etc). The\n   * SDK uses the access token until it expires, then rotates via\n   * `auth.refresh(...)` transparently. `onRotate` fires after every\n   * rotation so callers can persist the new pair.\n   */\n  tokens?: {\n    accessToken: string;\n    refreshToken: string;\n    /** Access token TTL (seconds), as returned by the auth surface. */\n    expiresIn: number;\n    /** OAuth client id used during the original login (required by the refresh handler). */\n    clientId: string;\n    onRotate?: (pair: {\n      accessToken: string;\n      refreshToken: string;\n      expiresAt: number;\n    }) => void | Promise<void>;\n  };\n\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  zones: ZonesClient;\n  auth: typeof authNamespace;\n  /**\n   * Resolve the current access token, minting via the configured auth\n   * mode if the cache is cold. Useful for `auth.verifyAccessToken(...)`\n   * round-trips and for callers that want to log / forward the bearer\n   * to a downstream service.\n   *\n   * Throws `ConfigError` when the client was built with no auth mode.\n   */\n  getAccessToken(): Promise<string>;\n}\n\nconst DEFAULT_BASE_URL = 'https://api.platform.uengage.io';\n\n/**\n * Build a fresh, isolated client. With no args, reads `UENGAGE_*`\n * env vars; explicit fields override per call. Each call gets its own\n * TokenSource state — concurrent `createClient(...)` use does not\n * stampede the cache.\n */\nexport function createClient(input: ClientConfig = {}): PlatformClient {\n  const merged = mergeWithEnv(input);\n  warnIfBrowserSecret(merged);\n  return buildClient(merged);\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  const zonesClient = createZonesClient({ baseUrl, fetchFn: input.fetchFn, auth });\n\n  return {\n    business: businessClient,\n    audit: auditClient,\n    zones: zonesClient,\n    auth: authNamespace,\n    getAccessToken: async () => {\n      if (!tokenSourceState) {\n        throw new ConfigError(\n          'getAccessToken: no auth mode configured. Pass {serviceId, serviceSecret} | {authToken} | {session}.',\n        );\n      }\n      return resolveAccessToken(tokenSourceState);\n    },\n  };\n}\n\nconst AUTH_MODE_FIELDS = [\n  'serviceId',\n  'serviceSecret',\n  'scope',\n  'authToken',\n  'session',\n  'tokens',\n] as const;\n\n/**\n * Merge env-derived defaults with the caller's explicit input. Any\n * explicit auth-mode field suppresses *all* env-derived auth defaults,\n * so an explicit `{authToken}` override doesn't accidentally inherit\n * `serviceId`/`serviceSecret` from env. Non-auth fields fall through\n * normally (caller `baseUrl` overrides env baseUrl; absent input keeps\n * env baseUrl).\n */\nfunction mergeWithEnv(input: ClientConfig): ClientConfig {\n  const env = readEnvDefaults();\n  const inputHasAuth = inputHasAuthMode(input);\n  const envForMerge = inputHasAuth ? withoutAuthFields(env) : env;\n\n  const merged: ClientConfig = {\n    baseUrl: input.baseUrl ?? envForMerge.baseUrl,\n    authBaseUrl: input.authBaseUrl ?? envForMerge.authBaseUrl,\n    customerAuthBaseUrl: input.customerAuthBaseUrl ?? envForMerge.customerAuthBaseUrl,\n    serviceId: input.serviceId ?? envForMerge.serviceId,\n    serviceSecret: input.serviceSecret ?? envForMerge.serviceSecret,\n    scope: input.scope ?? envForMerge.scope,\n    authToken: input.authToken ?? envForMerge.authToken,\n    session: input.session ?? envForMerge.session,\n    tokens: input.tokens,\n    actorVia: input.actorVia ?? envForMerge.actorVia,\n    expiryBufferMs: input.expiryBufferMs ?? envForMerge.expiryBufferMs,\n    fetchFn: input.fetchFn,\n  };\n  assertExactlyOneAuthMode(merged);\n  return merged;\n}\n\nfunction readEnvDefaults(): ClientConfig {\n  if (typeof process === 'undefined') return {};\n  const e = (process as { env?: Record<string, string | undefined> }).env ?? {};\n  const expiry = e.UENGAGE_EXPIRY_BUFFER_MS ? Number(e.UENGAGE_EXPIRY_BUFFER_MS) : undefined;\n  // UENGAGE_SESSION_ID + UENGAGE_SESSION_TOKEN must be paired; either alone is ignored\n  // so an env-only setup never produces a half-configured session.\n  const session =\n    e.UENGAGE_SESSION_ID && e.UENGAGE_SESSION_TOKEN\n      ? { id: e.UENGAGE_SESSION_ID, token: e.UENGAGE_SESSION_TOKEN }\n      : undefined;\n  return {\n    baseUrl: e.UENGAGE_BASE_URL,\n    authBaseUrl: e.UENGAGE_AUTH_BASE_URL,\n    customerAuthBaseUrl: e.UENGAGE_CUSTOMER_AUTH_BASE_URL,\n    serviceId: e.UENGAGE_SERVICE_ID,\n    serviceSecret: e.UENGAGE_SERVICE_SECRET,\n    scope: e.UENGAGE_SCOPE,\n    authToken: e.UENGAGE_AUTH_TOKEN,\n    session,\n    actorVia: e.UENGAGE_ACTOR_VIA,\n    expiryBufferMs: Number.isFinite(expiry) ? (expiry as number) : undefined,\n  };\n}\n\nfunction inputHasAuthMode(input: ClientConfig): boolean {\n  return AUTH_MODE_FIELDS.some((f) => input[f] !== undefined);\n}\n\nfunction withoutAuthFields(c: ClientConfig): ClientConfig {\n  return {\n    ...c,\n    serviceId: undefined,\n    serviceSecret: undefined,\n    scope: undefined,\n    authToken: undefined,\n    session: undefined,\n    tokens: undefined,\n  };\n}\n\nfunction assertExactlyOneAuthMode(input: ClientConfig): void {\n  const modes: string[] = [];\n  if (input.authToken !== undefined) modes.push('authToken');\n  if (input.session !== undefined) modes.push('session');\n  if (input.tokens !== undefined) modes.push('tokens');\n  if (input.serviceId !== undefined || input.serviceSecret !== undefined) {\n    modes.push('serviceId+serviceSecret');\n  }\n  if (modes.length > 1) {\n    throw new ConfigError(\n      `createClient: pick exactly one auth mode. Got ${modes.join(', ')}. ` +\n        'Use one of {serviceId, serviceSecret} | {authToken} | {session} | {tokens}.',\n    );\n  }\n  // Zero modes is allowed — caller may want a fully-anonymous client for\n  // public endpoints. The first request that needs auth will surface a\n  // ConfigError downstream.\n}\n\n/**\n * Probe the business `legacy_session` grant first, fall back to customer\n * on `invalid_grant`. Either surface mints a JWT — the SDK doesn't care\n * which side answered.\n *\n * Why probe both: `id` (numeric) overlaps users.userId vs\n * addo_contacts_mapping.id/contactId. Callers usually don't know which\n * table their (id, token) pair belongs to.\n */\nasync function exchangeLegacySession(\n  session: { id: string | number; token: string },\n  authBaseUrl: string,\n  customerAuthBaseUrl: string,\n  fetchFn: typeof fetch,\n): Promise<string> {\n  const body = new URLSearchParams({\n    grant_type: 'legacy_session',\n    id: String(session.id),\n    token: session.token,\n  }).toString();\n\n  const businessRes = await fetchFn(`${authBaseUrl}/oauth/token`, {\n    method: 'POST',\n    headers: { 'content-type': 'application/x-www-form-urlencoded' },\n    body,\n  });\n  if (businessRes.ok) {\n    return parseAccessToken(businessRes);\n  }\n  if (await isInvalidGrant(businessRes)) {\n    const customerRes = await fetchFn(`${customerAuthBaseUrl}/oauth/token`, {\n      method: 'POST',\n      headers: { 'content-type': 'application/x-www-form-urlencoded' },\n      body,\n    });\n    if (customerRes.ok) {\n      return parseAccessToken(customerRes);\n    }\n    const text = await customerRes.text().catch(() => '');\n    throw new AuthenticationError(\n      `legacy_session exchange failed on both surfaces: customer HTTP ${customerRes.status} ${text}`,\n    );\n  }\n  const text = await businessRes.text().catch(() => '');\n  throw new AuthenticationError(\n    `legacy_session exchange failed: HTTP ${businessRes.status} ${text}`,\n  );\n}\n\nasync function isInvalidGrant(res: Response): Promise<boolean> {\n  if (res.status !== 400) return false;\n  const cloned = res.clone();\n  const json = (await cloned.json().catch(() => ({}))) as { error?: string };\n  return json.error === 'invalid_grant';\n}\n\nasync function parseAccessToken(res: Response): Promise<string> {\n  const json = (await res.json()) as { access_token?: string };\n  if (!json.access_token) {\n    throw new ConfigError('legacy_session exchange response missing access_token');\n  }\n  return json.access_token;\n}\n\nfunction resolveTokenSource(input: ClientConfig, baseUrl: string): TokenSourceState | undefined {\n  const authBaseUrl = input.authBaseUrl ?? `${baseUrl}/auth/business`;\n  const fetchFn = input.fetchFn ?? (globalThis.fetch as typeof fetch);\n\n  if (input.authToken !== undefined) {\n    if (typeof input.authToken === 'string') {\n      return makeTokenSourceState(\n        { kind: 'static-string', token: input.authToken },\n        { expiryBufferMs: input.expiryBufferMs, fetchFn: input.fetchFn },\n      );\n    }\n    return makeTokenSourceState(\n      { kind: 'callback', getToken: input.authToken },\n      { expiryBufferMs: input.expiryBufferMs, fetchFn: input.fetchFn },\n    );\n  }\n  if (input.session !== undefined) {\n    const customerAuthBaseUrl = input.customerAuthBaseUrl ?? `${baseUrl}/auth/customer`;\n    const session = input.session;\n    return makeTokenSourceState(\n      {\n        kind: 'callback',\n        getToken: () => exchangeLegacySession(session, authBaseUrl, customerAuthBaseUrl, fetchFn),\n      },\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  if (input.tokens) {\n    return makeTokenSourceState(\n      {\n        kind: 'access-refresh-pair',\n        accessToken: input.tokens.accessToken,\n        refreshToken: input.tokens.refreshToken,\n        expiresAt: Date.now() + input.tokens.expiresIn * 1000,\n        clientId: input.tokens.clientId,\n        onRotate: input.tokens.onRotate,\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 `authToken` (a Bearer obtained via OAuth) or `sessionToken` instead.',\n    );\n  }\n}\n"]}

package/dist/http.d.ts

@@ -22,3 +22,25 @@ export interface SignedHeaderParams {
  *     and refreshes on expiry / 401
  */
 export declare function buildHeaders(config: PlatformConfig, params: SignedHeaderParams): Promise<Record<string, string>>;
+export interface SendRequestParams {
+    method: string;
+    /** URL pathname only, without query string. Must match `c.req.path` server-side. */
+    path: string;
+    /** Fully-qualified URL the fetch is sent to (base + path + querystring). */
+    url: string;
+    /** Raw JSON body string, or undefined for none. */
+    body?: string;
+}
+/**
+ * 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. Bubble the response so the caller surfaces it.
+ *
+ * Shared by every namespace client (business, audit, zones, ...) so
+ * the retry semantics are uniform. Lifted out of `business/client.ts`
+ * with no behaviour change.
+ */
+export declare function sendWithAuthRetry(config: PlatformConfig, params: SendRequestParams): Promise<Response>;

package/dist/http.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildHeaders = buildHeaders;
+exports.sendWithAuthRetry = sendWithAuthRetry;
 const node_crypto_1 = require("node:crypto");
 const token_source_1 = require("./token-source");
 const version_1 = require("./version");
@@ -40,4 +41,41 @@ async function buildHeaders(config, params) {
     headers['authorization'] = `Bearer ${token}`;
     return headers;
 }
-//# 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. Bubble the response so the caller surfaces it.
+ *
+ * Shared by every namespace client (business, audit, zones, ...) so
+ * the retry semantics are uniform. Lifted out of `business/client.ts`
+ * with no behaviour change.
+ */
+async function sendWithAuthRetry(config, params) {
+    const headers = await 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 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,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

package/dist/index.d.ts

@@ -1,24 +1,8 @@
 export * from './audit';
 export * from './business';
+export * from './zones';
 export * from './errors';
 export { auth } from './auth';
 export type { PkcePair, AuthorizeUrlInput, ExchangeCodeInput, RefreshInput, TokenPair, } from './auth';
 export { type PlatformAuth, type PlatformAuthInput, type PlatformConfig, type PlatformConfigInput, DEFAULT_BASE_URL, } from './config';
-export { createClient, platform, withToken, type ClientConfig, type PlatformClient, } from './client';
-/**
- * Default singleton clients. Both read defaults from the environment on
- * every call:
- *   - UENGAGE_BASE_URL          defaults to https://api.platform.uengage.io
- *   - UENGAGE_AUTH_TOKEN        static Bearer token
- *   - UENGAGE_SERVICE_ID        OAuth2 client_credentials clientId
- *   - UENGAGE_SERVICE_SECRET    OAuth2 client_credentials clientSecret
- *   - UENGAGE_SERVICE_SCOPE     optional space-separated scope list
- *
- * The chainable `.config({...})` / `.auth({...})` API on the audit and
- * business clients is preserved for back-compat. `.auth({token})`
- * accepts a static Bearer token; for OAuth2 client_credentials use the
- * unified `createClient(...)` factory instead — that builds a
- * TokenSource which handles caching + refresh dedup + 401 retry.
- */
-export declare const audit: import("./audit").AuditClient;
-export declare const business: import("./business").BusinessClient;
+export { createClient, type ClientConfig, type PlatformClient } from './client';