@usearazzo/runner 1.0.1-alpha.11 → 1.0.1-alpha.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usearazzo/runner",
-  "version": "1.0.1-alpha.11",
+  "version": "1.0.1-alpha.12",
   "description": "Runner for Arazzo Workflows.",
   "keywords": [
     "arazzo",
@@ -72,8 +72,8 @@
     "@swaggerexpert/json-pointer": "^3.0.2",
     "@swaggerexpert/jsonpath": "^4.0.5",
     "@swaggerexpert/media-types": "^1.0.1",
-    "@usearazzo/parser": "1.0.1-alpha.11",
-    "@usearazzo/resolver": "1.0.1-alpha.11",
+    "@usearazzo/parser": "1.0.1-alpha.12",
+    "@usearazzo/resolver": "1.0.1-alpha.12",
     "@xmldom/xmldom": "^0.9.12",
     "fontoxpath": "^3.34.0",
     "ramda": "^0.32.0",
@@ -93,5 +93,5 @@
   "devDependencies": {
     "swagger-client": "^3.38.4"
   },
-  "gitHead": "3cfffaf0045eff162d73df30f840c35cc593af77"
+  "gitHead": "cc5d9b2fb744662650068a5993ebcdd19e8568c2"
 }

package/src/client/OpenAPIOperationResponse.cjs

@@ -17,6 +17,14 @@ exports.default = void 0;
 
 /**
  * Response from an OpenAPI operation execution.
+ *
+ * `body` is the payload parsed by its content type, what `$response.body`
+ * reads. The body as received is read through `text()`, `blob()` and
+ * `bytes()`, named after the WHATWG `Response` methods but synchronous, and
+ * empty when the response carried no body (e.g. `204`, `304`). `bytes()` and
+ * `blob()` always return the bytes received. A body that is valid UTF-8 is held
+ * as its decoded string, which a plain-text or XML `body` shares rather than
+ * duplicates, and is encoded back on read; any other body is held as bytes.
  * @public
  */
 class OpenAPIOperationResponse {
@@ -25,18 +33,45 @@ class OpenAPIOperationResponse {
   status;
   statusText;
   headers;
-  text;
   body;
   request;
+  #content;
   constructor(raw) {
     this.ok = raw.ok;
     this.url = raw.url;
     this.status = raw.status;
     this.statusText = raw.statusText;
     this.headers = raw.headers;
-    this.text = raw.text;
     this.body = raw.body;
+    this.#content = raw.content;
     this.request = raw.request;
   }
+
+  /**
+   * The body as text, like `Response.text()`; `''` when there is none.
+   */
+  text() {
+    return typeof this.#content === 'string' ? this.#content : new TextDecoder().decode(this.#content);
+  }
+
+  /**
+   * The body as a `Blob` typed by the response's `Content-Type`, like
+   * `Response.blob()`.
+   */
+  blob() {
+    // the lib types only take ArrayBuffer-backed views; the normalizer never
+    // produces a shared one.
+    return new Blob([this.#content], {
+      type: this.headers['content-type'] ?? ''
+    });
+  }
+
+  /**
+   * The body as bytes, like `Response.bytes()`; a fresh copy on every call, so
+   * the response stays immutable.
+   */
+  bytes() {
+    return typeof this.#content === 'string' ? new TextEncoder().encode(this.#content) : this.#content.slice();
+  }
 }
 var _default = exports.default = OpenAPIOperationResponse;

package/src/client/OpenAPIOperationResponse.mjs

@@ -11,6 +11,14 @@
 
 /**
  * Response from an OpenAPI operation execution.
+ *
+ * `body` is the payload parsed by its content type, what `$response.body`
+ * reads. The body as received is read through `text()`, `blob()` and
+ * `bytes()`, named after the WHATWG `Response` methods but synchronous, and
+ * empty when the response carried no body (e.g. `204`, `304`). `bytes()` and
+ * `blob()` always return the bytes received. A body that is valid UTF-8 is held
+ * as its decoded string, which a plain-text or XML `body` shares rather than
+ * duplicates, and is encoded back on read; any other body is held as bytes.
  * @public
  */
 class OpenAPIOperationResponse {
@@ -19,18 +27,45 @@ class OpenAPIOperationResponse {
   status;
   statusText;
   headers;
-  text;
   body;
   request;
+  #content;
   constructor(raw) {
     this.ok = raw.ok;
     this.url = raw.url;
     this.status = raw.status;
     this.statusText = raw.statusText;
     this.headers = raw.headers;
-    this.text = raw.text;
     this.body = raw.body;
+    this.#content = raw.content;
     this.request = raw.request;
   }
+
+  /**
+   * The body as text, like `Response.text()`; `''` when there is none.
+   */
+  text() {
+    return typeof this.#content === 'string' ? this.#content : new TextDecoder().decode(this.#content);
+  }
+
+  /**
+   * The body as a `Blob` typed by the response's `Content-Type`, like
+   * `Response.blob()`.
+   */
+  blob() {
+    // the lib types only take ArrayBuffer-backed views; the normalizer never
+    // produces a shared one.
+    return new Blob([this.#content], {
+      type: this.headers['content-type'] ?? ''
+    });
+  }
+
+  /**
+   * The body as bytes, like `Response.bytes()`; a fresh copy on every call, so
+   * the response stays immutable.
+   */
+  bytes() {
+    return typeof this.#content === 'string' ? new TextEncoder().encode(this.#content) : this.#content.slice();
+  }
 }
 export default OpenAPIOperationResponse;

package/src/client/OpenAPIOperationResponseNormalizer.cjs

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+var _mediaTypes = require("@swaggerexpert/media-types");
 var _swaggerClient = require("../vendor/swagger-client.cjs");
 var _OpenAPIOperationResponse = _interopRequireDefault(require("./OpenAPIOperationResponse.cjs"));
 // @ts-expect-error vendored swagger-client bundle has no type declarations
@@ -20,7 +21,11 @@ var _OpenAPIOperationResponse = _interopRequireDefault(require("./OpenAPIOperati
  * Headers are taken from the `Response` directly rather than from the
  * deserializer, which splits every value containing `", "` into an array:
  * values stay strings as sent, with repeated fields (`Set-Cookie` included)
- * combined by `Headers.get`.
+ * combined by `Headers.get`. The body is read once, as bytes, and handed to the
+ * deserializer from memory. A body that decodes as UTF-8 without loss is kept
+ * as that one string, the same one the deserializer parses, so a plain-text or
+ * XML `body` shares it; any other body (binary, another charset, a leading
+ * byte-order mark) is kept as the bytes, so they are never re-encoded lossily.
  * @public
  */
 class OpenAPIOperationResponseNormalizer {
@@ -31,7 +36,30 @@ class OpenAPIOperationResponseNormalizer {
    * carries none (e.g. a stubbed transport).
    */
   async normalize(response, request) {
-    const deserialized = await (0, _swaggerClient.deserializeResponse)(response, request?.url);
+    const bytes = new Uint8Array(await response.arrayBuffer());
+    const text = this.#decodeLosslessly(bytes);
+    // the deserializer matches the raw Content-Type case-sensitively and against
+    // its parameters too, so it is handed only the parsed essence; the response's
+    // own `headers` below stay as sent.
+    const deserializerHeaders = new Headers(response.headers);
+    const contentType = response.headers.get('content-type');
+    const mediaType = contentType === null ? undefined : (0, _mediaTypes.parse)(contentType, {
+      type: 'media-type'
+    }).tree;
+    if (mediaType !== undefined) {
+      deserializerHeaders.set('content-type', `${mediaType.type}/${mediaType.subtype}`);
+    }
+    // the deserializer only reads the body through text() or blob(), by content
+    // type; answering from memory spares a second copy of the stream.
+    const deserialized = await (0, _swaggerClient.deserializeResponse)({
+      ok: response.ok,
+      url: response.url,
+      status: response.status,
+      statusText: response.statusText,
+      headers: deserializerHeaders,
+      text: async () => text ?? new TextDecoder().decode(bytes),
+      blob: async () => new Blob([bytes])
+    }, request?.url);
     const headers = Object.fromEntries(Array.from(response.headers.keys(), name => [name, response.headers.get(name)]));
     return new _OpenAPIOperationResponse.default({
       ok: deserialized.ok,
@@ -39,10 +67,26 @@ class OpenAPIOperationResponseNormalizer {
       status: deserialized.status,
       statusText: deserialized.statusText,
       headers,
-      text: deserialized.text,
       body: deserialized.body,
+      content: text ?? bytes,
       request
     });
   }
+
+  /**
+   * The bytes as a string that encodes back to exactly them, or `undefined`
+   * when there is none: invalid UTF-8, or a leading byte-order mark, which
+   * decoding strips.
+   */
+  #decodeLosslessly(bytes) {
+    if (bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf) return undefined;
+    try {
+      return new TextDecoder('utf-8', {
+        fatal: true
+      }).decode(bytes);
+    } catch {
+      return undefined;
+    }
+  }
 }
 var _default = exports.default = OpenAPIOperationResponseNormalizer;

package/src/client/OpenAPIOperationResponseNormalizer.mjs

@@ -1,3 +1,5 @@
+import { parse } from '@swaggerexpert/media-types';
+
 // @ts-expect-error vendored swagger-client bundle has no type declarations
 import { deserializeResponse } from '../vendor/swagger-client.mjs';
 import OpenAPIOperationResponse from "./OpenAPIOperationResponse.mjs";
@@ -12,7 +14,11 @@ import OpenAPIOperationResponse from "./OpenAPIOperationResponse.mjs";
  * Headers are taken from the `Response` directly rather than from the
  * deserializer, which splits every value containing `", "` into an array:
  * values stay strings as sent, with repeated fields (`Set-Cookie` included)
- * combined by `Headers.get`.
+ * combined by `Headers.get`. The body is read once, as bytes, and handed to the
+ * deserializer from memory. A body that decodes as UTF-8 without loss is kept
+ * as that one string, the same one the deserializer parses, so a plain-text or
+ * XML `body` shares it; any other body (binary, another charset, a leading
+ * byte-order mark) is kept as the bytes, so they are never re-encoded lossily.
  * @public
  */
 class OpenAPIOperationResponseNormalizer {
@@ -23,7 +29,30 @@ class OpenAPIOperationResponseNormalizer {
    * carries none (e.g. a stubbed transport).
    */
   async normalize(response, request) {
-    const deserialized = await deserializeResponse(response, request?.url);
+    const bytes = new Uint8Array(await response.arrayBuffer());
+    const text = this.#decodeLosslessly(bytes);
+    // the deserializer matches the raw Content-Type case-sensitively and against
+    // its parameters too, so it is handed only the parsed essence; the response's
+    // own `headers` below stay as sent.
+    const deserializerHeaders = new Headers(response.headers);
+    const contentType = response.headers.get('content-type');
+    const mediaType = contentType === null ? undefined : parse(contentType, {
+      type: 'media-type'
+    }).tree;
+    if (mediaType !== undefined) {
+      deserializerHeaders.set('content-type', `${mediaType.type}/${mediaType.subtype}`);
+    }
+    // the deserializer only reads the body through text() or blob(), by content
+    // type; answering from memory spares a second copy of the stream.
+    const deserialized = await deserializeResponse({
+      ok: response.ok,
+      url: response.url,
+      status: response.status,
+      statusText: response.statusText,
+      headers: deserializerHeaders,
+      text: async () => text ?? new TextDecoder().decode(bytes),
+      blob: async () => new Blob([bytes])
+    }, request?.url);
     const headers = Object.fromEntries(Array.from(response.headers.keys(), name => [name, response.headers.get(name)]));
     return new OpenAPIOperationResponse({
       ok: deserialized.ok,
@@ -31,10 +60,26 @@ class OpenAPIOperationResponseNormalizer {
       status: deserialized.status,
       statusText: deserialized.statusText,
       headers,
-      text: deserialized.text,
       body: deserialized.body,
+      content: text ?? bytes,
       request
     });
   }
+
+  /**
+   * The bytes as a string that encodes back to exactly them, or `undefined`
+   * when there is none: invalid UTF-8, or a leading byte-order mark, which
+   * decoding strips.
+   */
+  #decodeLosslessly(bytes) {
+    if (bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf) return undefined;
+    try {
+      return new TextDecoder('utf-8', {
+        fatal: true
+      }).decode(bytes);
+    } catch {
+      return undefined;
+    }
+  }
 }
 export default OpenAPIOperationResponseNormalizer;

package/types/runner.d.ts

@@ -1261,15 +1261,23 @@ export declare interface OpenAPIOperationRequestInfo {
 
 /**
  * Response from an OpenAPI operation execution.
+ *
+ * `body` is the payload parsed by its content type, what `$response.body`
+ * reads. The body as received is read through `text()`, `blob()` and
+ * `bytes()`, named after the WHATWG `Response` methods but synchronous, and
+ * empty when the response carried no body (e.g. `204`, `304`). `bytes()` and
+ * `blob()` always return the bytes received. A body that is valid UTF-8 is held
+ * as its decoded string, which a plain-text or XML `body` shares rather than
+ * duplicates, and is encoded back on read; any other body is held as bytes.
  * @public
  */
 export declare class OpenAPIOperationResponse {
+    #private;
     readonly ok: boolean;
     readonly url: string;
     readonly status: number;
     readonly statusText: string;
     readonly headers: Record<string, string>;
-    readonly text: string;
     readonly body: unknown;
     readonly request: OpenAPIOperationRequestInfo | undefined;
     constructor(raw: {
@@ -1278,10 +1286,24 @@ export declare class OpenAPIOperationResponse {
         status: number;
         statusText: string;
         headers: Record<string, string>;
-        text: string;
         body: unknown;
+        content: string | Uint8Array;
         request?: OpenAPIOperationRequestInfo;
     });
+    /**
+     * The body as text, like `Response.text()`; `''` when there is none.
+     */
+    text(): string;
+    /**
+     * The body as a `Blob` typed by the response's `Content-Type`, like
+     * `Response.blob()`.
+     */
+    blob(): Blob;
+    /**
+     * The body as bytes, like `Response.bytes()`; a fresh copy on every call, so
+     * the response stays immutable.
+     */
+    bytes(): Uint8Array;
 }
 
 /**
@@ -1295,10 +1317,15 @@ export declare class OpenAPIOperationResponse {
  * Headers are taken from the `Response` directly rather than from the
  * deserializer, which splits every value containing `", "` into an array:
  * values stay strings as sent, with repeated fields (`Set-Cookie` included)
- * combined by `Headers.get`.
+ * combined by `Headers.get`. The body is read once, as bytes, and handed to the
+ * deserializer from memory. A body that decodes as UTF-8 without loss is kept
+ * as that one string, the same one the deserializer parses, so a plain-text or
+ * XML `body` shares it; any other body (binary, another charset, a leading
+ * byte-order mark) is kept as the bytes, so they are never re-encoded lossily.
  * @public
  */
 export declare class OpenAPIOperationResponseNormalizer {
+    #private;
     /**
      * Deserializes the response body by content type and maps the result into the
      * runner's response model. `request` is the request the operation was