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

package/dist/batch/AdtBatchConnection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AdtBatchConnection.d.ts","sourceRoot":"","sources":["../../src/batch/AdtBatchConnection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,mBAAmB,EACnB,gBAAgB,EACjB,MAAM,yCAAyC,CAAC;AACjD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AAS9D,KAAK,OAAO,GAAG,UAAU,GAAG,WAAW,CAAC;AAQxC,sFAAsF;AACtF,qBAAa,kBAAmB,YAAW,eAAe;IAOtD,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,OAAO;IAP1B,OAAO,CAAC,KAAK,CAAiB;IAC9B,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAU;IACzC,OAAO,CAAC,iBAAiB,CAAC,CAAqB;IAC/C,OAAO,CAAC,SAAS,CAAS;gBAEP,UAAU,EAAE,eAAe,EAC3B,OAAO,EAAE;QACxB,QAAQ,EAAE,eAAe,GAAG,UAAU,CAAC;QACvC,MAAM,CAAC,EAAE,OAAO,CAAC;KAClB;IAWH,OAAO,CAAC,cAAc;IAWtB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAGxB,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC;IAG7B,YAAY,IAAI,MAAM,GAAG,IAAI;IAG7B,cAAc,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;IAGnC,cAAc,IAAI,OAAO;IAGzB,cAAc,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,EACrC,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAuBlC,OAAO,CAAC,WAAW;IAkBnB,6EAA6E;IACvE,OAAO,IAAI,OAAO,CAAC,gBAAgB,CAAC;CAiG3C"}
+{"version":3,"file":"AdtBatchConnection.d.ts","sourceRoot":"","sources":["../../src/batch/AdtBatchConnection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,mBAAmB,EACnB,gBAAgB,EACjB,MAAM,yCAAyC,CAAC;AACjD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AAU9D,KAAK,OAAO,GAAG,UAAU,GAAG,WAAW,CAAC;AAQxC,sFAAsF;AACtF,qBAAa,kBAAmB,YAAW,eAAe;IAOtD,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,OAAO;IAP1B,OAAO,CAAC,KAAK,CAAiB;IAC9B,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAU;IACzC,OAAO,CAAC,iBAAiB,CAAC,CAAqB;IAC/C,OAAO,CAAC,SAAS,CAAS;gBAEP,UAAU,EAAE,eAAe,EAC3B,OAAO,EAAE;QACxB,QAAQ,EAAE,eAAe,GAAG,UAAU,CAAC;QACvC,MAAM,CAAC,EAAE,OAAO,CAAC;KAClB;IAWH,OAAO,CAAC,cAAc;IAWtB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAGxB,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC;IAG7B,YAAY,IAAI,MAAM,GAAG,IAAI;IAG7B,cAAc,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;IAGnC,cAAc,IAAI,OAAO;IAGzB,cAAc,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,EACrC,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAuBlC,OAAO,CAAC,WAAW;IAkBnB,6EAA6E;IACvE,OAAO,IAAI,OAAO,CAAC,gBAAgB,CAAC;CAmH3C"}

package/dist/batch/AdtBatchConnection.js

@@ -4,6 +4,7 @@ exports.AdtBatchConnection = void 0;
 const objects_1 = require("../endpoints/objects");
 const acceptNegotiation_1 = require("../utils/acceptNegotiation");
 const adtResponse_1 = require("../utils/adtResponse");
+const requestTrace_1 = require("../utils/requestTrace");
 const wire_1 = require("./wire");
 /** Records member requests; execute also drains requests queued during settlement. */
 class AdtBatchConnection {
@@ -149,6 +150,25 @@ class AdtBatchConnection {
             const unsentError = (0, adtResponse_1.isUnansweredCredentialRefusal)(error)
                 ? error
                 : new Error('ADT batch request not sent because an earlier batch envelope failed', { cause: error });
+            // The envelope failed as a whole: every part it carried rejects with
+            // this one object. The request that failed is the envelope's own POST,
+            // not any part — and no part's trace may write its own over it.
+            // Marked first: the mark cannot fail. The request is written only where
+            // the failure takes it — a frozen one does not, and the parts settle
+            // with it as it came either way.
+            if (active.length && !(0, adtResponse_1.isUnansweredCredentialRefusal)(error)) {
+                (0, requestTrace_1.markEnvelopeFailure)(error);
+                if (error !== null && typeof error === 'object')
+                    Reflect.defineProperty(error, 'request', {
+                        value: { method: 'POST', url: objects_1.BATCH[this.options.endpoint] },
+                        writable: true,
+                        enumerable: true,
+                        configurable: true,
+                    });
+            }
+            // The "not sent" failure is one object shared by every unsent part, too.
+            if (unsentError !== error)
+                (0, requestTrace_1.markEnvelopeFailure)(unsentError);
             this.settlementFailure = { error: unsentError };
             for (const part of active)
                 part.reject(error);

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 } from './utils/acceptNegotiation';
+export { exemptFromAcceptNegotiation, getBaseRequest, } 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,EAAE,2BAA2B,EAAE,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,2BAA2B,EAC3B,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.exemptFromAcceptNegotiation = exports.CT_INCLUDE = exports.AdtInclude = exports.AdtBatchConnection = void 0;
+exports.getBaseRequest = exports.exemptFromAcceptNegotiation = 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");
@@ -48,3 +48,4 @@ __exportStar(require("./index.runtime"), exports);
 __exportStar(require("./index.ws"), exports);
 var acceptNegotiation_1 = require("./utils/acceptNegotiation");
 Object.defineProperty(exports, "exemptFromAcceptNegotiation", { enumerable: true, get: function () { return acceptNegotiation_1.exemptFromAcceptNegotiation; } });
+Object.defineProperty(exports, "getBaseRequest", { enumerable: true, get: function () { return acceptNegotiation_1.getBaseRequest; } });

package/dist/utils/acceptNegotiation.d.ts

@@ -26,8 +26,10 @@ export declare function extractSupportedContentType(error: unknown): string[];
  * wrapped it: accept negotiation corrects and resends nothing. The
  * connection's own handling (credential, CSRF, session) is untouched.
  *
- * Exported for the batch connection: what SAP answers to an envelope is the
- * caller's to read.
+ * Exported for the batch connection, and public for a consumer that forwards a
+ * batch's envelope through a connection of its own over one an `AdtClient`
+ * wrapped: what SAP answers to an envelope is the caller's to read. For a
+ * connection never wrapped it is the connection's own `makeAdtRequest`, bound.
  */
 export declare function getBaseRequest(connection: IAbapConnection): IAbapConnection['makeAdtRequest'];
 export declare function wrapConnectionAcceptNegotiation(connection: IAbapConnection, logger?: ILogger): void;

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;;;;;;;GAOG;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,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"}

package/dist/utils/acceptNegotiation.js

@@ -139,8 +139,10 @@ function buildCacheKey(request) {
  * wrapped it: accept negotiation corrects and resends nothing. The
  * connection's own handling (credential, CSRF, session) is untouched.
  *
- * Exported for the batch connection: what SAP answers to an envelope is the
- * caller's to read.
+ * Exported for the batch connection, and public for a consumer that forwards a
+ * batch's envelope through a connection of its own over one an `AdtClient`
+ * wrapped: what SAP answers to an envelope is the caller's to read. For a
+ * connection never wrapped it is the connection's own `makeAdtRequest`, bound.
  */
 function getBaseRequest(connection) {
     return (baseRequestMap.get(connection) ?? connection.makeAdtRequest.bind(connection));

package/dist/utils/requestTrace.d.ts

@@ -44,6 +44,12 @@ export interface IAdtRequestTrace {
  * the field only when it means something.
  */
 export declare function requestOf(answer?: IAdtWireResponse): IAdtRequestTrace | undefined;
+/**
+ * Mark `error` as a batch envelope's failure, so the trace leaves it as it
+ * came. Module-internal (not in the package's index): the batch connection is
+ * its one caller.
+ */
+export declare function markEnvelopeFailure(error: unknown): void;
 /**
  * Put the request back on the answer.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"requestTrace.d.ts","sourceRoot":"","sources":["../../src/utils/requestTrace.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,KAAK,EACV,eAAe,EAEf,gBAAgB,EACjB,MAAM,yCAAyC,CAAC;AAGjD,+EAA+E;AAC/E,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CACvB,MAAM,CAAC,EAAE,gBAAgB,GACxB,gBAAgB,GAAG,SAAS,CAI9B;AAKD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,eAAe,GAAG,eAAe,CAmD7E"}
+{"version":3,"file":"requestTrace.d.ts","sourceRoot":"","sources":["../../src/utils/requestTrace.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,KAAK,EACV,eAAe,EAEf,gBAAgB,EACjB,MAAM,yCAAyC,CAAC;AAGjD,+EAA+E;AAC/E,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CACvB,MAAM,CAAC,EAAE,gBAAgB,GACxB,gBAAgB,GAAG,SAAS,CAI9B;AAgBD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAExD;AAWD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,eAAe,GAAG,eAAe,CAsD7E"}

package/dist/utils/requestTrace.js

@@ -32,6 +32,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.requestOf = requestOf;
+exports.markEnvelopeFailure = markEnvelopeFailure;
 exports.withRequestTrace = withRequestTrace;
 const adtResponse_1 = require("./adtResponse");
 /**
@@ -48,6 +49,31 @@ function requestOf(answer) {
         return undefined;
     return { method: carried.method, url: carried.url };
 }
+/**
+ * The mark of a batch envelope's failure: one object, rejected to every part
+ * the envelope carried. Each part's request passes through the trace, and a
+ * part writing its own request onto that shared object would name itself on
+ * every other part's failure — the last part's winning, a request never sent
+ * on its own. The object carries the envelope's own request instead, set by
+ * the batch connection that sent it.
+ *
+ * Kept in a `WeakSet` rather than under a symbol on the error: a transport may
+ * reject with a frozen error, which takes no property, and the mark must hold
+ * on it all the same — the parts settle with that failure as it came.
+ */
+const envelopeFailures = new WeakSet();
+/**
+ * Mark `error` as a batch envelope's failure, so the trace leaves it as it
+ * came. Module-internal (not in the package's index): the batch connection is
+ * its one caller.
+ */
+function markEnvelopeFailure(error) {
+    if (error !== null && typeof error === 'object')
+        envelopeFailures.add(error);
+}
+function isEnvelopeFailure(error) {
+    return (error !== null && typeof error === 'object' && envelopeFailures.has(error));
+}
 /** Connections already carrying the trace. */
 const traced = new WeakSet();
 /**
@@ -101,8 +127,10 @@ function withRequestTrace(connection) {
             //
             // A credential refusal SAP was never asked about is not annotated: it is
             // the connection's own object, rethrown to the caller as it came, and
-            // this wrapper does not write onto it.
-            if ((0, adtResponse_1.isUnansweredCredentialRefusal)(error))
+            // this wrapper does not write onto it. Nor is a batch envelope's
+            // failure: every part of the envelope rejects with that one object, and
+            // it already names the request that failed — the envelope's own.
+            if ((0, adtResponse_1.isUnansweredCredentialRefusal)(error) || isEnvelopeFailure(error))
                 throw error;
             error.request = asked;
             throw error;

package/docs/usage/BATCH.md

@@ -83,7 +83,10 @@ that part's answer like any other status; nothing reads it, corrects it or
 sends it again. A connection of your own that members send through instead of
 the batch connection — a per-call wrapper over it, say — is a different object
 and is negotiated like any other; mark it with `exemptFromAcceptNegotiation(wrapper)`
-(exported by the package) and it is exempt too. A batch is yours, and so is
+(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
 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,
@@ -115,9 +118,14 @@ Recorded request promises receive inner responses, in order: 2xx resolves; other
 statuses reject with an Error carrying `response: { status, statusText, headers,
 data }`, matching direct HTTP failure handling. Members keep their usual
 `IAdtResponse` and strategy behavior. Envelope/parse failures stop execution immediately and reject `execute()` and
-parts in the failed envelope. Unsent runs and queued follow-ups reject with a
+parts in the failed envelope. Every part of that envelope rejects with the same
+object and message, and its `request` is the envelope's own
+(`{ method: 'POST', url: '/sap/bc/adt/communication/batch' }`, or the debugger's
+batch URL), not any part's; a failure that takes no property, a frozen one,
+reaches every part as it came, without it. Unsent runs and queued follow-ups reject with a
 library error saying the request was not sent because an earlier envelope failed;
-that error carries the cause, without a SAP response. Missing parts reject with a part-count error. A count
+that error carries the cause, without a SAP response and without a `request` of
+its own. Missing parts reject with a part-count error. A count
 mismatch also rejects `execute()`. Attach rejection handlers before execution when
 using raw connection promises. Each execute sends follow-up envelopes for requests recorded during settlement
 by member continuations; accept negotiation records none. It yields one event-loop turn

package/package.json

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