@mcp-abap-adt/adt-clients 34.2.1 → 35.0.0

package/README.md

@@ -834,20 +834,28 @@ Some ADT endpoints return `406` when the `Accept` header does not match the
 system's supported media types. The client retries once with a type the `406`
 names, and remembers it for that endpoint.
 
-**It is on unless you turn it off** — per client, or for the process:
+**It is off unless you turn it on** (since 35.0.0) — per client, or for the
+process. Without a switch a `406` or `415` is the call's answer and nothing is
+sent again:
 
 ```typescript
 import { AdtClient } from '@mcp-abap-adt/adt-clients';
 
 const client = new AdtClient(connection, console, {
-  enableAcceptCorrection: false,
+  enableAcceptCorrection: true,
 });
 ```
 
 ```bash
-ADT_ACCEPT_CORRECTION=false npm test
+ADT_ACCEPT_CORRECTION=true npm test
 ```
 
+The variable turns it on only when it is exactly `true`. To correct requests
+yourself instead, read a `406` with `extractSupportedAccept(error)` and keep
+the result in the connection's cache with `rememberAccept(connection, request,
+accept)`; `cachedAccept(connection, request)` reads it back, whatever the
+switch says. See [batch](docs/usage/BATCH.md).
+
 **The state is the connection's** since 23.0.0: the remembered types and the
 switch live on the connection object. They used to be module globals, so a
 header learned on one system was sent to every other, and one client's switch
@@ -1021,6 +1029,7 @@ See [Architecture Documentation](docs/architecture/ARCHITECTURE.md#type-system-a
 One document per breaking release, each written for a consumer on the contract
 before it:
 
+- **[34.x → 35.0.0](docs/usage/MIGRATION-35.md)** — accept negotiation is off by default: a `406`/`415` is the call's answer unless you switch it on.
 - **[33.x → 34.0.0](docs/usage/MIGRATION-34.md)** — a batch corrects and resends nothing: a part's `406`/`415` is that call's answer.
 - **[32.x → 33.0.0](docs/usage/MIGRATION-33.md)** — a credential the provider refused before SAP was asked rejects with the connection's refusal as it came; a `401` SAP refused it with comes back carrying that response.
 - **[31.x → 32.0.0](docs/usage/MIGRATION-32.md)** — interfaces-adt 18, three enhancement subtypes, subtype-specific create fields, two new result slots for enhancement hosts, and `metadataUpdated` for enhancement document writes.

package/dist/index.d.ts

@@ -26,5 +26,5 @@ export * from './index.executors';
 export * from './index.readings';
 export * from './index.runtime';
 export * from './index.ws';
-export { exemptFromAcceptNegotiation, getBaseRequest, } from './utils/acceptNegotiation';
+export { cachedAccept, exemptFromAcceptNegotiation, extractSupportedAccept, getBaseRequest, rememberAccept, } from './utils/acceptNegotiation';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACxD,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,OAAO,EACL,2BAA2B,EAC3B,cAAc,GACf,MAAM,2BAA2B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACxD,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,OAAO,EACL,YAAY,EACZ,2BAA2B,EAC3B,sBAAsB,EACtB,cAAc,EACd,cAAc,GACf,MAAM,2BAA2B,CAAC"}

package/dist/index.js

@@ -34,7 +34,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBaseRequest = exports.exemptFromAcceptNegotiation = exports.CT_INCLUDE = exports.AdtInclude = exports.AdtBatchConnection = void 0;
+exports.rememberAccept = exports.getBaseRequest = exports.extractSupportedAccept = exports.exemptFromAcceptNegotiation = exports.cachedAccept = exports.CT_INCLUDE = exports.AdtInclude = exports.AdtBatchConnection = void 0;
 var batch_1 = require("./batch");
 Object.defineProperty(exports, "AdtBatchConnection", { enumerable: true, get: function () { return batch_1.AdtBatchConnection; } });
 var include_1 = require("./core/include");
@@ -47,5 +47,8 @@ __exportStar(require("./index.readings"), exports);
 __exportStar(require("./index.runtime"), exports);
 __exportStar(require("./index.ws"), exports);
 var acceptNegotiation_1 = require("./utils/acceptNegotiation");
+Object.defineProperty(exports, "cachedAccept", { enumerable: true, get: function () { return acceptNegotiation_1.cachedAccept; } });
 Object.defineProperty(exports, "exemptFromAcceptNegotiation", { enumerable: true, get: function () { return acceptNegotiation_1.exemptFromAcceptNegotiation; } });
+Object.defineProperty(exports, "extractSupportedAccept", { enumerable: true, get: function () { return acceptNegotiation_1.extractSupportedAccept; } });
 Object.defineProperty(exports, "getBaseRequest", { enumerable: true, get: function () { return acceptNegotiation_1.getBaseRequest; } });
+Object.defineProperty(exports, "rememberAccept", { enumerable: true, get: function () { return acceptNegotiation_1.rememberAccept; } });

package/dist/utils/acceptNegotiation.d.ts

@@ -17,10 +17,28 @@ export interface IAcceptNegotiationOptions {
 export declare function clearAcceptCache(connection: IAbapConnection): void;
 /** Switch correction on or off for this connection alone. */
 export declare function setAcceptCorrectionEnabled(connection: IAbapConnection, enabled?: boolean): void;
-/** This connection's switch, or the `ADT_ACCEPT_CORRECTION` default. */
+/**
+ * This connection's switch, else the `ADT_ACCEPT_CORRECTION` default. Off
+ * unless explicitly on: the environment variable turns it on only when it is
+ * exactly `true`; unset, or any other value, leaves it off.
+ */
 export declare function getAcceptCorrectionEnabled(connection: IAbapConnection): boolean;
 export declare function extractSupportedAccept(error: unknown): string[];
 export declare function extractSupportedContentType(error: unknown): string[];
+/**
+ * The Accept stored for `request`'s method and URL on this connection: what a
+ * `406` taught negotiation or `rememberAccept` stored, or `undefined` when
+ * there is none. A plain read of the per-connection cache, whatever the
+ * correction switch says, so a consumer that corrects requests itself can read
+ * it while negotiation is off.
+ */
+export declare function cachedAccept(connection: IAbapConnection, request: IAbapRequestOptions): string | undefined;
+/**
+ * Store a corrected Accept for `request`'s method and URL on this connection,
+ * as the negotiation's own `406` branch does: a later request through the
+ * connection's negotiation sends it. A plain write of the per-connection cache.
+ */
+export declare function rememberAccept(connection: IAbapConnection, request: IAbapRequestOptions, accept: string): void;
 /**
  * The connection's request as it was before an `AdtClient` with correction on
  * wrapped it: accept negotiation corrects and resends nothing. The

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,EACV,eAAe,EACf,mBAAmB,EACnB,gBAAgB,EACjB,MAAM,yCAAyC,CAAC;AAEjD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AAkD9D;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CAAC,UAAU,EAAE,eAAe,GAAG,IAAI,CAM7E;AAaD,MAAM,WAAW,yBAAyB;IACxC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,2CAA2C;AAC3C,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,eAAe,GAAG,IAAI,CAIlE;AAED,6DAA6D;AAC7D,wBAAgB,0BAA0B,CACxC,UAAU,EAAE,eAAe,EAC3B,OAAO,CAAC,EAAE,OAAO,GAChB,IAAI,CAEN;AAED,wEAAwE;AACxE,wBAAgB,0BAA0B,CACxC,UAAU,EAAE,eAAe,GAC1B,OAAO,CAIT;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAoC/D;AAED,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAsCpE;AAMD;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,eAAe,GAC1B,eAAe,CAAC,gBAAgB,CAAC,CAInC;AAED,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,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAkFjC"}
+{"version":3,"file":"acceptNegotiation.d.ts","sourceRoot":"","sources":["../../src/utils/acceptNegotiation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,mBAAmB,EACnB,gBAAgB,EACjB,MAAM,yCAAyC,CAAC;AAEjD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AAkD9D;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CAAC,UAAU,EAAE,eAAe,GAAG,IAAI,CAM7E;AAaD,MAAM,WAAW,yBAAyB;IACxC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,2CAA2C;AAC3C,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,eAAe,GAAG,IAAI,CAIlE;AAED,6DAA6D;AAC7D,wBAAgB,0BAA0B,CACxC,UAAU,EAAE,eAAe,EAC3B,OAAO,CAAC,EAAE,OAAO,GAChB,IAAI,CAEN;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,UAAU,EAAE,eAAe,GAC1B,OAAO,CAIT;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAoC/D;AAED,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAsCpE;AAMD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,UAAU,EAAE,eAAe,EAC3B,OAAO,EAAE,mBAAmB,GAC3B,MAAM,GAAG,SAAS,CAEpB;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,eAAe,EAC3B,OAAO,EAAE,mBAAmB,EAC5B,MAAM,EAAE,MAAM,GACb,IAAI,CAEN;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,eAAe,GAC1B,eAAe,CAAC,gBAAgB,CAAC,CAInC;AAED,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,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAkFjC"}

package/dist/utils/acceptNegotiation.js

@@ -6,6 +6,8 @@ exports.setAcceptCorrectionEnabled = setAcceptCorrectionEnabled;
 exports.getAcceptCorrectionEnabled = getAcceptCorrectionEnabled;
 exports.extractSupportedAccept = extractSupportedAccept;
 exports.extractSupportedContentType = extractSupportedContentType;
+exports.cachedAccept = cachedAccept;
+exports.rememberAccept = rememberAccept;
 exports.getBaseRequest = getBaseRequest;
 exports.wrapConnectionAcceptNegotiation = wrapConnectionAcceptNegotiation;
 exports.makeAdtRequestWithAcceptNegotiation = makeAdtRequestWithAcceptNegotiation;
@@ -59,12 +61,16 @@ function clearAcceptCache(connection) {
 function setAcceptCorrectionEnabled(connection, enabled) {
     stateOf(connection).enabled = enabled;
 }
-/** This connection's switch, or the `ADT_ACCEPT_CORRECTION` default. */
+/**
+ * This connection's switch, else the `ADT_ACCEPT_CORRECTION` default. Off
+ * unless explicitly on: the environment variable turns it on only when it is
+ * exactly `true`; unset, or any other value, leaves it off.
+ */
 function getAcceptCorrectionEnabled(connection) {
     const enabled = stateOf(connection).enabled;
     if (enabled !== undefined)
         return enabled;
-    return process.env.ADT_ACCEPT_CORRECTION !== 'false';
+    return process.env.ADT_ACCEPT_CORRECTION === 'true';
 }
 function extractSupportedAccept(error) {
     const types = new Set();
@@ -134,6 +140,24 @@ function extractSupportedContentType(error) {
 function buildCacheKey(request) {
     return `${request.method.toUpperCase()} ${request.url}`;
 }
+/**
+ * The Accept stored for `request`'s method and URL on this connection: what a
+ * `406` taught negotiation or `rememberAccept` stored, or `undefined` when
+ * there is none. A plain read of the per-connection cache, whatever the
+ * correction switch says, so a consumer that corrects requests itself can read
+ * it while negotiation is off.
+ */
+function cachedAccept(connection, request) {
+    return stateOf(connection).accept.get(buildCacheKey(request));
+}
+/**
+ * Store a corrected Accept for `request`'s method and URL on this connection,
+ * as the negotiation's own `406` branch does: a later request through the
+ * connection's negotiation sends it. A plain write of the per-connection cache.
+ */
+function rememberAccept(connection, request, accept) {
+    stateOf(connection).accept.set(buildCacheKey(request), accept);
+}
 /**
  * The connection's request as it was before an `AdtClient` with correction on
  * wrapped it: accept negotiation corrects and resends nothing. The

package/docs/usage/BATCH.md

@@ -73,7 +73,8 @@ Use the real handles and inspect activation messages, including `type="E"`.
 The transport provides no transaction or rollback; callers own recovery and
 cleanup after partial failures.
 
-Accept negotiation never corrects or resends an envelope or its parts. A batch
+Accept negotiation never corrects or resends an envelope or its parts. (Since
+35.0.0 it corrects nothing anywhere unless switched on.) A batch
 connection is exempt from it: an `AdtClient` built over one does not wrap it,
 whatever `enableAcceptCorrection` it is given, and a member that negotiates by
 itself sends through it once. On a connection an `AdtClient` wrapped with
@@ -86,7 +87,27 @@ and is negotiated like any other; mark it with `exemptFromAcceptNegotiation(wrap
 (exported by the package) and it is exempt too. When the batch connection wraps
 a forwarder of yours over a connection an `AdtClient` wrapped, forward through
 `getBaseRequest(thatConnection)` (exported): the envelope then bypasses that
-connection's accept negotiation and is sent once. A batch is yours, and so is
+connection's accept negotiation and is sent once. To correct a part that SAP
+answered with `406` yourself, read the acceptable formats from that answer with
+`extractSupportedAccept(error)` (exported): it takes the error the `406` came
+as — any value; one without a response yields an empty list — and returns the
+supported media types as a `string[]`. It reads them from the response headers
+`accept`, `x-sap-adt-supported-accept`, `x-sap-adt-accept`, `supported-accept`
+and `accept-supported` (comma-separated), and from every `type/subtype`
+(with an optional `;parameter`) found in the response body, without
+duplicates. It is the reading accept negotiation applies to a `406` itself.
+
+The corrected Accept is remembered where negotiation remembers its own: the
+connection's accept cache, keyed by method and URL. `cachedAccept(connection,
+request)` (exported) returns the Accept stored for that request's method and
+URL on that connection — what a `406` taught negotiation or `rememberAccept`
+stored — or `undefined` when there is none. It is a plain read of the cache and
+ignores the correction switch, so a consumer that corrects requests itself can
+use it while negotiation is off. `rememberAccept(connection, request, accept)` (exported) stores
+`accept` for the request's method and URL on the connection and returns nothing;
+a later request through an `AdtClient` with correction on over the same
+connection sends it (with correction off, only the consumer's own code reads it). Both read and write that cache only, so a correction
+learned on either path serves both. A batch is yours, and so is
 what SAP answered to each of its parts. The envelope request itself still goes
 through the connection's own handling — credential renewal, CSRF recovery and
 session — as every request does: that is about the connection to the endpoint,

package/docs/usage/CLIENT_API_REFERENCE.md

@@ -1042,7 +1042,10 @@ judgement moved to the caller, who knows which types they are activating.
 
 ### Accept Negotiation
 
-The client can optionally auto-correct `Accept` headers after a 406 response:
+The client can optionally auto-correct `Accept` headers after a 406 response
+(and `Content-Type` after a 415). It is **off** unless switched on, per client
+as below or with `ADT_ACCEPT_CORRECTION=true`; with no switch a `406`/`415` is
+the call's answer and nothing is sent again (default flipped in 35.0.0):
 
 ```typescript
 const client = new AdtClient(connection, console, {

package/docs/usage/MIGRATION-35.md

@@ -0,0 +1,33 @@
+# Migrating to 35.0.0
+
+35.0.0 changes no type and no dependency range. It changes one default.
+
+## Accept negotiation is off unless switched on
+
+Until 34.x, a request SAP answered `406` (its `Accept` not served) or `415`
+(its `Content-Type` not accepted) was corrected from the types SAP named and
+sent once more, unless you turned that off. Now nothing is corrected or sent
+again unless you turn it on: the `406`/`415` is the call's answer, like any
+other status.
+
+- `getAcceptCorrectionEnabled(connection)` is `false` without an explicit
+  switch.
+- `ADT_ACCEPT_CORRECTION=true` turns it on. Only the exact value `true` does;
+  unset, `false` or anything else leaves it off.
+- The `enableAcceptCorrection` option and `setAcceptCorrectionEnabled` are
+  unchanged.
+
+What to do if you relied on the default:
+
+1. Switch it on: `new AdtClient(connection, logger, { enableAcceptCorrection:
+   true })` (the same option on `AdtRuntimeClient`), or set
+   `ADT_ACCEPT_CORRECTION=true`; or
+2. Correct the request yourself. `extractSupportedAccept(error)` returns the
+   media types a `406` names; `rememberAccept(connection, request, accept)`
+   stores the one you choose in the connection's accept cache;
+   `cachedAccept(connection, request)` reads it back. All three are exported
+   from the package root; the last two read and write the cache negotiation
+   itself uses, so a correction made either way serves both.
+
+`cachedAccept` is a plain read of the cache and no longer depends on the switch.
+A batch connection stays exempt from negotiation.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcp-abap-adt/adt-clients",
-  "version": "34.2.1",
+  "version": "35.0.0",
   "description": "ADT clients for SAP ABAP systems - AdtClient and AdtRuntimeClient",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",