create-request 1.0.0 → 1.2.0

package/dist/library/index.cjs

@@ -82,6 +82,18 @@ exports.ReferrerPolicy = void 0;
     ReferrerPolicy["NO_REFERRER_WHEN_DOWNGRADE"] = "no-referrer-when-downgrade";
     ReferrerPolicy["STRICT_ORIGIN_WHEN_CROSS_ORIGIN"] = "strict-origin-when-cross-origin";
 })(exports.ReferrerPolicy || (exports.ReferrerPolicy = {}));
+/**
+ * Cache modes for fetch requests
+ */
+var CacheMode;
+(function (CacheMode) {
+    CacheMode["RELOAD"] = "reload";
+    CacheMode["DEFAULT"] = "default";
+    CacheMode["NO_CACHE"] = "no-cache";
+    CacheMode["NO_STORE"] = "no-store";
+    CacheMode["FORCE_CACHE"] = "force-cache";
+    CacheMode["ONLY_IF_CACHED"] = "only-if-cached";
+})(CacheMode || (CacheMode = {}));
 
 class RequestError extends Error {
     constructor(message, url, method, options = {}) {
@@ -178,11 +190,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() {
@@ -200,19 +217,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) {
@@ -221,40 +270,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,
+            });
         }
     }
     /**
@@ -263,7 +315,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();
@@ -286,20 +338,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 {
@@ -308,13 +356,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,
+            });
         }
     }
     /**
@@ -323,7 +368,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();
@@ -339,12 +384,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 {
@@ -353,13 +396,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,
+            });
         }
     }
     /**
@@ -367,7 +407,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();
@@ -378,12 +418,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;
@@ -394,6 +432,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
@@ -401,6 +440,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 {
@@ -419,20 +468,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);
         }
     }
 }
@@ -840,6 +884,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
@@ -925,14 +976,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;
     }
@@ -941,14 +992,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;
     }
@@ -1057,6 +1108,35 @@ class BaseRequest {
             AUTO: exports.RequestPriority.AUTO,
         });
     }
+    /**
+     * Sets the integrity hash for subresource integrity verification
+     * @param integrity - The integrity hash string (e.g., "sha256-...")
+     * @returns The instance for chaining
+     * @example
+     * request.withIntegrity("sha256-abcdef1234567890...")
+     */
+    withIntegrity(integrity) {
+        this.requestOptions.integrity = integrity;
+        return this;
+    }
+    /**
+     * Sets cache mode - supports both direct call and fluent API
+     * @example
+     * request.withCache("no-cache")
+     * request.withCache(CacheMode.NO_CACHE)
+     * request.withCache.NO_CACHE()
+     */
+    get withCache() {
+        const cacheOptions = {
+            DEFAULT: "default",
+            NO_STORE: "no-store",
+            RELOAD: "reload",
+            NO_CACHE: "no-cache",
+            FORCE_CACHE: "force-cache",
+            ONLY_IF_CACHED: "only-if-cached",
+        };
+        return this.createFluentSetter("cache", cacheOptions);
+    }
     /**
      * Adds query parameters to the request URL
      * @param params - An object containing the query parameters
@@ -1155,7 +1235,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
@@ -1336,9 +1416,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();
@@ -1386,6 +1477,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
@@ -1393,6 +1485,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();
@@ -1442,7 +1544,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 {
@@ -1458,7 +1561,7 @@ class BaseRequest {
             // Handle relative URLs
             const hasExistingParams = url.includes("?");
             const separator = hasExistingParams ? "&" : "?";
-            return `${url}${separator}${this.queryParams.toString()}`;
+            return `${url}${separator}${queryString}`;
         }
     }
     /**
@@ -1507,8 +1610,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;
@@ -1530,12 +1632,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;
@@ -1569,11 +1668,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
@@ -1674,6 +1778,8 @@ class BaseRequest {
             referrerPolicy: fetchOptions.referrerPolicy,
             keepalive: fetchOptions.keepalive,
             priority: extendedOptions.priority,
+            integrity: fetchOptions.integrity,
+            cache: fetchOptions.cache,
         };
     }
     /**
@@ -1684,6 +1790,12 @@ class BaseRequest {
         if (config.body !== undefined) {
             fetchOptions.body = config.body;
         }
+        if (config.integrity !== undefined) {
+            fetchOptions.integrity = config.integrity;
+        }
+        if (config.cache !== undefined) {
+            fetchOptions.cache = config.cache;
+        }
     }
     async executeRequest(url, fetchOptions) {
         const method = typeof fetchOptions.method === "string" ? fetchOptions.method : "GET";
@@ -1695,7 +1807,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
@@ -1731,7 +1844,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) {
@@ -1764,6 +1878,7 @@ class BaseRequest {
 class BodyRequest extends BaseRequest {
     constructor(url) {
         super(url);
+        this.graphQLOptions = undefined;
     }
     /**
      * Sets the body of the request
@@ -1786,7 +1901,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 {
@@ -1800,6 +1916,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
@@ -1809,13 +1926,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)) {
@@ -1823,12 +1945,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;
@@ -1851,6 +1985,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