keepkey-vault-sdk 1.0.0

package/dist/src/sdk-config.js

@@ -0,0 +1,142 @@
+"use strict";
+/**
+ * Enhanced SDK Configuration with Version Detection
+ *
+ * Extends the generated Configuration with automatic API version detection
+ * and intelligent routing between v1 and v2 APIs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSDKConfigWithVersion = exports.createSDKConfig = exports.SDKConfiguration = void 0;
+const runtime_1 = require("./generated/runtime");
+const version_router_1 = require("./middleware/version-router");
+const version_detector_1 = require("./version-detector");
+class SDKConfiguration extends runtime_1.Configuration {
+    constructor(params = {}) {
+        super(params);
+        this.autoDetectVersion = params.autoDetectVersion !== false; // Default to true
+        this.manualApiVersion = params.apiVersion;
+        this.versionDetector = params.versionDetector || new version_detector_1.VersionDetector(this.basePath);
+    }
+    /**
+     * Initialize version detection.
+     * This is called automatically when needed, but can be called explicitly for early detection.
+     */
+    async initVersionDetection() {
+        // Return cached version if available
+        if (this.apiVersionInfo) {
+            return this.apiVersionInfo;
+        }
+        // Return in-flight promise if detection is already running
+        if (this.versionDetectionPromise) {
+            return this.versionDetectionPromise;
+        }
+        // Start new detection
+        this.versionDetectionPromise = this.performVersionDetection();
+        try {
+            this.apiVersionInfo = await this.versionDetectionPromise;
+            this.versionRouter = new version_router_1.VersionRouter(this.apiVersionInfo);
+            return this.apiVersionInfo;
+        }
+        finally {
+            this.versionDetectionPromise = undefined;
+        }
+    }
+    async performVersionDetection() {
+        // Manual override takes precedence
+        if (this.manualApiVersion) {
+            console.log(`[SDKConfiguration] Using manual API version: ${this.manualApiVersion}`);
+            return {
+                apiVersion: this.manualApiVersion,
+                version: `${this.manualApiVersion}.0.0`,
+                supportedChains: [],
+            };
+        }
+        // Auto-detect if enabled
+        if (this.autoDetectVersion) {
+            console.log('[SDKConfiguration] Auto-detecting API version...');
+            return await this.versionDetector.detectVersion();
+        }
+        // Default to v1 if auto-detection disabled
+        console.log('[SDKConfiguration] Auto-detection disabled, defaulting to v1');
+        return {
+            apiVersion: 1,
+            version: '1.0.0',
+            supportedChains: [],
+        };
+    }
+    /**
+     * Get current API version (may trigger detection if not yet initialized)
+     */
+    async getApiVersion() {
+        if (!this.apiVersionInfo) {
+            await this.initVersionDetection();
+        }
+        return this.apiVersionInfo.apiVersion;
+    }
+    /**
+     * Get full version information (may trigger detection if not yet initialized)
+     */
+    async getVersionInfo() {
+        if (!this.apiVersionInfo) {
+            await this.initVersionDetection();
+        }
+        return this.apiVersionInfo;
+    }
+    /**
+     * Get version router (may trigger detection if not yet initialized)
+     */
+    async getVersionRouter() {
+        if (!this.versionRouter) {
+            await this.initVersionDetection();
+        }
+        return this.versionRouter;
+    }
+    /**
+     * Check if a feature/chain is supported
+     */
+    async isFeatureSupported(feature) {
+        const router = await this.getVersionRouter();
+        return router.isFeatureSupported(feature);
+    }
+    /**
+     * Clear cached version information and force re-detection
+     */
+    clearVersionCache() {
+        this.apiVersionInfo = undefined;
+        this.versionRouter = undefined;
+        this.versionDetectionPromise = undefined;
+        this.versionDetector.clearCache();
+        console.log('[SDKConfiguration] Version cache cleared');
+    }
+    /**
+     * Get synchronous API version (returns undefined if not yet detected)
+     */
+    getApiVersionSync() {
+        return this.apiVersionInfo?.apiVersion;
+    }
+    /**
+     * Check if version detection has completed
+     */
+    isVersionDetected() {
+        return this.apiVersionInfo !== undefined;
+    }
+}
+exports.SDKConfiguration = SDKConfiguration;
+/**
+ * Create an SDK configuration with automatic version detection
+ */
+function createSDKConfig(params = {}) {
+    return new SDKConfiguration(params);
+}
+exports.createSDKConfig = createSDKConfig;
+/**
+ * Create an SDK configuration with manual version override
+ */
+function createSDKConfigWithVersion(apiVersion, params = {}) {
+    return new SDKConfiguration({
+        ...params,
+        apiVersion,
+        autoDetectVersion: false,
+    });
+}
+exports.createSDKConfigWithVersion = createSDKConfigWithVersion;

package/dist/src/spec-loader.d.ts

@@ -0,0 +1,45 @@
+/**
+ * OpenAPI Spec Loader
+ *
+ * Loads the appropriate OpenAPI spec based on detected API version.
+ */
+export interface OpenAPISpec {
+    openapi: string;
+    info: {
+        title: string;
+        version: string;
+        [key: string]: any;
+    };
+    servers: {
+        url: string;
+        [key: string]: any;
+    }[];
+    paths: Record<string, any>;
+    components?: Record<string, any>;
+    [key: string]: any;
+}
+export declare class SpecLoader {
+    /**
+     * Loads the appropriate OpenAPI spec based on detected API version
+     */
+    static loadSpec(apiVersion: number): OpenAPISpec;
+    /**
+     * Gets the base path from the spec
+     */
+    static getBasePath(spec: OpenAPISpec): string;
+    /**
+     * Gets spec version information
+     */
+    static getSpecInfo(apiVersion: number): {
+        title: string;
+        version: string;
+    };
+    /**
+     * Checks if a path exists in the spec
+     */
+    static hasPath(apiVersion: number, path: string): boolean;
+    /**
+     * Gets all paths from the spec
+     */
+    static getPaths(apiVersion: number): string[];
+}

package/dist/src/spec-loader.js

@@ -0,0 +1,60 @@
+"use strict";
+/**
+ * OpenAPI Spec Loader
+ *
+ * Loads the appropriate OpenAPI spec based on detected API version.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpecLoader = void 0;
+const swagger_json_1 = __importDefault(require("../specs/v1/swagger.json"));
+const swagger_json_2 = __importDefault(require("../specs/v2/swagger.json"));
+class SpecLoader {
+    /**
+     * Loads the appropriate OpenAPI spec based on detected API version
+     */
+    static loadSpec(apiVersion) {
+        if (apiVersion === 2) {
+            console.log('[SpecLoader] Loading v2 API spec');
+            return swagger_json_2.default;
+        }
+        console.log('[SpecLoader] Loading v1 API spec');
+        return swagger_json_1.default;
+    }
+    /**
+     * Gets the base path from the spec
+     */
+    static getBasePath(spec) {
+        if (spec.servers && spec.servers.length > 0) {
+            return spec.servers[0].url;
+        }
+        return '/api';
+    }
+    /**
+     * Gets spec version information
+     */
+    static getSpecInfo(apiVersion) {
+        const spec = SpecLoader.loadSpec(apiVersion);
+        return {
+            title: spec.info.title,
+            version: spec.info.version,
+        };
+    }
+    /**
+     * Checks if a path exists in the spec
+     */
+    static hasPath(apiVersion, path) {
+        const spec = SpecLoader.loadSpec(apiVersion);
+        return path in spec.paths;
+    }
+    /**
+     * Gets all paths from the spec
+     */
+    static getPaths(apiVersion) {
+        const spec = SpecLoader.loadSpec(apiVersion);
+        return Object.keys(spec.paths);
+    }
+}
+exports.SpecLoader = SpecLoader;

package/dist/src/version-detector.d.ts

@@ -0,0 +1,34 @@
+/**
+ * API Version Detection
+ *
+ * Detects the API version by calling /api/health endpoint.
+ * Returns version information or defaults to v1 if detection fails.
+ */
+export interface ApiVersionInfo {
+    apiVersion: number;
+    version: string;
+    supportedChains: string[];
+}
+export declare class VersionDetector {
+    private basePath;
+    private cachedVersion;
+    constructor(basePath: string);
+    /**
+     * Detects API version by calling /health endpoint.
+     * Returns version info or defaults to v1 if detection fails.
+     * Results are cached after first successful detection.
+     */
+    detectVersion(): Promise<ApiVersionInfo>;
+    /**
+     * Returns default v1 version info
+     */
+    private defaultToV1;
+    /**
+     * Clears cached version information, forcing re-detection on next call
+     */
+    clearCache(): void;
+    /**
+     * Returns cached version info without performing detection
+     */
+    getCached(): ApiVersionInfo | null;
+}

package/dist/src/version-detector.js

@@ -0,0 +1,83 @@
+"use strict";
+/**
+ * API Version Detection
+ *
+ * Detects the API version by calling /api/health endpoint.
+ * Returns version information or defaults to v1 if detection fails.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersionDetector = void 0;
+class VersionDetector {
+    constructor(basePath) {
+        this.cachedVersion = null;
+        this.basePath = basePath.replace(/\/+$/, ''); // Remove trailing slashes
+    }
+    /**
+     * Detects API version by calling /health endpoint.
+     * Returns version info or defaults to v1 if detection fails.
+     * Results are cached after first successful detection.
+     */
+    async detectVersion() {
+        // Return cached version if available
+        if (this.cachedVersion) {
+            return this.cachedVersion;
+        }
+        try {
+            const response = await fetch(`${this.basePath}/api/health`, {
+                method: 'GET',
+                headers: {
+                    Accept: 'application/json',
+                },
+            });
+            if (!response.ok) {
+                console.warn(`[VersionDetector] Health check failed with status ${response.status}, defaulting to v1`);
+                return this.defaultToV1();
+            }
+            const health = await response.json();
+            // v2 API returns apiVersion field
+            if (health.apiVersion === 2) {
+                this.cachedVersion = {
+                    apiVersion: 2,
+                    version: health.version || '2.0.0',
+                    supportedChains: health.supportedChains || [],
+                };
+                console.log(`[VersionDetector] Detected API v2 (version ${this.cachedVersion.version})`);
+                console.log(`[VersionDetector] Supported chains: ${this.cachedVersion.supportedChains.length}`);
+                return this.cachedVersion;
+            }
+            // v1 API (current) doesn't have apiVersion field
+            console.log('[VersionDetector] Detected API v1 (no apiVersion field in health response)');
+            return this.defaultToV1();
+        }
+        catch (error) {
+            console.warn('[VersionDetector] Version detection failed:', error);
+            console.warn('[VersionDetector] Defaulting to v1');
+            return this.defaultToV1();
+        }
+    }
+    /**
+     * Returns default v1 version info
+     */
+    defaultToV1() {
+        const v1Info = {
+            apiVersion: 1,
+            version: '1.0.0',
+            supportedChains: [],
+        };
+        this.cachedVersion = v1Info;
+        return v1Info;
+    }
+    /**
+     * Clears cached version information, forcing re-detection on next call
+     */
+    clearCache() {
+        this.cachedVersion = null;
+    }
+    /**
+     * Returns cached version info without performing detection
+     */
+    getCached() {
+        return this.cachedVersion;
+    }
+}
+exports.VersionDetector = VersionDetector;