@mcp-abap-adt/connection 0.1.0

package/dist/connection/BaseAbapConnection.d.ts

@@ -0,0 +1,17 @@
+import { SapConfig } from "../config/sapConfig.js";
+import { AbstractAbapConnection } from "./AbstractAbapConnection.js";
+import { ILogger, ISessionStorage } from "../logger.js";
+/**
+ * Basic Authentication connection for on-premise SAP systems
+ */
+export declare class BaseAbapConnection extends AbstractAbapConnection {
+    constructor(config: SapConfig, logger: ILogger, sessionStorage?: ISessionStorage, sessionId?: string);
+    /**
+     * Connect to SAP system with Basic Auth
+     * Fetches CSRF token which also establishes session cookies
+     */
+    connect(): Promise<void>;
+    protected buildAuthorizationHeader(): string;
+    private static validateConfig;
+}
+//# sourceMappingURL=BaseAbapConnection.d.ts.map

package/dist/connection/BaseAbapConnection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseAbapConnection.d.ts","sourceRoot":"","sources":["../../src/connection/BaseAbapConnection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAGxD;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,sBAAsB;gBAE1D,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,OAAO,EACf,cAAc,CAAC,EAAE,eAAe,EAChC,SAAS,CAAC,EAAE,MAAM;IAMpB;;;OAGG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAoC9B,SAAS,CAAC,wBAAwB,IAAI,MAAM;IAQ5C,OAAO,CAAC,MAAM,CAAC,cAAc;CAa9B"}

package/dist/connection/BaseAbapConnection.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseAbapConnection = void 0;
+const AbstractAbapConnection_js_1 = require("./AbstractAbapConnection.js");
+const axios_1 = require("axios");
+/**
+ * Basic Authentication connection for on-premise SAP systems
+ */
+class BaseAbapConnection extends AbstractAbapConnection_js_1.AbstractAbapConnection {
+    constructor(config, logger, sessionStorage, sessionId) {
+        BaseAbapConnection.validateConfig(config);
+        super(config, logger, sessionStorage, sessionId);
+    }
+    /**
+     * Connect to SAP system with Basic Auth
+     * Fetches CSRF token which also establishes session cookies
+     */
+    async connect() {
+        const baseUrl = await this.getBaseUrl();
+        const discoveryUrl = `${baseUrl}/sap/bc/adt/discovery`;
+        this.logger.debug(`[DEBUG] BaseAbapConnection - Connecting to SAP system: ${discoveryUrl}`);
+        try {
+            // Try to get CSRF token (this will also get cookies)
+            const token = await this.fetchCsrfToken(discoveryUrl, 3, 1000);
+            this.setCsrfToken(token);
+            // Save session state after successful connection
+            await this.saveSessionState();
+            this.logger.debug("Successfully connected to SAP system", {
+                hasCsrfToken: !!this.getCsrfToken(),
+                hasCookies: !!this.getCookies(),
+                cookieLength: this.getCookies()?.length || 0
+            });
+        }
+        catch (error) {
+            // For Basic auth, log warning but don't fail
+            // The retry logic in makeAdtRequest will handle transient errors automatically
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            this.logger.warn(`[WARN] BaseAbapConnection - Could not connect to SAP system upfront: ${errorMsg}. Will retry on first request.`);
+            // Still try to extract cookies from error response if available
+            if (error instanceof axios_1.AxiosError && error.response?.headers) {
+                // updateCookiesFromResponse is private, but cookies are extracted in fetchCsrfToken
+                if (this.getCookies()) {
+                    this.logger.debug(`[DEBUG] BaseAbapConnection - Cookies extracted from error response during connect (first 100 chars): ${this.getCookies().substring(0, 100)}...`);
+                    await this.saveSessionState();
+                }
+            }
+        }
+    }
+    buildAuthorizationHeader() {
+        const { username, password } = this.getConfig();
+        const safeUsername = username ?? "";
+        const safePassword = password ?? "";
+        const token = Buffer.from(`${safeUsername}:${safePassword}`).toString("base64");
+        return `Basic ${token}`;
+    }
+    static validateConfig(config) {
+        if (config.authType !== "basic") {
+            throw new Error(`Basic authentication connection expects authType "basic", got "${config.authType}"`);
+        }
+        if (!config.username || !config.password) {
+            throw new Error("Basic authentication requires both username and password");
+        }
+        if (!config.client) {
+            throw new Error("Basic authentication requires SAP_CLIENT to be provided");
+        }
+    }
+}
+exports.BaseAbapConnection = BaseAbapConnection;

package/dist/connection/JwtAbapConnection.d.ts

@@ -0,0 +1,33 @@
+import { SapConfig } from "../config/sapConfig.js";
+import { AbstractAbapConnection } from "./AbstractAbapConnection.js";
+import { AbapRequestOptions } from "./AbapConnection.js";
+import { ILogger, ISessionStorage } from "../logger.js";
+import { AxiosResponse } from "axios";
+/**
+ * JWT Authentication connection for SAP BTP Cloud systems
+ * Supports automatic token refresh using OAuth2 refresh tokens
+ */
+export declare class JwtAbapConnection extends AbstractAbapConnection {
+    private tokenRefreshInProgress;
+    constructor(config: SapConfig, logger: ILogger, sessionStorage?: ISessionStorage, sessionId?: string);
+    protected buildAuthorizationHeader(): string;
+    /**
+     * Refresh JWT token using refresh token
+     * @returns Promise that resolves when token is refreshed
+     */
+    refreshToken(): Promise<void>;
+    /**
+     * Check if token refresh is possible
+     */
+    canRefreshToken(): boolean;
+    /**
+     * Override connect to handle JWT token refresh on errors
+     */
+    connect(): Promise<void>;
+    /**
+     * Override makeAdtRequest to handle JWT token refresh on 401/403
+     */
+    makeAdtRequest(options: AbapRequestOptions): Promise<AxiosResponse>;
+    private static validateConfig;
+}
+//# sourceMappingURL=JwtAbapConnection.d.ts.map

package/dist/connection/JwtAbapConnection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JwtAbapConnection.d.ts","sourceRoot":"","sources":["../../src/connection/JwtAbapConnection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,EAAE,OAAO,EAAE,eAAe,EAAgB,MAAM,cAAc,CAAC;AAEtE,OAAO,EAAc,aAAa,EAAE,MAAM,OAAO,CAAC;AAElD;;;GAGG;AACH,qBAAa,iBAAkB,SAAQ,sBAAsB;IAC3D,OAAO,CAAC,sBAAsB,CAAkB;gBAG9C,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,OAAO,EACf,cAAc,CAAC,EAAE,eAAe,EAChC,SAAS,CAAC,EAAE,MAAM;IAMpB,SAAS,CAAC,wBAAwB,IAAI,MAAM;IAS5C;;;OAGG;IACG,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IA6EnC;;OAEG;IACH,eAAe,IAAI,OAAO;IAU1B;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IA2G9B;;OAEG;IACG,cAAc,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,aAAa,CAAC;IAgGzE,OAAO,CAAC,MAAM,CAAC,cAAc;CAS9B"}

package/dist/connection/JwtAbapConnection.js

@@ -0,0 +1,305 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JwtAbapConnection = void 0;
+const AbstractAbapConnection_js_1 = require("./AbstractAbapConnection.js");
+const tokenRefresh_js_1 = require("../utils/tokenRefresh.js");
+const axios_1 = require("axios");
+/**
+ * JWT Authentication connection for SAP BTP Cloud systems
+ * Supports automatic token refresh using OAuth2 refresh tokens
+ */
+class JwtAbapConnection extends AbstractAbapConnection_js_1.AbstractAbapConnection {
+    tokenRefreshInProgress = false;
+    constructor(config, logger, sessionStorage, sessionId) {
+        JwtAbapConnection.validateConfig(config);
+        super(config, logger, sessionStorage, sessionId);
+    }
+    buildAuthorizationHeader() {
+        const config = this.getConfig();
+        const { jwtToken } = config;
+        // Log token preview for debugging (first 10 and last 4 chars)
+        const tokenPreview = jwtToken ? `${jwtToken.substring(0, 10)}...${jwtToken.substring(Math.max(0, jwtToken.length - 4))}` : 'null';
+        this.logger.debug(`[DEBUG] JwtAbapConnection.buildAuthorizationHeader - Using token: ${tokenPreview}`);
+        return `Bearer ${jwtToken}`;
+    }
+    /**
+     * Refresh JWT token using refresh token
+     * @returns Promise that resolves when token is refreshed
+     */
+    async refreshToken() {
+        const config = this.getConfig();
+        if (!config.refreshToken) {
+            throw new Error("Refresh token is not available. Please re-authenticate.");
+        }
+        if (!config.uaaUrl || !config.uaaClientId || !config.uaaClientSecret) {
+            throw new Error("UAA credentials are not available for token refresh. " +
+                "Please provide UAA_URL, UAA_CLIENT_ID, and UAA_CLIENT_SECRET in configuration or re-authenticate.");
+        }
+        // Prevent concurrent refresh attempts
+        if (this.tokenRefreshInProgress) {
+            this.logger.debug("Token refresh already in progress, waiting...");
+            // Wait for ongoing refresh to complete
+            while (this.tokenRefreshInProgress) {
+                await new Promise(resolve => setTimeout(resolve, 100));
+            }
+            return;
+        }
+        this.tokenRefreshInProgress = true;
+        try {
+            this.logger.debug("Refreshing JWT token...");
+            const tokens = await (0, tokenRefresh_js_1.refreshJwtToken)(config.refreshToken, config.uaaUrl, config.uaaClientId, config.uaaClientSecret);
+            // Update config with new tokens
+            // NOTE: This updates the config object directly, which is shared with the connection cache
+            // The connection cache will be invalidated on next getManagedConnection() call because
+            // sapConfigSignature includes token preview, so signature will change
+            const oldTokenPreview = config.jwtToken ? `${config.jwtToken.substring(0, 10)}...${config.jwtToken.substring(Math.max(0, config.jwtToken.length - 4))}` : 'null';
+            config.jwtToken = tokens.accessToken;
+            if (tokens.refreshToken) {
+                config.refreshToken = tokens.refreshToken;
+            }
+            const newTokenPreview = config.jwtToken ? `${config.jwtToken.substring(0, 10)}...${config.jwtToken.substring(Math.max(0, config.jwtToken.length - 4))}` : 'null';
+            this.logger.debug(`[DEBUG] JwtAbapConnection.refreshToken - Token updated in config: ${oldTokenPreview} -> ${newTokenPreview}`);
+            this.logger.debug(`[DEBUG] JwtAbapConnection.refreshToken - Config object reference check: ${config === this.getConfig() ? 'same object ✓' : 'different object ✗'}`);
+            // Clear CSRF token and cookies to force new session with new token
+            // IMPORTANT: After token refresh, we must clear saved session state because
+            // old cookies/CSRF token are tied to the old JWT token and won't work with new token
+            this.reset();
+            // Also clear saved session state from storage if using stateful session
+            // This prevents reloading old cookies/CSRF token that are tied to old JWT token
+            const sessionStorage = this.getSessionStorage();
+            const sessionId = this.getSessionId();
+            if (sessionStorage && sessionId) {
+                try {
+                    await this.clearSessionState();
+                    this.logger.debug(`[DEBUG] JwtAbapConnection.refreshToken - Cleared saved session state from storage`);
+                }
+                catch (error) {
+                    this.logger.warn(`[DEBUG] JwtAbapConnection.refreshToken - Failed to clear session state: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+            this.logger.debug("JWT token refreshed successfully");
+            this.logger.debug("NOTE: Connection cache will be invalidated on next getManagedConnection() call due to changed token signature");
+        }
+        catch (error) {
+            this.logger.error(`Failed to refresh JWT token: ${error.message}`);
+            throw error;
+        }
+        finally {
+            this.tokenRefreshInProgress = false;
+        }
+    }
+    /**
+     * Check if token refresh is possible
+     */
+    canRefreshToken() {
+        const config = this.getConfig();
+        return !!(config.refreshToken &&
+            config.uaaUrl &&
+            config.uaaClientId &&
+            config.uaaClientSecret);
+    }
+    /**
+     * Override connect to handle JWT token refresh on errors
+     */
+    async connect() {
+        const baseUrl = await this.getBaseUrl();
+        const discoveryUrl = `${baseUrl}/sap/bc/adt/discovery`;
+        this.logger.debug(`[DEBUG] JwtAbapConnection - Connecting to SAP system: ${discoveryUrl}`);
+        // If we have saved session state, load it first to compare later
+        const sessionStorage = this.getSessionStorage();
+        const sessionId = this.getSessionId();
+        let savedState = null;
+        if (sessionStorage && sessionId) {
+            try {
+                savedState = await sessionStorage.load(sessionId);
+                if (savedState) {
+                    this.logger.debug(`[DEBUG] JwtAbapConnection.connect - Loaded saved session state for comparison`);
+                }
+            }
+            catch (error) {
+                this.logger.debug(`[DEBUG] JwtAbapConnection.connect - No saved session state found or failed to load`);
+            }
+        }
+        try {
+            // Try to get CSRF token (this will also get cookies)
+            const token = await this.fetchCsrfToken(discoveryUrl, 3, 1000);
+            this.setCsrfToken(token);
+            // Compare new session state with saved state
+            const newState = {
+                cookies: this.getCookies(),
+                csrfToken: this.getCsrfToken(),
+                cookieStore: Object.fromEntries(this.cookieStore || new Map())
+            };
+            // Only save if session state changed
+            if (savedState) {
+                const cookiesChanged = savedState.cookies !== newState.cookies;
+                const csrfTokenChanged = savedState.csrfToken !== newState.csrfToken;
+                const cookieStoreChanged = JSON.stringify(savedState.cookieStore) !== JSON.stringify(newState.cookieStore);
+                if (cookiesChanged || csrfTokenChanged || cookieStoreChanged) {
+                    this.logger.debug(`[DEBUG] JwtAbapConnection.connect - Session state changed, saving new state`, {
+                        cookiesChanged,
+                        csrfTokenChanged,
+                        cookieStoreChanged
+                    });
+                    await this.saveSessionState();
+                }
+                else {
+                    this.logger.debug(`[DEBUG] JwtAbapConnection.connect - Session state unchanged, not saving`);
+                }
+            }
+            else {
+                // No saved state, save new one
+                await this.saveSessionState();
+            }
+            this.logger.debug("Successfully connected to SAP system", {
+                hasCsrfToken: !!this.getCsrfToken(),
+                hasCookies: !!this.getCookies(),
+                cookieLength: this.getCookies()?.length || 0
+            });
+        }
+        catch (error) {
+            // Handle JWT auth errors (401/403) during connect
+            if (error instanceof axios_1.AxiosError &&
+                (error.response?.status === 401 || error.response?.status === 403)) {
+                // Check if this is really an auth error, not a permissions error
+                const responseData = error.response?.data;
+                const responseText = typeof responseData === "string" ? responseData : JSON.stringify(responseData || "");
+                // Don't retry on "No Access" errors
+                if (responseText.includes("ExceptionResourceNoAccess") ||
+                    responseText.includes("No authorization") ||
+                    responseText.includes("Missing authorization")) {
+                    throw error;
+                }
+                // Try token refresh if possible
+                if (this.canRefreshToken()) {
+                    try {
+                        this.logger.debug(`Received ${error.response.status} during connect, attempting JWT token refresh...`);
+                        await this.refreshToken();
+                        this.logger.debug(`✓ Token refreshed successfully, retrying connect...`);
+                        // Retry CSRF token fetch with new JWT token
+                        const token = await this.fetchCsrfToken(discoveryUrl, 3, 1000);
+                        this.setCsrfToken(token);
+                        await this.saveSessionState();
+                        this.logger.debug("Successfully connected after JWT refresh", {
+                            hasCsrfToken: !!this.getCsrfToken(),
+                            hasCookies: !!this.getCookies()
+                        });
+                        return;
+                    }
+                    catch (refreshError) {
+                        this.logger.error(`❌ Token refresh failed during connect: ${refreshError.message}`);
+                        throw new Error("JWT token has expired and refresh failed. Please re-authenticate.");
+                    }
+                }
+                else {
+                    throw new Error("JWT token has expired. Please refresh your authentication token.");
+                }
+            }
+            // Re-throw other errors
+            throw error;
+        }
+    }
+    /**
+     * Override makeAdtRequest to handle JWT token refresh on 401/403
+     */
+    async makeAdtRequest(options) {
+        this.logger.debug(`[DEBUG] JwtAbapConnection.makeAdtRequest - Starting request: ${options.method} ${options.url}`);
+        try {
+            const response = await super.makeAdtRequest(options);
+            this.logger.debug(`[DEBUG] JwtAbapConnection.makeAdtRequest - Request succeeded: ${response.status}`);
+            return response;
+        }
+        catch (error) {
+            this.logger.debug(`[DEBUG] JwtAbapConnection.makeAdtRequest - Request failed: ${error instanceof Error ? error.message : String(error)}`);
+            // Handle JWT auth errors (401/403)
+            if (error instanceof axios_1.AxiosError &&
+                (error.response?.status === 401 || error.response?.status === 403)) {
+                this.logger.debug(`[DEBUG] JwtAbapConnection.makeAdtRequest - Got ${error.response.status}, checking if refresh is possible...`);
+                // Check if this is really an auth error, not a permissions error
+                const responseData = error.response?.data;
+                const responseText = typeof responseData === "string" ? responseData : JSON.stringify(responseData || "");
+                // Don't retry on "No Access" errors - these are permission issues, not auth issues
+                if (responseText.includes("ExceptionResourceNoAccess") ||
+                    responseText.includes("No authorization") ||
+                    responseText.includes("Missing authorization")) {
+                    throw error;
+                }
+                // Try token refresh if possible
+                const canRefresh = this.canRefreshToken();
+                const config = this.getConfig();
+                this.logger.debug(`[DEBUG] JwtAbapConnection.makeAdtRequest - canRefreshToken: ${canRefresh}`, {
+                    hasRefreshToken: !!config.refreshToken,
+                    hasUaaUrl: !!config.uaaUrl,
+                    hasUaaClientId: !!config.uaaClientId,
+                    hasUaaClientSecret: !!config.uaaClientSecret
+                });
+                if (canRefresh) {
+                    // Step 1: Refresh token
+                    try {
+                        this.logger.debug(`Received ${error.response.status}, attempting JWT token refresh...`);
+                        await this.refreshToken();
+                        this.logger.debug(`✓ Token refreshed successfully, reconnecting to get new CSRF token...`);
+                    }
+                    catch (refreshError) {
+                        // Only catch errors from refreshToken()
+                        this.logger.error(`❌ Token refresh failed: ${refreshError.message}`);
+                        throw new Error("JWT token has expired and refresh failed. Please re-authenticate.");
+                    }
+                    // Step 2: Reconnect to get new CSRF token and cookies
+                    try {
+                        this.logger.debug(`[DEBUG] JwtAbapConnection - Calling connect() after token refresh to get CSRF token...`);
+                        await this.connect();
+                        const hasCsrf = !!this.getCsrfToken();
+                        const hasCookies = !!this.getCookies();
+                        this.logger.debug(`✓ Reconnected successfully after token refresh`, {
+                            hasCsrfToken: hasCsrf,
+                            hasCookies: hasCookies,
+                            csrfTokenLength: this.getCsrfToken()?.length || 0,
+                            cookiesLength: this.getCookies()?.length || 0
+                        });
+                        if (!hasCsrf) {
+                            this.logger.error(`❌ CRITICAL: CSRF token not obtained after reconnect! Request may fail.`);
+                        }
+                    }
+                    catch (connectError) {
+                        this.logger.error(`❌ Failed to reconnect after token refresh: ${connectError.message}`);
+                        this.logger.error(`❌ This means CSRF token will not be available for POST/PUT/DELETE requests`);
+                        // Continue anyway - ensureFreshCsrfToken will try to get CSRF token during request retry
+                        // But this is likely to fail if connect() failed
+                    }
+                    // Step 3: Retry the request with new token
+                    // ensureFreshCsrfToken will be called automatically if CSRF token is missing
+                    this.logger.debug(`[DEBUG] JwtAbapConnection - Retrying ADT request after token refresh...`);
+                    try {
+                        return await super.makeAdtRequest(options);
+                    }
+                    catch (retryError) {
+                        // If retry fails with 401/403, it means token refresh didn't help - re-throw as auth error
+                        if (retryError instanceof axios_1.AxiosError &&
+                            (retryError.response?.status === 401 || retryError.response?.status === 403)) {
+                            this.logger.error(`❌ Token refresh didn't help - still getting ${retryError.response.status}`);
+                            throw new Error("JWT token has expired and refresh failed. Please re-authenticate.");
+                        }
+                        // For other errors (400, 500, etc.), re-throw the original error
+                        // These are not auth errors, so they should be handled by the caller
+                        this.logger.debug(`[DEBUG] JwtAbapConnection - Retry request failed with non-auth error: ${retryError.response?.status || 'unknown'}`);
+                        throw retryError;
+                    }
+                }
+                else {
+                    throw new Error("JWT token has expired. Please refresh your authentication token.");
+                }
+            }
+            throw error;
+        }
+    }
+    static validateConfig(config) {
+        if (config.authType !== "jwt") {
+            throw new Error(`JWT connection expects authType "jwt", got "${config.authType}"`);
+        }
+        if (!config.jwtToken) {
+            throw new Error("JWT authentication requires SAP_JWT_TOKEN to be provided");
+        }
+    }
+}
+exports.JwtAbapConnection = JwtAbapConnection;

package/dist/connection/connectionFactory.d.ts

@@ -0,0 +1,5 @@
+import { SapConfig } from "../config/sapConfig.js";
+import { AbapConnection } from "./AbapConnection.js";
+import { ILogger, ISessionStorage } from "../logger.js";
+export declare function createAbapConnection(config: SapConfig, logger: ILogger, sessionStorage?: ISessionStorage, sessionId?: string): AbapConnection;
+//# sourceMappingURL=connectionFactory.d.ts.map

package/dist/connection/connectionFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connectionFactory.d.ts","sourceRoot":"","sources":["../../src/connection/connectionFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAGrD,OAAO,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAExD,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,OAAO,EACf,cAAc,CAAC,EAAE,eAAe,EAChC,SAAS,CAAC,EAAE,MAAM,GACjB,cAAc,CAShB"}

package/dist/connection/connectionFactory.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAbapConnection = createAbapConnection;
+const JwtAbapConnection_js_1 = require("./JwtAbapConnection.js");
+const BaseAbapConnection_js_1 = require("./BaseAbapConnection.js");
+function createAbapConnection(config, logger, sessionStorage, sessionId) {
+    switch (config.authType) {
+        case "basic":
+            return new BaseAbapConnection_js_1.BaseAbapConnection(config, logger, sessionStorage, sessionId);
+        case "jwt":
+            return new JwtAbapConnection_js_1.JwtAbapConnection(config, logger, sessionStorage, sessionId);
+        default:
+            throw new Error(`Unsupported SAP authentication type: ${config.authType}`);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export type { SapConfig, SapAuthType, } from "./config/sapConfig.js";
+export type { AbapRequestOptions } from "./connection/AbapConnection.js";
+export { type AbapConnection } from "./connection/AbapConnection.js";
+export type { ILogger, SessionState, ISessionStorage } from "./logger.js";
+export { FileSessionStorage, type FileSessionStorageOptions } from "./utils/FileSessionStorage.js";
+export { BaseAbapConnection } from "./connection/BaseAbapConnection.js";
+export { JwtAbapConnection } from "./connection/JwtAbapConnection.js";
+export { BaseAbapConnection as OnPremAbapConnection } from "./connection/BaseAbapConnection.js";
+export { JwtAbapConnection as CloudAbapConnection } from "./connection/JwtAbapConnection.js";
+export { createAbapConnection } from "./connection/connectionFactory.js";
+export { sapConfigSignature, getConfigFromEnv, loadEnvFile, loadConfigFromEnvFile } from "./config/sapConfig.js";
+export { getTimeout, getTimeoutConfig, type TimeoutConfig } from "./utils/timeouts.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,YAAY,EACV,SAAS,EACT,WAAW,GACZ,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAGzE,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,gCAAgC,CAAC;AACrE,YAAY,EAAE,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAG1E,OAAO,EAAE,kBAAkB,EAAE,KAAK,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAGnG,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AACxE,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAGtE,OAAO,EAAE,kBAAkB,IAAI,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAChG,OAAO,EAAE,iBAAiB,IAAI,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AAG7F,OAAO,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AAGzE,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAGjH,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,KAAK,aAAa,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/index.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTimeoutConfig = exports.getTimeout = exports.loadConfigFromEnvFile = exports.loadEnvFile = exports.getConfigFromEnv = exports.sapConfigSignature = exports.createAbapConnection = exports.CloudAbapConnection = exports.OnPremAbapConnection = exports.JwtAbapConnection = exports.BaseAbapConnection = exports.FileSessionStorage = void 0;
+// Session storage implementations
+var FileSessionStorage_js_1 = require("./utils/FileSessionStorage.js");
+Object.defineProperty(exports, "FileSessionStorage", { enumerable: true, get: function () { return FileSessionStorage_js_1.FileSessionStorage; } });
+// Connection classes - only final implementations
+var BaseAbapConnection_js_1 = require("./connection/BaseAbapConnection.js");
+Object.defineProperty(exports, "BaseAbapConnection", { enumerable: true, get: function () { return BaseAbapConnection_js_1.BaseAbapConnection; } });
+var JwtAbapConnection_js_1 = require("./connection/JwtAbapConnection.js");
+Object.defineProperty(exports, "JwtAbapConnection", { enumerable: true, get: function () { return JwtAbapConnection_js_1.JwtAbapConnection; } });
+// Deprecated aliases for backward compatibility
+var BaseAbapConnection_js_2 = require("./connection/BaseAbapConnection.js");
+Object.defineProperty(exports, "OnPremAbapConnection", { enumerable: true, get: function () { return BaseAbapConnection_js_2.BaseAbapConnection; } });
+var JwtAbapConnection_js_2 = require("./connection/JwtAbapConnection.js");
+Object.defineProperty(exports, "CloudAbapConnection", { enumerable: true, get: function () { return JwtAbapConnection_js_2.JwtAbapConnection; } });
+// Factory
+var connectionFactory_js_1 = require("./connection/connectionFactory.js");
+Object.defineProperty(exports, "createAbapConnection", { enumerable: true, get: function () { return connectionFactory_js_1.createAbapConnection; } });
+// Config utilities
+var sapConfig_js_1 = require("./config/sapConfig.js");
+Object.defineProperty(exports, "sapConfigSignature", { enumerable: true, get: function () { return sapConfig_js_1.sapConfigSignature; } });
+Object.defineProperty(exports, "getConfigFromEnv", { enumerable: true, get: function () { return sapConfig_js_1.getConfigFromEnv; } });
+Object.defineProperty(exports, "loadEnvFile", { enumerable: true, get: function () { return sapConfig_js_1.loadEnvFile; } });
+Object.defineProperty(exports, "loadConfigFromEnvFile", { enumerable: true, get: function () { return sapConfig_js_1.loadConfigFromEnvFile; } });
+// Timeouts
+var timeouts_js_1 = require("./utils/timeouts.js");
+Object.defineProperty(exports, "getTimeout", { enumerable: true, get: function () { return timeouts_js_1.getTimeout; } });
+Object.defineProperty(exports, "getTimeoutConfig", { enumerable: true, get: function () { return timeouts_js_1.getTimeoutConfig; } });

package/dist/logger.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Logger interface for connection layer
+ * Allows connection layer to be independent of specific logger implementation
+ */
+export interface ILogger {
+    /**
+     * Log informational message
+     */
+    info(message: string, meta?: any): void;
+    /**
+     * Log error message
+     */
+    error(message: string, meta?: any): void;
+    /**
+     * Log warning message
+     */
+    warn(message: string, meta?: any): void;
+    /**
+     * Log debug message
+     */
+    debug(message: string, meta?: any): void;
+    /**
+     * Log CSRF token operations
+     * @param action - Type of CSRF operation: "fetch", "retry", "success", or "error"
+     * @param message - Log message
+     * @param meta - Additional metadata
+     */
+    csrfToken?(action: "fetch" | "retry" | "success" | "error", message: string, meta?: any): void;
+    /**
+     * Log TLS configuration
+     * @param rejectUnauthorized - Whether TLS certificate validation is enabled
+     */
+    tlsConfig?(rejectUnauthorized: boolean): void;
+}
+/**
+ * Session state interface for stateful connections
+ * Contains cookies and CSRF token that need to be preserved across requests
+ */
+export interface SessionState {
+    cookies: string | null;
+    csrfToken: string | null;
+    cookieStore: Record<string, string>;
+}
+/**
+ * Interface for storing and retrieving session state
+ * Allows connection layer to persist session state (cookies, CSRF token) externally
+ */
+export interface ISessionStorage {
+    /**
+     * Save session state for a given session ID
+     * @param sessionId - Unique session identifier
+     * @param state - Session state to save
+     */
+    save(sessionId: string, state: SessionState): Promise<void>;
+    /**
+     * Load session state for a given session ID
+     * @param sessionId - Unique session identifier
+     * @returns Session state or null if not found
+     */
+    load(sessionId: string): Promise<SessionState | null>;
+    /**
+     * Delete session state for a given session ID
+     * @param sessionId - Unique session identifier
+     */
+    delete(sessionId: string): Promise<void>;
+}
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,OAAO;IACtB;;OAEG;IACH,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI,CAAC;IAExC;;OAEG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI,CAAC;IAEzC;;OAEG;IACH,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI,CAAC;IAExC;;OAEG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI,CAAC;IAEzC;;;;;OAKG;IACH,SAAS,CAAC,CACR,MAAM,EAAE,OAAO,GAAG,OAAO,GAAG,SAAS,GAAG,OAAO,EAC/C,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,GAAG,GACT,IAAI,CAAC;IAER;;;OAGG;IACH,SAAS,CAAC,CAAC,kBAAkB,EAAE,OAAO,GAAG,IAAI,CAAC;CAC/C;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACrC;AAED;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE5D;;;;OAIG;IACH,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAAC;IAEtD;;;OAGG;IACH,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1C"}

package/dist/logger.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });