@mcp-abap-adt/adt-clients 3.11.2 → 3.12.0

package/dist/batch/buildBatchPayload.js

@@ -51,9 +51,9 @@ function buildBatchPayload(parts, boundary = createBatchBoundary()) {
             innerRequest,
         ].join('\r\n');
     })
-        .join('');
+        .join('\r\n');
     return {
         boundary,
-        body: `${multipartParts}--${boundary}--\r\n`,
+        body: `${multipartParts}\r\n--${boundary}--\r\n`,
     };
 }

package/dist/core/class/AdtClassLegacy.d.ts

@@ -1,11 +1,27 @@
 /**
  * AdtClassLegacy - Class handler for legacy SAP systems (BASIS < 7.50)
  *
- * Overrides delete() to use direct DELETE instead of /sap/bc/adt/deletion/ API.
+ * On legacy systems, the x-sap-adt-sessiontype: stateful header causes locks
+ * to be stored in ABAP session memory instead of the global enqueue server.
+ * This means lock + update + unlock MUST happen within the same stateful
+ * HTTP session — switching to stateless between lock and update invalidates
+ * the lock handle (GitHub #11).
+ *
+ * Overrides:
+ * - update() — keeps lock→check→update→unlock in one stateful session
+ * - delete() — uses direct DELETE instead of /sap/bc/adt/deletion/ API
  */
+import type { IAdtOperationOptions } from '@mcp-abap-adt/interfaces';
 import { AdtClass } from './AdtClass';
 import type { IClassConfig, IClassState } from './types';
 export declare class AdtClassLegacy extends AdtClass {
+    /**
+     * Update class — legacy override.
+     *
+     * Keeps lock→check→update→unlock in a single stateful session so the
+     * lock handle remains valid (legacy stores locks in ABAP session memory).
+     */
+    update(config: Partial<IClassConfig>, options?: IAdtOperationOptions): Promise<IClassState>;
     delete(config: Partial<IClassConfig>): Promise<IClassState>;
 }
 //# sourceMappingURL=AdtClassLegacy.d.ts.map

package/dist/core/class/AdtClassLegacy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AdtClassLegacy.d.ts","sourceRoot":"","sources":["../../../src/core/class/AdtClassLegacy.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAQH,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAGzD,qBAAa,cAAe,SAAQ,QAAQ;IAC3B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC;CA+C3E"}
+{"version":3,"file":"AdtClassLegacy.d.ts","sourceRoot":"","sources":["../../../src/core/class/AdtClassLegacy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAa,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAMhF,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAItC,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAIzD,qBAAa,cAAe,SAAQ,QAAQ;IAC1C;;;;;OAKG;IACY,MAAM,CACnB,MAAM,EAAE,OAAO,CAAC,YAAY,CAAC,EAC7B,OAAO,CAAC,EAAE,oBAAoB,GAC7B,OAAO,CAAC,WAAW,CAAC;IA6HR,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC;CA+C3E"}

package/dist/core/class/AdtClassLegacy.js

@@ -2,16 +2,115 @@
 /**
  * AdtClassLegacy - Class handler for legacy SAP systems (BASIS < 7.50)
  *
- * Overrides delete() to use direct DELETE instead of /sap/bc/adt/deletion/ API.
+ * On legacy systems, the x-sap-adt-sessiontype: stateful header causes locks
+ * to be stored in ABAP session memory instead of the global enqueue server.
+ * This means lock + update + unlock MUST happen within the same stateful
+ * HTTP session — switching to stateless between lock and update invalidates
+ * the lock handle (GitHub #11).
+ *
+ * Overrides:
+ * - update() — keeps lock→check→update→unlock in one stateful session
+ * - delete() — uses direct DELETE instead of /sap/bc/adt/deletion/ API
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AdtClassLegacy = void 0;
 const internalUtils_1 = require("../../utils/internalUtils");
 const deleteLegacy_1 = require("../shared/deleteLegacy");
 const AdtClass_1 = require("./AdtClass");
+const activation_1 = require("./activation");
+const check_1 = require("./check");
 const lock_1 = require("./lock");
 const unlock_1 = require("./unlock");
+const update_1 = require("./update");
 class AdtClassLegacy extends AdtClass_1.AdtClass {
+    /**
+     * Update class — legacy override.
+     *
+     * Keeps lock→check→update→unlock in a single stateful session so the
+     * lock handle remains valid (legacy stores locks in ABAP session memory).
+     */
+    async update(config, options) {
+        if (!config.className) {
+            throw new Error('Class name is required');
+        }
+        // Low-level mode: caller owns the session
+        if (options?.lockHandle) {
+            return super.update(config, options);
+        }
+        let lockHandle;
+        const state = { errors: [] };
+        try {
+            // Enter stateful session for the entire lock→update→unlock chain
+            this.connection.setSessionType('stateful');
+            // 1. Lock
+            this.logger?.info?.('Legacy update step 1: Locking class');
+            lockHandle = await (0, lock_1.lockClass)(this.connection, config.className);
+            state.lockHandle = lockHandle;
+            this.logger?.info?.('Class locked, handle:', lockHandle);
+            // 2. Check inactive with source code
+            const codeToUpdate = options?.sourceCode || config.sourceCode;
+            if (codeToUpdate) {
+                this.logger?.info?.('Legacy update step 2: Checking inactive version');
+                state.checkResult = await (0, check_1.checkClass)(this.connection, config.className, 'inactive', codeToUpdate, this.contentTypes?.sourceArtifactContentType());
+                this.logger?.info?.('Check passed');
+            }
+            // 3. Update
+            if (codeToUpdate && lockHandle) {
+                this.logger?.info?.('Legacy update step 3: Updating class');
+                state.updateResult = await (0, update_1.updateClass)(this.connection, config.className, codeToUpdate, lockHandle, config.transportRequest, this.contentTypes?.sourceArtifactContentType());
+                this.logger?.info?.('Class updated');
+            }
+            // 4. Unlock (still within the same stateful session)
+            if (lockHandle) {
+                this.logger?.info?.('Legacy update step 4: Unlocking class');
+                state.unlockResult = await (0, unlock_1.unlockClass)(this.connection, config.className, lockHandle);
+                lockHandle = undefined;
+                this.logger?.info?.('Class unlocked');
+            }
+        }
+        catch (error) {
+            // Cleanup: try to unlock if still locked (within same session)
+            if (lockHandle) {
+                try {
+                    this.logger?.warn?.('Unlocking class during error cleanup');
+                    await (0, unlock_1.unlockClass)(this.connection, config.className, lockHandle);
+                }
+                catch (unlockError) {
+                    this.logger?.warn?.('Failed to unlock during cleanup:', (0, internalUtils_1.safeErrorMessage)(unlockError));
+                }
+            }
+            throw error;
+        }
+        finally {
+            // Always return to stateless after the chain
+            this.connection.setSessionType('stateless');
+        }
+        // Post-lock operations (stateless is fine)
+        // 5. Final check
+        this.logger?.info?.('Legacy update step 5: Final check');
+        state.checkResult = await (0, check_1.checkClass)(this.connection, config.className, 'inactive');
+        this.logger?.info?.('Final check passed');
+        // 6. Activate (if requested)
+        if (options?.activateOnUpdate) {
+            this.logger?.info?.('Legacy update step 6: Activating class');
+            const activateResult = await (0, activation_1.activateClass)(this.connection, config.className);
+            state.activateResult = activateResult;
+            this.logger?.info?.('Class activated, status:', activateResult.status);
+            // Read with long polling to ensure object is ready after activation
+            this.logger?.info?.('Read (wait for object ready after activation)');
+            try {
+                const readState = await this.read({ className: config.className }, 'active', { withLongPolling: true });
+                if (readState) {
+                    state.readResult = readState.readResult;
+                }
+                this.logger?.info?.('Object is ready after activation');
+            }
+            catch (readError) {
+                this.logger?.warn?.('Read with long polling failed after activation:', (0, internalUtils_1.safeErrorMessage)(readError));
+            }
+        }
+        return state;
+    }
     async delete(config) {
         if (!config.className) {
             throw new Error('Class name is required');

package/dist/utils/acceptNegotiation.d.ts

@@ -7,6 +7,7 @@ export declare function clearAcceptCache(): void;
 export declare function setAcceptCorrectionEnabled(enabled?: boolean): void;
 export declare function getAcceptCorrectionEnabled(): boolean;
 export declare function extractSupportedAccept(error: unknown): string[];
+export declare function extractSupportedContentType(error: unknown): string[];
 export declare function wrapConnectionAcceptNegotiation(connection: IAbapConnection, logger?: ILogger): void;
 export declare function makeAdtRequestWithAcceptNegotiation<T = unknown, D = unknown>(connection: IAbapConnection, request: IAbapRequestOptions, options?: IAcceptNegotiationOptions): Promise<IAdtResponse<T, D>>;
 //# sourceMappingURL=acceptNegotiation.d.ts.map

package/dist/utils/acceptNegotiation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"acceptNegotiation.d.ts","sourceRoot":"","sources":["../../src/utils/acceptNegotiation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,eAAe,EACf,mBAAmB,EACnB,YAAY,EACZ,OAAO,EACR,MAAM,0BAA0B,CAAC;AASlC,MAAM,WAAW,yBAAyB;IACxC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,wBAAgB,gBAAgB,IAAI,IAAI,CAEvC;AAED,wBAAgB,0BAA0B,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI,CAElE;AAED,wBAAgB,0BAA0B,IAAI,OAAO,CAKpD;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAoC/D;AAcD,wBAAgB,+BAA+B,CAC7C,UAAU,EAAE,eAAe,EAC3B,MAAM,CAAC,EAAE,OAAO,GACf,IAAI,CAkBN;AAED,wBAAsB,mCAAmC,CACvD,CAAC,GAAG,OAAO,EACX,CAAC,GAAG,OAAO,EAEX,UAAU,EAAE,eAAe,EAC3B,OAAO,EAAE,mBAAmB,EAC5B,OAAO,CAAC,EAAE,yBAAyB,GAClC,OAAO,CAAC,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CA8C7B"}
+{"version":3,"file":"acceptNegotiation.d.ts","sourceRoot":"","sources":["../../src/utils/acceptNegotiation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,eAAe,EACf,mBAAmB,EACnB,YAAY,EACZ,OAAO,EACR,MAAM,0BAA0B,CAAC;AAUlC,MAAM,WAAW,yBAAyB;IACxC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,wBAAgB,gBAAgB,IAAI,IAAI,CAGvC;AAED,wBAAgB,0BAA0B,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI,CAElE;AAED,wBAAgB,0BAA0B,IAAI,OAAO,CAKpD;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAoC/D;AAED,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAsCpE;AAcD,wBAAgB,+BAA+B,CAC7C,UAAU,EAAE,eAAe,EAC3B,MAAM,CAAC,EAAE,OAAO,GACf,IAAI,CAkBN;AAED,wBAAsB,mCAAmC,CACvD,CAAC,GAAG,OAAO,EACX,CAAC,GAAG,OAAO,EAEX,UAAU,EAAE,eAAe,EAC3B,OAAO,EAAE,mBAAmB,EAC5B,OAAO,CAAC,EAAE,yBAAyB,GAClC,OAAO,CAAC,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CA6E7B"}

package/dist/utils/acceptNegotiation.js

@@ -4,13 +4,16 @@ exports.clearAcceptCache = clearAcceptCache;
 exports.setAcceptCorrectionEnabled = setAcceptCorrectionEnabled;
 exports.getAcceptCorrectionEnabled = getAcceptCorrectionEnabled;
 exports.extractSupportedAccept = extractSupportedAccept;
+exports.extractSupportedContentType = extractSupportedContentType;
 exports.wrapConnectionAcceptNegotiation = wrapConnectionAcceptNegotiation;
 exports.makeAdtRequestWithAcceptNegotiation = makeAdtRequestWithAcceptNegotiation;
 const acceptCache = new Map();
+const contentTypeCache = new Map();
 const baseRequestMap = new WeakMap();
 let acceptCorrectionOverride;
 function clearAcceptCache() {
     acceptCache.clear();
+    contentTypeCache.clear();
 }
 function setAcceptCorrectionEnabled(enabled) {
     acceptCorrectionOverride = enabled;
@@ -19,7 +22,7 @@ function getAcceptCorrectionEnabled() {
     if (acceptCorrectionOverride !== undefined) {
         return acceptCorrectionOverride;
     }
-    return process.env.ADT_ACCEPT_CORRECTION === 'true';
+    return process.env.ADT_ACCEPT_CORRECTION !== 'false';
 }
 function extractSupportedAccept(error) {
     const types = new Set();
@@ -53,6 +56,39 @@ function extractSupportedAccept(error) {
     }
     return Array.from(types).filter(Boolean);
 }
+function extractSupportedContentType(error) {
+    const e = error;
+    if (e?.response?.status !== 415) {
+        return [];
+    }
+    const types = new Set();
+    const headers = (e?.response?.headers || {});
+    const headerCandidates = [
+        headers['content-type'],
+        headers['x-sap-adt-supported-content-type'],
+        headers['supported-content-type'],
+    ];
+    for (const value of headerCandidates) {
+        if (typeof value === 'string') {
+            value
+                .split(',')
+                .map((entry) => entry.trim())
+                .filter(Boolean)
+                .forEach((entry) => {
+                types.add(entry);
+            });
+        }
+    }
+    const data = e?.response?.data;
+    const text = typeof data === 'string' ? data : data ? JSON.stringify(data) : '';
+    if (text) {
+        const matches = text.match(/[a-zA-Z0-9.+-]+\/[a-zA-Z0-9.+-]+(?:;[^,\s]+)?/g) || [];
+        for (const match of matches) {
+            types.add(match);
+        }
+    }
+    return Array.from(types).filter(Boolean);
+}
 function buildCacheKey(request) {
     return `${request.method.toUpperCase()} ${request.url}`;
 }
@@ -78,6 +114,12 @@ async function makeAdtRequestWithAcceptNegotiation(connection, request, options)
     if (cachedAccept) {
         headers.Accept = cachedAccept;
     }
+    const cachedContentType = enableCorrection
+        ? contentTypeCache.get(cacheKey)
+        : undefined;
+    if (cachedContentType) {
+        headers['Content-Type'] = cachedContentType;
+    }
     const baseRequest = getBaseRequest(connection);
     try {
         return await baseRequest({
@@ -104,6 +146,23 @@ async function makeAdtRequestWithAcceptNegotiation(connection, request, options)
                 }
             }
         }
+        if (e.response?.status === 415) {
+            const supported = extractSupportedContentType(error);
+            if (supported.length > 0) {
+                logger?.warn?.(`Content-Type not supported for ${request.url}. Supported Content-Type: ${supported.join(', ')}`);
+            }
+            if (enableCorrection && supported.length > 0) {
+                const nextContentType = supported[0];
+                if (headers['Content-Type'] !== nextContentType) {
+                    contentTypeCache.set(cacheKey, nextContentType);
+                    logger?.warn?.(`Retrying ${request.url} with corrected Content-Type: ${nextContentType}`);
+                    return await baseRequest({
+                        ...request,
+                        headers: { ...headers, 'Content-Type': nextContentType },
+                    });
+                }
+            }
+        }
         throw error;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcp-abap-adt/adt-clients",
-  "version": "3.11.2",
+  "version": "3.12.0",
   "description": "ADT clients for SAP ABAP systems - AdtClient and AdtRuntimeClient",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -60,7 +60,8 @@
     "shared:teardown": "npx jest --testPathIgnorePatterns node_modules --testPathPatterns admin/shared-deps/teardown",
     "shared:check": "npx jest --testPathIgnorePatterns node_modules --testPathPatterns admin/shared-deps/check",
     "pretest": "npm run test:check:integration",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "prepare": "husky"
   },
   "engines": {
     "node": ">=18.0.0"
@@ -81,6 +82,7 @@
     "@types/jest": "^30.0.0",
     "@types/node": "^25.3.3",
     "dotenv": "^17.3.1",
+    "husky": "^9.1.7",
     "jest": "^30.0.5",
     "jest-util": "^30.2.0",
     "ts-jest": "^29.4.1",