@uengage.io/platform-sdk 0.15.0 → 2.0.0

package/README.md

@@ -114,6 +114,96 @@ await client.audit.flush(); // optional: drain on shutdown
 - `flush()` resolves when the queue is empty or retries are exhausted.
 - If `actorVia` is unset, `record()` logs an error and drops the event.
 
+## Events client (platform event bus)
+
+A **subpath export**, like `/realtime`, and for the same reason: it wraps
+`@aws-sdk/client-sns`, which is declared as an **optional peer dependency** so
+it is installed only by code that actually publishes. Consumers that just read
+businesses or zones — and any frontend bundle touching the root import — pay
+nothing. This mirrors the PHP SDK, where `aws/aws-sdk-php` is a `suggest`.
+
+```bash
+npm install @aws-sdk/client-sns   # only if you publish events
+```
+
+```ts
+import { events, createEventsClient } from '@uengage.io/platform-sdk/events';
+
+await events.publish(
+  'order.status_changed',
+  { orderId, orderType, status, deliveryStatus, statusRank },
+  { tenantId },
+);
+
+await events.publishBatch([
+  { type: 'order.created', data: { orderId: '1' }, tenantId: '38112' },
+  { type: 'order.status_changed', data: { orderId: '1' }, tenantId: '38112' },
+]);
+```
+
+`events` is a lazy singleton configured from the environment; use
+`createEventsClient({ topicArn, source, snsClient })` for an isolated client.
+It is deliberately **not** on the object returned by `createClient()` — that
+would put the SNS dependency back on the main entry.
+
+- The SDK builds the whole envelope: monotonic ULID `id`, `occurredAt`,
+  `version`, and `domain` (mapped from the `type` prefix — an explicit map, not
+  a pluralisation rule, since `menu`, `loyalty` and `usage` are not plural).
+- `type` / `domain` / `source` are also set as SNS message attributes, which is
+  what consumer filter policies match on.
+- Config is env-first: `PLATFORM_EVENTS_TOPIC_ARN`, optionally
+  `PLATFORM_EVENTS_SOURCE` (defaults to `SERVICE_NAME`). Region is read from
+  the topic ARN.
+- **`publish()` throws** — `ConfigError`, `ValidationError`, or
+  `EventPublishError` (which carries `failedEventIds`). Fail-open is the
+  caller's decision because it differs by call site: a legacy order flow must
+  never block on the bus, a service reconciling state may want to retry. The
+  PHP SDK makes that choice for you; here you make it.
+- `publishBatch()` validates and serializes every envelope before publishing
+  anything, then chunks by **both** SNS limits: 10 entries and 256 KB per
+  request. An envelope over the 256 KB message ceiling throws a
+  `ValidationError` naming the event and its size.
+
+## Realtime client (browser)
+
+A separate, browser-safe subpath export — **zero runtime dependencies, no Node
+built-ins, ~6 KB minified**. Same client for web and React Native.
+
+```ts
+import { realtime } from '@uengage.io/platform-sdk/realtime';
+
+const client = realtime.connect({
+  env: 'prod', // resolves endpoints; no URLs in app code
+  getToken: () => session.jwt(), // called on connect, resubscribe, and refresh
+});
+
+const sub = client.subscribe(`/orders/${orderId}`, {
+  onUpdate(event, meta) {
+    render(event.data);
+  }, // meta.origin: 'snapshot' | 'live'
+  onError(err) {
+    showOffline(err);
+  },
+});
+
+sub.unsubscribe();
+```
+
+Channels are the only concept — the realtime layer knows nothing about orders;
+`/orders/{id}` is a naming convention the service's namespace policy enforces.
+
+The SDK owns the AppSync Events wire protocol, the keepalive watchdog and
+dead-connection detection, reconnect with jittered backoff, resubscribing every
+channel, token refresh via `getToken`, and ULID-based ordering/dedupe. One
+socket multiplexes all subscriptions.
+
+**No manual resync.** The stream cannot replay missed events, so on every
+subscribe _and_ reconnect the SDK opens the subscription first, then fetches the
+channel's last value from `GET /v1/realtime/latest`, and emits whichever is
+newer through the same `onUpdate`. Subscribing first means nothing falls between
+the snapshot and the stream. Pass `getSnapshot` per-subscribe to override where
+that catch-up value comes from.
+
 ## Business client
 
 ```ts

package/dist/client.d.ts

@@ -2,6 +2,7 @@ import { type AuditClient } from './audit/client';
 import { type BusinessClient } from './business/client';
 import { type ZonesClient } from './zones/client';
 import { type WalletClient } from './wallet/client';
+import { type UpsellClient } from './upsell/client';
 import { auth as authNamespace } from './auth';
 /**
  * Caller-facing config for `createClient(...)`.
@@ -91,11 +92,23 @@ export interface ClientConfig {
     expiryBufferMs?: number;
     fetchFn?: typeof fetch;
 }
+/**
+ * The namespaces that reach the platform HTTP API.
+ *
+ * `events` is deliberately NOT here. It publishes straight to SNS, so
+ * wiring it onto this client would make `@aws-sdk/client-sns` a hard
+ * dependency of the SDK's main entry — paid by every consumer that only
+ * reads businesses or zones, and by every frontend bundle that touches
+ * the root import. It lives at the `@uengage.io/platform-sdk/events`
+ * subpath instead, alongside `/realtime`, and is configured from the
+ * environment (`PLATFORM_EVENTS_TOPIC_ARN`) or `createEventsClient(...)`.
+ */
 export interface PlatformClient {
     business: BusinessClient;
     audit: AuditClient;
     zones: ZonesClient;
     wallet: WalletClient;
+    upsell: UpsellClient;
     auth: typeof authNamespace;
     /**
      * Resolve the current access token, minting via the configured auth

package/dist/client.js

@@ -5,6 +5,7 @@ const client_1 = require("./audit/client");
 const client_2 = require("./business/client");
 const client_3 = require("./zones/client");
 const client_4 = require("./wallet/client");
+const client_5 = require("./upsell/client");
 const auth_1 = require("./auth");
 const token_source_1 = require("./token-source");
 const errors_1 = require("./errors");
@@ -35,11 +36,13 @@ function buildClient(input) {
     });
     const zonesClient = (0, client_3.createZonesClient)({ baseUrl, fetchFn: input.fetchFn, auth });
     const walletClient = (0, client_4.createWalletClient)({ baseUrl, fetchFn: input.fetchFn, auth });
+    const upsellClient = (0, client_5.createUpsellClient)({ baseUrl, fetchFn: input.fetchFn, auth });
     return {
         business: businessClient,
         audit: auditClient,
         zones: zonesClient,
         wallet: walletClient,
+        upsell: upsellClient,
         auth: auth_1.auth,
         getAccessToken: async () => {
             if (!tokenSourceState) {
@@ -243,4 +246,4 @@ function warnIfBrowserSecret(config) {
             'Use `authToken` (a Bearer obtained via OAuth) or `sessionToken` instead.');
     }
 }
-//# 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 { createWalletClient, type WalletClient } from './wallet/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  wallet: WalletClient;\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  const walletClient = createWalletClient({ baseUrl, fetchFn: input.fetchFn, auth });\n\n  return {\n    business: businessClient,\n    audit: auditClient,\n    zones: zonesClient,\n    wallet: walletClient,\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"]}
+//# 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 { createWalletClient, type WalletClient } from './wallet/client';\nimport { createUpsellClient, type UpsellClient } from './upsell/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\n/**\n * The namespaces that reach the platform HTTP API.\n *\n * `events` is deliberately NOT here. It publishes straight to SNS, so\n * wiring it onto this client would make `@aws-sdk/client-sns` a hard\n * dependency of the SDK's main entry — paid by every consumer that only\n * reads businesses or zones, and by every frontend bundle that touches\n * the root import. It lives at the `@uengage.io/platform-sdk/events`\n * subpath instead, alongside `/realtime`, and is configured from the\n * environment (`PLATFORM_EVENTS_TOPIC_ARN`) or `createEventsClient(...)`.\n */\nexport interface PlatformClient {\n  business: BusinessClient;\n  audit: AuditClient;\n  zones: ZonesClient;\n  wallet: WalletClient;\n  upsell: UpsellClient;\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  const walletClient = createWalletClient({ baseUrl, fetchFn: input.fetchFn, auth });\n  const upsellClient = createUpsellClient({ baseUrl, fetchFn: input.fetchFn, auth });\n\n  return {\n    business: businessClient,\n    audit: auditClient,\n    zones: zonesClient,\n    wallet: walletClient,\n    upsell: upsellClient,\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/config.d.ts

@@ -31,11 +31,6 @@ export interface PlatformConfigInput {
 export interface PlatformAuthInput {
     token?: string;
 }
-/**
- * Resolve env-defaulted config. Re-read on every call so that callers can
- * set env vars after the SDK has been imported and still pick them up on
- * the next request.
- */
 export declare function envDefaults(): PlatformConfig;
 /**
  * Coerce `.auth()` input or `config({auth})` input into a typed

package/dist/config.js

@@ -9,15 +9,26 @@ exports.DEFAULT_BASE_URL = 'https://api.platform.uengage.io';
  * set env vars after the SDK has been imported and still pick them up on
  * the next request.
  */
+/**
+ * Read `process.env` defensively: in a browser bundle `process` is not
+ * defined at all, and touching it throws a ReferenceError rather than
+ * yielding undefined. The SDK is used from browsers (the
+ * `whitelabel_web` channel), so every env read goes through here.
+ */
+function env(name) {
+    if (typeof process === 'undefined')
+        return undefined;
+    return process.env?.[name];
+}
 function envDefaults() {
     return {
-        baseUrl: process.env.UENGAGE_BASE_URL ?? exports.DEFAULT_BASE_URL,
+        baseUrl: env('UENGAGE_BASE_URL') ?? exports.DEFAULT_BASE_URL,
         auth: envAuth(),
         fetchFn: globalThis.fetch,
     };
 }
 function envAuth() {
-    const token = process.env.UENGAGE_AUTH_TOKEN;
+    const token = env('UENGAGE_AUTH_TOKEN');
     if (token)
         return { type: 'bearer', token };
     return undefined;
@@ -76,4 +87,4 @@ class ConfigState {
     }
 }
 exports.ConfigState = ConfigState;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":";;;AAmDA,kCAMC;AAiBD,sCAQC;AA/EY,QAAA,gBAAgB,GAAG,iCAAiC,CAAC;AAgClE;;;;GAIG;AACH;;;;;GAKG;AACH,SAAS,GAAG,CAAC,IAAY;IACvB,IAAI,OAAO,OAAO,KAAK,WAAW;QAAE,OAAO,SAAS,CAAC;IACrD,OAAQ,OAAwD,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC;AAC/E,CAAC;AAED,SAAgB,WAAW;IACzB,OAAO;QACL,OAAO,EAAE,GAAG,CAAC,kBAAkB,CAAC,IAAI,wBAAgB;QACpD,IAAI,EAAE,OAAO,EAAE;QACf,OAAO,EAAE,UAAU,CAAC,KAAqB;KAC1C,CAAC;AACJ,CAAC;AAED,SAAS,OAAO;IACd,MAAM,KAAK,GAAG,GAAG,CAAC,oBAAoB,CAAC,CAAC;IACxC,IAAI,KAAK;QAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;IAC5C,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;;;;;;GAQG;AACH,SAAgB,aAAa,CAAC,KAAuC;IACnE,IAAI,MAAM,IAAI,KAAK;QAAE,OAAO,KAAK,CAAC;IAClC,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;QAChB,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC;IAChD,CAAC;IACD,MAAM,IAAI,KAAK,CACb,sIAAsI,CACvI,CAAC;AACJ,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: '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\nexport interface PlatformConfigInput {\n  baseUrl?: string;\n  auth?: PlatformAuthInput | PlatformAuth;\n  fetchFn?: typeof fetch;\n  logger?: Logger;\n}\n\n/**\n * `.auth()` shape. Pass `{token}` for a static Bearer access token.\n * OAuth2 client_credentials live at `createClient()` config-time\n * (`serviceId` + `serviceSecret` fields), not via `.auth()`.\n */\nexport interface PlatformAuthInput {\n  token?: 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 */\n/**\n * Read `process.env` defensively: in a browser bundle `process` is not\n * defined at all, and touching it throws a ReferenceError rather than\n * yielding undefined. The SDK is used from browsers (the\n * `whitelabel_web` channel), so every env read goes through here.\n */\nfunction env(name: string): string | undefined {\n  if (typeof process === 'undefined') return undefined;\n  return (process as { env?: Record<string, string | undefined> }).env?.[name];\n}\n\nexport function envDefaults(): PlatformConfig {\n  return {\n    baseUrl: env('UENGAGE_BASE_URL') ?? DEFAULT_BASE_URL,\n    auth: envAuth(),\n    fetchFn: globalThis.fetch as typeof fetch,\n  };\n}\n\nfunction envAuth(): PlatformAuth | undefined {\n  const token = env('UENGAGE_AUTH_TOKEN');\n  if (token) return { type: 'bearer', token };\n  return undefined;\n}\n\n/**\n * Coerce `.auth()` input or `config({auth})` input into a typed\n * PlatformAuth. Throws when the input has no usable credentials.\n *\n * Today this only accepts `{token}` or a pre-shaped `PlatformAuth`.\n * For OAuth2 client_credentials use `createClient({serviceId, serviceSecret})`\n * instead — that builds a TokenSource which mints + caches Bearer\n * tokens.\n */\nexport function normalizeAuth(input: PlatformAuthInput | PlatformAuth): PlatformAuth {\n  if ('type' in input) return input;\n  if (input.token) {\n    return { type: 'bearer', token: input.token };\n  }\n  throw new Error(\n    'auth(): pass {token} for a static Bearer access token, or use createClient({serviceId, serviceSecret}) for OAuth2 client_credentials',\n  );\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

@@ -55,6 +55,23 @@ export declare class RateLimitError extends PlatformError {
 export declare class TokenExpiredError extends PlatformError {
     constructor(message?: string);
 }
+/**
+ * Thrown when publishing to the platform event bus fails.
+ *
+ * The events client does NOT swallow publish failures — fail-open is the
+ * caller's decision, and it differs by call site (a legacy order flow
+ * must never block on the bus; a platform service reconciling state may
+ * well want to retry). `failed` carries the per-event breakdown for a
+ * partially-failed `publishBatch`.
+ */
+export declare class EventPublishError extends PlatformError {
+    /** Envelope ids that did not make it onto the bus. */
+    readonly failedEventIds: string[];
+    constructor(message?: string, opts?: {
+        failedEventIds?: string[];
+        cause?: unknown;
+    });
+}
 /** Thrown for missing / inconsistent SDK configuration. */
 export declare class ConfigError extends PlatformError {
     constructor(message: string);

package/dist/errors.js

@@ -1,6 +1,6 @@
 "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;
+exports.ConfigError = exports.EventPublishError = 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
@@ -75,6 +75,25 @@ class TokenExpiredError extends PlatformError {
     }
 }
 exports.TokenExpiredError = TokenExpiredError;
+/**
+ * Thrown when publishing to the platform event bus fails.
+ *
+ * The events client does NOT swallow publish failures — fail-open is the
+ * caller's decision, and it differs by call site (a legacy order flow
+ * must never block on the bus; a platform service reconciling state may
+ * well want to retry). `failed` carries the per-event breakdown for a
+ * partially-failed `publishBatch`.
+ */
+class EventPublishError extends PlatformError {
+    /** Envelope ids that did not make it onto the bus. */
+    failedEventIds;
+    constructor(message = 'event publish failed', opts) {
+        super(message, { cause: opts?.cause });
+        this.name = 'EventPublishError';
+        this.failedEventIds = opts?.failedEventIds ?? [];
+    }
+}
+exports.EventPublishError = EventPublishError;
 /** Thrown for missing / inconsistent SDK configuration. */
 class ConfigError extends PlatformError {
     constructor(message) {
@@ -83,4 +102,4 @@ class ConfigError extends PlatformError {
     }
 }
 exports.ConfigError = ConfigError;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Platform-SDK error hierarchy. Consumers should `instanceof`-check\n * against `PlatformError` for the catch-all and the specific subclasses\n * for the cases they care about. Status codes mirror the HTTP responses\n * the platform API actually emits, so `error.status` is the simplest\n * routing signal.\n */\nexport class PlatformError extends Error {\n  readonly status?: number;\n  readonly cause?: unknown;\n  constructor(message: string, opts?: { status?: number; cause?: unknown }) {\n    super(message);\n    this.name = 'PlatformError';\n    this.status = opts?.status;\n    this.cause = opts?.cause;\n  }\n}\n\nexport class AuthenticationError extends PlatformError {\n  constructor(message = 'authentication failed', opts?: { cause?: unknown }) {\n    super(message, { status: 401, cause: opts?.cause });\n    this.name = 'AuthenticationError';\n  }\n}\n\nexport class AuthorizationError extends PlatformError {\n  /** When the API returns a `requiredScope`, surface it for the consumer. */\n  readonly requiredScope?: string;\n  constructor(\n    message = 'authorization failed',\n    opts?: { requiredScope?: string; cause?: unknown },\n  ) {\n    super(message, { status: 403, cause: opts?.cause });\n    this.name = 'AuthorizationError';\n    this.requiredScope = opts?.requiredScope;\n  }\n}\n\nexport class NotFoundError extends PlatformError {\n  constructor(message = 'not found', opts?: { cause?: unknown }) {\n    super(message, { status: 404, cause: opts?.cause });\n    this.name = 'NotFoundError';\n  }\n}\n\nexport class ValidationError extends PlatformError {\n  /** Per-field issues in the platform's standard `issues` array shape. */\n  readonly issues?: unknown[];\n  constructor(message = 'validation failed', opts?: { issues?: unknown[]; cause?: unknown }) {\n    super(message, { status: 422, cause: opts?.cause });\n    this.name = 'ValidationError';\n    this.issues = opts?.issues;\n  }\n}\n\nexport class RateLimitError extends PlatformError {\n  /** Seconds the consumer should back off (from `Retry-After`). */\n  readonly retryAfter?: number;\n  constructor(message = 'rate limited', opts?: { retryAfter?: number; cause?: unknown }) {\n    super(message, { status: 429, cause: opts?.cause });\n    this.name = 'RateLimitError';\n    this.retryAfter = opts?.retryAfter;\n  }\n}\n\n/**\n * Thrown when the SDK detects an expired access token before the request\n * is sent. Callers using a static externally-supplied token must update\n * the config with a fresh one.\n */\nexport class TokenExpiredError extends PlatformError {\n  constructor(message = 'access token has expired') {\n    super(message, { status: 401 });\n    this.name = 'TokenExpiredError';\n  }\n}\n\n/**\n * Thrown when publishing to the platform event bus fails.\n *\n * The events client does NOT swallow publish failures — fail-open is the\n * caller's decision, and it differs by call site (a legacy order flow\n * must never block on the bus; a platform service reconciling state may\n * well want to retry). `failed` carries the per-event breakdown for a\n * partially-failed `publishBatch`.\n */\nexport class EventPublishError extends PlatformError {\n  /** Envelope ids that did not make it onto the bus. */\n  readonly failedEventIds: string[];\n  constructor(\n    message = 'event publish failed',\n    opts?: { failedEventIds?: string[]; cause?: unknown },\n  ) {\n    super(message, { cause: opts?.cause });\n    this.name = 'EventPublishError';\n    this.failedEventIds = opts?.failedEventIds ?? [];\n  }\n}\n\n/** Thrown for missing / inconsistent SDK configuration. */\nexport class ConfigError extends PlatformError {\n  constructor(message: string) {\n    super(message);\n    this.name = 'ConfigError';\n  }\n}\n"]}

package/dist/events/client.d.ts

@@ -0,0 +1,81 @@
+import { SNSClient } from '@aws-sdk/client-sns';
+import { type PlatformEvent } from './schema';
+/** What a call site supplies; the SDK derives everything else. */
+export interface PublishOptions {
+    /** uEngage business id the event belongs to. */
+    tenantId: string;
+    /**
+     * When the thing happened, if it wasn't now — e.g. replaying a
+     * transition read back off a DB row. UTC ISO 8601. Defaults to the
+     * moment `publish()` was called.
+     */
+    occurredAt?: string;
+    /** Overrides the client-level `source` for this one event. */
+    source?: string;
+}
+export interface PublishBatchInput extends PublishOptions {
+    type: string;
+    data: Record<string, unknown>;
+}
+export interface EventsClientInput {
+    /**
+     * Bus topic ARN. Defaults to `PLATFORM_EVENTS_TOPIC_ARN`.
+     */
+    topicArn?: string;
+    /**
+     * AWS region. Defaults to the region embedded in `topicArn`, then
+     * `AWS_REGION` / `AWS_DEFAULT_REGION`. Rarely needs setting.
+     */
+    region?: string;
+    /**
+     * Which system is emitting. Defaults to `PLATFORM_EVENTS_SOURCE`, then
+     * `SERVICE_NAME` (set on every platform Lambda by `LambdaService`),
+     * then `'platform-sdk'`.
+     */
+    source?: string;
+    /** Inject a pre-built SNS client (tests, custom credentials/retry config). */
+    snsClient?: SNSClient;
+}
+export interface EventsClient {
+    /**
+     * Publish one event onto the platform event bus.
+     *
+     * Builds the envelope (monotonic ULID `id`, `occurredAt`, `version`,
+     * `domain` derived from the `type` prefix), validates it, and publishes
+     * with `type` / `domain` / `source` set as SNS message attributes so
+     * consumer filter policies match without deserialising the body.
+     *
+     * THROWS on failure — it does not fail open. Fail-open is the caller's
+     * call and it differs by call site: a legacy order-status transition
+     * must never be blocked by a bus outage (wrap in try/catch and log),
+     * whereas a service that needs the event delivered may want to retry.
+     * The PHP SDK's buffered client makes the fail-open choice explicitly
+     * for the legacy request path.
+     *
+     * @throws {ConfigError} no topic ARN configured
+     * @throws {ValidationError} the envelope failed schema validation
+     * @throws {EventPublishError} SNS rejected or errored on the publish
+     */
+    publish(type: string, data: Record<string, unknown>, opts: PublishOptions): Promise<PlatformEvent>;
+    /**
+     * Publish many events in one round trip, chunked at SNS's 10-per-call
+     * `PublishBatch` limit.
+     *
+     * All-or-nothing it is NOT: chunks are attempted independently, and a
+     * partial failure throws `EventPublishError` carrying the ids that did
+     * not land in `failedEventIds`. Envelope validation runs over the whole
+     * input first, so a malformed event fails the call before anything is
+     * published.
+     *
+     * @throws {ConfigError} no topic ARN configured
+     * @throws {ValidationError} any envelope failed schema validation
+     * @throws {EventPublishError} one or more events did not reach the bus
+     */
+    publishBatch(events: PublishBatchInput[]): Promise<PlatformEvent[]>;
+}
+/**
+ * Build an isolated events client. Reads `PLATFORM_EVENTS_TOPIC_ARN` and
+ * friends from the environment for anything not passed explicitly, so a
+ * Lambda whose deploy stack injected the ARN needs no arguments.
+ */
+export declare function createEventsClient(input?: EventsClientInput): EventsClient;