@uengage.io/platform-sdk 0.2.0 → 0.6.0

package/dist/errors.js

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

package/dist/http.d.ts

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

package/dist/http.js

@@ -3,22 +3,40 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildHeaders = buildHeaders;
 const node_crypto_1 = require("node:crypto");
 const sign_1 = require("./audit/sign");
+const token_source_1 = require("./token-source");
+const version_1 = require("./version");
+const MUTATING_METHODS = new Set(['POST', 'PUT', 'PATCH', 'DELETE']);
 /**
- * Build the headers required for a request to the platform API, given the
- * effective auth on `config`. With no auth configured we still return any
- * non-auth headers (e.g. content-type) - some endpoints accept anonymous
- * callers and the server decides whether to allow.
+ * Build the headers required for a request to the platform API, given
+ * the effective auth on `config`. Async because the `token-source`
+ * auth path may need to mint or refresh before returning.
+ *
+ * Adds three platform-wide headers automatically:
+ *   - `User-Agent` so the gateway can attribute traffic to SDK version
+ *   - `Idempotency-Key` (UUID v4) on mutating methods, so callers don't
+ *     have to generate one per call
+ *   - `content-type: application/json` when a body is supplied
  */
-function buildHeaders(config, params) {
-    const headers = {};
+async function buildHeaders(config, params) {
+    const headers = {
+        'user-agent': `uengage-platform-sdk/${version_1.SDK_VERSION}`,
+    };
     if (params.body !== undefined)
         headers['content-type'] = 'application/json';
+    if (MUTATING_METHODS.has(params.method.toUpperCase())) {
+        headers['idempotency-key'] = (0, node_crypto_1.randomUUID)();
+    }
     if (!config.auth)
         return headers;
     if (config.auth.type === 'bearer') {
         headers['authorization'] = `Bearer ${config.auth.token}`;
         return headers;
     }
+    if (config.auth.type === 'token-source') {
+        const token = await (0, token_source_1.getAccessToken)(config.auth.state);
+        headers['authorization'] = `Bearer ${token}`;
+        return headers;
+    }
     // HMAC
     const timestamp = new Date().toISOString().replace(/\.\d{3}Z$/, 'Z');
     const nonce = (0, node_crypto_1.randomUUID)();
@@ -37,4 +55,4 @@ function buildHeaders(config, params) {
     headers['x-signature'] = signature;
     return headers;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/index.d.ts

@@ -1,6 +1,10 @@
 export * from './audit';
 export * from './business';
+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:

package/dist/index.js

@@ -14,11 +14,18 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.business = exports.audit = exports.DEFAULT_BASE_URL = void 0;
+exports.business = exports.audit = exports.withToken = exports.platform = exports.createClient = exports.DEFAULT_BASE_URL = exports.auth = void 0;
 __exportStar(require("./audit"), exports);
 __exportStar(require("./business"), exports);
+__exportStar(require("./errors"), exports);
+var auth_1 = require("./auth");
+Object.defineProperty(exports, "auth", { enumerable: true, get: function () { return auth_1.auth; } });
 var config_1 = require("./config");
 Object.defineProperty(exports, "DEFAULT_BASE_URL", { enumerable: true, get: function () { return config_1.DEFAULT_BASE_URL; } });
+var client_1 = require("./client");
+Object.defineProperty(exports, "createClient", { enumerable: true, get: function () { return client_1.createClient; } });
+Object.defineProperty(exports, "platform", { enumerable: true, get: function () { return client_1.platform; } });
+Object.defineProperty(exports, "withToken", { enumerable: true, get: function () { return client_1.withToken; } });
 const audit_1 = require("./audit");
 const business_1 = require("./business");
 /**
@@ -35,4 +42,4 @@ const business_1 = require("./business");
  */
 exports.audit = (0, audit_1.createAuditClient)();
 exports.business = (0, business_1.createBusinessClient)();
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSwwQ0FBd0I7QUFDeEIsNkNBQTJCO0FBQzNCLG1DQU1rQjtBQURoQiwwR0FBQSxnQkFBZ0IsT0FBQTtBQUdsQixtQ0FBNEM7QUFDNUMseUNBQWtEO0FBRWxEOzs7Ozs7Ozs7OztHQVdHO0FBQ1UsUUFBQSxLQUFLLEdBQUcsSUFBQSx5QkFBaUIsR0FBRSxDQUFDO0FBQzVCLFFBQUEsUUFBUSxHQUFHLElBQUEsK0JBQW9CLEdBQUUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYXVkaXQnO1xuZXhwb3J0ICogZnJvbSAnLi9idXNpbmVzcyc7XG5leHBvcnQge1xuICB0eXBlIFBsYXRmb3JtQXV0aCxcbiAgdHlwZSBQbGF0Zm9ybUF1dGhJbnB1dCxcbiAgdHlwZSBQbGF0Zm9ybUNvbmZpZyxcbiAgdHlwZSBQbGF0Zm9ybUNvbmZpZ0lucHV0LFxuICBERUZBVUxUX0JBU0VfVVJMLFxufSBmcm9tICcuL2NvbmZpZyc7XG5cbmltcG9ydCB7IGNyZWF0ZUF1ZGl0Q2xpZW50IH0gZnJvbSAnLi9hdWRpdCc7XG5pbXBvcnQgeyBjcmVhdGVCdXNpbmVzc0NsaWVudCB9IGZyb20gJy4vYnVzaW5lc3MnO1xuXG4vKipcbiAqIERlZmF1bHQgc2luZ2xldG9uIGNsaWVudHMuIEJvdGggcmVhZCBkZWZhdWx0cyBmcm9tIHRoZSBlbnZpcm9ubWVudCBvblxuICogZXZlcnkgY2FsbDpcbiAqICAgLSBQTEFURk9STV9CQVNFX1VSTCAgICAgICAgICAoZGVmYXVsdHMgdG8gaHR0cHM6Ly9hcGkucGxhdGZvcm0udWVuZ2FnZS5pbylcbiAqICAgLSBQTEFURk9STV9TSUdOSU5HX1NFQ1JFVCAgICBITUFDIHNlY3JldCBoZXhcbiAqICAgLSBQTEFURk9STV9TRVJWSUNFX0lEICAgICAgICBITUFDIHNlcnZpY2UgaWRcbiAqICAgLSBQTEFURk9STV9BVVRIX1RPS0VOICAgICAgICBCZWFyZXIgdG9rZW4gKG92ZXJyaWRlcyBITUFDIGlmIHNldClcbiAqXG4gKiBPdmVycmlkZSBwZXItaW5zdGFuY2Ugd2l0aCBgLmNvbmZpZyh7Li4ufSlgIGFuZC9vciBgLmF1dGgoey4uLn0pYC4gRm9yXG4gKiBpc29sYXRlZCBjb25maWd1cmF0aW9uICh0ZXN0cywgbXVsdGktdGVuYW50IGNvZGUgcGF0aHMpLCBjb25zdHJ1Y3QgeW91clxuICogb3duIHZpYSBgY3JlYXRlQXVkaXRDbGllbnQoLi4uKWAgb3IgYGNyZWF0ZUJ1c2luZXNzQ2xpZW50KC4uLilgIGluc3RlYWQuXG4gKi9cbmV4cG9ydCBjb25zdCBhdWRpdCA9IGNyZWF0ZUF1ZGl0Q2xpZW50KCk7XG5leHBvcnQgY29uc3QgYnVzaW5lc3MgPSBjcmVhdGVCdXNpbmVzc0NsaWVudCgpO1xuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/dist/token-source.d.ts

@@ -0,0 +1,60 @@
+/**
+ * How the SDK gets a fresh access token. Three shapes per the brief:
+ *
+ *   - `static-string` — caller hands in a token string. Used until its
+ *     `exp` has passed; on expiry we throw `TokenExpiredError` rather
+ *     than try to refresh (the SDK has no way to refresh a static
+ *     externally-supplied token).
+ *
+ *   - `callback` — caller supplies a function the SDK calls on miss
+ *     and on 401 invalidation. The consumer's logic is responsible for
+ *     refresh; the SDK just caches the result between invocations.
+ *
+ *   - `service-credentials` — `client_id` + `client_secret` for the
+ *     OAuth2 `client_credentials` grant. SDK mints + caches; on
+ *     expiry it re-mints with the same credentials.
+ */
+export type TokenSource = {
+    kind: 'static-string';
+    token: string;
+} | {
+    kind: 'callback';
+    getToken: () => string | Promise<string>;
+} | {
+    kind: 'service-credentials';
+    clientId: string;
+    clientSecret: string;
+    authBaseUrl: string;
+    scope?: string;
+};
+export interface TokenSourceState {
+    source: TokenSource;
+    cached?: {
+        token: string;
+        expiresAt: number;
+    };
+    /** Refresh dedup: concurrent requests share the same fetch. */
+    inflight?: Promise<{
+        token: string;
+        expiresAt: number;
+    }>;
+    /** Buffer (ms) before `exp` at which we treat a token as expired. */
+    expiryBufferMs: number;
+    /** Used only by the service-credentials path. */
+    fetchFn: typeof fetch;
+}
+export declare function makeTokenSourceState(source: TokenSource, options?: {
+    expiryBufferMs?: number;
+    fetchFn?: typeof fetch;
+}): TokenSourceState;
+/**
+ * Return a fresh access token, using the cache when warm. Concurrent
+ * callers during a refresh share the in-flight Promise so we don't
+ * stampede the auth server.
+ */
+export declare function getAccessToken(state: TokenSourceState): Promise<string>;
+/**
+ * Drop the cached token. The next `getAccessToken` will mint or
+ * re-fetch. Called by the request layer on 401.
+ */
+export declare function invalidateToken(state: TokenSourceState): void;

package/dist/token-source.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTokenSourceState = makeTokenSourceState;
+exports.getAccessToken = getAccessToken;
+exports.invalidateToken = invalidateToken;
+const errors_1 = require("./errors");
+const issuer_1 = require("./auth/issuer");
+const DEFAULT_EXPIRY_BUFFER_MS = 5000;
+function makeTokenSourceState(source, options = {}) {
+    return {
+        source,
+        expiryBufferMs: options.expiryBufferMs ?? DEFAULT_EXPIRY_BUFFER_MS,
+        fetchFn: options.fetchFn ?? globalThis.fetch,
+    };
+}
+/**
+ * Return a fresh access token, using the cache when warm. Concurrent
+ * callers during a refresh share the in-flight Promise so we don't
+ * stampede the auth server.
+ */
+async function getAccessToken(state) {
+    const now = Date.now();
+    if (state.cached && state.cached.expiresAt > now + state.expiryBufferMs) {
+        return state.cached.token;
+    }
+    if (state.inflight) {
+        const fresh = await state.inflight;
+        return fresh.token;
+    }
+    const inflight = mintToken(state).then((res) => {
+        state.cached = res;
+        state.inflight = undefined;
+        return res;
+    });
+    state.inflight = inflight;
+    try {
+        const fresh = await inflight;
+        return fresh.token;
+    }
+    catch (err) {
+        state.inflight = undefined;
+        throw err;
+    }
+}
+/**
+ * Drop the cached token. The next `getAccessToken` will mint or
+ * re-fetch. Called by the request layer on 401.
+ */
+function invalidateToken(state) {
+    state.cached = undefined;
+}
+async function mintToken(state) {
+    switch (state.source.kind) {
+        case 'static-string': {
+            const exp = (0, issuer_1.getExpiry)(state.source.token);
+            if (exp !== null && exp * 1000 < Date.now() + state.expiryBufferMs) {
+                throw new errors_1.TokenExpiredError('static access token has expired; consumer must update the config with a fresh token');
+            }
+            return {
+                token: state.source.token,
+                // No `exp`? Treat as opaque non-expiring; cache for 1h to avoid
+                // re-using the same string forever in case the issuer rotates.
+                expiresAt: exp !== null ? exp * 1000 : Date.now() + 60 * 60 * 1000,
+            };
+        }
+        case 'callback': {
+            const token = await state.source.getToken();
+            const exp = (0, issuer_1.getExpiry)(token);
+            return {
+                token,
+                expiresAt: exp !== null ? exp * 1000 : Date.now() + 5 * 60 * 1000,
+            };
+        }
+        case 'service-credentials': {
+            const body = new URLSearchParams({ grant_type: 'client_credentials' });
+            if (state.source.scope)
+                body.set('scope', state.source.scope);
+            const basic = base64(`${state.source.clientId}:${state.source.clientSecret}`);
+            const res = await state.fetchFn(`${state.source.authBaseUrl}/oauth/token`, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/x-www-form-urlencoded',
+                    authorization: `Basic ${basic}`,
+                },
+                body: body.toString(),
+            });
+            if (!res.ok) {
+                const text = await res.text();
+                throw new errors_1.ConfigError(`client_credentials mint failed: HTTP ${res.status} ${text}`);
+            }
+            const json = (await res.json());
+            if (!json.access_token) {
+                throw new errors_1.ConfigError('auth server response missing access_token');
+            }
+            const ttl = (json.expires_in ?? 0) * 1000;
+            return {
+                token: json.access_token,
+                expiresAt: ttl > 0 ? Date.now() + ttl : Date.now() + 5 * 60 * 1000,
+            };
+        }
+    }
+}
+function base64(s) {
+    // Works in Node and browser (Buffer is polyfilled via @types/node and
+    // most bundlers; btoa is a fallback for envs without Buffer).
+    if (typeof Buffer !== 'undefined')
+        return Buffer.from(s, 'utf8').toString('base64');
+    // eslint-disable-next-line no-undef
+    return btoa(s);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"token-source.js","sourceRoot":"","sources":["../src/token-source.ts"],"names":[],"mappings":"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","sourcesContent":["import { ConfigError, TokenExpiredError } from './errors';\nimport { getExpiry } from './auth/issuer';\n\n/**\n * How the SDK gets a fresh access token. Three shapes per the brief:\n *\n *   - `static-string` — caller hands in a token string. Used until its\n *     `exp` has passed; on expiry we throw `TokenExpiredError` rather\n *     than try to refresh (the SDK has no way to refresh a static\n *     externally-supplied token).\n *\n *   - `callback` — caller supplies a function the SDK calls on miss\n *     and on 401 invalidation. The consumer's logic is responsible for\n *     refresh; the SDK just caches the result between invocations.\n *\n *   - `service-credentials` — `client_id` + `client_secret` for the\n *     OAuth2 `client_credentials` grant. SDK mints + caches; on\n *     expiry it re-mints with the same credentials.\n */\nexport type TokenSource =\n  | { kind: 'static-string'; token: string }\n  | { kind: 'callback'; getToken: () => string | Promise<string> }\n  | {\n      kind: 'service-credentials';\n      clientId: string;\n      clientSecret: string;\n      authBaseUrl: string;\n      scope?: string;\n    };\n\nexport interface TokenSourceState {\n  source: TokenSource;\n  cached?: { token: string; expiresAt: number };\n  /** Refresh dedup: concurrent requests share the same fetch. */\n  inflight?: Promise<{ token: string; expiresAt: number }>;\n  /** Buffer (ms) before `exp` at which we treat a token as expired. */\n  expiryBufferMs: number;\n  /** Used only by the service-credentials path. */\n  fetchFn: typeof fetch;\n}\n\nconst DEFAULT_EXPIRY_BUFFER_MS = 5000;\n\nexport function makeTokenSourceState(\n  source: TokenSource,\n  options: { expiryBufferMs?: number; fetchFn?: typeof fetch } = {},\n): TokenSourceState {\n  return {\n    source,\n    expiryBufferMs: options.expiryBufferMs ?? DEFAULT_EXPIRY_BUFFER_MS,\n    fetchFn: options.fetchFn ?? (globalThis.fetch as typeof fetch),\n  };\n}\n\n/**\n * Return a fresh access token, using the cache when warm. Concurrent\n * callers during a refresh share the in-flight Promise so we don't\n * stampede the auth server.\n */\nexport async function getAccessToken(state: TokenSourceState): Promise<string> {\n  const now = Date.now();\n  if (state.cached && state.cached.expiresAt > now + state.expiryBufferMs) {\n    return state.cached.token;\n  }\n  if (state.inflight) {\n    const fresh = await state.inflight;\n    return fresh.token;\n  }\n  const inflight = mintToken(state).then((res) => {\n    state.cached = res;\n    state.inflight = undefined;\n    return res;\n  });\n  state.inflight = inflight;\n  try {\n    const fresh = await inflight;\n    return fresh.token;\n  } catch (err) {\n    state.inflight = undefined;\n    throw err;\n  }\n}\n\n/**\n * Drop the cached token. The next `getAccessToken` will mint or\n * re-fetch. Called by the request layer on 401.\n */\nexport function invalidateToken(state: TokenSourceState): void {\n  state.cached = undefined;\n}\n\nasync function mintToken(state: TokenSourceState): Promise<{ token: string; expiresAt: number }> {\n  switch (state.source.kind) {\n    case 'static-string': {\n      const exp = getExpiry(state.source.token);\n      if (exp !== null && exp * 1000 < Date.now() + state.expiryBufferMs) {\n        throw new TokenExpiredError(\n          'static access token has expired; consumer must update the config with a fresh token',\n        );\n      }\n      return {\n        token: state.source.token,\n        // No `exp`? Treat as opaque non-expiring; cache for 1h to avoid\n        // re-using the same string forever in case the issuer rotates.\n        expiresAt: exp !== null ? exp * 1000 : Date.now() + 60 * 60 * 1000,\n      };\n    }\n    case 'callback': {\n      const token = await state.source.getToken();\n      const exp = getExpiry(token);\n      return {\n        token,\n        expiresAt: exp !== null ? exp * 1000 : Date.now() + 5 * 60 * 1000,\n      };\n    }\n    case 'service-credentials': {\n      const body = new URLSearchParams({ grant_type: 'client_credentials' });\n      if (state.source.scope) body.set('scope', state.source.scope);\n      const basic = base64(`${state.source.clientId}:${state.source.clientSecret}`);\n      const res = await state.fetchFn(`${state.source.authBaseUrl}/oauth/token`, {\n        method: 'POST',\n        headers: {\n          'content-type': 'application/x-www-form-urlencoded',\n          authorization: `Basic ${basic}`,\n        },\n        body: body.toString(),\n      });\n      if (!res.ok) {\n        const text = await res.text();\n        throw new ConfigError(`client_credentials mint failed: HTTP ${res.status} ${text}`);\n      }\n      const json = (await res.json()) as { access_token?: string; expires_in?: number };\n      if (!json.access_token) {\n        throw new ConfigError('auth server response missing access_token');\n      }\n      const ttl = (json.expires_in ?? 0) * 1000;\n      return {\n        token: json.access_token,\n        expiresAt: ttl > 0 ? Date.now() + ttl : Date.now() + 5 * 60 * 1000,\n      };\n    }\n  }\n}\n\nfunction base64(s: string): string {\n  // Works in Node and browser (Buffer is polyfilled via @types/node and\n  // most bundlers; btoa is a fallback for envs without Buffer).\n  if (typeof Buffer !== 'undefined') return Buffer.from(s, 'utf8').toString('base64');\n  // eslint-disable-next-line no-undef\n  return btoa(s);\n}\n"]}

package/dist/version.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Manually-maintained version string surfaced via the `User-Agent`
+ * header. Kept in sync with `package.json` by hand because pulling the
+ * value from package.json at runtime would require either a JSON import
+ * (TS lib settings dependent) or a build-time replacement, and the
+ * cost of one bump-in-two-places per release is small.
+ */
+export declare const SDK_VERSION = "0.6.0";

package/dist/version.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SDK_VERSION = void 0;
+/**
+ * Manually-maintained version string surfaced via the `User-Agent`
+ * header. Kept in sync with `package.json` by hand because pulling the
+ * value from package.json at runtime would require either a JSON import
+ * (TS lib settings dependent) or a build-time replacement, and the
+ * cost of one bump-in-two-places per release is small.
+ */
+exports.SDK_VERSION = '0.6.0';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy92ZXJzaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBOzs7Ozs7R0FNRztBQUNVLFFBQUEsV0FBVyxHQUFHLE9BQU8sQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogTWFudWFsbHktbWFpbnRhaW5lZCB2ZXJzaW9uIHN0cmluZyBzdXJmYWNlZCB2aWEgdGhlIGBVc2VyLUFnZW50YFxuICogaGVhZGVyLiBLZXB0IGluIHN5bmMgd2l0aCBgcGFja2FnZS5qc29uYCBieSBoYW5kIGJlY2F1c2UgcHVsbGluZyB0aGVcbiAqIHZhbHVlIGZyb20gcGFja2FnZS5qc29uIGF0IHJ1bnRpbWUgd291bGQgcmVxdWlyZSBlaXRoZXIgYSBKU09OIGltcG9ydFxuICogKFRTIGxpYiBzZXR0aW5ncyBkZXBlbmRlbnQpIG9yIGEgYnVpbGQtdGltZSByZXBsYWNlbWVudCwgYW5kIHRoZVxuICogY29zdCBvZiBvbmUgYnVtcC1pbi10d28tcGxhY2VzIHBlciByZWxlYXNlIGlzIHNtYWxsLlxuICovXG5leHBvcnQgY29uc3QgU0RLX1ZFUlNJT04gPSAnMC42LjAnO1xuIl19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uengage.io/platform-sdk",
-  "version": "0.2.0",
+  "version": "0.6.0",
   "description": "Client SDK for the uEngage platform API (audit, business, ...). Namespaced singletons with HMAC or Bearer auth.",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -21,9 +21,10 @@
     "hmac"
   ],
   "dependencies": {
+    "jose": "^5.9.6",
     "ulid": "^2.3.0",
     "zod": "^3.23.8",
-    "@uengage.io/js-logger": "0.9.3"
+    "@uengage.io/js-logger": "0.10.0"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",