create-request 1.0.0 → 1.1.0

package/dist/library/index.esm.js

@@ -176,11 +176,16 @@ class RequestError extends Error {
  * Provides caching and conversion between different response formats.
  */
 class ResponseWrapper {
-    constructor(response, url, method) {
+    constructor(response, url, method, graphQLOptions) {
         this.bodyUsed = false;
         this.response = response;
         this.url = url;
         this.method = method;
+        if (graphQLOptions) {
+            this.graphQLOptions = {
+                throwOnError: graphQLOptions.throwOnError,
+            };
+        }
     }
     // Wrapper properties
     get status() {
@@ -198,19 +203,51 @@ class ResponseWrapper {
     get raw() {
         return this.response;
     }
+    /**
+     * Check for GraphQL errors and throw if throwOnError is enabled
+     * @param data - The parsed JSON data
+     * @throws RequestError if GraphQL response contains errors and throwOnError is enabled
+     */
+    checkGraphQLErrors(data) {
+        var _a;
+        if (!((_a = this.graphQLOptions) === null || _a === void 0 ? void 0 : _a.throwOnError) || typeof data !== "object" || data === null)
+            return;
+        const responseData = data;
+        if (!Array.isArray(responseData.errors) || responseData.errors.length === 0)
+            return;
+        const errors = responseData.errors;
+        const errorMessages = errors.map(x => typeof x === "string" ? x : x && typeof x === "object" && "message" in x ? String(x.message || "Unknown error") : String(x));
+        const errorMessage = errorMessages.join(", ");
+        throw new RequestError(`GraphQL request failed with errors: ${errorMessage}`, this.url || "", this.method || "", {
+            status: this.response.status,
+            response: this.response,
+        });
+    }
     /**
      * Parse the response body as JSON
      * Caches the result for subsequent calls.
+     * If GraphQL options are set with throwOnError=true, will check for GraphQL errors and throw.
      *
      * @returns The parsed JSON data
-     * @throws Error if the response has already been consumed in a different format
+     * @throws {RequestError} When the request fails, JSON parsing fails, GraphQL errors occur (if throwOnError enabled), or body is already consumed
      *
      * @example
      * const data = await response.getJson();
      * console.log(data.items);
+     *
+     * @example
+     * // Error handling - errors are always RequestError
+     * try {
+     *   const data = await response.getJson();
+     * } catch (error) {
+     *   if (error instanceof RequestError) {
+     *     console.log(error.status, error.url, error.method);
+     *   }
+     * }
      */
     async getJson() {
         if (this.jsonCache !== undefined) {
+            this.checkGraphQLErrors(this.jsonCache);
             return this.jsonCache;
         }
         if (this.bodyUsed) {
@@ -219,40 +256,43 @@ class ResponseWrapper {
                 try {
                     const parsed = JSON.parse(this.textCache);
                     this.jsonCache = parsed;
+                    this.checkGraphQLErrors(parsed);
                     return parsed;
                 }
-                catch (e) {
-                    const errorMessage = e instanceof Error ? e.message : String(e);
-                    if (this.url && this.method) {
-                        throw new RequestError(`Invalid JSON: ${errorMessage}`, this.url, this.method, {
-                            response: this.response,
-                        });
+                catch (error) {
+                    // Re-throw RequestErrors from checkGraphQLErrors without wrapping
+                    if (error instanceof RequestError) {
+                        throw error;
                     }
-                    throw new Error(`Invalid JSON: ${errorMessage}`);
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    throw new RequestError(`Invalid JSON: ${errorMessage}`, this.url || "", this.method || "", {
+                        status: this.response.status,
+                        response: this.response,
+                    });
                 }
             }
-            if (this.url && this.method) {
-                throw new RequestError("Body already consumed", this.url, this.method, {
-                    response: this.response,
-                });
-            }
-            throw new Error("Body already consumed");
+            throw new RequestError("Body already consumed", this.url || "", this.method || "", {
+                status: this.response.status,
+                response: this.response,
+            });
         }
         this.bodyUsed = true;
         try {
             const parsed = await this.response.json();
             this.jsonCache = parsed;
+            this.checkGraphQLErrors(parsed);
             return parsed;
         }
-        catch (e) {
-            const errorMessage = e instanceof Error ? e.message : String(e);
-            if (this.url && this.method) {
-                throw new RequestError(`Invalid JSON: ${errorMessage}`, this.url, this.method, {
-                    status: this.response.status,
-                    response: this.response,
-                });
+        catch (error) {
+            // Re-throw RequestErrors from checkGraphQLErrors without wrapping
+            if (error instanceof RequestError) {
+                throw error;
             }
-            throw e;
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new RequestError(`Invalid JSON: ${errorMessage}`, this.url || "", this.method || "", {
+                status: this.response.status,
+                response: this.response,
+            });
         }
     }
     /**
@@ -261,7 +301,7 @@ class ResponseWrapper {
      * if the body has already been consumed in those formats.
      *
      * @returns The response text
-     * @throws Error if the response has already been consumed in an incompatible format
+     * @throws {RequestError} When reading fails or the response has already been consumed in an incompatible format
      *
      * @example
      * const text = await response.getText();
@@ -284,20 +324,16 @@ class ResponseWrapper {
                 }
                 catch (e) {
                     const errorMessage = e instanceof Error ? e.message : String(e);
-                    if (this.url && this.method) {
-                        throw new RequestError(`Cannot convert to text: ${errorMessage}`, this.url, this.method, {
-                            response: this.response,
-                        });
-                    }
-                    throw e;
+                    throw new RequestError(`Cannot convert to text: ${errorMessage}`, this.url || "", this.method || "", {
+                        status: this.response.status,
+                        response: this.response,
+                    });
                 }
             }
-            if (this.url && this.method) {
-                throw new RequestError("Cannot convert to text", this.url, this.method, {
-                    response: this.response,
-                });
-            }
-            throw new Error("Cannot convert to text");
+            throw new RequestError("Cannot convert to text", this.url || "", this.method || "", {
+                status: this.response.status,
+                response: this.response,
+            });
         }
         this.bodyUsed = true;
         try {
@@ -306,13 +342,10 @@ class ResponseWrapper {
         }
         catch (e) {
             const errorMessage = e instanceof Error ? e.message : String(e);
-            if (this.url && this.method) {
-                throw new RequestError(`Read failed: ${errorMessage}`, this.url, this.method, {
-                    status: this.response.status,
-                    response: this.response,
-                });
-            }
-            throw e;
+            throw new RequestError(`Read failed: ${errorMessage}`, this.url || "", this.method || "", {
+                status: this.response.status,
+                response: this.response,
+            });
         }
     }
     /**
@@ -321,7 +354,7 @@ class ResponseWrapper {
      * if the body has already been consumed as text.
      *
      * @returns The response as a Blob
-     * @throws Error if the response has already been consumed in an incompatible format
+     * @throws {RequestError} When reading fails or the response has already been consumed in an incompatible format
      *
      * @example
      * const blob = await response.getBlob();
@@ -337,12 +370,10 @@ class ResponseWrapper {
                 this.blobCache = new Blob([this.textCache], { type: "text/plain" });
                 return this.blobCache;
             }
-            if (this.url && this.method) {
-                throw new RequestError("Cannot convert to Blob", this.url, this.method, {
-                    response: this.response,
-                });
-            }
-            throw new Error("Cannot convert to Blob");
+            throw new RequestError("Cannot convert to Blob", this.url || "", this.method || "", {
+                status: this.response.status,
+                response: this.response,
+            });
         }
         this.bodyUsed = true;
         try {
@@ -351,13 +382,10 @@ class ResponseWrapper {
         }
         catch (e) {
             const errorMessage = e instanceof Error ? e.message : String(e);
-            if (this.url && this.method) {
-                throw new RequestError(`Read failed: ${errorMessage}`, this.url, this.method, {
-                    status: this.response.status,
-                    response: this.response,
-                });
-            }
-            throw e;
+            throw new RequestError(`Read failed: ${errorMessage}`, this.url || "", this.method || "", {
+                status: this.response.status,
+                response: this.response,
+            });
         }
     }
     /**
@@ -365,7 +393,7 @@ class ResponseWrapper {
      * This method consumes the body and should only be called once.
      *
      * @returns The response body as a ReadableStream or null
-     * @throws Error if the response body has already been consumed
+     * @throws {RequestError} When the response body has already been consumed
      *
      * @example
      * const stream = response.getBody();
@@ -376,12 +404,10 @@ class ResponseWrapper {
      */
     getBody() {
         if (this.bodyUsed) {
-            if (this.url && this.method) {
-                throw new RequestError("Body already consumed", this.url, this.method, {
-                    response: this.response,
-                });
-            }
-            throw new Error("Body already consumed");
+            throw new RequestError("Body already consumed", this.url || "", this.method || "", {
+                status: this.response.status,
+                response: this.response,
+            });
         }
         this.bodyUsed = true;
         return this.response.body;
@@ -392,6 +418,7 @@ class ResponseWrapper {
      *
      * @param selector - Optional function to extract and transform data
      * @returns A promise that resolves to the selected data
+     * @throws {RequestError} When the request fails, JSON parsing fails, or the selector throws an error
      *
      * @example
      * // Get full response
@@ -399,6 +426,16 @@ class ResponseWrapper {
      *
      * // Extract specific data
      * const users = await response.getData(data => data.results.users);
+     *
+     * @example
+     * // Error handling - errors are always RequestError
+     * try {
+     *   const data = await response.getData();
+     * } catch (error) {
+     *   if (error instanceof RequestError) {
+     *     console.log(error.status, error.url, error.method);
+     *   }
+     * }
      */
     async getData(selector) {
         try {
@@ -417,20 +454,15 @@ class ResponseWrapper {
             // Enhance selector errors with context
             if (selector) {
                 const errorMessage = error instanceof Error ? error.message : String(error);
-                if (this.url && this.method) {
-                    throw new RequestError(`Data selector failed: ${errorMessage}`, this.url, this.method, {
-                        response: this.response,
-                    });
-                }
-                throw new Error(`Data selector failed: ${errorMessage}`);
+                throw new RequestError(`Data selector failed: ${errorMessage}`, this.url || "", this.method || "", {
+                    status: this.response.status,
+                    response: this.response,
+                });
             }
             // If we get here and it's not a RequestError, wrap it
             // This should rarely happen as getJson() should throw RequestError
             const errorObj = error instanceof Error ? error : new Error(String(error));
-            if (this.url && this.method) {
-                throw RequestError.networkError(this.url, this.method, errorObj);
-            }
-            throw errorObj;
+            throw RequestError.networkError(this.url || "", this.method || "", errorObj);
         }
     }
 }
@@ -838,6 +870,13 @@ class BaseRequest {
         this.errorInterceptors = [];
         this.url = url;
     }
+    /**
+     * Get GraphQL options if set (only for BodyRequest subclasses)
+     * @returns GraphQL options or undefined
+     */
+    getGraphQLOptions() {
+        return undefined;
+    }
     /**
      * Creates a fluent API for setting enum-based options
      * Combines direct setter with convenience methods
@@ -923,14 +962,14 @@ class BaseRequest {
      *
      * @param timeout - The timeout in milliseconds
      * @returns The request instance for chaining
-     * @throws Error if timeout is not a positive number
+     * @throws RequestError if timeout is not a positive number
      *
      * @example
      * request.withTimeout(5000); // 5 seconds timeout
      */
     withTimeout(timeout) {
         if (!Number.isFinite(timeout) || timeout <= 0)
-            throw new Error("Timeout must be a positive number");
+            throw new RequestError("Timeout must be a positive number", this.url, this.method);
         this.requestOptions.timeout = timeout;
         return this;
     }
@@ -939,14 +978,14 @@ class BaseRequest {
      *
      * @param retries - Number of retry attempts before failing
      * @returns The request instance for chaining
-     * @throws Error if retries is not a non-negative integer
+     * @throws RequestError if retries is not a non-negative integer
      *
      * @example
      * request.withRetries(3); // Retry up to 3 times
      */
     withRetries(retries) {
         if (!Number.isInteger(retries) || retries < 0)
-            throw new Error("Retry count must be a non-negative integer");
+            throw new RequestError("Retry count must be a non-negative integer", this.url, this.method);
         this.requestOptions.retries = retries;
         return this;
     }
@@ -1153,7 +1192,7 @@ class BaseRequest {
         if (typeof Buffer !== "undefined")
             return Buffer.from(str).toString("base64");
         // Fallback (should never happen in modern environments)
-        throw new Error("Base64 encoding is not supported");
+        throw new RequestError("Base64 encoding is not supported", this.url, this.method);
     }
     /**
      * Sets the bearer token for authentication
@@ -1334,9 +1373,20 @@ class BaseRequest {
      * Execute the request and parse the response as JSON
      *
      * @returns A promise that resolves to the parsed JSON data
+     * @throws {RequestError} When the request fails, JSON parsing fails, GraphQL errors occur (if throwOnError enabled), or body is already consumed
      *
      * @example
      * const users = await request.getJson<User[]>();
+     *
+     * @example
+     * // Error handling - errors are always RequestError
+     * try {
+     *   const data = await request.getJson();
+     * } catch (error) {
+     *   if (error instanceof RequestError) {
+     *     console.log(error.status, error.url, error.method);
+     *   }
+     * }
      */
     async getJson() {
         const response = await this.getResponse();
@@ -1384,6 +1434,7 @@ class BaseRequest {
      *
      * @param selector - Optional function to extract and transform data
      * @returns A promise that resolves to the selected data
+     * @throws {RequestError} When the request fails, JSON parsing fails, or the selector throws an error
      *
      * @example
      * // Get full response
@@ -1391,6 +1442,16 @@ class BaseRequest {
      *
      * // Extract specific data
      * const users = await request.getData(data => data.results.users);
+     *
+     * @example
+     * // Error handling - errors are always RequestError
+     * try {
+     *   const data = await request.getData();
+     * } catch (error) {
+     *   if (error instanceof RequestError) {
+     *     console.log(error.status, error.url, error.method);
+     *   }
+     * }
      */
     async getData(selector) {
         const response = await this.getResponse();
@@ -1440,7 +1501,8 @@ class BaseRequest {
      * @returns The URL with query parameters appended
      */
     formatUrlWithQueryParams(url) {
-        if (!this.queryParams.toString()) {
+        const queryString = this.queryParams.toString();
+        if (!queryString) {
             return url;
         }
         try {
@@ -1456,7 +1518,7 @@ class BaseRequest {
             // Handle relative URLs
             const hasExistingParams = url.includes("?");
             const separator = hasExistingParams ? "&" : "?";
-            return `${url}${separator}${this.queryParams.toString()}`;
+            return `${url}${separator}${queryString}`;
         }
     }
     /**
@@ -1505,8 +1567,7 @@ class BaseRequest {
             }
             catch (error) {
                 const errorMessage = error instanceof Error ? error.message : String(error);
-                // Use RequestError when we have request context
-                throw new RequestError(`Interceptor failed: ${errorMessage}`, currentConfig.url, currentConfig.method);
+                throw new RequestError(`Request interceptor failed: ${errorMessage}`, currentConfig.url, currentConfig.method);
             }
         }
         return currentConfig;
@@ -1528,12 +1589,9 @@ class BaseRequest {
             }
             catch (error) {
                 const errorMessage = error instanceof Error ? error.message : String(error);
-                // Use RequestError when we have response context (url/method from ResponseWrapper)
-                if (currentResponse.url && currentResponse.method) {
-                    throw new RequestError(`Interceptor failed: ${errorMessage}`, currentResponse.url, currentResponse.method);
-                }
-                // Fallback to generic Error if no context available (shouldn't happen in practice)
-                throw new Error(`Interceptor failed: ${errorMessage}`);
+                const url = currentResponse.url || "";
+                const method = currentResponse.method || "";
+                throw new RequestError(`Response interceptor failed: ${errorMessage}`, url, method);
             }
         }
         return currentResponse;
@@ -1567,11 +1625,16 @@ class BaseRequest {
                     const errorMessage = interceptorError instanceof Error ? interceptorError.message : String(interceptorError);
                     // Always wrap in RequestError when we have context
                     if (currentError instanceof RequestError) {
-                        currentError = new RequestError(`Error interceptor ${i + 1} failed: ${errorMessage}`, currentError.url, currentError.method);
+                        currentError = new RequestError(`Error interceptor ${i + 1} failed: ${errorMessage}`, currentError.url, currentError.method, {
+                            status: currentError.status,
+                            response: currentError.response,
+                        });
                     }
                     else if (currentError instanceof ResponseWrapper && currentError.url && currentError.method) {
                         // If it's a ResponseWrapper, we can still create a proper RequestError from its context
-                        currentError = new RequestError(`Error interceptor ${i + 1} failed: ${errorMessage}`, currentError.url, currentError.method);
+                        currentError = new RequestError(`Error interceptor ${i + 1} failed: ${errorMessage}`, currentError.url, currentError.method, {
+                            status: currentError.status,
+                        });
                     }
                     else {
                         // Last resort: if we have no context at all, use the original error's context
@@ -1693,7 +1756,8 @@ class BaseRequest {
             const interceptorResult = await this.runRequestInterceptors(requestConfig);
             // If interceptor returned a Response, short-circuit and wrap it
             if (interceptorResult instanceof Response) {
-                const wrappedResponse = new ResponseWrapper(interceptorResult, this.url, this.method);
+                const graphQLOptions = this.getGraphQLOptions();
+                const wrappedResponse = new ResponseWrapper(interceptorResult, this.url, this.method, graphQLOptions);
                 return await this.runResponseInterceptors(wrappedResponse);
             }
             // Update fetchOptions with interceptor modifications
@@ -1729,7 +1793,8 @@ class BaseRequest {
             if (!response.ok) {
                 throw RequestError.fromResponse(response, url, method);
             }
-            const wrappedResponse = new ResponseWrapper(response, url, method);
+            const graphQLOptions = this.getGraphQLOptions();
+            const wrappedResponse = new ResponseWrapper(response, url, method, graphQLOptions);
             return await this.runResponseInterceptors(wrappedResponse);
         }
         catch (error) {
@@ -1762,6 +1827,7 @@ class BaseRequest {
 class BodyRequest extends BaseRequest {
     constructor(url) {
         super(url);
+        this.graphQLOptions = undefined;
     }
     /**
      * Sets the body of the request
@@ -1784,7 +1850,8 @@ class BodyRequest extends BaseRequest {
                 JSON.stringify(body);
             }
             catch (error) {
-                throw new RequestError(`Stringify failed: ${String(error)}`, this.url, this.method);
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                throw new RequestError(`JSON stringify failed: ${errorMessage}`, this.url, this.method);
             }
         }
         else {
@@ -1798,6 +1865,7 @@ class BodyRequest extends BaseRequest {
      *
      * @param query - The GraphQL query or mutation string
      * @param variables - Optional variables object to pass with the query
+     * @param options - Optional GraphQL-specific options
      * @returns The request instance for chaining
      *
      * @example
@@ -1807,13 +1875,18 @@ class BodyRequest extends BaseRequest {
      * @example
      * const request = new PostRequest('/graphql')
      *   .withGraphQL('mutation { createUser(name: $name) { id } }', { name: 'John' });
+     *
+     * @example
+     * // Throw an error if the GraphQL response contains errors
+     * const request = new PostRequest('/graphql')
+     *   .withGraphQL('query { user { id } }', undefined, { throwOnError: true });
      */
-    withGraphQL(query, variables) {
-        if (typeof query !== "string" || query.trim().length === 0) {
+    withGraphQL(query, variables, options) {
+        if (typeof query !== "string" || query.length === 0) {
             throw new RequestError("Invalid GraphQL query", this.url, this.method);
         }
         const graphQLBody = {
-            query: query.trim(),
+            query: query,
         };
         if (variables !== undefined) {
             if (typeof variables !== "object" || variables === null || Array.isArray(variables)) {
@@ -1821,12 +1894,24 @@ class BodyRequest extends BaseRequest {
             }
             graphQLBody.variables = variables;
         }
+        // Store GraphQL options if provided
+        if (options !== undefined) {
+            if (typeof options !== "object" || options === null || Array.isArray(options)) {
+                throw new RequestError("Invalid GraphQL options", this.url, this.method);
+            }
+            // Store only the known GraphQL options properties
+            const opts = options;
+            this.graphQLOptions = {
+                throwOnError: typeof opts.throwOnError === "boolean" ? opts.throwOnError : undefined,
+            };
+        }
         // Validate JSON is stringifiable early
         try {
             JSON.stringify(graphQLBody);
         }
         catch (error) {
-            throw new RequestError(`Stringify failed: ${String(error)}`, this.url, this.method);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new RequestError(`JSON stringify failed: ${errorMessage}`, this.url, this.method);
         }
         this.body = graphQLBody;
         this.bodyType = BodyType.JSON;
@@ -1849,6 +1934,13 @@ class BodyRequest extends BaseRequest {
             this.withContentType(contentType);
         }
     }
+    /**
+     * Get the GraphQL options if set
+     * @returns The GraphQL options or undefined
+     */
+    getGraphQLOptions() {
+        return this.graphQLOptions;
+    }
     /**
      * Execute the request and return the ResponseWrapper
      * Overrides the base implementation to add body handling