veryfront 0.1.1213 → 0.1.1214

package/esm/src/platform/adapters/token/factory.js

@@ -0,0 +1,79 @@
+/**
+ * Token Storage Adapter Factory
+ *
+ * Creates the appropriate token storage adapter based on configuration.
+ * For auto-detection from environment variables, use getTokenStorageAdapter()
+ * from token/integration.ts instead.
+ */
+import { logger as baseLogger } from "../../../utils/index.js";
+import { withSpan } from "../../../observability/tracing/otlp-setup.js";
+import { createError, toError } from "../../../errors/veryfront-error.js";
+const logger = baseLogger.component("token-adapter-factory");
+export function createTokenStorageAdapter(config) {
+    const type = config.type ?? "memory";
+    const veryfront = config.veryfront;
+    const veryfrontSnapshot = type === "veryfront-api" && veryfront !== undefined
+        ? snapshotVeryfrontOptions(veryfront)
+        : undefined;
+    return withSpan("platform.token.createAdapter", async () => {
+        logger.debug("Creating adapter", { type });
+        if (type === "memory") {
+            if (veryfront !== undefined) {
+                throw toError(createError({
+                    type: "config",
+                    message: 'Veryfront token configuration requires adapter type "veryfront-api"; refusing to fall back to memory storage.',
+                }));
+            }
+            const { MemoryTokenAdapter } = await import("./veryfront/memory-adapter.js");
+            return await initializeAdapter(new MemoryTokenAdapter());
+        }
+        if (type === "veryfront-api") {
+            if (veryfrontSnapshot === undefined) {
+                throw toError(createError({
+                    type: "config",
+                    message: "Veryfront token adapter requires veryfront configuration",
+                }));
+            }
+            const { VeryfrontTokenAdapter } = await import("./veryfront/adapter.js");
+            return await initializeAdapter(new VeryfrontTokenAdapter({
+                type: "veryfront-api",
+                veryfront: veryfrontSnapshot,
+            }));
+        }
+        throw toError(createError({
+            type: "config",
+            message: `Token storage adapter type "${type}" is not implemented. Supported types: "memory", "veryfront-api".`,
+        }));
+    }, { "token.adapter.type": type });
+}
+function snapshotVeryfrontOptions(options) {
+    const retry = options.retry;
+    return Object.freeze({
+        apiToken: options.apiToken,
+        projectSlug: options.projectSlug,
+        apiBaseUrl: options.apiBaseUrl,
+        timeoutMs: options.timeoutMs,
+        retry: retry === undefined ? undefined : Object.freeze({
+            maxRetries: retry.maxRetries,
+            initialDelay: retry.initialDelay,
+            maxDelay: retry.maxDelay,
+        }),
+    });
+}
+async function initializeAdapter(adapter) {
+    try {
+        await adapter.initialize?.();
+        return adapter;
+    }
+    catch (error) {
+        try {
+            adapter.dispose?.();
+        }
+        catch (cleanupError) {
+            logger.warn("Failed to dispose token adapter after initialization failure", {
+                cleanupError,
+            });
+        }
+        throw error;
+    }
+}

package/esm/src/platform/adapters/token/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Adapters - Token
+ *
+ * @module platform/adapters/token
+ */
+export { MemoryTokenAdapter, TOKEN_STORAGE_ERROR, type TokenStorageAdapter, type TokenStorageAdapterConfig, TokenStorageApiClient, VeryfrontTokenAdapter, type VeryfrontTokenConfig, } from "./veryfront/index.js";
+export { createTokenStorageAdapter } from "./factory.js";
+export { getTokenStorageAdapter, getTokenStorageType, isTokenStorageConfigured, resetTokenStorageAdapter, } from "./integration.js";
+//# sourceMappingURL=index.d.ts.map

package/esm/src/platform/adapters/token/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/src/platform/adapters/token/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,kBAAkB,EAClB,mBAAmB,EACnB,KAAK,mBAAmB,EACxB,KAAK,yBAAyB,EAC9B,qBAAqB,EACrB,qBAAqB,EACrB,KAAK,oBAAoB,GAC1B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AACzD,OAAO,EACL,sBAAsB,EACtB,mBAAmB,EACnB,wBAAwB,EACxB,wBAAwB,GACzB,MAAM,kBAAkB,CAAC"}

package/esm/src/platform/adapters/token/index.js

@@ -0,0 +1,8 @@
+/**
+ * Adapters - Token
+ *
+ * @module platform/adapters/token
+ */
+export { MemoryTokenAdapter, TOKEN_STORAGE_ERROR, TokenStorageApiClient, VeryfrontTokenAdapter, } from "./veryfront/index.js";
+export { createTokenStorageAdapter } from "./factory.js";
+export { getTokenStorageAdapter, getTokenStorageType, isTokenStorageConfigured, resetTokenStorageAdapter, } from "./integration.js";

package/esm/src/platform/adapters/token/integration.d.ts

@@ -0,0 +1,6 @@
+import type { TokenStorageAdapter } from "./veryfront/types.js";
+export declare function getTokenStorageAdapter(): Promise<TokenStorageAdapter>;
+export declare function isTokenStorageConfigured(): boolean;
+export declare function getTokenStorageType(): string;
+export declare function resetTokenStorageAdapter(): void;
+//# sourceMappingURL=integration.d.ts.map

package/esm/src/platform/adapters/token/integration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration.d.ts","sourceRoot":"","sources":["../../../../../src/src/platform/adapters/token/integration.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,mBAAmB,EAA6B,MAAM,sBAAsB,CAAC;AAQ3F,wBAAgB,sBAAsB,IAAI,OAAO,CAAC,mBAAmB,CAAC,CA0BrE;AAED,wBAAgB,wBAAwB,IAAI,OAAO,CAElD;AAED,wBAAgB,mBAAmB,IAAI,MAAM,CAE5C;AAED,wBAAgB,wBAAwB,IAAI,IAAI,CAK/C"}

package/esm/src/platform/adapters/token/integration.js

@@ -0,0 +1,61 @@
+import { logger as baseLogger } from "../../../utils/index.js";
+import { withSpan } from "../../../observability/tracing/otlp-setup.js";
+import { getEnv } from "../../compat/process/env.js";
+import { createTokenStorageAdapter } from "./factory.js";
+const logger = baseLogger.component("token-adapter-integration");
+let tokenStorageAdapter = null;
+let tokenStorageAdapterCreation = null;
+let tokenStorageGeneration = 0;
+export function getTokenStorageAdapter() {
+    if (tokenStorageAdapter)
+        return Promise.resolve(tokenStorageAdapter);
+    if (tokenStorageAdapterCreation)
+        return tokenStorageAdapterCreation;
+    const generation = tokenStorageGeneration;
+    const rawCreation = withSpan("platform.token.getTokenStorageAdapter", async () => {
+        const adapterConfig = buildAdapterConfigFromEnv();
+        const candidate = await createTokenStorageAdapter(adapterConfig);
+        if (generation !== tokenStorageGeneration) {
+            candidate.dispose?.();
+            throw new Error("Token storage adapter creation was invalidated by reset");
+        }
+        tokenStorageAdapter = candidate;
+        return candidate;
+    }, { "token.storage.type": getTokenStorageType() });
+    const trackedCreation = rawCreation.finally(() => {
+        if (tokenStorageAdapterCreation === trackedCreation) {
+            tokenStorageAdapterCreation = null;
+        }
+    });
+    tokenStorageAdapterCreation = trackedCreation;
+    return trackedCreation;
+}
+export function isTokenStorageConfigured() {
+    return Boolean(getEnvVar("VERYFRONT_API_TOKEN") && getEnvVar("VERYFRONT_PROJECT_SLUG"));
+}
+export function getTokenStorageType() {
+    return isTokenStorageConfigured() ? "veryfront-api" : "memory";
+}
+export function resetTokenStorageAdapter() {
+    tokenStorageGeneration++;
+    tokenStorageAdapter?.dispose?.();
+    tokenStorageAdapter = null;
+    tokenStorageAdapterCreation = null;
+}
+function buildAdapterConfigFromEnv() {
+    const apiToken = getEnvVar("VERYFRONT_API_TOKEN");
+    const projectSlug = getEnvVar("VERYFRONT_PROJECT_SLUG");
+    const apiBaseUrl = getEnvVar("VERYFRONT_API_URL");
+    if (!apiToken || !projectSlug) {
+        logger.debug("Using in-memory storage (development)");
+        return { type: "memory" };
+    }
+    logger.debug("Using Veryfront Cloud storage", { projectSlug });
+    return {
+        type: "veryfront-api",
+        veryfront: { apiToken, projectSlug, apiBaseUrl },
+    };
+}
+function getEnvVar(name) {
+    return getEnv(name);
+}

package/esm/src/platform/adapters/token/veryfront/adapter.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Veryfront Token Storage Adapter
+ *
+ * Stores encrypted OAuth tokens in Veryfront Cloud.
+ * Tokens are encrypted client-side before being sent to the API.
+ */
+import { type TokenStorageAdapter, type TokenStorageAdapterConfig } from "./types.js";
+export declare class VeryfrontTokenAdapter implements TokenStorageAdapter {
+    private client;
+    private initialized;
+    private initialization;
+    private lifecycleGeneration;
+    constructor(config: TokenStorageAdapterConfig);
+    initialize(): Promise<void>;
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    delete(key: string): Promise<void>;
+    list(prefix?: string): Promise<string[]>;
+    dispose(): void;
+    private doInitialize;
+}
+//# sourceMappingURL=adapter.d.ts.map

package/esm/src/platform/adapters/token/veryfront/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../../../../../src/src/platform/adapters/token/veryfront/adapter.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,EAEL,KAAK,mBAAmB,EACxB,KAAK,yBAAyB,EAC/B,MAAM,YAAY,CAAC;AASpB,qBAAa,qBAAsB,YAAW,mBAAmB;IAC/D,OAAO,CAAC,MAAM,CAAwB;IACtC,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,cAAc,CAAsC;IAC5D,OAAO,CAAC,mBAAmB,CAAK;gBAEpB,MAAM,EAAE,yBAAyB;IAUvC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAuB3B,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAMxC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAM9C,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAMlC,IAAI,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAM9C,OAAO,IAAI,IAAI;YAUD,YAAY;CAqB3B"}

package/esm/src/platform/adapters/token/veryfront/adapter.js

@@ -0,0 +1,88 @@
+/**
+ * Veryfront Token Storage Adapter
+ *
+ * Stores encrypted OAuth tokens in Veryfront Cloud.
+ * Tokens are encrypted client-side before being sent to the API.
+ */
+import { logger as baseLogger } from "../../../../utils/index.js";
+import { TOKEN_STORAGE_ERROR } from "../../../../errors/index.js";
+import { TokenStorageApiClient } from "./api-client.js";
+import { createTokenConfig, } from "./types.js";
+const logger = baseLogger.component("veryfront-token-adapter");
+export class VeryfrontTokenAdapter {
+    client;
+    initialized = false;
+    initialization = null;
+    lifecycleGeneration = 0;
+    constructor(config) {
+        const tokenConfig = createTokenConfig(config);
+        this.client = new TokenStorageApiClient(tokenConfig);
+        logger.debug("Created", {
+            apiBaseUrl: tokenConfig.apiBaseUrl,
+            projectSlug: tokenConfig.projectSlug,
+        });
+    }
+    async initialize() {
+        if (this.initialized)
+            return;
+        if (this.initialization)
+            return await this.initialization.promise;
+        logger.debug("Initializing...");
+        const generation = this.lifecycleGeneration;
+        const controller = new AbortController();
+        const initialization = {
+            controller,
+            promise: this.doInitialize(generation, controller.signal),
+        };
+        this.initialization = initialization;
+        try {
+            await initialization.promise;
+        }
+        finally {
+            if (this.initialization === initialization) {
+                this.initialization = null;
+            }
+        }
+    }
+    async get(key) {
+        await this.initialize();
+        logger.debug("Get", { key });
+        return this.client.get(key);
+    }
+    async set(key, value) {
+        await this.initialize();
+        logger.debug("Set", { key, valueLength: value.length });
+        await this.client.set(key, value);
+    }
+    async delete(key) {
+        await this.initialize();
+        logger.debug("Delete", { key });
+        await this.client.delete(key);
+    }
+    async list(prefix) {
+        await this.initialize();
+        logger.debug("List", { prefix });
+        return this.client.list(prefix);
+    }
+    dispose() {
+        this.lifecycleGeneration++;
+        this.initialization?.controller.abort(new DOMException("Token storage initialization was invalidated", "AbortError"));
+        this.initialization = null;
+        this.initialized = false;
+        logger.debug("Disposed");
+    }
+    async doInitialize(generation, signal) {
+        const connected = await this.client.ping(signal);
+        signal.throwIfAborted();
+        if (generation !== this.lifecycleGeneration) {
+            throw new DOMException("Token storage initialization was invalidated", "AbortError");
+        }
+        if (!connected) {
+            throw TOKEN_STORAGE_ERROR.create({
+                detail: "Failed to connect to Veryfront token storage API",
+            });
+        }
+        this.initialized = true;
+        logger.debug("Initialized successfully");
+    }
+}

package/esm/src/platform/adapters/token/veryfront/api-client.d.ts

@@ -0,0 +1,15 @@
+import { type VeryfrontTokenConfig } from "./types.js";
+export declare class TokenStorageApiClient {
+    private readonly config;
+    private readonly transport;
+    constructor(config: VeryfrontTokenConfig);
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    delete(key: string): Promise<void>;
+    list(prefix?: string, signal?: AbortSignal): Promise<string[]>;
+    ping(signal?: AbortSignal): Promise<boolean>;
+    private buildUrl;
+    private parseJsonBody;
+    private wrapError;
+}
+//# sourceMappingURL=api-client.d.ts.map

package/esm/src/platform/adapters/token/veryfront/api-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-client.d.ts","sourceRoot":"","sources":["../../../../../../src/src/platform/adapters/token/veryfront/api-client.ts"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,oBAAoB,EAC1B,MAAM,YAAY,CAAC;AAsCpB,qBAAa,qBAAqB;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuB;IAC9C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAkD;gBAEhE,MAAM,EAAE,oBAAoB;IAkDlC,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IA+BxC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAuB9C,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAoBlC,IAAI,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAiD9D,IAAI,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;IAWlD,OAAO,CAAC,QAAQ;IAMhB,OAAO,CAAC,aAAa;IAYrB,OAAO,CAAC,SAAS;CAgBlB"}

package/esm/src/platform/adapters/token/veryfront/api-client.js

@@ -0,0 +1,212 @@
+import { logger as baseLogger } from "../../../../utils/index.js";
+import { readResponseTextPrefix } from "../../../../utils/response-body.js";
+import { assertTokenStorageKey, assertTokenStoragePrefix, assertTokenStorageValue, } from "./types.js";
+import { TOKEN_STORAGE_ERROR } from "../../../../errors/error-registry.js";
+import { VeryfrontError } from "../../../../errors/types.js";
+import { createVeryfrontApiTransport, } from "../../veryfront-api-transport.js";
+const logger = baseLogger.component("token-storage-api-client");
+const MAX_TOKEN_STORAGE_RESPONSE_BODY_BYTES = 1024 * 1024;
+function cancelResponseBody(response, operation) {
+    if (!response.body)
+        return;
+    try {
+        void response.body.cancel().catch((error) => {
+            logger.debug("Response body cancellation failed during token storage cleanup", {
+                operation,
+                status: response.status,
+                error,
+            });
+        });
+    }
+    catch (error) {
+        logger.debug("Response body cancellation failed during token storage cleanup", {
+            operation,
+            status: response.status,
+            error,
+        });
+    }
+}
+export class TokenStorageApiClient {
+    config;
+    transport;
+    constructor(config) {
+        this.config = config;
+        const { maxRetries, initialDelay, maxDelay } = config.retry;
+        this.transport = createVeryfrontApiTransport({
+            baseUrl: config.apiBaseUrl,
+            getToken: () => config.apiToken,
+            retry: { maxRetries, initialDelay, maxDelay },
+            timeoutMs: config.timeoutMs,
+            defaultHeaders: { "Accept": "application/json" },
+            onResponse: async (response, _init, _url, signal) => {
+                // 5xx / 429: throw to trigger retry logic. Cancel the body first so
+                // retries do not hold connections/buffers open.
+                if (!response.ok && (response.status >= 500 || response.status === 429)) {
+                    cancelResponseBody(response, "retry");
+                    throw TOKEN_STORAGE_ERROR.create({
+                        detail: `Server error: ${response.status}`,
+                        status: response.status,
+                    });
+                }
+                const { text, truncated } = await readResponseTextPrefix(response, MAX_TOKEN_STORAGE_RESPONSE_BODY_BYTES, signal);
+                if (truncated) {
+                    throw TOKEN_STORAGE_ERROR.create({
+                        detail: `Token storage response body exceeds ${MAX_TOKEN_STORAGE_RESPONSE_BODY_BYTES} bytes`,
+                        status: 502,
+                    });
+                }
+                return {
+                    ok: response.ok,
+                    status: response.status,
+                    statusText: response.statusText,
+                    bodyText: text,
+                };
+            },
+            wrapFinalError: (lastError) => TOKEN_STORAGE_ERROR.create({
+                detail: `Request failed after ${maxRetries} retries: ${lastError.message}`,
+            }),
+        });
+    }
+    async get(key) {
+        assertTokenStorageKey(key);
+        const url = this.buildUrl(key);
+        try {
+            const response = await this.transport.request(url);
+            if (response.status === 404) {
+                return null;
+            }
+            if (!response.ok) {
+                throw TOKEN_STORAGE_ERROR.create({
+                    detail: `Failed to get token: ${response.statusText}`,
+                    status: response.status,
+                });
+            }
+            const data = this.parseJsonBody(response, "get");
+            if (!isRecord(data) || typeof data.value !== "string") {
+                throw TOKEN_STORAGE_ERROR.create({
+                    detail: "Malformed get response: expected an object with a string value",
+                    status: 502,
+                });
+            }
+            return data.value;
+        }
+        catch (error) {
+            throw this.wrapError(error, "Get", key, `Failed to get token`);
+        }
+    }
+    async set(key, value) {
+        assertTokenStorageKey(key);
+        assertTokenStorageValue(value);
+        const url = this.buildUrl(key);
+        try {
+            const response = await this.transport.request(url, {
+                method: "PUT",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ value }),
+            });
+            if (!response.ok) {
+                throw TOKEN_STORAGE_ERROR.create({
+                    detail: `Failed to set token: ${response.statusText}`,
+                    status: response.status,
+                });
+            }
+        }
+        catch (error) {
+            throw this.wrapError(error, "Set", key, `Failed to set token`);
+        }
+    }
+    async delete(key) {
+        assertTokenStorageKey(key);
+        const url = this.buildUrl(key);
+        try {
+            const response = await this.transport.request(url, { method: "DELETE" });
+            if (response.ok || response.status === 404) {
+                return;
+            }
+            throw TOKEN_STORAGE_ERROR.create({
+                detail: `Failed to delete token: ${response.statusText}`,
+                status: response.status,
+            });
+        }
+        catch (error) {
+            throw this.wrapError(error, "Delete", key, `Failed to delete token`);
+        }
+    }
+    async list(prefix, signal) {
+        assertTokenStoragePrefix(prefix);
+        let url = `/v1/projects/${encodeURIComponent(this.config.projectSlug)}/tokens`;
+        if (prefix !== undefined && prefix.length > 0) {
+            const search = new URLSearchParams({ prefix });
+            url += `?${search.toString()}`;
+        }
+        try {
+            const response = await this.transport.request(url, { signal });
+            if (!response.ok) {
+                throw TOKEN_STORAGE_ERROR.create({
+                    detail: `Failed to list tokens: ${response.statusText}`,
+                    status: response.status,
+                });
+            }
+            const data = this.parseJsonBody(response, "list");
+            if (!isRecord(data) ||
+                (data.keys !== undefined &&
+                    (!Array.isArray(data.keys) ||
+                        !data.keys.every((key) => typeof key === "string")))) {
+                throw TOKEN_STORAGE_ERROR.create({
+                    detail: "Malformed list response: expected an object with a string keys array",
+                    status: 502,
+                });
+            }
+            return data.keys ?? [];
+        }
+        catch (error) {
+            signal?.throwIfAborted();
+            if (error instanceof VeryfrontError && error.slug === "token-storage-error") {
+                throw error;
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            logger.error("List failed", {
+                prefix,
+                error: message,
+            });
+            throw TOKEN_STORAGE_ERROR.create({ detail: `Failed to list tokens: ${message}` });
+        }
+    }
+    async ping(signal) {
+        try {
+            await this.list(undefined, signal);
+            return true;
+        }
+        catch {
+            signal?.throwIfAborted();
+            /* expected: ping returns false when API is unreachable */
+            return false;
+        }
+    }
+    buildUrl(key) {
+        return `/v1/projects/${encodeURIComponent(this.config.projectSlug)}/tokens/${encodeURIComponent(key)}`;
+    }
+    parseJsonBody(response, operation) {
+        try {
+            return JSON.parse(response.bodyText);
+        }
+        catch (cause) {
+            throw TOKEN_STORAGE_ERROR.create({
+                detail: `Malformed ${operation} response: expected valid JSON`,
+                cause,
+                status: 502,
+            });
+        }
+    }
+    wrapError(error, action, key, prefixMessage) {
+        if (error instanceof VeryfrontError && error.slug === "token-storage-error") {
+            return error;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        logger.error(`${action} failed`, { key, error: message });
+        return TOKEN_STORAGE_ERROR.create({ detail: `${prefixMessage}: ${message}` });
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/esm/src/platform/adapters/token/veryfront/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Token - Veryfront
+ *
+ * @module platform/adapters/token/veryfront
+ */
+export { TokenStorageApiClient } from "./api-client.js";
+export { VeryfrontTokenAdapter } from "./adapter.js";
+export { MemoryTokenAdapter } from "./memory-adapter.js";
+export { createTokenConfig, TOKEN_STORAGE_ERROR, type TokenStorageAdapter, type TokenStorageAdapterConfig, type VeryfrontTokenConfig, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/esm/src/platform/adapters/token/veryfront/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/src/platform/adapters/token/veryfront/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,KAAK,mBAAmB,EACxB,KAAK,yBAAyB,EAC9B,KAAK,oBAAoB,GAC1B,MAAM,YAAY,CAAC"}

package/esm/src/platform/adapters/token/veryfront/index.js

@@ -0,0 +1,9 @@
+/**
+ * Token - Veryfront
+ *
+ * @module platform/adapters/token/veryfront
+ */
+export { TokenStorageApiClient } from "./api-client.js";
+export { VeryfrontTokenAdapter } from "./adapter.js";
+export { MemoryTokenAdapter } from "./memory-adapter.js";
+export { createTokenConfig, TOKEN_STORAGE_ERROR, } from "./types.js";

package/esm/src/platform/adapters/token/veryfront/memory-adapter.d.ts

@@ -0,0 +1,20 @@
+/**
+ * In-Memory Token Storage Adapter
+ *
+ * Development-only adapter that stores tokens in memory.
+ * Tokens are lost when the process restarts.
+ */
+import { type TokenStorageAdapter } from "./types.js";
+export declare class MemoryTokenAdapter implements TokenStorageAdapter {
+    private readonly storage;
+    constructor();
+    initialize(): Promise<void>;
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    delete(key: string): Promise<void>;
+    list(prefix?: string): Promise<string[]>;
+    dispose(): void;
+    get size(): number;
+    clear(): void;
+}
+//# sourceMappingURL=memory-adapter.d.ts.map

package/esm/src/platform/adapters/token/veryfront/memory-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-adapter.d.ts","sourceRoot":"","sources":["../../../../../../src/src/platform/adapters/token/veryfront/memory-adapter.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAIL,KAAK,mBAAmB,EACzB,MAAM,YAAY,CAAC;AAIpB,qBAAa,kBAAmB,YAAW,mBAAmB;IAC5D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA6B;;IAUrD,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAKxC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAO9C,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAMlC,IAAI,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAOxC,OAAO,IAAI,IAAI;IAKf,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,KAAK,IAAI,IAAI;CAGd"}

package/esm/src/platform/adapters/token/veryfront/memory-adapter.js

@@ -0,0 +1,52 @@
+/**
+ * In-Memory Token Storage Adapter
+ *
+ * Development-only adapter that stores tokens in memory.
+ * Tokens are lost when the process restarts.
+ */
+import { logger as baseLogger } from "../../../../utils/index.js";
+import { assertTokenStorageKey, assertTokenStoragePrefix, assertTokenStorageValue, } from "./types.js";
+const logger = baseLogger.component("memory-token-adapter");
+export class MemoryTokenAdapter {
+    storage = new Map();
+    constructor() {
+        logger.warn("[MemoryTokenAdapter] Using in-memory storage. " +
+            "Tokens will be lost on restart. " +
+            "Configure Veryfront Cloud for production.");
+    }
+    initialize() {
+        return Promise.resolve();
+    }
+    get(key) {
+        assertTokenStorageKey(key);
+        return Promise.resolve(this.storage.get(key) ?? null);
+    }
+    set(key, value) {
+        assertTokenStorageKey(key);
+        assertTokenStorageValue(value);
+        this.storage.set(key, value);
+        return Promise.resolve();
+    }
+    delete(key) {
+        assertTokenStorageKey(key);
+        this.storage.delete(key);
+        return Promise.resolve();
+    }
+    list(prefix) {
+        assertTokenStoragePrefix(prefix);
+        const keys = Array.from(this.storage.keys());
+        if (!prefix)
+            return Promise.resolve(keys);
+        return Promise.resolve(keys.filter((k) => k.startsWith(prefix)));
+    }
+    dispose() {
+        this.storage.clear();
+        logger.debug("Disposed");
+    }
+    get size() {
+        return this.storage.size;
+    }
+    clear() {
+        this.storage.clear();
+    }
+}