@mcp-abap-adt/auth-stores 0.1.0

package/dist/stores/abstract/AbstractSafeSessionStore.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Abstract Safe Session Store - base class for in-memory session stores
+ *
+ * Provides common functionality for in-memory session storage.
+ * Subclasses implement type-specific validation and conversion logic.
+ */
+import type { IAuthorizationConfig, IConnectionConfig } from '@mcp-abap-adt/auth-broker';
+import type { IConfig } from '@mcp-abap-adt/auth-broker';
+/**
+ * Abstract base class for safe (in-memory) session stores
+ *
+ * Handles common in-memory operations. Subclasses provide type-specific logic.
+ */
+export declare abstract class AbstractSafeSessionStore {
+    protected sessions: Map<string, unknown>;
+    /**
+     * Load raw session data (internal representation)
+     * Used internally by getAuthorizationConfig, getConnectionConfig, setAuthorizationConfig, setConnectionConfig
+     */
+    protected loadRawSession(destination: string): unknown | null;
+    /**
+     * Load session configuration for destination
+     * Returns optional composition of IAuthorizationConfig and IConnectionConfig
+     * @param destination Destination name (e.g., "TRIAL" or "mcp")
+     * @returns IConfig with actual values or null if not found
+     */
+    loadSession(destination: string): Promise<IConfig | null>;
+    /**
+     * Save session configuration for destination
+     * @param destination Destination name (e.g., "TRIAL" or "mcp")
+     * @param config Session configuration to save (IConfig or internal format)
+     */
+    saveSession(destination: string, config: unknown): Promise<void>;
+    /**
+     * Convert IConfig to internal format (override in subclasses if needed)
+     * @param config IConfig or internal format
+     * @returns Internal format
+     */
+    protected convertToInternalFormat(config: unknown): unknown;
+    /**
+     * Delete session for destination
+     * @param destination Destination name (e.g., "TRIAL" or "mcp")
+     */
+    deleteSession(destination: string): Promise<void>;
+    /**
+     * Clear all sessions
+     */
+    clearAll(): void;
+    /**
+     * Get authorization configuration with actual values (not file paths)
+     * Returns values needed for obtaining and refreshing tokens
+     * Must be implemented by subclasses
+     * @param destination Destination name
+     * @returns IAuthorizationConfig with actual values or null if not found
+     */
+    abstract getAuthorizationConfig(destination: string): Promise<IAuthorizationConfig | null>;
+    /**
+     * Set authorization configuration
+     * Updates values needed for obtaining and refreshing tokens
+     * Must be implemented by subclasses
+     * @param destination Destination name (e.g., "TRIAL" or "mcp")
+     * @param config IAuthorizationConfig with values to set
+     */
+    abstract setAuthorizationConfig(destination: string, config: IAuthorizationConfig): Promise<void>;
+    /**
+     * Validate session configuration (must be implemented by subclasses)
+     * @param config Session configuration to validate
+     * @throws Error if config is invalid for this store type
+     */
+    protected abstract validateSessionConfig(config: unknown): void;
+    /**
+     * Check if session config is valid for this store type (must be implemented by subclasses)
+     * @param config Session configuration to check
+     * @returns true if config is valid for this store type
+     */
+    protected abstract isValidSessionConfig(config: unknown): boolean;
+    /**
+     * Get connection configuration with actual values (must be implemented by subclasses)
+     * @param destination Destination name
+     * @returns IConnectionConfig with actual values or null if not found
+     */
+    abstract getConnectionConfig(destination: string): Promise<IConnectionConfig | null>;
+    /**
+     * Set connection configuration (must be implemented by subclasses)
+     * @param destination Destination name (e.g., "TRIAL" or "mcp")
+     * @param config IConnectionConfig with values to set
+     */
+    abstract setConnectionConfig(destination: string, config: IConnectionConfig): Promise<void>;
+}

package/dist/stores/abstract/AbstractSafeSessionStore.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * Abstract Safe Session Store - base class for in-memory session stores
+ *
+ * Provides common functionality for in-memory session storage.
+ * Subclasses implement type-specific validation and conversion logic.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractSafeSessionStore = void 0;
+/**
+ * Abstract base class for safe (in-memory) session stores
+ *
+ * Handles common in-memory operations. Subclasses provide type-specific logic.
+ */
+class AbstractSafeSessionStore {
+    sessions = new Map();
+    /**
+     * Load raw session data (internal representation)
+     * Used internally by getAuthorizationConfig, getConnectionConfig, setAuthorizationConfig, setConnectionConfig
+     */
+    loadRawSession(destination) {
+        return this.sessions.get(destination) || null;
+    }
+    /**
+     * Load session configuration for destination
+     * Returns optional composition of IAuthorizationConfig and IConnectionConfig
+     * @param destination Destination name (e.g., "TRIAL" or "mcp")
+     * @returns IConfig with actual values or null if not found
+     */
+    async loadSession(destination) {
+        const authConfig = await this.getAuthorizationConfig(destination);
+        const connConfig = await this.getConnectionConfig(destination);
+        // Return null if both are null, otherwise return composition (even if one is null)
+        if (!authConfig && !connConfig) {
+            return null;
+        }
+        return {
+            ...(authConfig || {}),
+            ...(connConfig || {}),
+        };
+    }
+    /**
+     * Save session configuration for destination
+     * @param destination Destination name (e.g., "TRIAL" or "mcp")
+     * @param config Session configuration to save (IConfig or internal format)
+     */
+    async saveSession(destination, config) {
+        this.validateSessionConfig(config);
+        // Convert IConfig to internal format if needed
+        const internalConfig = this.convertToInternalFormat(config);
+        this.sessions.set(destination, internalConfig);
+    }
+    /**
+     * Convert IConfig to internal format (override in subclasses if needed)
+     * @param config IConfig or internal format
+     * @returns Internal format
+     */
+    convertToInternalFormat(config) {
+        // Default: return as-is (subclasses can override)
+        return config;
+    }
+    /**
+     * Delete session for destination
+     * @param destination Destination name (e.g., "TRIAL" or "mcp")
+     */
+    async deleteSession(destination) {
+        this.sessions.delete(destination);
+    }
+    /**
+     * Clear all sessions
+     */
+    clearAll() {
+        this.sessions.clear();
+    }
+}
+exports.AbstractSafeSessionStore = AbstractSafeSessionStore;

package/dist/stores/abstract/AbstractServiceKeyStore.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Abstract Service Key Store - base class for service key stores
+ *
+ * Provides common functionality for file-based service key stores.
+ * Subclasses implement format-specific parsing logic.
+ */
+import type { IServiceKeyStore, IAuthorizationConfig, IConnectionConfig } from '@mcp-abap-adt/auth-broker';
+import type { IConfig } from '@mcp-abap-adt/auth-broker';
+/**
+ * Abstract base class for service key stores
+ *
+ * Handles file I/O operations. Subclasses provide parsing logic.
+ */
+export declare abstract class AbstractServiceKeyStore implements IServiceKeyStore {
+    protected searchPaths: string[];
+    /**
+     * Create a new AbstractServiceKeyStore instance
+     * @param searchPaths Optional search paths for .json files.
+     *                    Can be a single path (string) or array of paths.
+     *                    If not provided, uses AUTH_BROKER_PATH env var or current working directory.
+     */
+    constructor(searchPaths?: string | string[]);
+    /**
+     * Load raw JSON data from file
+     * @param destination Destination name
+     * @returns Raw JSON data or null if file not found
+     */
+    protected loadRawData(destination: string): Promise<any | null>;
+    /**
+     * Parse raw JSON data into service key format
+     * Must be implemented by subclasses
+     * @param rawData Raw JSON data from service key file
+     * @returns Parsed service key object (implementation-specific)
+     * @throws Error if data cannot be parsed or is invalid
+     */
+    protected abstract parse(rawData: unknown): unknown;
+    /**
+     * Get raw parsed service key (internal representation)
+     * Used internally by getAuthorizationConfig and getConnectionConfig
+     */
+    private getRawServiceKey;
+    /**
+     * Get service key for destination
+     * Returns optional composition of IAuthorizationConfig and IConnectionConfig
+     * @param destination Destination name (e.g., "TRIAL" or "mcp")
+     * @returns IConfig with actual values or null if not found
+     */
+    getServiceKey(destination: string): Promise<IConfig | null>;
+    /**
+     * Get authorization configuration from service key
+     * @param destination Destination name (e.g., "TRIAL")
+     * @returns IAuthorizationConfig with actual values or null if not found
+     */
+    getAuthorizationConfig(destination: string): Promise<IAuthorizationConfig | null>;
+    /**
+     * Get connection configuration from service key
+     * @param destination Destination name (e.g., "TRIAL")
+     * @returns IConnectionConfig with actual values or null if not found
+     */
+    getConnectionConfig(destination: string): Promise<IConnectionConfig | null>;
+    /**
+     * Get search paths (for error messages)
+     * @returns Array of search paths
+     */
+    getSearchPaths(): string[];
+}

package/dist/stores/abstract/AbstractServiceKeyStore.js

@@ -0,0 +1,165 @@
+"use strict";
+/**
+ * Abstract Service Key Store - base class for service key stores
+ *
+ * Provides common functionality for file-based service key stores.
+ * Subclasses implement format-specific parsing logic.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractServiceKeyStore = void 0;
+const pathResolver_1 = require("../../utils/pathResolver");
+const fs = __importStar(require("fs"));
+/**
+ * Abstract base class for service key stores
+ *
+ * Handles file I/O operations. Subclasses provide parsing logic.
+ */
+class AbstractServiceKeyStore {
+    searchPaths;
+    /**
+     * Create a new AbstractServiceKeyStore instance
+     * @param searchPaths Optional search paths for .json files.
+     *                    Can be a single path (string) or array of paths.
+     *                    If not provided, uses AUTH_BROKER_PATH env var or current working directory.
+     */
+    constructor(searchPaths) {
+        this.searchPaths = (0, pathResolver_1.resolveSearchPaths)(searchPaths);
+    }
+    /**
+     * Load raw JSON data from file
+     * @param destination Destination name
+     * @returns Raw JSON data or null if file not found
+     */
+    async loadRawData(destination) {
+        const fileName = `${destination}.json`;
+        const serviceKeyPath = (0, pathResolver_1.findFileInPaths)(fileName, this.searchPaths);
+        if (!serviceKeyPath) {
+            return null;
+        }
+        try {
+            const fileContent = fs.readFileSync(serviceKeyPath, 'utf8');
+            return JSON.parse(fileContent);
+        }
+        catch (error) {
+            if (error instanceof SyntaxError) {
+                throw new Error(`Invalid JSON in service key file for destination "${destination}": ${error.message}`);
+            }
+            throw new Error(`Failed to load service key file for destination "${destination}": ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Get raw parsed service key (internal representation)
+     * Used internally by getAuthorizationConfig and getConnectionConfig
+     */
+    async getRawServiceKey(destination) {
+        const rawData = await this.loadRawData(destination);
+        if (!rawData) {
+            return null;
+        }
+        try {
+            return this.parse(rawData);
+        }
+        catch (error) {
+            throw new Error(`Failed to parse service key for destination "${destination}": ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Get service key for destination
+     * Returns optional composition of IAuthorizationConfig and IConnectionConfig
+     * @param destination Destination name (e.g., "TRIAL" or "mcp")
+     * @returns IConfig with actual values or null if not found
+     */
+    async getServiceKey(destination) {
+        const authConfig = await this.getAuthorizationConfig(destination);
+        const connConfig = await this.getConnectionConfig(destination);
+        // Return null if both are null, otherwise return composition (even if one is null)
+        if (!authConfig && !connConfig) {
+            return null;
+        }
+        return {
+            ...(authConfig || {}),
+            ...(connConfig || {}),
+        };
+    }
+    /**
+     * Get authorization configuration from service key
+     * @param destination Destination name (e.g., "TRIAL")
+     * @returns IAuthorizationConfig with actual values or null if not found
+     */
+    async getAuthorizationConfig(destination) {
+        const serviceKey = await this.getRawServiceKey(destination);
+        if (!serviceKey || typeof serviceKey !== 'object') {
+            return null;
+        }
+        const key = serviceKey;
+        if (!key.uaa || !key.uaa.url || !key.uaa.clientid || !key.uaa.clientsecret) {
+            return null;
+        }
+        return {
+            uaaUrl: key.uaa.url,
+            uaaClientId: key.uaa.clientid,
+            uaaClientSecret: key.uaa.clientsecret,
+        };
+    }
+    /**
+     * Get connection configuration from service key
+     * @param destination Destination name (e.g., "TRIAL")
+     * @returns IConnectionConfig with actual values or null if not found
+     */
+    async getConnectionConfig(destination) {
+        const serviceKey = await this.getRawServiceKey(destination);
+        if (!serviceKey || typeof serviceKey !== 'object') {
+            return null;
+        }
+        const key = serviceKey;
+        // Service key doesn't have tokens - only URLs and client info
+        const serviceUrl = key.abap?.url || key.sap_url || (key.url && !key.url.includes('authentication') ? key.url : undefined);
+        return {
+            serviceUrl,
+            authorizationToken: '', // Service key doesn't contain tokens
+            sapClient: key.abap?.client || key.sap_client || key.client,
+            language: key.abap?.language || key.language,
+        };
+    }
+    /**
+     * Get search paths (for error messages)
+     * @returns Array of search paths
+     */
+    getSearchPaths() {
+        return [...this.searchPaths];
+    }
+}
+exports.AbstractServiceKeyStore = AbstractServiceKeyStore;

package/dist/stores/btp/BtpServiceKeyStore.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Base BTP Service key store - reads XSUAA service keys from {destination}.json files
+ *
+ * Uses AbstractServiceKeyStore for file I/O and XsuaaServiceKeyParser for parsing.
+ * Supports direct XSUAA service key format from BTP (without nested uaa object).
+ */
+import type { IServiceKeyStore } from '@mcp-abap-adt/auth-broker';
+import { AbstractServiceKeyStore } from '../abstract/AbstractServiceKeyStore';
+/**
+ * Base BTP Service key store implementation
+ *
+ * Uses AbstractServiceKeyStore for file operations and XsuaaServiceKeyParser for parsing.
+ * Search paths priority:
+ * 1. Constructor parameter (highest)
+ * 2. AUTH_BROKER_PATH environment variable
+ * 3. Current working directory (lowest)
+ */
+export declare class BtpServiceKeyStore extends AbstractServiceKeyStore implements IServiceKeyStore {
+    private parser;
+    /**
+     * Create a new BtpServiceKeyStore instance
+     * @param searchPaths Optional search paths for .json files.
+     *                    Can be a single path (string) or array of paths.
+     *                    If not provided, uses AUTH_BROKER_PATH env var or current working directory.
+     */
+    constructor(searchPaths?: string | string[]);
+    /**
+     * Parse raw JSON data using XsuaaServiceKeyParser
+     * @param rawData Raw JSON data from service key file
+     * @returns Parsed service key object
+     * @throws Error if data cannot be parsed or is invalid
+     */
+    protected parse(rawData: any): unknown;
+}

package/dist/stores/btp/BtpServiceKeyStore.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * Base BTP Service key store - reads XSUAA service keys from {destination}.json files
+ *
+ * Uses AbstractServiceKeyStore for file I/O and XsuaaServiceKeyParser for parsing.
+ * Supports direct XSUAA service key format from BTP (without nested uaa object).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BtpServiceKeyStore = void 0;
+const AbstractServiceKeyStore_1 = require("../abstract/AbstractServiceKeyStore");
+const XsuaaServiceKeyParser_1 = require("../../parsers/xsuaa/XsuaaServiceKeyParser");
+/**
+ * Base BTP Service key store implementation
+ *
+ * Uses AbstractServiceKeyStore for file operations and XsuaaServiceKeyParser for parsing.
+ * Search paths priority:
+ * 1. Constructor parameter (highest)
+ * 2. AUTH_BROKER_PATH environment variable
+ * 3. Current working directory (lowest)
+ */
+class BtpServiceKeyStore extends AbstractServiceKeyStore_1.AbstractServiceKeyStore {
+    parser;
+    /**
+     * Create a new BtpServiceKeyStore instance
+     * @param searchPaths Optional search paths for .json files.
+     *                    Can be a single path (string) or array of paths.
+     *                    If not provided, uses AUTH_BROKER_PATH env var or current working directory.
+     */
+    constructor(searchPaths) {
+        super(searchPaths);
+        this.parser = new XsuaaServiceKeyParser_1.XsuaaServiceKeyParser();
+    }
+    /**
+     * Parse raw JSON data using XsuaaServiceKeyParser
+     * @param rawData Raw JSON data from service key file
+     * @returns Parsed service key object
+     * @throws Error if data cannot be parsed or is invalid
+     */
+    parse(rawData) {
+        return this.parser.parse(rawData);
+    }
+}
+exports.BtpServiceKeyStore = BtpServiceKeyStore;

package/dist/stores/btp/BtpSessionStore.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Base BTP Session Store - stores BTP session data without sapUrl (XSUAA-like)
+ *
+ * This is the base implementation for BTP stores without sapUrl requirement.
+ * Stores to {destination}.env files with XSUAA_* variables.
+ */
+import type { IAuthorizationConfig, IConnectionConfig, ISessionStore } from '@mcp-abap-adt/auth-broker';
+import type { IConfig } from '@mcp-abap-adt/auth-broker';
+import { AbstractJsonSessionStore } from '../abstract/AbstractJsonSessionStore';
+/**
+ * Base BTP Session Store implementation (without sapUrl)
+ *
+ * Stores session data in {destination}.env files using XSUAA_* variables.
+ * Search paths priority:
+ * 1. Constructor parameter (highest)
+ * 2. AUTH_BROKER_PATH environment variable
+ * 3. Current working directory (lowest)
+ */
+export declare class BtpSessionStore extends AbstractJsonSessionStore implements ISessionStore {
+    /**
+     * Get file name for destination
+     * @param destination Destination name
+     * @returns File name (e.g., "mcp.env")
+     */
+    protected getFileName(destination: string): string;
+    /**
+     * Load session from file
+     * @param filePath Path to session file
+     * @returns Parsed BtpBaseSessionData or null if invalid
+     */
+    protected loadFromFile(filePath: string): Promise<unknown | null>;
+    /**
+     * Save session to file
+     * @param filePath Path to session file
+     * @param config Session configuration to save
+     */
+    protected saveToFile(filePath: string, config: unknown): Promise<void>;
+    /**
+     * Load session configuration for destination
+     * Returns optional composition of IAuthorizationConfig and IConnectionConfig
+     * @param destination Destination name
+     * @returns IConfig with actual values or null if not found
+     */
+    loadSession(destination: string): Promise<IConfig | null>;
+    /**
+     * Load raw session data (internal representation)
+     * Used internally for getAuthorizationConfig, getConnectionConfig, setAuthorizationConfig and setConnectionConfig
+     */
+    private loadRawSession;
+    /**
+     * Get authorization configuration with actual values (not file paths)
+     * Returns values needed for obtaining and refreshing tokens
+     * @param destination Destination name
+     * @returns AuthorizationConfig with actual values or null if not found
+     */
+    getAuthorizationConfig(destination: string): Promise<IAuthorizationConfig | null>;
+    /**
+     * Get connection configuration with actual values (not file paths)
+     * Returns values needed for connecting to services
+     * @param destination Destination name
+     * @returns ConnectionConfig with actual values or null if not found
+     * Note: For base BTP, serviceUrl may be undefined (not part of authentication)
+     */
+    getConnectionConfig(destination: string): Promise<IConnectionConfig | null>;
+    /**
+     * Set authorization configuration
+     * Updates values needed for obtaining and refreshing tokens
+     * @param destination Destination name
+     * @param config IAuthorizationConfig with values to set
+     */
+    setAuthorizationConfig(destination: string, config: IAuthorizationConfig): Promise<void>;
+    /**
+     * Set connection configuration
+     * Updates values needed for connecting to services
+     * @param destination Destination name
+     * @param config IConnectionConfig with values to set
+     */
+    setConnectionConfig(destination: string, config: IConnectionConfig): Promise<void>;
+}