@bpmnkit/api 0.0.8

package/dist/generated/types.js

@@ -0,0 +1,4 @@
+// This file is auto-generated by scripts/generate.mjs
+// Do not edit manually. Run `pnpm --filter @bpmnkit/api generate` to regenerate.
+export {};
+//# sourceMappingURL=types.js.map

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export type { CamundaClientConfig, CamundaClientInput, AuthConfig, RetryConfig, CacheConfig, LoggerConfig, LogLevel, CachedToken, TokenStore, TokenCacheConfig, } from "./runtime/types.js";
+export type { ClientEventMap, RequestEvent, ResponseEvent, RawResponseEvent, ErrorEvent, RetryEvent, TokenRefreshEvent, CacheEvent, } from "./runtime/types.js";
+export { CamundaError, CamundaHttpError, CamundaValidationError, CamundaAuthError, CamundaForbiddenError, CamundaNotFoundError, CamundaConflictError, CamundaRateLimitError, CamundaServerError, CamundaNetworkError, CamundaTimeoutError, } from "./runtime/errors.js";
+export { FileTokenStore, NullTokenStore, defaultTokenCachePath } from "./runtime/token-cache.js";
+export { CamundaClient } from "./generated/resources.js";
+export type * from "./generated/types.js";
+export { AdminApiClient } from "./generated/admin-resources.js";
+export type * from "./generated/admin-types.js";
+export type { Relation, RelationSource } from "./runtime/relations.js";
+export { buildRelations } from "./runtime/relations.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,10 @@
+// Runtime — errors
+export { CamundaError, CamundaHttpError, CamundaValidationError, CamundaAuthError, CamundaForbiddenError, CamundaNotFoundError, CamundaConflictError, CamundaRateLimitError, CamundaServerError, CamundaNetworkError, CamundaTimeoutError, } from "./runtime/errors.js";
+// Runtime — token store implementations
+export { FileTokenStore, NullTokenStore, defaultTokenCachePath } from "./runtime/token-cache.js";
+// Generated C8 client (the main export)
+export { CamundaClient } from "./generated/resources.js";
+// Generated Admin API client
+export { AdminApiClient } from "./generated/admin-resources.js";
+export { buildRelations } from "./runtime/relations.js";
+//# sourceMappingURL=index.js.map

package/dist/runtime/auth.d.ts

@@ -0,0 +1,31 @@
+import type { AuthConfig, TokenStore } from "./types.js";
+export interface AuthProvider {
+    /** Returns a value for the Authorization header, or null if not applicable. */
+    getAuthorizationHeader(): Promise<string | null>;
+    /** Called after a 401 to allow token refresh. Returns true if a retry may succeed. */
+    handleUnauthorized(): Promise<boolean>;
+}
+export declare class NoAuthProvider implements AuthProvider {
+    getAuthorizationHeader(): Promise<null>;
+    handleUnauthorized(): Promise<boolean>;
+}
+export declare class BearerAuthProvider implements AuthProvider {
+    private token;
+    constructor(token: string);
+    getAuthorizationHeader(): Promise<string>;
+    handleUnauthorized(): Promise<boolean>;
+}
+export declare class BasicAuthProvider implements AuthProvider {
+    #private;
+    constructor(username: string, password: string);
+    getAuthorizationHeader(): Promise<string>;
+    handleUnauthorized(): Promise<boolean>;
+}
+export declare class OAuth2Provider implements AuthProvider {
+    #private;
+    constructor(clientId: string, clientSecret: string, tokenUrl: string, scope?: string, audience?: string, store?: TokenStore, onRefresh?: () => void);
+    getAuthorizationHeader(): Promise<string>;
+    handleUnauthorized(): Promise<boolean>;
+}
+export declare function createAuthProvider(config: AuthConfig, store?: TokenStore, onRefresh?: () => void): AuthProvider;
+//# sourceMappingURL=auth.d.ts.map

package/dist/runtime/auth.js

@@ -0,0 +1,136 @@
+import { CamundaAuthError } from "./errors.js";
+import { buildTokenCacheKey, resolveTokenStore } from "./token-cache.js";
+export class NoAuthProvider {
+    async getAuthorizationHeader() {
+        return null;
+    }
+    async handleUnauthorized() {
+        return false;
+    }
+}
+export class BearerAuthProvider {
+    token;
+    constructor(token) {
+        this.token = token;
+    }
+    async getAuthorizationHeader() {
+        return `Bearer ${this.token}`;
+    }
+    async handleUnauthorized() {
+        return false;
+    }
+}
+export class BasicAuthProvider {
+    #encoded;
+    constructor(username, password) {
+        this.#encoded = btoa(`${username}:${password}`);
+    }
+    async getAuthorizationHeader() {
+        return `Basic ${this.#encoded}`;
+    }
+    async handleUnauthorized() {
+        return false;
+    }
+}
+export class OAuth2Provider {
+    #clientId;
+    #clientSecret;
+    #tokenUrl;
+    #scope;
+    #audience;
+    /** In-memory token for the current process. */
+    #memoryToken = null;
+    #memoryExpiresAt = 0;
+    /** Persistent store (file / custom). */
+    #store;
+    #cacheKey;
+    /** Deduplicates concurrent refresh calls. */
+    #refreshing = null;
+    #onRefresh;
+    constructor(clientId, clientSecret, tokenUrl, scope, audience, store, onRefresh) {
+        this.#clientId = clientId;
+        this.#clientSecret = clientSecret;
+        this.#tokenUrl = tokenUrl;
+        this.#scope = scope;
+        this.#audience = audience;
+        this.#store = store ?? resolveTokenStore(undefined); // default: FileTokenStore
+        this.#cacheKey = buildTokenCacheKey(clientId, tokenUrl, scope, audience);
+        this.#onRefresh = onRefresh;
+    }
+    async getAuthorizationHeader() {
+        const token = await this.#getToken();
+        return `Bearer ${token}`;
+    }
+    async handleUnauthorized() {
+        // Invalidate both in-memory and persistent cache so next call fetches fresh
+        this.#memoryToken = null;
+        this.#memoryExpiresAt = 0;
+        await this.#store.set(this.#cacheKey, { accessToken: "", expiresAt: 0 });
+        return true;
+    }
+    async #getToken() {
+        // 1. Check in-memory token first (fastest path)
+        if (this.#memoryToken && Date.now() < this.#memoryExpiresAt - 30_000) {
+            return this.#memoryToken;
+        }
+        // 2. Check persistent store
+        const cached = await this.#store.get(this.#cacheKey);
+        if (cached?.accessToken) {
+            this.#memoryToken = cached.accessToken;
+            this.#memoryExpiresAt = cached.expiresAt;
+            return cached.accessToken;
+        }
+        // 3. Fetch a new token — deduplicate concurrent calls
+        if (this.#refreshing) {
+            return this.#refreshing;
+        }
+        this.#refreshing = this.#fetchToken().finally(() => {
+            this.#refreshing = null;
+        });
+        return this.#refreshing;
+    }
+    async #fetchToken() {
+        this.#onRefresh?.();
+        const params = new URLSearchParams({
+            grant_type: "client_credentials",
+            client_id: this.#clientId,
+            client_secret: this.#clientSecret,
+        });
+        if (this.#scope)
+            params.set("scope", this.#scope);
+        if (this.#audience)
+            params.set("audience", this.#audience);
+        const response = await fetch(this.#tokenUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body: params.toString(),
+        });
+        if (!response.ok) {
+            throw new CamundaAuthError(`OAuth2 token request failed: ${response.status}`, response.status, await response.text(), this.#tokenUrl);
+        }
+        const data = (await response.json());
+        const expiresAt = Date.now() + (data.expires_in ?? 3600) * 1000;
+        // Update in-memory state
+        this.#memoryToken = data.access_token;
+        this.#memoryExpiresAt = expiresAt;
+        // Persist to store (fire and forget — failure is non-fatal)
+        this.#store.set(this.#cacheKey, {
+            accessToken: data.access_token,
+            expiresAt,
+        });
+        return data.access_token;
+    }
+}
+export function createAuthProvider(config, store, onRefresh) {
+    switch (config.type) {
+        case "bearer":
+            return new BearerAuthProvider(config.token);
+        case "basic":
+            return new BasicAuthProvider(config.username, config.password);
+        case "oauth2":
+            return new OAuth2Provider(config.clientId, config.clientSecret, config.tokenUrl, config.scope, config.audience, store, onRefresh);
+        case "none":
+            return new NoAuthProvider();
+    }
+}
+//# sourceMappingURL=auth.js.map

package/dist/runtime/cache.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Simple LRU cache with TTL expiry. No external dependencies.
+ */
+export declare class Cache {
+    #private;
+    constructor(ttl: number, maxSize: number);
+    get<T>(key: string): T | undefined;
+    set(key: string, value: unknown, ttlOverride?: number): void;
+    delete(key: string): void;
+    clear(): void;
+    get size(): number;
+}
+//# sourceMappingURL=cache.d.ts.map

package/dist/runtime/cache.js

@@ -0,0 +1,48 @@
+/**
+ * Simple LRU cache with TTL expiry. No external dependencies.
+ */
+export class Cache {
+    #store = new Map();
+    #ttl;
+    #maxSize;
+    constructor(ttl, maxSize) {
+        this.#ttl = ttl;
+        this.#maxSize = maxSize;
+    }
+    get(key) {
+        const entry = this.#store.get(key);
+        if (!entry)
+            return undefined;
+        if (Date.now() > entry.expiresAt) {
+            this.#store.delete(key);
+            return undefined;
+        }
+        // LRU: move to end by re-inserting
+        this.#store.delete(key);
+        this.#store.set(key, entry);
+        return entry.value;
+    }
+    set(key, value, ttlOverride) {
+        if (this.#store.size >= this.#maxSize) {
+            // Evict oldest entry (first in insertion order)
+            const oldest = this.#store.keys().next().value;
+            if (oldest !== undefined) {
+                this.#store.delete(oldest);
+            }
+        }
+        this.#store.set(key, {
+            value,
+            expiresAt: Date.now() + (ttlOverride ?? this.#ttl),
+        });
+    }
+    delete(key) {
+        this.#store.delete(key);
+    }
+    clear() {
+        this.#store.clear();
+    }
+    get size() {
+        return this.#store.size;
+    }
+}
+//# sourceMappingURL=cache.js.map

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

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

package/dist/runtime/cache.test.js

@@ -0,0 +1,38 @@
+import { describe, expect, it, vi } from "vitest";
+import { Cache } from "./cache.js";
+describe("Cache", () => {
+    it("stores and retrieves values", () => {
+        const cache = new Cache(60_000, 100);
+        cache.set("key", { value: 42 });
+        expect(cache.get("key")).toEqual({ value: 42 });
+    });
+    it("returns undefined for missing keys", () => {
+        const cache = new Cache(60_000, 100);
+        expect(cache.get("missing")).toBeUndefined();
+    });
+    it("expires entries after TTL", () => {
+        vi.useFakeTimers();
+        const cache = new Cache(100, 100);
+        cache.set("key", "value");
+        vi.advanceTimersByTime(200);
+        expect(cache.get("key")).toBeUndefined();
+        vi.useRealTimers();
+    });
+    it("evicts oldest entry when maxSize is exceeded", () => {
+        const cache = new Cache(60_000, 2);
+        cache.set("a", 1);
+        cache.set("b", 2);
+        cache.set("c", 3); // should evict "a"
+        expect(cache.get("a")).toBeUndefined();
+        expect(cache.get("b")).toBe(2);
+        expect(cache.get("c")).toBe(3);
+    });
+    it("clear removes all entries", () => {
+        const cache = new Cache(60_000, 100);
+        cache.set("a", 1);
+        cache.set("b", 2);
+        cache.clear();
+        expect(cache.size).toBe(0);
+    });
+});
+//# sourceMappingURL=cache.test.js.map

package/dist/runtime/client.d.ts

@@ -0,0 +1,25 @@
+import { TypedEventEmitter } from "./events.js";
+import { HttpClient } from "./http.js";
+import type { CamundaClientConfig, CamundaClientInput, ClientEventMap } from "./types.js";
+/**
+ * Base class for CamundaClient. The generated subclass adds all resource
+ * properties (processInstance, job, userTask, …).
+ */
+export declare class CamundaBaseClient extends TypedEventEmitter<ClientEventMap> {
+    readonly http: HttpClient;
+    /** The fully resolved configuration used by this client. */
+    readonly config: CamundaClientConfig;
+    constructor(input?: CamundaClientInput);
+    /**
+     * Clears the in-memory response cache (if caching is enabled).
+     */
+    clearCache(): void;
+}
+/**
+ * Base class for all generated resource classes.
+ */
+export declare class ResourceBase {
+    protected readonly _http: HttpClient;
+    constructor(_http: HttpClient);
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/runtime/client.js

@@ -0,0 +1,33 @@
+import { resolveConfig } from "./config.js";
+import { TypedEventEmitter } from "./events.js";
+import { HttpClient } from "./http.js";
+/**
+ * Base class for CamundaClient. The generated subclass adds all resource
+ * properties (processInstance, job, userTask, …).
+ */
+export class CamundaBaseClient extends TypedEventEmitter {
+    http;
+    /** The fully resolved configuration used by this client. */
+    config;
+    constructor(input = {}) {
+        super();
+        this.config = resolveConfig(input);
+        this.http = new HttpClient(this.config, this);
+    }
+    /**
+     * Clears the in-memory response cache (if caching is enabled).
+     */
+    clearCache() {
+        this.http.cache?.clear();
+    }
+}
+/**
+ * Base class for all generated resource classes.
+ */
+export class ResourceBase {
+    _http;
+    constructor(_http) {
+        this._http = _http;
+    }
+}
+//# sourceMappingURL=client.js.map

package/dist/runtime/config.d.ts

@@ -0,0 +1,15 @@
+import type { CamundaClientConfig, CamundaClientInput } from "./types.js";
+declare function loadFromEnv(): CamundaClientInput;
+declare function loadFromFile(filePath: string): CamundaClientInput;
+/**
+ * Resolve the final `CamundaClientConfig` from three layers (lowest → highest):
+ *  1. Environment variables (CAMUNDA_*)
+ *  2. YAML config file (path from `input.configFile` or `CAMUNDA_CONFIG_FILE`)
+ *  3. Values passed directly to the constructor (`input`)
+ *
+ * Throws `CamundaError` if `baseUrl` or `auth` cannot be resolved.
+ */
+export declare function resolveConfig(input: CamundaClientInput): CamundaClientConfig;
+/** Exported for testing. */
+export { loadFromEnv, loadFromFile };
+//# sourceMappingURL=config.d.ts.map