api-def 0.12.1 → 0.13.0

package/esm/RequestContext.js

@@ -1,14 +1,5 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { resolvePathParams, resolveUrl } from "./ApiUtils";
-import * as Utils from "./Utils";
+import { resolvePathParams, resolveUrl } from "./ApiUtils.js";
+import * as Utils from "./Utils.js";
 let contextIdCounter = 0;
 export default class RequestContext {
     constructor(backend, host, config, rawPath, mocking) {
@@ -100,15 +91,14 @@ export default class RequestContext {
         return this;
     }
     parseRequestBody() {
-        var _a;
         if (this.requestConfig.body && this.requestConfig.headers) {
             const contentTypeKey = Object.keys(this.requestConfig.headers).find((key) => key.toLowerCase() === "content-type");
-            const contentType = contentTypeKey && ((_a = this.requestConfig.headers[contentTypeKey]) === null || _a === void 0 ? void 0 : _a.toString().split(";")[0].trim());
+            const contentType = contentTypeKey && this.requestConfig.headers[contentTypeKey]?.toString().split(";")[0].trim();
             if (contentType === "application/x-www-form-urlencoded") {
                 const searchParams = new URLSearchParams();
                 for (const key of Object.keys(this.requestConfig.body)) {
                     const value = this.requestConfig.body[key];
-                    searchParams.append(key, value === null || value === void 0 ? void 0 : value.toString());
+                    searchParams.append(key, value?.toString());
                 }
                 this.parsedBody = searchParams;
             }
@@ -128,20 +118,18 @@ export default class RequestContext {
         this.computedRequestUrl = this.resolveRequestUrl();
         return this;
     }
-    triggerEvent(eventType) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const eventHandlers = this.eventHandlers[eventType];
-            if (eventHandlers) {
-                for (let i = 0; i < eventHandlers.length; i++) {
-                    const eventHandler = eventHandlers[i];
-                    const eventResult = yield eventHandler(this);
-                    if (eventResult) {
-                        return eventResult;
-                    }
+    async triggerEvent(eventType) {
+        const eventHandlers = this.eventHandlers[eventType];
+        if (eventHandlers) {
+            for (let i = 0; i < eventHandlers.length; i++) {
+                const eventHandler = eventHandlers[i];
+                const eventResult = await eventHandler(this);
+                if (eventResult) {
+                    return eventResult;
                 }
             }
-            return undefined;
-        });
+        }
+        return undefined;
     }
     addCanceller(canceler) {
         this.canceler = canceler;
@@ -170,7 +158,7 @@ export default class RequestContext {
         this.computedMethod = method;
     }
     updateBody(body) {
-        // @ts-ignore
+        // @ts-expect-error
         this.requestConfig.body = body;
         this.parseRequestBody();
     }

package/esm/RequestError.d.ts

@@ -1,6 +1,6 @@
-import type { ApiResponse } from "./ApiTypes";
-import type RequestContext from "./RequestContext";
-import type { EnumOf } from "./Utils";
+import type { ApiResponse } from "./ApiTypes.js";
+import type RequestContext from "./RequestContext.js";
+import type { EnumOf } from "./Utils.js";
 export declare const RequestErrorCode: {
     readonly MISC_UNKNOWN_ERROR: "misc/unknown-error";
     readonly REQUEST_NETWORK_ERROR: "request/network-error";

package/esm/RequestError.js

@@ -46,7 +46,7 @@ export const convertToRequestError = (config) => {
     });
     try {
         Object.defineProperty(resultError, "message", {
-            value: `A ${context.method.toUpperCase()} request to '${context.requestUrl.href}' failed${(response === null || response === void 0 ? void 0 : response.status) ? ` with status code ${response.status}` : ""} [${code}]: ${resultError.message}`,
+            value: `A ${context.method.toUpperCase()} request to '${context.requestUrl.href}' failed${response?.status ? ` with status code ${response.status}` : ""} [${code}]: ${resultError.message}`,
         });
     }
     catch (e) {
@@ -57,9 +57,8 @@ export const convertToRequestError = (config) => {
     return resultError;
 };
 export const getErrorResponse = (error) => {
-    var _a;
     if (isRequestError(error)) {
-        return (_a = error.response) !== null && _a !== void 0 ? _a : undefined;
+        return error.response ?? undefined;
     }
     return undefined;
 };

package/esm/Requester.d.ts

@@ -1,3 +1,3 @@
-import type { ApiResponse, Body, Params, Query, RequestConfig, RequestHost, State } from "./ApiTypes";
-import type { EndpointMockingConfig } from "./MockingTypes";
+import type { ApiResponse, Body, Params, Query, RequestConfig, RequestHost, State } from "./ApiTypes.js";
+import type { EndpointMockingConfig } from "./MockingTypes.js";
 export declare const submit: <TResponse, TParams extends Params | undefined, TQuery extends Query | undefined, TBody extends Body | undefined, TState extends State>(host: RequestHost, config: RequestConfig<TParams, TQuery, TBody, TState>, mocking: EndpointMockingConfig<TResponse, TParams, TQuery, TBody, TState> | null | undefined) => Promise<ApiResponse<TResponse>>;

package/esm/Requester.js

@@ -1,23 +1,14 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { EventResultType, RequestEvent } from "./ApiConstants";
-import { inferResponseType, isAcceptableStatus, isNetworkError } from "./ApiUtils";
-import RequestContext from "./RequestContext";
-import { RequestErrorCode, convertToRequestError, isRequestError } from "./RequestError";
-import { textDecode } from "./TextDecoding";
-import MockRequestBackend from "./backend/MockRequestBackend";
-import retry from "./util/retry";
+import { EventResultType, RequestEvent } from "./ApiConstants.js";
+import { inferResponseType, isAcceptableStatus, isNetworkError } from "./ApiUtils.js";
+import MockRequestBackend from "./backend/MockRequestBackend.js";
+import RequestContext from "./RequestContext.js";
+import { convertToRequestError, isRequestError, RequestErrorCode } from "./RequestError.js";
+import { textDecode } from "./TextDecoding.js";
+import retry from "./util/retry/index.js";
 const locks = {};
 const runningOperations = {};
 const MOCK_REQUEST_BACKEND = new MockRequestBackend();
-export const submit = (host, config, mocking) => __awaiter(void 0, void 0, void 0, function* () {
+export const submit = async (host, config, mocking) => {
     const computedConfig = host.computeConfig(config);
     const backend = mocking ? MOCK_REQUEST_BACKEND : host.getRequestBackend();
     const context = new RequestContext(backend, host, computedConfig, host.path, mocking);
@@ -39,8 +30,8 @@ export const submit = (host, config, mocking) => __awaiter(void 0, void 0, void
         locks[lock] = context;
     }
     try {
-        let response = yield (runningOperations[key] = makeRequest(context));
-        const successEventResult = yield context.triggerEvent(RequestEvent.SUCCESS);
+        let response = await (runningOperations[key] = makeRequest(context));
+        const successEventResult = await context.triggerEvent(RequestEvent.SUCCESS);
         if (successEventResult && successEventResult.type === EventResultType.RESPOND) {
             context.response = response = successEventResult.response;
         }
@@ -56,7 +47,7 @@ export const submit = (host, config, mocking) => __awaiter(void 0, void 0, void
             delete locks[lock];
         }
     }
-});
+};
 const parseRetryOptions = (retryConfig) => {
     if (retryConfig && typeof retryConfig === "object") {
         return retryConfig;
@@ -66,9 +57,8 @@ const parseRetryOptions = (retryConfig) => {
     }
     return { maxAttempts: 0 };
 };
-const makeRequest = (context) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c;
-    const beforeSendEventResult = yield context.triggerEvent(RequestEvent.BEFORE_SEND);
+const makeRequest = async (context) => {
+    const beforeSendEventResult = await context.triggerEvent(RequestEvent.BEFORE_SEND);
     if (beforeSendEventResult && beforeSendEventResult.type === EventResultType.RESPOND) {
         return (context.response = beforeSendEventResult.response);
     }
@@ -98,22 +88,22 @@ const makeRequest = (context) => __awaiter(void 0, void 0, void 0, function* ()
             });
         }
     }
-    const retryOptions = parseRetryOptions((_a = context.requestConfig) === null || _a === void 0 ? void 0 : _a.retry);
+    const retryOptions = parseRetryOptions(context.requestConfig?.retry);
     const internalRetryOptions = {
         retries: retryOptions.maxAttempts,
         // assume most users won't want to tune the delay between retries
-        minTimeout: (_b = retryOptions.minDelay) !== null && _b !== void 0 ? _b : 200,
-        maxTimeout: (_c = retryOptions.maxDelay) !== null && _c !== void 0 ? _c : 1000,
+        minTimeout: retryOptions.minDelay ?? 200,
+        maxTimeout: retryOptions.maxDelay ?? 1000,
         randomize: true,
     };
     context.stats.attempt = 0;
-    const performRequest = (fnBail, attemptCount) => __awaiter(void 0, void 0, void 0, function* () {
+    const performRequest = async (fnBail, attemptCount) => {
         context.stats.attempt++;
         try {
             const { promise, canceler } = context.backend.makeRequest(context);
             context.addCanceller(canceler);
-            const response = yield promise;
-            const parsedResponse = (yield parseResponse(context, response));
+            const response = await promise;
+            const parsedResponse = (await parseResponse(context, response));
             if (!isAcceptableStatus(parsedResponse.status, context.requestConfig.acceptableStatus)) {
                 throw convertToRequestError({
                     error: new Error(`[api-def] Invalid response status code '${parsedResponse.status}'`),
@@ -130,12 +120,12 @@ const makeRequest = (context) => __awaiter(void 0, void 0, void 0, function* ()
             if (context.cancelled) {
                 rawError.isCancelledRequest = true;
             }
-            const error = yield parseError(context, rawError);
+            const error = await parseError(context, rawError);
             context.error = error;
             context.response = error.response;
             context.stats.endTimestamp = Date.now();
-            const errorEventResult = yield context.triggerEvent(RequestEvent.ERROR);
-            if ((errorEventResult === null || errorEventResult === void 0 ? void 0 : errorEventResult.type) === EventResultType.RESPOND) {
+            const errorEventResult = await context.triggerEvent(RequestEvent.ERROR);
+            if (errorEventResult?.type === EventResultType.RESPOND) {
                 return errorEventResult.response;
             }
             // allow retry logic to handle network errors
@@ -144,7 +134,7 @@ const makeRequest = (context) => __awaiter(void 0, void 0, void 0, function* ()
             //  throw error;
             //}
             // if we have an event that tells us to retry, we must do it
-            const forceRetry = (errorEventResult === null || errorEventResult === void 0 ? void 0 : errorEventResult.type) === EventResultType.RETRY;
+            const forceRetry = errorEventResult?.type === EventResultType.RETRY;
             if (forceRetry) {
                 return performRequest(fnBail, attemptCount);
             }
@@ -153,7 +143,7 @@ const makeRequest = (context) => __awaiter(void 0, void 0, void 0, function* ()
                 throw error;
             }
             // error is unrecoverable, bail
-            const unrecoverableErrorEventResult = yield context.triggerEvent(RequestEvent.UNRECOVERABLE_ERROR);
+            const unrecoverableErrorEventResult = await context.triggerEvent(RequestEvent.UNRECOVERABLE_ERROR);
             if (unrecoverableErrorEventResult) {
                 if (unrecoverableErrorEventResult.type === EventResultType.RESPOND) {
                     return unrecoverableErrorEventResult.response;
@@ -161,8 +151,8 @@ const makeRequest = (context) => __awaiter(void 0, void 0, void 0, function* ()
             }
             fnBail(error);
         }
-    });
-    const response = yield retry(performRequest, internalRetryOptions);
+    };
+    const response = await retry(performRequest, internalRetryOptions);
     if (context.validation.response) {
         try {
             response.data = context.validation.response.parse(response.data);
@@ -176,11 +166,10 @@ const makeRequest = (context) => __awaiter(void 0, void 0, void 0, function* ()
         }
     }
     return response;
-});
-const parseResponse = (context, response, error) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
+};
+const parseResponse = async (context, response, error) => {
     if (response) {
-        const parsedResponse = yield context.backend.convertResponse(context, response);
+        const parsedResponse = await context.backend.convertResponse(context, response);
         const contentType = parsedResponse.headers.get("content-type");
         const inferredResponseType = inferResponseType(contentType);
         if (!error) {
@@ -197,7 +186,7 @@ const parseResponse = (context, response, error) => __awaiter(void 0, void 0, vo
             if (inferredResponseType === "arraybuffer" && context.responseType === "json") {
                 if (parsedResponse.data && typeof parsedResponse.data === "object") {
                     const data = response.data;
-                    if (((_a = data.constructor) === null || _a === void 0 ? void 0 : _a.name) === "ArrayBuffer") {
+                    if (data.constructor?.name === "ArrayBuffer") {
                         try {
                             const decodedData = (response.data = textDecode(data));
                             response.data = JSON.parse(decodedData);
@@ -217,18 +206,17 @@ const parseResponse = (context, response, error) => __awaiter(void 0, void 0, vo
         return parsedResponse;
     }
     return response;
-});
-const parseError = (context, rawError) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
+};
+const parseError = async (context, rawError) => {
     let error;
     if (isRequestError(rawError)) {
         error = rawError;
     }
     else {
-        const extractedResponse = yield context.backend.extractResponseFromError(rawError);
-        let errorResponse = undefined;
+        const extractedResponse = await context.backend.extractResponseFromError(rawError);
+        let errorResponse;
         if (extractedResponse !== undefined) {
-            errorResponse = yield parseResponse(context, extractedResponse, true);
+            errorResponse = await parseResponse(context, extractedResponse, true);
         }
         let code = isNetworkError(rawError)
             ? RequestErrorCode.REQUEST_NETWORK_ERROR
@@ -239,12 +227,18 @@ const parseError = (context, rawError) => __awaiter(void 0, void 0, void 0, func
             }
         }
         else {
-            if (rawError.code === "ENOTFOUND" || ((_a = rawError.cause) === null || _a === void 0 ? void 0 : _a.code) === "ENOTFOUND") {
+            if (rawError.code === "ENOTFOUND" || rawError.cause?.code === "ENOTFOUND") {
                 code = RequestErrorCode.REQUEST_HOST_NAME_NOT_FOUND;
             }
         }
         const errorInfo = context.backend.getErrorInfo(rawError, errorResponse);
-        error = convertToRequestError(Object.assign({ error: rawError, response: errorResponse, code: code, context: context }, errorInfo));
+        error = convertToRequestError({
+            error: rawError,
+            response: errorResponse,
+            code: code,
+            context: context,
+            ...errorInfo,
+        });
     }
     return error;
-});
+};

package/esm/UtilTypes.d.ts

@@ -1,4 +1,4 @@
-import type Endpoint from "./Endpoint";
+import type Endpoint from "./Endpoint.js";
 export type ResponseOf<E extends Endpoint<any, any, any, any>> = E extends Endpoint<infer R, any, any, any> ? R : never;
 export type ParamsOf<E extends Endpoint<any, any, any, any>> = E extends Endpoint<any, infer P, any, any> ? P : never;
 export type QueryOf<E extends Endpoint<any, any, any, any>> = E extends Endpoint<any, any, infer Q, any> ? Q : never;

package/esm/Utils.js

@@ -1,4 +1,5 @@
 // polyfill from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign
+const hasOwn = (object, key) => Object.prototype.hasOwnProperty.call(object, key);
 export const assign = Object.assign ||
     ((target, ...varArgs) => {
         if (target === null || target === undefined) {
@@ -10,7 +11,7 @@ export const assign = Object.assign ||
             if (nextSource !== null && nextSource !== undefined) {
                 for (const nextKey in nextSource) {
                     // Avoid bugs when hasOwnProperty is shadowed
-                    if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
+                    if (hasOwn(nextSource, nextKey)) {
                         to[nextKey] = nextSource[nextKey];
                     }
                 }

package/esm/Validation.d.ts

@@ -1,5 +1,5 @@
 import type * as zod from "zod";
-import type { Body, Params, Query, State } from "./ApiTypes";
+import type { Body, Params, Query, State } from "./ApiTypes.js";
 export interface Validation<TResponse = any, TParams extends Params | undefined = Params | undefined, TQuery extends Query | undefined = Query | undefined, TBody extends Body | undefined = Body | undefined, TState extends State = State> {
     query?: zod.Schema<TQuery>;
     params?: zod.Schema<TParams>;

package/esm/backend/AxiosRequestBackend.d.ts

@@ -1,8 +1,8 @@
 import type { AxiosError, AxiosResponse } from "axios";
-import type { ApiResponse } from "../ApiTypes";
-import type RequestContext from "../RequestContext";
-import type { ConvertedApiResponse, RequestBackendErrorInfo, RequestOperation } from "./RequestBackend";
-import type RequestBackend from "./RequestBackend";
+import type { ApiResponse } from "../ApiTypes.js";
+import type RequestContext from "../RequestContext.js";
+import type RequestBackend from "./RequestBackend.js";
+import type { ConvertedApiResponse, RequestBackendErrorInfo, RequestOperation } from "./RequestBackend.js";
 export declare const isAxiosError: (error: Error) => error is AxiosError;
 export default class AxiosRequestBackend implements RequestBackend<AxiosResponse> {
     readonly id = "axios";

package/esm/backend/AxiosRequestBackend.js

@@ -1,38 +1,4 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
-var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
-var __asyncDelegator = (this && this.__asyncDelegator) || function (o) {
-    var i, p;
-    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
-    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
-};
-var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
-    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
-    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
-    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
-    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
-    function fulfill(value) { resume("next", value); }
-    function reject(value) { resume("throw", value); }
-    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
-};
-import { inferResponseType } from "../ApiUtils";
+import { inferResponseType } from "../ApiUtils.js";
 let axios;
 export const isAxiosError = (error) => {
     return "isAxiosError" in error;
@@ -66,56 +32,50 @@ export default class AxiosRequestBackend {
         this.id = "axios";
         axios = axiosLibrary;
     }
-    extractResponseFromError(error) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (isAxiosError(error)) {
-                return error.response ? error.response : null;
-            }
-            return undefined;
-        });
+    async extractResponseFromError(error) {
+        if (isAxiosError(error)) {
+            return error.response ? error.response : null;
+        }
+        return undefined;
     }
-    convertResponse(context, response) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e;
-            const responseType = (_a = context.responseType) !== null && _a !== void 0 ? _a : inferResponseType(response.headers["content-type"]);
-            let data;
-            if (responseType === "stream") {
-                // For streaming responses, we create an async iterator from the response data
-                if (!response.data) {
-                    throw new Error("[api-def] Response data is null for streaming response");
-                }
-                data = {
-                    [Symbol.asyncIterator]() {
-                        return __asyncGenerator(this, arguments, function* _a() {
-                            const stream = response.data;
-                            if (stream[Symbol.asyncIterator]) {
-                                yield __await(yield* __asyncDelegator(__asyncValues(stream)));
-                            }
-                            else if (stream.on) {
-                                // Handle Node.js streams
-                                yield __await(yield* __asyncDelegator(__asyncValues(stream)));
-                            }
-                            else {
-                                throw new Error("[api-def] Response data is not a valid stream");
-                            }
-                        });
-                    },
-                };
+    async convertResponse(context, response) {
+        const contentType = response.headers["content-type"];
+        const responseType = context.responseType ?? inferResponseType(contentType == null ? contentType : String(contentType));
+        let data;
+        if (responseType === "stream") {
+            // For streaming responses, we create an async iterator from the response data
+            if (!response.data) {
+                throw new Error("[api-def] Response data is null for streaming response");
             }
-            else {
-                data = response.data;
-            }
-            return {
-                method: context.method,
-                url: (_c = (_b = response.request.res) === null || _b === void 0 ? void 0 : _b.responseUrl) !== null && _c !== void 0 ? _c : (_e = (_d = response.request) === null || _d === void 0 ? void 0 : _d._redirectable) === null || _e === void 0 ? void 0 : _e._currentUrl,
-                data: data,
-                headers: response.headers,
-                status: response.status,
-                state: context.requestConfig.state,
-                __lowercaseHeaders: response._lowerCaseResponseHeaders,
-                stats: context.stats,
+            data = {
+                async *[Symbol.asyncIterator]() {
+                    const stream = response.data;
+                    if (stream[Symbol.asyncIterator]) {
+                        yield* stream;
+                    }
+                    else if (stream.on) {
+                        // Handle Node.js streams
+                        yield* stream;
+                    }
+                    else {
+                        throw new Error("[api-def] Response data is not a valid stream");
+                    }
+                },
             };
-        });
+        }
+        else {
+            data = response.data;
+        }
+        return {
+            method: context.method,
+            url: response.request.res?.responseUrl ?? response.request?._redirectable?._currentUrl,
+            data: data,
+            headers: response.headers,
+            status: response.status,
+            state: context.requestConfig.state,
+            __lowercaseHeaders: response._lowerCaseResponseHeaders,
+            stats: context.stats,
+        };
     }
     makeRequest(context) {
         const { requestConfig } = context;
@@ -125,7 +85,10 @@ export default class AxiosRequestBackend {
             method: context.method,
             url: url.href,
             data: context.getParsedBody(),
-            headers: Object.assign(Object.assign({}, getCacheHeaders(requestConfig.browserCache)), requestConfig.headers),
+            headers: {
+                ...getCacheHeaders(requestConfig.browserCache),
+                ...requestConfig.headers,
+            },
             responseType: context.responseType,
             withCredentials: requestConfig.credentials === "include" || requestConfig.credentials === "same-origin",
             cancelToken: new axios.CancelToken((cancellerFunc) => {
@@ -134,7 +97,7 @@ export default class AxiosRequestBackend {
         });
         return {
             promise: promise,
-            canceler: () => canceler === null || canceler === void 0 ? void 0 : canceler(),
+            canceler: () => canceler?.(),
         };
     }
     getErrorInfo(error, response) {

package/esm/backend/FetchRequestBackend.d.ts

@@ -1,8 +1,8 @@
-import type { ApiResponse } from "../ApiTypes";
-import type RequestContext from "../RequestContext";
-import { type Fetch } from "../Utils";
-import type { ConvertedApiResponse, RequestBackendErrorInfo, RequestOperation } from "./RequestBackend";
-import type RequestBackend from "./RequestBackend";
+import type { ApiResponse } from "../ApiTypes.js";
+import type RequestContext from "../RequestContext.js";
+import { type Fetch } from "../Utils.js";
+import type RequestBackend from "./RequestBackend.js";
+import type { ConvertedApiResponse, RequestBackendErrorInfo, RequestOperation } from "./RequestBackend.js";
 export default class FetchRequestBackend implements RequestBackend<Response> {
     fetch: (((input: RequestInfo | URL, init?: RequestInit) => Promise<Response>) & typeof fetch) | undefined;
     readonly id = "fetch";