@mcp-abap-adt/connection 1.10.2 → 3.0.0

package/README.md

@@ -34,18 +34,19 @@ The package uses a clean separation of concerns:
 
 - **`AbstractAbapConnection`** (abstract, internal only):
   - Common HTTP request logic
+  - Session lifecycle: `connect()` / `disconnect()`, admission, lock windows, teardown draining
   - Session management (cookies, CSRF tokens)
   - CSRF token fetching with retry
   - Auth-agnostic - knows nothing about Basic or JWT
   
 - **`BaseAbapConnection`** (concrete, exported):
   - Basic Authentication implementation
-  - Simple connect() - fetches CSRF token
+  - `connect()` establishes the session (required before any request)
   - Suitable for on-premise SAP systems
   
 - **`JwtAbapConnection`** (concrete, exported):
   - JWT/OAuth2 Authentication implementation
-  - Simple connect() - establishes connection with JWT token
+  - `connect()` establishes the session with the JWT token (required before any request)
   - Suitable for SAP BTP ABAP Environment
   - Token refresh handled by auth-broker package
 
@@ -112,6 +113,7 @@ This package interacts with external packages **ONLY through interfaces**:
 
 - 📦 **[Installation Guide](./docs/INSTALLATION.md)** - Setup and installation instructions
 - 📚 **[Usage Guide](./docs/USAGE.md)** - Detailed usage examples and API documentation
+- 🚚 **[Migration: the explicit session lifecycle](./docs/MIGRATION-2.0.md)** - `connect()` is now required; start here if you are coming from 1.x
 - 💡 **[Examples](./examples/)** - Working code examples
 
 ## Features
@@ -156,6 +158,7 @@ const logger = {
 
 // Create connection
 const connection = createAbapConnection(config, logger);
+await connection.connect();   // required before any request
 
 // Make ADT request
 const response = await connection.makeAdtRequest({
@@ -186,6 +189,7 @@ const logger = {
 
 // Logger is optional - if not provided, no logging output
 const connection = createAbapConnection(config, logger);
+await connection.connect();
 
 // Note: Token refresh is handled by @mcp-abap-adt/auth-broker package
 const response = await connection.makeAdtRequest({
@@ -206,6 +210,8 @@ const config: SapConfig = {
 };
 
 const connection = createAbapConnection(config, logger);
+await connection.connect();
+
 const response = await connection.makeAdtRequest({
   method: "GET",
   url: "/sap/bc/adt/programs/programs/your-program",
@@ -236,8 +242,11 @@ const config: SapConfig = {
 
 // Create connection with token refresher - 401/403 handled automatically
 const connection = new JwtAbapConnection(config, logger, undefined, tokenRefresher);
+await connection.connect();
 
-// Requests automatically retry with refreshed token on auth errors
+// Requests automatically retry with refreshed token on auth errors. A refresh
+// replaces the SAP session, so if a lock window is open the request fails with
+// ADT_SESSION_REPLACED instead of continuing on a session your lock is not in.
 const response = await connection.makeAdtRequest({
   method: "GET",
   url: "/sap/bc/adt/programs/programs/your-program",
@@ -252,6 +261,7 @@ For operations that require session state (e.g., object modifications), you can
 import { createAbapConnection } from "@mcp-abap-adt/connection";
 
 const connection = createAbapConnection(config, logger);
+await connection.connect();
 
 // Enable stateful session mode (adds x-sap-adt-sessiontype: stateful header)
 connection.setSessionType("stateful");
@@ -388,19 +398,43 @@ type SapConfig = {
 Main interface for ABAP connections.
 
 ```typescript
+// The shared contract (IAbapConnection), what every connection provides:
 interface AbapConnection {
+  connect(): Promise<void>; // REQUIRED before any request; rejects on failure
   makeAdtRequest(options: AbapRequestOptions): Promise<AxiosResponse>;
-  reset(): void;
+  getBaseUrl(): Promise<string>;
   setSessionType(type: "stateless" | "stateful"): void; // Switch session type
-  getSessionMode(): "stateless" | "stateful"; // Get current session mode
-  getSessionId(): string | null; // Get current session ID
+  getSessionId(): string | null; // Client-side conversation id
 }
 ```
 
+The HTTP connection classes carry the rest of the session lifecycle. It is on the
+shared contract as a **capability atom** in `@mcp-abap-adt/interfaces` rather than
+as methods on `IAbapConnection`, which is why `RfcAbapConnection` — a transport
+that owns no HTTP session — is unaffected by its existence:
+
+```typescript
+// ISessionLifecycleAware
+disconnect(): Promise<void>;         // never throws, and waits for nothing
+isConnected(): boolean;
+getSessionIdentity(): string | null; // WHICH SAP session; null is not "disconnected"
+```
+
+Import those names from `@mcp-abap-adt/interfaces`, not from this package: a
+contract type re-exported under a second name is a contract type that can drift.
+
+**The connection does not track locks.** Deciding when to disconnect, and
+preparing for it, belongs to the caller; pairing every LOCK with its UNLOCK
+belongs to `@mcp-abap-adt/adt-clients`, which holds the handles. What this layer
+owns is not being interrupted by a timeout mid-operation — see
+`beginCriticalSection()` below.
+
+See [docs/USAGE.md — Session Lifecycle](./docs/USAGE.md#session-lifecycle).
+
 **Session Management:**
-- `setSessionType(type)`: Programmatically switch between stateful and stateless modes
-- `getSessionMode()`: Returns current session mode
-- `getSessionId()`: Returns the current session ID (auto-generated UUID)
+- `setSessionType(type)`: Programmatically switch between stateful and stateless modes *(on the contract)*
+- `getSessionId()`: Returns the client-side conversation id, an auto-generated UUID *(on the contract)*
+- `getSessionMode()`: Returns current session mode *(HTTP classes only)*
 
 #### `ILogger`
 
@@ -489,7 +523,6 @@ async function fetchCsrfToken(baseUrl: string): Promise<string> {
 }
 ```
 
-See [PR Proposal](./PR_PROPOSAL_CSRF_CONFIG.md) for more details.
 
 ## Requirements
 
@@ -500,7 +533,7 @@ See [PR Proposal](./PR_PROPOSAL_CSRF_CONFIG.md) for more details.
 
 See [CHANGELOG.md](./CHANGELOG.md) for detailed version history and breaking changes.
 
-**Latest version: 0.2.0**
+**Version history:** [CHANGELOG.md](./CHANGELOG.md)
 - Removed token refresh functionality (handled by `@mcp-abap-adt/auth-broker`)
 - Removed session storage functionality (handled by `@mcp-abap-adt/auth-broker`)
 - Logger is now optional

package/dist/__tests__/helpers/session.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Test precondition: put a connection into the connected state without a
+ * network round trip.
+ *
+ * `connect()` is mandatory now, so a test whose subject is something else —
+ * timeouts, headers, retry classification — needs the session to exist before
+ * it can say anything. Establishing it for real would mean teaching every such
+ * mock to answer a CSRF fetch, which tests the wrong thing and adds retry
+ * delays to suites that are not about connecting.
+ *
+ * Tests that ARE about connecting use a real stub instead; see
+ * `connection/sessionComposition.test.ts`.
+ */
+export declare function markConnectedForTest(connection: unknown, fingerprint?: Map<string, string>): void;
+//# sourceMappingURL=session.d.ts.map

package/dist/__tests__/helpers/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../../src/__tests__/helpers/session.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,OAAO,EACnB,WAAW,GAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAA4C,GAC1E,IAAI,CAMN"}

package/dist/__tests__/helpers/session.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.markConnectedForTest = markConnectedForTest;
+/**
+ * Test precondition: put a connection into the connected state without a
+ * network round trip.
+ *
+ * `connect()` is mandatory now, so a test whose subject is something else —
+ * timeouts, headers, retry classification — needs the session to exist before
+ * it can say anything. Establishing it for real would mean teaching every such
+ * mock to answer a CSRF fetch, which tests the wrong thing and adds retry
+ * delays to suites that are not about connecting.
+ *
+ * Tests that ARE about connecting use a real stub instead; see
+ * `connection/sessionComposition.test.ts`.
+ */
+function markConnectedForTest(connection, fingerprint = new Map([['SAP_SESSIONID_T_100', 'S1']])) {
+    connection.lifecycle.markConnected(fingerprint);
+}

package/dist/auth/ntlm.d.ts

@@ -8,4 +8,19 @@
  *    bytes starting with the NTLM signature "NTLMSSP\0" (base64 prefix "TlRMTVNTUAA").
  */
 export declare function isNtlmChallenge(wwwAuthenticate: string | undefined): boolean;
+/**
+ * `Negotiate <gssapi-data>` — the server has handed back a token for the client
+ * to feed into its GSS context and retry (RFC 4559 continuation).
+ */
+export declare function isNegotiateContinuation(wwwAuthenticate: string | undefined): boolean;
+/**
+ * A bare `Negotiate`, with no token.
+ *
+ * Told apart from a continuation deliberately: once the client has ALREADY sent
+ * its initial Authorization, a bare challenge is the server declining it — the
+ * credentials were not accepted. There is no server token here, so nothing
+ * could be stepped even by a client that supports multi-leg. Diagnosing the two
+ * alike sends the reader after the wrong problem.
+ */
+export declare function isBareNegotiateChallenge(wwwAuthenticate: string | undefined): boolean;
 //# sourceMappingURL=ntlm.d.ts.map

package/dist/auth/ntlm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ntlm.d.ts","sourceRoot":"","sources":["../../src/auth/ntlm.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,eAAe,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAiB5E"}
+{"version":3,"file":"ntlm.d.ts","sourceRoot":"","sources":["../../src/auth/ntlm.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,eAAe,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAiB5E;AAcD;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,eAAe,EAAE,MAAM,GAAG,SAAS,GAClC,OAAO,CAKT;AAED;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CACtC,eAAe,EAAE,MAAM,GAAG,SAAS,GAClC,OAAO,CAIT"}

package/dist/auth/ntlm.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isNtlmChallenge = isNtlmChallenge;
+exports.isNegotiateContinuation = isNegotiateContinuation;
+exports.isBareNegotiateChallenge = isBareNegotiateChallenge;
 /**
  * Detect whether a WWW-Authenticate header (or a Negotiate challenge token) indicates NTLM.
  * NTLM is rejected: only Kerberos/SPNEGO Negotiate is acceptable.
@@ -32,3 +34,39 @@ function isNtlmChallenge(wwwAuthenticate) {
     }
     return false;
 }
+/**
+ * A `Negotiate` challenge that is not NTLM in disguise. Says nothing about
+ * whether it carries a token — callers that care must ask which kind it is.
+ */
+function isNegotiate(wwwAuthenticate) {
+    if (!wwwAuthenticate)
+        return false;
+    if (isNtlmChallenge(wwwAuthenticate))
+        return false;
+    return wwwAuthenticate
+        .split(',')
+        .some((part) => /^negotiate\b/i.test(part.trim()));
+}
+/**
+ * `Negotiate <gssapi-data>` — the server has handed back a token for the client
+ * to feed into its GSS context and retry (RFC 4559 continuation).
+ */
+function isNegotiateContinuation(wwwAuthenticate) {
+    if (!isNegotiate(wwwAuthenticate))
+        return false;
+    return wwwAuthenticate
+        .split(',')
+        .some((part) => /^negotiate\s+\S/i.test(part.trim()));
+}
+/**
+ * A bare `Negotiate`, with no token.
+ *
+ * Told apart from a continuation deliberately: once the client has ALREADY sent
+ * its initial Authorization, a bare challenge is the server declining it — the
+ * credentials were not accepted. There is no server token here, so nothing
+ * could be stepped even by a client that supports multi-leg. Diagnosing the two
+ * alike sends the reader after the wrong problem.
+ */
+function isBareNegotiateChallenge(wwwAuthenticate) {
+    return (isNegotiate(wwwAuthenticate) && !isNegotiateContinuation(wwwAuthenticate));
+}

package/dist/connection/AbstractAbapConnection.d.ts

@@ -1,10 +1,23 @@
-import { type IAdtResponse } from '@mcp-abap-adt/interfaces';
+import { type IAdtResponse, type ISessionLifecycleAware } from '@mcp-abap-adt/interfaces';
 import type { SapConfig } from '../config/sapConfig.js';
 import type { ILogger } from '../logger.js';
+import { SessionLifecycle } from '../session/SessionLifecycle.js';
 import type { AbapConnection, AbapRequestOptions } from './AbapConnection.js';
-declare abstract class AbstractAbapConnection implements AbapConnection {
+/**
+ * Declares the capabilities explicitly rather than satisfying them by accident.
+ * `AbapConnection` is the base contract every transport honours; these two are
+ * the HTTP session's own, and naming them means a signature that drifts from
+ * the published contract fails to compile here instead of at the consumer.
+ */
+declare abstract class AbstractAbapConnection implements AbapConnection, ISessionLifecycleAware {
     private readonly config;
     protected readonly logger: ILogger | null;
+    /**
+     * Owns session state, admission and teardown ordering. Composed rather than
+     * inherited: RfcAbapConnection implements the interface directly, so the two
+     * transports share this unit instead of a base class.
+     */
+    protected readonly lifecycle: SessionLifecycle;
     private axiosInstance;
     private csrfToken;
     private cookies;
@@ -79,26 +92,175 @@ declare abstract class AbstractAbapConnection implements AbapConnection {
      */
     getSessionId(): string | null;
     getConfig(): SapConfig;
+    /**
+     * Establish the session for this auth type. Implementations do their own auth
+     * preparation and fetch the CSRF token; connect() owns everything around it.
+     */
+    protected abstract establishSession(): Promise<void>;
+    /**
+     * Establishes the session, once, under the lifecycle.
+     *
+     * Idempotent, and concurrent callers share one establishment: the transition
+     * joins the tail of its own kind. A teardown requested while establishment
+     * was in flight means the caller asked to stop, so usability is NOT published
+     * and what was established is released — otherwise a slow connect would hand
+     * back a session someone had already discarded.
+     */
+    connect(): Promise<void>;
+    /**
+     * 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.
+     */
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /**
+     * Fingerprint of the SAP-side session, or null when none is known.
+     *
+     * `null` is NOT a statement about the connection. Two situations produce it:
+     * no session exists, or the connection is live over a server that issued no
+     * session cookie. Use {@link isConnected} for connection state.
+     *
+     * It follows that null → non-null is not a replacement but an identity being
+     * learned; only a CHANGED value means the session was replaced.
+     */
+    getSessionIdentity(): string | null;
+    /**
+     * Discards the session at a caller's request: cancels queued recoveries and
+     * queues the cleanup rather than tearing down under a live request.
+     */
     reset(): void;
-    getBaseUrl(): Promise<string>;
-    getAuthHeaders(): Promise<Record<string, string>>;
     /**
-     * Connect to SAP system and initialize session (get CSRF token and cookies)
-     * This should be called explicitly before making the first request to ensure
-     * proper authentication and session initialization.
+     * Re-establishes the session for a request that is recovering from a
+     * credential renewal, then lets that request retry.
      *
-     * Concrete implementations must provide auth-specific connection logic:
-     * - BaseAbapConnection: Basic auth with CSRF token fetch
-     * - JwtAbapConnection: JWT auth with token refresh on 401/403
+     * Runs as its own `recover` transition, which never joins another: each
+     * recovery carries the baseline of its own request. It yields to a caller's
+     * teardown — if the epoch moved since `baselineEpoch`, someone asked to stop
+     * while this was being prepared, and a retry must not resurrect a session
+     * they discarded.
+     *
+     * The transition queues behind the cleanup that the renewal itself raised, so
+     * it never re-establishes on top of stale transport state.
+     */
+    protected recoverSession(baselineEpoch: number): Promise<void>;
+    /**
+     * Establishes a session and publishes it — but only if nobody asked to stop
+     * meanwhile.
+     *
+     * The epoch is checked BEFORE, so a teardown already requested costs no round
+     * trip, and AFTER, because establishment takes time and a caller can ask to
+     * stop during it. Checking only before is the defect this exists to prevent:
+     * markConnected() would then clear the teardown state and hand back a session
+     * the caller had already discarded.
+     *
+     * Shared by connect() and recoverSession() rather than written twice —
+     * the two drifted apart once already, and a third caller would drift again.
      */
-    abstract connect(): Promise<void>;
+    private establishAndCommit;
+    /** The teardown epoch, for a recovery to capture before it starts. */
+    protected get teardownEpoch(): number;
+    /**
+     * Raises a session-lost teardown from inside request handling.
+     *
+     * There are exactly three things that can cost us the ABAP session, and they
+     * were found one at a time precisely because they were written apart. They go
+     * through here so a fourth joins the list instead of inventing its own
+     * sequence:
+     *
+     *   - the credential was renewed (the injected auth says so);
+     *   - the server says the session is gone (a dead-session response);
+     *   - the tracked cookie changed under us while a lock was held.
+     *
+     * `internal` origin, so it does not cancel the recovery that raised it, and
+     * `sessionLost`, so admission shuts at once and the identity is dropped
+     * 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 cleanup must not
+     * wait for the very request that raised it.
+     */
+    protected raiseSessionLost(reason: string): void;
+    /** The credential-renewal raiser; see raiseSessionLost(). */
+    protected discardSession(): void;
+    /**
+     * Whether an error is this connection's own verdict about the session rather
+     * than something the server said about a request.
+     *
+     * A retry path that swallows one of these and rethrows the original error
+     * turns "your lock is dead" back into "your request 403'd", which is the very
+     * information the caller needs and the only one it cannot recover itself.
+     */
+    private isSessionVerdict;
+    /**
+     * Folds a response into the session state AND acts on what it means, in one
+     * step.
+     *
+     * Never call updateCookiesFromResponse() directly: it MUTATES the fingerprint,
+     * so discarding its classification absorbs a replacement silently and every
+     * later check reads `unchanged`. That is one call site forgetting, and it
+     * happened — on the error path and on every retry response.
+     */
+    private observeResponse;
+    /**
+     * Acts on what a response said about the session identity.
+     *
+     * 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.
+     */
+    private applyIdentityPolicy;
+    /**
+     * Whether the server is telling us the session it was given no longer exists.
+     *
+     * The E19 shape was HTTP 400 with "Session not found", answered in ~60 ms
+     * with the cookie present — which is why identity comparison cannot see this:
+     * the cookie, and therefore the fingerprint, is completely unchanged. The
+     * exact match is landscape-specific and is one of the live probes this design
+     * still owes.
+     */
+    private isDeadSessionResponse;
+    /** Drops everything that described the session. Not a lifecycle transition. */
+    private clearSessionState;
+    /**
+     * The session-bearing cookies, and only those.
+     *
+     * `sap-XSRF_*` is excluded deliberately: it changes on a token refresh WITHIN
+     * the same session, so including it would report an ordinary refresh as a new
+     * session and fail exactly where nothing is wrong. `sap-usercontext` is ours,
+     * overwritten on every response.
+     */
+    protected sessionFingerprint(): Map<string, string>;
+    getBaseUrl(): Promise<string>;
+    getAuthHeaders(): Promise<Record<string, string>>;
     makeAdtRequest<T = any, D = any>(options: AbapRequestOptions): Promise<IAdtResponse<T, D>>;
+    private performRequest;
     protected abstract buildAuthorizationHeader(): string;
     /**
      * Fetch CSRF token from SAP system
      * Protected method for use by concrete implementations in their connect() method
      */
-    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>;
     /**
      * Fetch CSRF token from a specific endpoint with retries
      */
@@ -116,6 +278,12 @@ declare abstract class AbstractAbapConnection implements AbapConnection {
      */
     protected getCookies(): string | null;
     protected setInitialCookies(cookies: string): void;
+    /**
+     * Folds a response's cookies into the jar and classifies what that means for
+     * the session identity. Returns the classification rather than acting on it:
+     * cookie parsing stays free of policy, and no exception fires in the middle
+     * of a state update. The caller decides.
+     */
     private updateCookiesFromResponse;
     /**
      * Subclasses override to inject extra https.Agent options (e.g. mTLS cert/key/pfx).

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

@@ -1 +1 @@
-{"version":3,"file":"AbstractAbapConnection.d.ts","sourceRoot":"","sources":["../../src/connection/AbstractAbapConnection.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"AbstractAbapConnection.d.ts","sourceRoot":"","sources":["../../src/connection/AbstractAbapConnection.ts"],"names":[],"mappings":"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"}