@bpmnkit/api 0.0.8

package/dist/runtime/events.test.js

@@ -0,0 +1,57 @@
+import { describe, expect, it, vi } from "vitest";
+import { TypedEventEmitter } from "./events.js";
+describe("TypedEventEmitter", () => {
+    it("emits events to registered listeners", () => {
+        const emitter = new TypedEventEmitter();
+        const handler = vi.fn();
+        emitter.on("ping", handler);
+        emitter.emit("ping", { id: 42 });
+        expect(handler).toHaveBeenCalledWith({ id: 42 });
+    });
+    it("supports multiple listeners for the same event", () => {
+        const emitter = new TypedEventEmitter();
+        const a = vi.fn();
+        const b = vi.fn();
+        emitter.on("ping", a);
+        emitter.on("ping", b);
+        emitter.emit("ping", { id: 1 });
+        expect(a).toHaveBeenCalledOnce();
+        expect(b).toHaveBeenCalledOnce();
+    });
+    it("off removes a listener", () => {
+        const emitter = new TypedEventEmitter();
+        const handler = vi.fn();
+        emitter.on("ping", handler);
+        emitter.off("ping", handler);
+        emitter.emit("ping", { id: 1 });
+        expect(handler).not.toHaveBeenCalled();
+    });
+    it("once fires exactly once", () => {
+        const emitter = new TypedEventEmitter();
+        const handler = vi.fn();
+        emitter.once("ping", handler);
+        emitter.emit("ping", { id: 1 });
+        emitter.emit("ping", { id: 2 });
+        expect(handler).toHaveBeenCalledOnce();
+    });
+    it("does not propagate listener errors", () => {
+        const emitter = new TypedEventEmitter();
+        emitter.on("ping", () => {
+            throw new Error("boom");
+        });
+        expect(() => emitter.emit("ping", { id: 1 })).not.toThrow();
+    });
+    it("removeAllListeners clears all events", () => {
+        const emitter = new TypedEventEmitter();
+        const a = vi.fn();
+        const b = vi.fn();
+        emitter.on("ping", a);
+        emitter.on("pong", b);
+        emitter.removeAllListeners();
+        emitter.emit("ping", { id: 1 });
+        emitter.emit("pong", { message: "hi" });
+        expect(a).not.toHaveBeenCalled();
+        expect(b).not.toHaveBeenCalled();
+    });
+});
+//# sourceMappingURL=events.test.js.map

package/dist/runtime/http.d.ts

@@ -0,0 +1,15 @@
+import { Cache } from "./cache.js";
+import type { TypedEventEmitter } from "./events.js";
+import type { CamundaClientConfig, ClientEventMap, RequestOptions } from "./types.js";
+/**
+ * Core HTTP transport layer. Handles auth, retries, caching, timeouts,
+ * logging, and event emission. Used by all generated resource classes.
+ */
+export declare class HttpClient {
+    #private;
+    constructor(config: CamundaClientConfig, emitter: TypedEventEmitter<ClientEventMap>);
+    request<T>(options: RequestOptions): Promise<T>;
+    /** Expose cache for manual invalidation. */
+    get cache(): Cache | null;
+}
+//# sourceMappingURL=http.d.ts.map

package/dist/runtime/http.js

@@ -0,0 +1,210 @@
+import { createAuthProvider } from "./auth.js";
+import { Cache } from "./cache.js";
+import { CamundaHttpError, CamundaNetworkError, CamundaTimeoutError, buildHttpError, } from "./errors.js";
+import { createLogger } from "./logger.js";
+import { withRetry } from "./retry.js";
+import { resolveTokenStore } from "./token-cache.js";
+/**
+ * Core HTTP transport layer. Handles auth, retries, caching, timeouts,
+ * logging, and event emission. Used by all generated resource classes.
+ */
+export class HttpClient {
+    #config;
+    #auth;
+    #cache;
+    #logger;
+    #emitter;
+    constructor(config, emitter) {
+        this.#config = config;
+        this.#emitter = emitter;
+        this.#logger = createLogger(config.logger);
+        const tokenStore = config.auth.type === "oauth2" ? resolveTokenStore(config.auth.tokenCache) : undefined;
+        this.#auth = createAuthProvider(config.auth, tokenStore, () => {
+            if (config.auth.type === "oauth2") {
+                emitter.emit("tokenRefresh", { tokenUrl: config.auth.tokenUrl });
+            }
+        });
+        const cacheConfig = config.cache;
+        this.#cache =
+            cacheConfig?.enabled === true
+                ? new Cache(cacheConfig.ttl ?? 30_000, cacheConfig.maxSize ?? 500)
+                : null;
+    }
+    async request(options) {
+        const url = this.#buildUrl(options);
+        // Cache check (only for cacheable requests)
+        if (options.cacheable && this.#cache) {
+            const cacheKey = this.#cacheKey(options);
+            const cached = this.#cache.get(cacheKey);
+            if (cached !== undefined) {
+                this.#logger.debug("Cache hit", { url });
+                this.#emitter.emit("cacheHit", { url });
+                this.#emitter.emit("response", {
+                    method: options.method,
+                    url,
+                    status: 200,
+                    durationMs: 0,
+                    cached: true,
+                });
+                return cached;
+            }
+            this.#emitter.emit("cacheMiss", { url });
+        }
+        return withRetry(() => this.#executeRequest(url, options), this.#config.retry, (err) => this.#shouldRetry(err), (ctx) => {
+            this.#logger.warn("Retrying request", { url, ...ctx });
+            this.#emitter.emit("retry", {
+                method: options.method,
+                url,
+                ...ctx,
+            });
+        });
+    }
+    async #executeRequest(url, options) {
+        const authHeader = await this.#auth.getAuthorizationHeader();
+        const headers = {
+            "Content-Type": "application/json",
+            Accept: options.accept ?? "application/json",
+        };
+        if (authHeader) {
+            headers.Authorization = authHeader;
+        }
+        const body = options.body !== undefined ? JSON.stringify(options.body) : undefined;
+        if (body === undefined) {
+            // biome-ignore lint/performance/noDelete: removing the header key is correct here
+            delete headers["Content-Type"];
+        }
+        const requestEvent = { method: options.method, url, headers, body: options.body };
+        this.#logger.debug("Request", requestEvent);
+        this.#emitter.emit("request", requestEvent);
+        const timeout = options.timeout ?? this.#config.timeout ?? 30_000;
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeout);
+        const startMs = Date.now();
+        let response;
+        try {
+            response = await fetch(url, {
+                method: options.method,
+                headers,
+                body,
+                signal: controller.signal,
+            });
+        }
+        catch (err) {
+            clearTimeout(timer);
+            const durationMs = Date.now() - startMs;
+            this.#logger.error("Network error", { url, durationMs, err });
+            if (err instanceof Error && err.name === "AbortError") {
+                const timeoutErr = new CamundaTimeoutError(`Request timed out after ${timeout}ms: ${options.method} ${url}`);
+                this.#emitter.emit("error", { method: options.method, url, error: timeoutErr });
+                throw timeoutErr;
+            }
+            const netErr = new CamundaNetworkError(`Network error: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+            this.#emitter.emit("error", { method: options.method, url, error: netErr });
+            throw netErr;
+        }
+        clearTimeout(timer);
+        const durationMs = Date.now() - startMs;
+        this.#logger.debug("Response", { url, status: response.status, durationMs });
+        this.#emitter.emit("response", {
+            method: options.method,
+            url,
+            status: response.status,
+            durationMs,
+            cached: false,
+        });
+        // Emit raw response event (clones body so the original stream is untouched)
+        {
+            const rawHeaders = {};
+            for (const [k, v] of response.headers.entries()) {
+                rawHeaders[k] = v;
+            }
+            const rawBody = await response.clone().text();
+            this.#emitter.emit("rawResponse", {
+                method: options.method,
+                url,
+                status: response.status,
+                headers: rawHeaders,
+                body: rawBody,
+                requestHeaders: headers,
+                requestBody: body,
+            });
+        }
+        // Handle 401 with potential token refresh
+        if (response.status === 401) {
+            const canRetry = await this.#auth.handleUnauthorized();
+            if (canRetry) {
+                return this.#executeRequest(url, options);
+            }
+        }
+        if (!response.ok) {
+            let errorBody;
+            try {
+                errorBody = await response.json();
+            }
+            catch {
+                errorBody = await response.text().catch(() => null);
+            }
+            const err = buildHttpError(response.status, errorBody, url);
+            this.#logger.error("API error", { url, status: response.status, body: errorBody });
+            this.#emitter.emit("error", { method: options.method, url, error: err });
+            throw err;
+        }
+        if (response.status === 204 || response.headers.get("content-length") === "0") {
+            return undefined;
+        }
+        const data = (options.responseType === "text" ? await response.text() : await response.json());
+        // Store in cache if applicable
+        if (options.cacheable && this.#cache) {
+            this.#cache.set(this.#cacheKey(options), data);
+        }
+        return data;
+    }
+    #buildUrl(options) {
+        let path = options.path;
+        // Substitute path parameters
+        if (options.pathParams) {
+            for (const [key, value] of Object.entries(options.pathParams)) {
+                path = path.replace(`{${key}}`, encodeURIComponent(String(value)));
+            }
+        }
+        const base = this.#config.baseUrl.replace(/\/$/, "");
+        let url = `${base}${path}`;
+        // Append query string
+        if (options.query) {
+            const params = new URLSearchParams();
+            for (const [key, value] of Object.entries(options.query)) {
+                if (value !== undefined && value !== null) {
+                    params.set(key, String(value));
+                }
+            }
+            const qs = params.toString();
+            if (qs)
+                url += `?${qs}`;
+        }
+        return url;
+    }
+    #cacheKey(options) {
+        return `${options.method}:${this.#buildUrl(options)}:${JSON.stringify(options.body ?? null)}`;
+    }
+    #shouldRetry(err) {
+        if (err instanceof CamundaTimeoutError) {
+            return { retry: true, reason: "timeout" };
+        }
+        if (err instanceof CamundaNetworkError) {
+            return { retry: true, reason: "network error" };
+        }
+        if (err instanceof CamundaHttpError) {
+            return {
+                retry: true,
+                reason: `HTTP ${err.status}`,
+                statusCode: err.status,
+            };
+        }
+        return { retry: false, reason: "unknown error" };
+    }
+    /** Expose cache for manual invalidation. */
+    get cache() {
+        return this.#cache;
+    }
+}
+//# sourceMappingURL=http.js.map

package/dist/runtime/logger.d.ts

@@ -0,0 +1,9 @@
+import type { LoggerConfig } from "./types.js";
+export interface Logger {
+    debug(message: string, data?: unknown): void;
+    info(message: string, data?: unknown): void;
+    warn(message: string, data?: unknown): void;
+    error(message: string, data?: unknown): void;
+}
+export declare function createLogger(config?: LoggerConfig): Logger;
+//# sourceMappingURL=logger.d.ts.map

package/dist/runtime/logger.js

@@ -0,0 +1,34 @@
+const LEVELS = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+    none: 4,
+};
+const defaultSink = (level, message, data) => {
+    const ts = new Date().toISOString();
+    const prefix = `[camunda-api] [${ts}] [${level.toUpperCase()}] ${message}`;
+    if (data !== undefined) {
+        /* eslint-disable no-console */
+        console[level === "debug" ? "debug" : level === "warn" ? "warn" : level === "error" ? "error" : "log"](prefix, data);
+    }
+    else {
+        console[level === "debug" ? "debug" : level === "warn" ? "warn" : level === "error" ? "error" : "log"](prefix);
+    }
+};
+export function createLogger(config) {
+    const minLevel = LEVELS[config?.level ?? "info"];
+    const sink = config?.sink ?? defaultSink;
+    const log = (level, message, data) => {
+        if (LEVELS[level] >= minLevel) {
+            sink(level, message, data);
+        }
+    };
+    return {
+        debug: (m, d) => log("debug", m, d),
+        info: (m, d) => log("info", m, d),
+        warn: (m, d) => log("warn", m, d),
+        error: (m, d) => log("error", m, d),
+    };
+}
+//# sourceMappingURL=logger.js.map

package/dist/runtime/relations.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Framework-agnostic relation graph between API operations.
+ *
+ * A Relation declares that a field produced by one operation (e.g. the
+ * "processDefinitionKey" column of the process-definition list) can be
+ * used as a parameter for another operation (e.g. get-xml). Both the CLI
+ * (to pre-fill command args) and the operate frontend (to suggest navigation)
+ * import these types and use buildRelations() to compute the graph.
+ */
+/** A follow-up link from one operation's output field to another's input param. */
+export interface Relation {
+    /** Name of the group containing the target operation */
+    groupName: string;
+    /** Name of the target operation/command */
+    commandName: string;
+    /** Human-readable description of the follow-up action */
+    description: string;
+    /** How to map source fields to target params */
+    params: Array<{
+        field: string;
+        param: string;
+    }>;
+}
+/**
+ * Generic descriptor for an operation in the relation graph.
+ * CLI commands and operate views can both be described as RelationSources.
+ */
+export interface RelationSource {
+    groupName: string;
+    commandName: string;
+    description: string;
+    /** Field names this operation produces (e.g. list column keys). */
+    outputFields: string[];
+    /** Parameter names this operation accepts as input (e.g. arg names). */
+    inputParams: string[];
+}
+/**
+ * Build a map of relations for all provided sources.
+ * For each source with output fields, finds other sources whose input
+ * params match those fields. Returns a map keyed by "groupName/commandName".
+ */
+export declare function buildRelations(sources: RelationSource[]): Map<string, Relation[]>;
+//# sourceMappingURL=relations.d.ts.map

package/dist/runtime/relations.js

@@ -0,0 +1,54 @@
+/**
+ * Framework-agnostic relation graph between API operations.
+ *
+ * A Relation declares that a field produced by one operation (e.g. the
+ * "processDefinitionKey" column of the process-definition list) can be
+ * used as a parameter for another operation (e.g. get-xml). Both the CLI
+ * (to pre-fill command args) and the operate frontend (to suggest navigation)
+ * import these types and use buildRelations() to compute the graph.
+ */
+/**
+ * Build a map of relations for all provided sources.
+ * For each source with output fields, finds other sources whose input
+ * params match those fields. Returns a map keyed by "groupName/commandName".
+ */
+export function buildRelations(sources) {
+    // Build index: inputParam → sources that accept it
+    const paramIndex = new Map();
+    for (const src of sources) {
+        for (const param of src.inputParams) {
+            const existing = paramIndex.get(param) ?? [];
+            existing.push(src);
+            paramIndex.set(param, existing);
+        }
+    }
+    const result = new Map();
+    for (const src of sources) {
+        if (src.outputFields.length === 0)
+            continue;
+        const relations = [];
+        const seen = new Set();
+        for (const field of src.outputFields) {
+            const targets = paramIndex.get(field) ?? [];
+            for (const target of targets) {
+                if (target === src)
+                    continue;
+                const key = `${target.groupName}/${target.commandName}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                relations.push({
+                    groupName: target.groupName,
+                    commandName: target.commandName,
+                    description: target.description,
+                    params: [{ field, param: field }],
+                });
+            }
+        }
+        if (relations.length > 0) {
+            result.set(`${src.groupName}/${src.commandName}`, relations);
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=relations.js.map

package/dist/runtime/retry.d.ts

@@ -0,0 +1,14 @@
+import type { RetryConfig } from "./types.js";
+export interface RetryContext {
+    attempt: number;
+    maxAttempts: number;
+    delayMs: number;
+    reason: string;
+}
+export type OnRetry = (ctx: RetryContext) => void;
+export declare function withRetry<T>(fn: () => Promise<T>, config: RetryConfig | undefined, shouldRetry: (error: unknown) => {
+    retry: boolean;
+    reason: string;
+    statusCode?: number;
+}, onRetry?: OnRetry): Promise<T>;
+//# sourceMappingURL=retry.d.ts.map

package/dist/runtime/retry.js

@@ -0,0 +1,41 @@
+const DEFAULTS = {
+    maxAttempts: 3,
+    initialDelay: 100,
+    maxDelay: 30_000,
+    backoffFactor: 2,
+    retryOn: [429, 500, 502, 503, 504],
+};
+export async function withRetry(fn, config, shouldRetry, onRetry) {
+    const cfg = { ...DEFAULTS, ...config };
+    let delay = cfg.initialDelay;
+    for (let attempt = 1; attempt <= cfg.maxAttempts; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            if (attempt === cfg.maxAttempts)
+                throw err;
+            const { retry, reason, statusCode } = shouldRetry(err);
+            // If status code given, check against retryOn list
+            if (!retry || (statusCode !== undefined && !cfg.retryOn.includes(statusCode))) {
+                throw err;
+            }
+            const jitter = Math.random() * 0.2 * delay;
+            const actualDelay = Math.min(delay + jitter, cfg.maxDelay);
+            onRetry?.({
+                attempt,
+                maxAttempts: cfg.maxAttempts,
+                delayMs: actualDelay,
+                reason,
+            });
+            await sleep(actualDelay);
+            delay = Math.min(delay * cfg.backoffFactor, cfg.maxDelay);
+        }
+    }
+    // Unreachable, but satisfies TS
+    throw new Error("Retry loop exhausted");
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=retry.js.map

package/dist/runtime/retry.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=retry.test.d.ts.map

package/dist/runtime/retry.test.js

@@ -0,0 +1,46 @@
+import { describe, expect, it, vi } from "vitest";
+import { CamundaHttpError, CamundaNetworkError } from "./errors.js";
+import { withRetry } from "./retry.js";
+const alwaysRetry = (err) => {
+    if (err instanceof CamundaHttpError)
+        return { retry: true, reason: `HTTP ${err.status}`, statusCode: err.status };
+    if (err instanceof CamundaNetworkError)
+        return { retry: true, reason: "network" };
+    return { retry: false, reason: "unknown" };
+};
+describe("withRetry", () => {
+    it("returns result on success", async () => {
+        const fn = vi.fn().mockResolvedValue("ok");
+        const result = await withRetry(fn, undefined, alwaysRetry);
+        expect(result).toBe("ok");
+        expect(fn).toHaveBeenCalledOnce();
+    });
+    it("retries on retryable error and eventually succeeds", async () => {
+        const err = new CamundaNetworkError("timeout");
+        const fn = vi.fn().mockRejectedValueOnce(err).mockResolvedValue("ok");
+        const onRetry = vi.fn();
+        const result = await withRetry(fn, { maxAttempts: 3, initialDelay: 0 }, alwaysRetry, onRetry);
+        expect(result).toBe("ok");
+        expect(fn).toHaveBeenCalledTimes(2);
+        expect(onRetry).toHaveBeenCalledOnce();
+    });
+    it("throws after maxAttempts", async () => {
+        const err = new CamundaNetworkError("fail");
+        const fn = vi.fn().mockRejectedValue(err);
+        await expect(withRetry(fn, { maxAttempts: 3, initialDelay: 0 }, alwaysRetry)).rejects.toThrow("fail");
+        expect(fn).toHaveBeenCalledTimes(3);
+    });
+    it("does not retry non-retryable errors", async () => {
+        const err = new TypeError("bad input");
+        const fn = vi.fn().mockRejectedValue(err);
+        await expect(withRetry(fn, { maxAttempts: 3, initialDelay: 0 }, alwaysRetry)).rejects.toThrow("bad input");
+        expect(fn).toHaveBeenCalledOnce();
+    });
+    it("does not retry when status code not in retryOn list", async () => {
+        const err = new CamundaHttpError("not found", 404, null, "http://test");
+        const fn = vi.fn().mockRejectedValue(err);
+        await expect(withRetry(fn, { maxAttempts: 3, initialDelay: 0, retryOn: [500] }, alwaysRetry)).rejects.toThrow();
+        expect(fn).toHaveBeenCalledOnce();
+    });
+});
+//# sourceMappingURL=retry.test.js.map

package/dist/runtime/token-cache.d.ts

@@ -0,0 +1,42 @@
+import type { CachedToken, TokenStore } from "./types.js";
+/** Returns the OS-appropriate application config directory. */
+export declare function osConfigDir(): string;
+/** Default path for the token cache file. */
+export declare function defaultTokenCachePath(): string;
+/**
+ * Builds a cache key for an OAuth2 client.
+ * Incorporates clientId, tokenUrl, and optional scope to support
+ * multiple clients/clusters from a single cache file.
+ */
+export declare function buildTokenCacheKey(clientId: string, tokenUrl: string, scope?: string, audience?: string): string;
+/**
+ * Persists OAuth2 tokens to a JSON file in the OS config directory.
+ * Multiple clients sharing the same file are safe because Node.js is
+ * single-threaded and each write is atomic (synchronous).
+ */
+export declare class FileTokenStore implements TokenStore {
+    #private;
+    constructor(filePath?: string);
+    get(key: string): Promise<CachedToken | null>;
+    set(key: string, token: CachedToken): Promise<void>;
+    get filePath(): string;
+}
+/** No-op store used when the token cache is disabled. */
+export declare class NullTokenStore implements TokenStore {
+    get(_key: string): Promise<null>;
+    set(_key: string, _token: CachedToken): Promise<void>;
+}
+/**
+ * Resolves the effective token store from the config.
+ *
+ * Priority:
+ *  1. `config.store`   — custom implementation (Redis, DB, …)
+ *  2. `config.disabled` — NullTokenStore (in-memory only)
+ *  3. FileTokenStore   — default, persists to the OS config dir
+ */
+export declare function resolveTokenStore(config: {
+    disabled?: boolean;
+    filePath?: string;
+    store?: TokenStore;
+} | undefined): TokenStore;
+//# sourceMappingURL=token-cache.d.ts.map

package/dist/runtime/token-cache.js

@@ -0,0 +1,104 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+/** Returns the OS-appropriate application config directory. */
+export function osConfigDir() {
+    if (process.platform === "win32") {
+        return process.env.APPDATA ?? join(homedir(), "AppData", "Roaming");
+    }
+    if (process.platform === "darwin") {
+        return join(homedir(), "Library", "Application Support");
+    }
+    // Linux / other — respect XDG
+    return process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config");
+}
+/** Default path for the token cache file. */
+export function defaultTokenCachePath() {
+    return join(osConfigDir(), "camunda-api", "token-cache.json");
+}
+/**
+ * Builds a cache key for an OAuth2 client.
+ * Incorporates clientId, tokenUrl, and optional scope to support
+ * multiple clients/clusters from a single cache file.
+ */
+export function buildTokenCacheKey(clientId, tokenUrl, scope, audience) {
+    let key = `${clientId}@${tokenUrl}`;
+    if (scope)
+        key += `:${scope}`;
+    if (audience)
+        key += `#${audience}`;
+    return key;
+}
+// ─── Implementations ──────────────────────────────────────────────────────────
+/**
+ * Persists OAuth2 tokens to a JSON file in the OS config directory.
+ * Multiple clients sharing the same file are safe because Node.js is
+ * single-threaded and each write is atomic (synchronous).
+ */
+export class FileTokenStore {
+    #filePath;
+    constructor(filePath) {
+        this.#filePath = filePath ?? defaultTokenCachePath();
+    }
+    async get(key) {
+        try {
+            const content = readFileSync(this.#filePath, "utf8");
+            const cache = JSON.parse(content);
+            const entry = cache[key];
+            if (!entry)
+                return null;
+            // Treat tokens as expired 60 s early so we never hand out a nearly-stale one
+            if (Date.now() >= entry.expiresAt - 60_000)
+                return null;
+            return entry;
+        }
+        catch {
+            // File absent or malformed — treat as cache miss
+            return null;
+        }
+    }
+    async set(key, token) {
+        try {
+            let cache = {};
+            try {
+                cache = JSON.parse(readFileSync(this.#filePath, "utf8"));
+            }
+            catch {
+                // Start with an empty cache if the file doesn't exist yet
+            }
+            cache[key] = token;
+            mkdirSync(dirname(this.#filePath), { recursive: true });
+            writeFileSync(this.#filePath, JSON.stringify(cache, null, 2), "utf8");
+        }
+        catch (err) {
+            // Non-fatal — the in-memory token still works for this session
+            process.stderr.write(`[camunda-api] Warning: could not write token cache to ${this.#filePath}: ${err}\n`);
+        }
+    }
+    get filePath() {
+        return this.#filePath;
+    }
+}
+/** No-op store used when the token cache is disabled. */
+export class NullTokenStore {
+    async get(_key) {
+        return null;
+    }
+    async set(_key, _token) { }
+}
+/**
+ * Resolves the effective token store from the config.
+ *
+ * Priority:
+ *  1. `config.store`   — custom implementation (Redis, DB, …)
+ *  2. `config.disabled` — NullTokenStore (in-memory only)
+ *  3. FileTokenStore   — default, persists to the OS config dir
+ */
+export function resolveTokenStore(config) {
+    if (config?.store)
+        return config.store;
+    if (config?.disabled === true)
+        return new NullTokenStore();
+    return new FileTokenStore(config?.filePath);
+}
+//# sourceMappingURL=token-cache.js.map