@mcp-abap-adt/connection 2.0.0 → 4.0.0

package/dist/connection/AbstractAbapConnection.js

@@ -197,22 +197,27 @@ class AbstractAbapConnection {
         });
     }
     /**
-     * Tears the session down. Never throws: the report says what did not finish
-     * rather than failing. Sends no ADT session-close — see the design's D2.
+     * Tears the session down. Never throws, and always settles.
+     *
+     * It waits for NOTHING. Deciding when to disconnect is the caller's, and so is
+     * preparing for it — finishing chains, releasing locks. Waiting here on a
+     * request whose caller chose no timeout is what made a teardown unbounded, and
+     * an unbounded teardown blocks every later transition on the serialized tail.
+     *
+     * Requests already in flight run to completion untouched. Generation fencing
+     * (see `SessionLifecycle.isCurrent`) keeps their results from reaching this
+     * connection afterwards.
+     *
+     * Sends no ADT session-close — see the design's D2.
      */
     async disconnect() {
+        // Synchronous, at the call: admission shuts and the generation moves before
+        // anything is queued, so a caller who has asked to disconnect cannot have
+        // requests still going through while this waits its turn.
         this.lifecycle.beginTeardown({ origin: 'caller', sessionLost: false });
-        // The report travels THROUGH the transition, so a joining caller gets the
-        // same one. Building it outside would leave every caller but the first
-        // reporting an empty teardown — the abandoned locks reported to nobody.
-        return this.lifecycle.transition('disconnect', async () => {
-            const drained = await this.lifecycle.drain();
+        await this.lifecycle.transition('disconnect', async () => {
             this.clearSessionState();
             this.lifecycle.markDisconnected();
-            return {
-                abandonedWindows: drained.abandonedWindows,
-                releasePending: false,
-            };
         });
     }
     isConnected() {
@@ -231,13 +236,6 @@ class AbstractAbapConnection {
     getSessionIdentity() {
         return this.lifecycle.identity;
     }
-    /** Opens a lock window. See the design: a lock outlives its request. */
-    beginWindow(label) {
-        return this.lifecycle.beginWindow(label);
-    }
-    endWindow(token) {
-        this.lifecycle.endWindow(token);
-    }
     /**
      * Discards the session at a caller's request: cancels queued recoveries and
      * queues the cleanup rather than tearing down under a live request.
@@ -245,7 +243,6 @@ class AbstractAbapConnection {
     reset() {
         this.lifecycle.beginTeardown({ origin: 'caller', sessionLost: true });
         void this.lifecycle.transition('cleanup', async () => {
-            await this.lifecycle.drain();
             this.clearSessionState();
             this.lifecycle.markDisconnected();
         });
@@ -285,6 +282,12 @@ class AbstractAbapConnection {
         if (this.lifecycle.teardownEpoch !== baselineEpoch) {
             throw (0, SessionLifecycle_js_1.sessionError)(interfaces_1.ADT_SESSION_ERROR.NOT_CONNECTED, 'Establishment abandoned: a teardown was requested for this connection');
         }
+        // Whatever session arrives from here is one we are deliberately
+        // establishing, so it must not read as a replacement: the identity policy
+        // treats a changed fingerprint as fatal, and it cannot tell our own
+        // re-establishment from a session taken out from under us. Forgetting first
+        // makes the new fingerprint `established`, which is what it is.
+        this.lifecycle.forgetIdentity();
         try {
             await this.establishSession();
         }
@@ -342,14 +345,13 @@ class AbstractAbapConnection {
      * immediately — a later comparison must see the change, and on a dead session
      * the cookie is unchanged, so only the state can tell.
      *
-     * Does not await: it is called from inside a request, and the queued cleanup
-     * drains that very request.
+     * Does not await: it is called from inside a request, and the cleanup must not
+     * wait for the very request that raised it.
      */
     raiseSessionLost(reason) {
         this.logger?.warn(`Session lost: ${reason}`);
         this.lifecycle.beginTeardown({ origin: 'internal', sessionLost: true });
         void this.lifecycle.transition('cleanup', async () => {
-            await this.lifecycle.drain();
             this.clearSessionState();
             this.lifecycle.markDisconnected();
         });
@@ -381,27 +383,44 @@ class AbstractAbapConnection {
      * later check reads `unchanged`. That is one call site forgetting, and it
      * happened — on the error path and on every retry response.
      */
-    observeResponse(headers) {
+    observeResponse(headers, generation) {
+        // Fenced by SESSION GENERATION, not by the teardown epoch. Only a
+        // caller-initiated teardown moves the epoch — a recovery deliberately does
+        // not — so after a session loss and a successful recovery, a request from
+        // the dead session carries the same epoch as the new one and would sail
+        // straight through. The generation moves whenever the current session does.
+        //
+        // `undefined` means "not issued against a session": the CSRF fetch during
+        // connect() has no lease and must apply, since it is establishing the very
+        // session this would compare against.
+        if (generation !== undefined &&
+            generation !== this.lifecycle.sessionGeneration) {
+            this.logger?.debug('Ignoring a response from a previous session: its effects are fenced');
+            return;
+        }
         this.applyIdentityPolicy(this.updateCookiesFromResponse(headers));
     }
     /**
      * Acts on what a response said about the session identity.
      *
-     * A replacement is fatal only while a lock is held — and "a lock is held"
-     * means an open window, not `sessionMode`: a mode flag cannot represent
-     * windows, another handler can flip it back, and a batch never sets it.
-     * With no lock held the same replacement is not a loss: nothing was being
-     * held, so the new identity simply becomes the current one.
+     * A replacement is always fatal, and that is a narrowing: an earlier version
+     * tolerated it "when no lock is held", deciding from the connection's own
+     * lock windows. Those are gone, and rightly — this layer does not know that a
+     * lock exists, what object it covers or what would release it. Locks are
+     * tracked a layer up, per object, by the code that took them.
+     *
+     * So the rule is written from what this layer CAN know: the ABAP session we
+     * were speaking to is not the one we are speaking to now. Anything the caller
+     * held against the old one is dead, and continuing quietly would hand them a
+     * session they never opened — the failure this whole design exists to prevent.
+     * Being wrong in this direction costs a reconnect; being wrong the other way
+     * costs a lock nobody can find.
      */
     applyIdentityPolicy(classification) {
         if (classification !== 'replaced')
             return;
-        if (this.lifecycle.openWindows.length === 0) {
-            this.logger?.debug('Session identity changed with no lock held; continuing on the new one');
-            return;
-        }
-        this.raiseSessionLost('the session cookie changed while a lock was held');
-        throw (0, SessionLifecycle_js_1.sessionError)(interfaces_1.ADT_SESSION_ERROR.SESSION_REPLACED, 'The SAP session was replaced while a lock was held; the lock handle is dead');
+        this.raiseSessionLost('the session cookie changed under us');
+        throw (0, SessionLifecycle_js_1.sessionError)(interfaces_1.ADT_SESSION_ERROR.SESSION_REPLACED, 'The SAP session was replaced; anything held against the previous one is dead');
     }
     /**
      * Whether the server is telling us the session it was given no longer exists.
@@ -476,13 +495,13 @@ class AbstractAbapConnection {
         // shut the door.
         const lease = this.lifecycle.admitRequest();
         try {
-            return await this.performRequest(options);
+            return await this.performRequest(options, lease);
         }
         finally {
             lease.release();
         }
     }
-    async performRequest(options) {
+    async performRequest(options, lease) {
         const { url: endpoint, method, timeout, data, params, headers: customHeaders, } = options;
         const normalizedMethod = method.toUpperCase();
         // Build full URL: baseUrl + endpoint
@@ -578,7 +597,7 @@ class AbstractAbapConnection {
         });
         try {
             const response = await this.getAxiosInstance()(requestConfig);
-            this.observeResponse(response.headers);
+            this.observeResponse(response.headers, lease.generation);
             this.logger?.debug(`Request succeeded with status ${response.status}`, {
                 type: 'REQUEST_SUCCESS',
                 status: response.status,
@@ -588,6 +607,20 @@ class AbstractAbapConnection {
             return response;
         }
         catch (error) {
+            // FENCE FIRST, before anything reads or writes shared state.
+            //
+            // Fencing observeResponse() alone was not enough, and the gap was wide:
+            // everything below acts on this connection, not on the request. A late
+            // 400 "session not found" would call raiseSessionLost() and tear down the
+            // healthy session established since; a late 401/403 would call
+            // invalidateSession(), write a fresh CSRF token, and RETRY — replaying a
+            // mutation from a dead session inside the live one.
+            //
+            // A stale request gets its error back and nothing else happens.
+            if (!this.lifecycle.isCurrent(lease)) {
+                this.logger?.debug('A request from a previous session failed; its recovery is fenced');
+                throw error;
+            }
             const errorDetails = {
                 type: 'REQUEST_ERROR',
                 message: error instanceof Error ? error.message : String(error),
@@ -601,7 +634,7 @@ class AbstractAbapConnection {
                     typeof error.response.data === 'string'
                         ? error.response.data.slice(0, 200)
                         : JSON.stringify(error.response.data).slice(0, 200);
-                this.observeResponse(error.response.headers);
+                this.observeResponse(error.response.headers, lease.generation);
             }
             // The server telling us the session is gone is invisible to the identity
             // comparison: the cookie, and therefore the fingerprint, is unchanged.
@@ -653,7 +686,7 @@ class AbstractAbapConnection {
                     delete requestHeaders.cookie;
                 }
                 try {
-                    this.setCsrfToken(await this.fetchCsrfToken(requestUrl, 5, 2000));
+                    this.setCsrfToken(await this.fetchCsrfToken(requestUrl, 5, 2000, lease.generation));
                     const refreshedToken = this.getCsrfToken();
                     if (refreshedToken) {
                         requestHeaders['x-csrf-token'] = refreshedToken;
@@ -663,7 +696,7 @@ class AbstractAbapConnection {
                         requestHeaders.Cookie = refreshedCookies;
                     }
                     const retryResponse = await this.getAxiosInstance()(requestConfig);
-                    this.observeResponse(retryResponse.headers);
+                    this.observeResponse(retryResponse.headers, lease.generation);
                     return retryResponse;
                 }
                 catch (retryError) {
@@ -691,19 +724,19 @@ class AbstractAbapConnection {
                     this.logger?.debug(`[DEBUG] BaseAbapConnection - 401 on GET request, retrying with cookies from error response`);
                     requestHeaders.Cookie = this.cookies;
                     const retryResponse = await this.getAxiosInstance()(requestConfig);
-                    this.observeResponse(retryResponse.headers);
+                    this.observeResponse(retryResponse.headers, lease.generation);
                     return retryResponse;
                 }
                 // If no cookies, try to get them via CSRF token fetch
                 this.logger?.debug(`[DEBUG] BaseAbapConnection - 401 on GET request, attempting to get cookies via CSRF token fetch`);
                 try {
                     // Try to get CSRF token (this will also get cookies)
-                    this.csrfToken = await this.fetchCsrfToken(requestUrl, 3, 1000);
+                    this.csrfToken = await this.fetchCsrfToken(requestUrl, 3, 1000, lease.generation);
                     if (this.cookies) {
                         requestHeaders.Cookie = this.cookies;
                         this.logger?.debug(`[DEBUG] BaseAbapConnection - Retrying GET request with cookies from CSRF fetch`);
                         const retryResponse = await this.getAxiosInstance()(requestConfig);
-                        this.observeResponse(retryResponse.headers);
+                        this.observeResponse(retryResponse.headers, lease.generation);
                         return retryResponse;
                     }
                 }
@@ -722,7 +755,9 @@ class AbstractAbapConnection {
      * Fetch CSRF token from SAP system
      * Protected method for use by concrete implementations in their connect() method
      */
-    async fetchCsrfToken(url, retryCount = csrfConfig_js_1.CSRF_CONFIG.RETRY_COUNT, retryDelay = csrfConfig_js_1.CSRF_CONFIG.RETRY_DELAY) {
+    async fetchCsrfToken(url, retryCount = csrfConfig_js_1.CSRF_CONFIG.RETRY_COUNT, retryDelay = csrfConfig_js_1.CSRF_CONFIG.RETRY_DELAY, 
+    /** Fences the response effects; omitted during connect(), which has no lease. */
+    generation) {
         // Try primary endpoint first, then fallback for older systems
         const baseUrl = url.includes('/sap/bc/adt/')
             ? url.split('/sap/bc/adt')[0]
@@ -746,7 +781,7 @@ class AbstractAbapConnection {
         let lastError;
         for (const csrfUrl of endpoints) {
             try {
-                return await this.fetchCsrfTokenFromEndpoint(csrfUrl, retryCount, retryDelay);
+                return await this.fetchCsrfTokenFromEndpoint(csrfUrl, retryCount, retryDelay, generation);
             }
             catch (error) {
                 // Third layer with a catch on this path, and the last one that could
@@ -766,7 +801,7 @@ class AbstractAbapConnection {
     /**
      * Fetch CSRF token from a specific endpoint with retries
      */
-    async fetchCsrfTokenFromEndpoint(csrfUrl, retryCount, retryDelay) {
+    async fetchCsrfTokenFromEndpoint(csrfUrl, retryCount, retryDelay, generation) {
         this.logger?.debug(`Fetching CSRF token from: ${csrfUrl}`);
         for (let attempt = 0; attempt <= retryCount; attempt++) {
             try {
@@ -804,7 +839,7 @@ class AbstractAbapConnection {
                     headers,
                     timeout: (0, timeouts_js_1.getTimeout)('csrf'),
                 });
-                this.observeResponse(response.headers);
+                this.observeResponse(response.headers, generation);
                 const token = response.headers['x-csrf-token'];
                 if (!token) {
                     this.logger?.error('No CSRF token in response headers', {
@@ -818,7 +853,7 @@ class AbstractAbapConnection {
                     throw new Error(csrfConfig_js_1.CSRF_ERROR_MESSAGES.NOT_IN_HEADERS);
                 }
                 if (response.headers['set-cookie']) {
-                    this.observeResponse(response.headers);
+                    this.observeResponse(response.headers, generation);
                     if (this.cookies) {
                         this.logger?.debug(`[DEBUG] BaseAbapConnection - Cookies received from CSRF response (first 100 chars): ${this.cookies.substring(0, 100)}...`);
                         this.logger?.debug('Cookies extracted from response', {
@@ -842,7 +877,7 @@ class AbstractAbapConnection {
                     // Always try to extract cookies from error response, even on 401
                     // This ensures cookies are available for subsequent requests
                     if (error.response?.headers) {
-                        this.observeResponse(error.response.headers);
+                        this.observeResponse(error.response.headers, generation);
                         if (this.cookies) {
                             this.logger?.debug('Cookies extracted from error response', {
                                 status: error.response.status,
@@ -861,14 +896,14 @@ class AbstractAbapConnection {
                         this.logger?.debug('CSRF: SAP returned 405 (Method Not Allowed) — not critical, token found in header');
                         const token = error.response.headers['x-csrf-token'];
                         if (token) {
-                            this.observeResponse(error.response.headers);
+                            this.observeResponse(error.response.headers, generation);
                             return token;
                         }
                     }
                     if (error.response?.headers['x-csrf-token']) {
                         this.logger?.debug(`Got CSRF token despite error (status: ${error.response?.status})`);
                         const token = error.response.headers['x-csrf-token'];
-                        this.observeResponse(error.response.headers);
+                        this.observeResponse(error.response.headers, generation);
                         return token;
                     }
                     if (error.response) {
@@ -1037,6 +1072,13 @@ class AbstractAbapConnection {
         this.setCsrfToken(null);
         this.cookies = null;
         this.cookieStore.clear();
+        // And the tracked identity, because WE discarded the session. Without this
+        // the cookie that arrives next reads as a foreign replacement — and since a
+        // replacement is now always fatal, our own deliberate re-authentication
+        // would tear the connection down. The distinction that matters is not
+        // "was a lock held" but "did we cause this": what we discarded on purpose
+        // is not a session taken from under us.
+        this.lifecycle.forgetIdentity();
     }
     shouldRetryCsrf(error) {
         if (!(error instanceof axios_1.AxiosError)) {

package/dist/connection/BaseAbapConnection.js

@@ -25,7 +25,7 @@ class BaseAbapConnection extends AbstractAbapConnection_js_1.AbstractAbapConnect
         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);
+            const token = await this.fetchCsrfToken(discoveryUrl);
             this.setCsrfToken(token);
             this.logger?.debug('Successfully connected to SAP system', {
                 hasCsrfToken: !!this.getCsrfToken(),

package/dist/connection/CertificateAbapConnection.js

@@ -47,7 +47,7 @@ class CertificateAbapConnection extends AbstractAbapConnection_js_1.AbstractAbap
         const baseUrl = await this.getBaseUrl();
         const discoveryUrl = `${baseUrl}/sap/bc/adt/discovery`;
         try {
-            const token = await this.fetchCsrfToken(discoveryUrl, 3, 1000);
+            const token = await this.fetchCsrfToken(discoveryUrl);
             this.setCsrfToken(token);
         }
         catch (error) {

package/dist/connection/JwtAbapConnection.d.ts

@@ -1,4 +1,4 @@
-import type { IAdtResponse, ITokenRefresher } from '@mcp-abap-adt/interfaces';
+import { type IAdtResponse, type ITokenRefresher } from '@mcp-abap-adt/interfaces';
 import type { SapConfig } from '../config/sapConfig.js';
 import type { ILogger } from '../logger.js';
 import type { AbapRequestOptions } from './AbapConnection.js';
@@ -7,19 +7,92 @@ import { AbstractAbapConnection } from './AbstractAbapConnection.js';
  * JWT Authentication connection for SAP BTP Cloud systems
  *
  * Supports automatic token refresh via ITokenRefresher injection:
- * - If tokenRefresher is provided, 401/403 errors trigger automatic token refresh
- * - If tokenRefresher is not provided, 401/403 errors throw an error (legacy behavior)
+ * - a **401** triggers a token refresh when a tokenRefresher is available;
+ * - without one, or when the refresh does not help, the server's own error is
+ *   thrown unchanged — status and body intact;
+ * - a **403** is never a token problem. It propagates as it arrived, because a
+ *   new token is the same caller and cannot change a permissions answer.
  */
 export declare class JwtAbapConnection extends AbstractAbapConnection {
     private tokenRefresher?;
     private currentToken;
+    /** Bumped by any token refresh, token-only ones included. */
+    private tokenGeneration;
+    /** Single-flight over the token fetch alone. Touches no session state. */
+    private tokenRefreshInFlight?;
+    /**
+     * The `tokenGeneration` a completed session recovery was built for. Only
+     * `performRenewal` moves it, and only after `recoverSession` resolves.
+     *
+     * Separate from `tokenGeneration` because a token-only refresh — which
+     * `fetchCsrfToken` does, from inside an establishment — bumps that counter
+     * without rebuilding anything. Reading it as "the session is settled" made
+     * the outer handler retry a request whose session was never rebuilt.
+     */
+    private recoveredGeneration;
+    /**
+     * Single-flight over the whole credential renewal, session included.
+     *
+     * Sharing only the token fetch leaves the expensive half racing: `recover`
+     * and `cleanup` never join (`SessionLifecycle.transition`), so two concurrent
+     * renewals queue as cleanup A → recover A → cleanup B → recover B, and A's
+     * retry meets a session B has just torn down.
+     */
+    private renewalInFlight?;
+    /**
+     * Per connection, deliberately NOT static. `baseline` is compared against
+     * `this.tokenGeneration`, which is instance state — a store shared between
+     * instances would let one connection's operation hand its baseline to
+     * another's, and the comparison would be between unrelated counters.
+     */
+    private readonly recoveryScope;
     constructor(config: SapConfig, logger?: ILogger | null, sessionId?: string, tokenRefresher?: ITokenRefresher);
     protected buildAuthorizationHeader(): string;
     /**
-     * Refresh the JWT token using the injected tokenRefresher
-     * @returns true if token was refreshed, false if no refresher available
+     * For the public entry point: this call is its own operation, always.
+     *
+     * A re-entrant `makeAdtRequest` — from a logger or a refresher callback the
+     * connection itself invokes while a scope is live — is a new caller-visible
+     * operation. Inheriting there would hand it a baseline from somebody else's
+     * refresh, which reads as "already refreshed for me" and skips a refresh it
+     * needs.
+     */
+    private inNewRecoveryScope;
+    /** For the inner levels: join the operation in progress, or start one. */
+    private inRecoveryScope;
+    /**
+     * The baseline this operation is reasoning from.
+     *
+     * The `active` check here and the one in `inRecoveryScope` OVERLAP: each
+     * compensates for the other, and the stale-context test only fails when both
+     * are removed. Kept as two because they answer different questions — "may I
+     * join this scope" and "may I trust this baseline" — and a reader who finds
+     * one redundant would be deleting half a guarantee.
+     */
+    private currentBaseline;
+    /**
+     * Fetch a new token, unless somebody already did for this operation.
+     *
+     * Single-flighted so two concurrent handlers — including two nested
+     * `fetchCsrfToken` calls, which is a level `renewalInFlight` cannot reach —
+     * share one network call instead of racing and leaving `currentToken` as
+     * whichever settled last.
+     *
+     * @returns true when the caller may retry.
+     */
+    private refreshTokenOnce;
+    private performTokenRefresh;
+    /**
+     * Renew the credential and the session it belongs to, once, shared.
+     */
+    private renewCredential;
+    private performRenewal;
+    /**
+     * May this operation retry?
+     *
+     * The order of the checks is the design, not style.
      */
-    private tryRefreshToken;
+    private ensureRecovered;
     /**
      * Establishes the session for this auth type. Called by
      * AbstractAbapConnection.connect(), which owns the lifecycle around it.
@@ -29,10 +102,14 @@ export declare class JwtAbapConnection extends AbstractAbapConnection {
      * Override makeAdtRequest to handle JWT auth errors with automatic token refresh
      */
     makeAdtRequest<T = any, D = any>(options: AbapRequestOptions): Promise<IAdtResponse<T, D>>;
+    private attemptRequest;
     /**
      * Override fetchCsrfToken to handle JWT auth errors with automatic token refresh
      */
-    protected fetchCsrfToken(url: string, retryCount?: number, retryDelay?: number): Promise<string>;
+    protected fetchCsrfToken(url: string, retryCount?: number, retryDelay?: number, 
+    /** Fences the response effects; omitted during connect(), which has no lease. */
+    generation?: number): Promise<string>;
+    private attemptCsrfToken;
     private static validateConfig;
 }
 //# sourceMappingURL=JwtAbapConnection.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"JwtAbapConnection.d.ts","sourceRoot":"","sources":["../../src/connection/JwtAbapConnection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAE9E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAErE;;;;;;GAMG;AACH,qBAAa,iBAAkB,SAAQ,sBAAsB;IAC3D,OAAO,CAAC,cAAc,CAAC,CAAkB;IACzC,OAAO,CAAC,YAAY,CAAS;gBAG3B,MAAM,EAAE,SAAS,EACjB,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI,EACvB,SAAS,CAAC,EAAE,MAAM,EAClB,cAAc,CAAC,EAAE,eAAe;IAWlC,SAAS,CAAC,wBAAwB,IAAI,MAAM;IAW5C;;;OAGG;YACW,eAAe;IA0B7B;;;OAGG;cACa,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IA2DjD;;OAEG;IACG,cAAc,CAAC,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,GAAG,EACnC,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAiE9B;;OAEG;cACa,cAAc,CAC5B,GAAG,EAAE,MAAM,EACX,UAAU,SAAI,EACd,UAAU,SAAO,GAChB,OAAO,CAAC,MAAM,CAAC;IA2ClB,OAAO,CAAC,MAAM,CAAC,cAAc;CAa9B"}
+{"version":3,"file":"JwtAbapConnection.d.ts","sourceRoot":"","sources":["../../src/connection/JwtAbapConnection.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,eAAe,EACrB,MAAM,0BAA0B,CAAC;AAElC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAE5C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAuBrE;;;;;;;;;GASG;AACH,qBAAa,iBAAkB,SAAQ,sBAAsB;IAC3D,OAAO,CAAC,cAAc,CAAC,CAAkB;IACzC,OAAO,CAAC,YAAY,CAAS;IAE7B,6DAA6D;IAC7D,OAAO,CAAC,eAAe,CAAK;IAE5B,0EAA0E;IAC1E,OAAO,CAAC,oBAAoB,CAAC,CAAmB;IAEhD;;;;;;;;OAQG;IACH,OAAO,CAAC,mBAAmB,CAAK;IAEhC;;;;;;;OAOG;IACH,OAAO,CAAC,eAAe,CAAC,CAAmB;IAE3C;;;;;OAKG;IACH,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA2C;gBAGvE,MAAM,EAAE,SAAS,EACjB,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI,EACvB,SAAS,CAAC,EAAE,MAAM,EAClB,cAAc,CAAC,EAAE,eAAe;IAWlC,SAAS,CAAC,wBAAwB,IAAI,MAAM;IAW5C;;;;;;;;OAQG;IACH,OAAO,CAAC,kBAAkB;IAc1B,0EAA0E;IAC1E,OAAO,CAAC,eAAe;IASvB;;;;;;;;OAQG;IACH,OAAO,CAAC,eAAe;IAQvB;;;;;;;;;OASG;IACH,OAAO,CAAC,gBAAgB;YAsBV,mBAAmB;IAoBjC;;OAEG;IACH,OAAO,CAAC,eAAe;YAiBT,cAAc;IAwB5B;;;;OAIG;YACW,eAAe;IAyB7B;;;OAGG;cACa,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IA4BjD;;OAEG;IACG,cAAc,CAAC,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,GAAG,EACnC,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;YAKhB,cAAc;IA8D5B;;OAEG;cACa,cAAc,CAC5B,GAAG,EAAE,MAAM,EACX,UAAU,GAAE,MAAgC,EAC5C,UAAU,GAAE,MAAgC;IAC5C,iFAAiF;IACjF,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,MAAM,CAAC;YASJ,gBAAgB;IAkD9B,OAAO,CAAC,MAAM,CAAC,cAAc;CAa9B"}