create-request 0.0.1-beta.2

package/dist/library/index.js

@@ -0,0 +1,635 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.createRequest = {}));
+})(this, (function (exports) { 'use strict';
+
+    /**
+     * Enum for HTTP methods
+     */
+    exports.HttpMethod = void 0;
+    (function (HttpMethod) {
+        HttpMethod["GET"] = "GET";
+        HttpMethod["POST"] = "POST";
+        HttpMethod["PUT"] = "PUT";
+        HttpMethod["DELETE"] = "DELETE";
+        HttpMethod["PATCH"] = "PATCH";
+        HttpMethod["HEAD"] = "HEAD";
+        HttpMethod["OPTIONS"] = "OPTIONS";
+    })(exports.HttpMethod || (exports.HttpMethod = {}));
+    /**
+     * Enum for request priorities
+     */
+    exports.RequestPriority = void 0;
+    (function (RequestPriority) {
+        RequestPriority["HIGH"] = "high";
+        RequestPriority["LOW"] = "low";
+        RequestPriority["AUTO"] = "auto";
+    })(exports.RequestPriority || (exports.RequestPriority = {}));
+    /**
+     * Enum for credentials policies
+     */
+    exports.CredentialsPolicy = void 0;
+    (function (CredentialsPolicy) {
+        CredentialsPolicy["INCLUDE"] = "include";
+        CredentialsPolicy["SAME_ORIGIN"] = "same-origin";
+        CredentialsPolicy["OMIT"] = "omit";
+    })(exports.CredentialsPolicy || (exports.CredentialsPolicy = {}));
+    /**
+     * Enum for request modes
+     */
+    exports.RequestMode = void 0;
+    (function (RequestMode) {
+        RequestMode["CORS"] = "cors";
+        RequestMode["NO_CORS"] = "no-cors";
+        RequestMode["SAME_ORIGIN"] = "same-origin";
+        RequestMode["NAVIGATE"] = "navigate";
+    })(exports.RequestMode || (exports.RequestMode = {}));
+    /**
+     * Enum for redirect modes
+     */
+    exports.RedirectMode = void 0;
+    (function (RedirectMode) {
+        RedirectMode["FOLLOW"] = "follow";
+        RedirectMode["ERROR"] = "error";
+        RedirectMode["MANUAL"] = "manual";
+    })(exports.RedirectMode || (exports.RedirectMode = {}));
+    /**
+     * Enum for cache modes
+     */
+    exports.CacheMode = void 0;
+    (function (CacheMode) {
+        CacheMode["DEFAULT"] = "default";
+        CacheMode["NO_STORE"] = "no-store";
+        CacheMode["RELOAD"] = "reload";
+        CacheMode["NO_CACHE"] = "no-cache";
+        CacheMode["FORCE_CACHE"] = "force-cache";
+        CacheMode["ONLY_IF_CACHED"] = "only-if-cached";
+    })(exports.CacheMode || (exports.CacheMode = {}));
+
+    class RequestError extends Error {
+        constructor(message, url, method, options = {}) {
+            super(message);
+            this.name = "RequestError";
+            this.url = url;
+            this.method = method;
+            this.status = options.status;
+            this.response = options.response;
+            this.timeoutError = options.timeoutError;
+            // For better stack traces in modern environments
+            if (Error.captureStackTrace) {
+                Error.captureStackTrace(this, RequestError);
+            }
+            // Maintains proper prototype chain for instanceof checks
+            Object.setPrototypeOf(this, RequestError.prototype);
+        }
+        /**
+         * Static methods for creating specific types of RequestError
+         */
+        static timeout(url, method, timeoutMs) {
+            return new RequestError(`Request timed out after ${timeoutMs}ms`, url, method, {
+                timeoutError: true,
+            });
+        }
+        static fromResponse(response, url, method) {
+            return new RequestError(`Request failed with status ${response.status}`, url, method, {
+                status: response.status,
+                response,
+            });
+        }
+        static networkError(url, method, originalError) {
+            const error = new RequestError(`Network error: ${originalError.message}`, url, method);
+            error.stack = originalError.stack;
+            return error;
+        }
+    }
+
+    /**
+     * Wrapper for HTTP responses with methods to transform the response data
+     */
+    class ResponseWrapper {
+        constructor(response) {
+            this.response = response;
+            this.ok = response.status >= 200 && response.status < 300; // Standard Fetch API behavior
+        }
+        /**
+         * Get the raw Response object
+         */
+        get raw() {
+            return this.response;
+        }
+        /**
+         * Get the HTTP status code
+         */
+        get status() {
+            return this.response.status;
+        }
+        /**
+         * Get the HTTP status text
+         */
+        get statusText() {
+            return this.response.statusText;
+        }
+        /**
+         * Get response headers
+         */
+        get headers() {
+            return this.response.headers;
+        }
+        /**
+         * Parse response as JSON
+         */
+        async json() {
+            return this.response.json();
+        }
+        /**
+         * Get response as text
+         */
+        async text() {
+            return this.response.text();
+        }
+        /**
+         * Get response as Blob
+         */
+        async blob() {
+            return this.response.blob();
+        }
+        /**
+         * Get response as ArrayBuffer
+         */
+        async arrayBuffer() {
+            return this.response.arrayBuffer();
+        }
+        /**
+         * Get response as ReadableStream
+         */
+        body() {
+            return this.response.body;
+        }
+    }
+
+    // Base class with common functionality for all request types
+    class BaseRequest {
+        constructor() {
+            this.requestOptions = {};
+            this.queryParams = new URLSearchParams();
+        }
+        withHeaders(headers) {
+            this.requestOptions.headers = {
+                ...(this.requestOptions.headers || {}),
+                ...headers,
+            };
+            return this;
+        }
+        withTimeout(timeout) {
+            this.requestOptions.timeout = timeout;
+            return this;
+        }
+        withRetries(retries) {
+            this.requestOptions.retries = retries;
+            return this;
+        }
+        onRetry(callback) {
+            this.requestOptions.onRetry = callback;
+            return this;
+        }
+        /**
+         * Sets the credentials policy for the request
+         * @param credentialsPolicy - Can be 'omit', 'same-origin', or 'include'
+         * @returns The instance for chaining
+         */
+        withCredentials(credentialsPolicy = exports.CredentialsPolicy.SAME_ORIGIN) {
+            this.requestOptions.credentials = credentialsPolicy;
+            return this;
+        }
+        /**
+         * Allows providing an external AbortController to cancel the request
+         * @param controller - The AbortController to use for this request
+         * @returns The instance for chaining
+         */
+        withAbortController(controller) {
+            this.abortController = controller;
+            return this;
+        }
+        /**
+         * Sets the referrer for the request
+         * @param referrer - The referrer URL or policy
+         * @returns The instance for chaining
+         */
+        withReferrer(referrer) {
+            this.requestOptions.referrer = referrer;
+            return this;
+        }
+        /**
+         * Sets the redirect policy for the request
+         * @param redirect - Can be 'follow', 'error', or 'manual'
+         * @returns The instance for chaining
+         */
+        withRedirect(redirect) {
+            this.requestOptions.redirect = redirect;
+            return this;
+        }
+        /**
+         * Sets the keepalive flag for the request
+         * @param keepalive - Whether to allow the request to outlive the page
+         * @returns The instance for chaining
+         */
+        withKeepAlive(keepalive) {
+            this.requestOptions.keepalive = keepalive;
+            return this;
+        }
+        /**
+         * Sets the priority of the request
+         * @param priority - Can be 'high', 'low', or 'auto'
+         * @returns The instance for chaining
+         */
+        withPriority(priority) {
+            this.requestOptions.priority = priority;
+            return this;
+        }
+        /**
+         * Adds query parameters to the request URL
+         * @param params - An object containing the query parameters
+         * @returns The instance for chaining
+         */
+        withQueryParams(params) {
+            Object.entries(params).forEach(([key, value]) => {
+                if (value === null || value === undefined) {
+                    return;
+                }
+                if (Array.isArray(value)) {
+                    // Handle array values - add multiple entries with the same key
+                    value.forEach(v => this.queryParams.append(key, String(v)));
+                }
+                else {
+                    this.queryParams.append(key, String(value));
+                }
+            });
+            return this;
+        }
+        /**
+         * Adds a single query parameter
+         * @param key - The parameter name
+         * @param value - The parameter value
+         * @returns The instance for chaining
+         */
+        withQueryParam(key, value) {
+            if (value !== null && value !== undefined) {
+                this.queryParams.append(key, String(value));
+            }
+            return this;
+        }
+        /**
+         * Sets the mode of the request
+         * @param mode - The mode for the request (cors, no-cors, same-origin, navigate)
+         * @returns The instance for chaining
+         */
+        withMode(mode) {
+            this.requestOptions.mode = mode;
+            return this;
+        }
+        /**
+         * Shorthand for setting the Content-Type header
+         * @param contentType - The content type
+         * @returns The instance for chaining
+         */
+        withContentType(contentType) {
+            return this.withHeaders({
+                "Content-Type": contentType,
+            });
+        }
+        /**
+         * Shorthand for setting the Authorization header
+         * @param authValue - The authorization value
+         * @returns The instance for chaining
+         */
+        withAuthorization(authValue) {
+            return this.withHeaders({
+                Authorization: authValue,
+            });
+        }
+        /**
+         * Shorthand for setting up Basic authentication
+         * @param username - The username
+         * @param password - The password
+         * @returns The instance for chaining
+         */
+        withBasicAuth(username, password) {
+            const credentials = btoa(`${username}:${password}`);
+            return this.withAuthorization(`Basic ${credentials}`);
+        }
+        /**
+         * Sets the bearer token for authentication
+         * @param token - The bearer token
+         * @returns The instance for chaining
+         */
+        withBearerToken(token) {
+            return this.withAuthorization(`Bearer ${token}`);
+        }
+        /**
+         * Sets cookies for the request
+         * @param cookies - An object containing cookie name-value pairs
+         * @returns The instance for chaining
+         */
+        withCookies(cookies) {
+            const cookieEntries = Object.entries(cookies);
+            if (cookieEntries.length === 0) {
+                return this;
+            }
+            // Format cookies as name=value pairs
+            const cookieString = cookieEntries
+                .map(([name, value]) => `${encodeURIComponent(name)}=${encodeURIComponent(value)}`)
+                .join("; ");
+            // Get current headers or initialize empty object
+            const currentHeaders = this.requestOptions.headers || {};
+            // If there's already a Cookie header, append to it; otherwise create a new one
+            const existingCookies = currentHeaders["Cookie"] || "";
+            const newCookieValue = existingCookies ? `${existingCookies}; ${cookieString}` : cookieString;
+            // Set the Cookie header
+            return this.withHeaders({
+                Cookie: newCookieValue,
+            });
+        }
+        /**
+         * Send the request to the specified URL
+         * @param url The URL to send the request to
+         */
+        sendTo(url) {
+            // Format the URL with query parameters
+            url = this.formatUrlWithQueryParams(url);
+            // Cast the request options to RequestInit to ensure compatibility
+            const fetchOptions = {
+                ...this.requestOptions,
+                method: this.method,
+            };
+            // Create the base promise
+            const basePromise = !this.requestOptions.retries
+                ? this.executeRequest(url, fetchOptions)
+                : this.executeWithRetries(url, fetchOptions);
+            // Enhance the promise with response methods
+            const responsePromise = basePromise.then(response => response);
+            // Attach convenience methods to the promise
+            responsePromise.json = async () => {
+                const response = await basePromise;
+                return response.json();
+            };
+            responsePromise.text = async () => {
+                const response = await basePromise;
+                return response.text();
+            };
+            responsePromise.blob = async () => {
+                const response = await basePromise;
+                return response.blob();
+            };
+            responsePromise.arrayBuffer = async () => {
+                const response = await basePromise;
+                return response.arrayBuffer();
+            };
+            responsePromise.body = async () => {
+                const response = await basePromise;
+                return response.body();
+            };
+            return responsePromise;
+        }
+        /**
+         * Formats the URL with any query parameters
+         * @param url The base URL
+         * @returns The URL with query parameters appended
+         */
+        formatUrlWithQueryParams(url) {
+            if (!this.queryParams.toString()) {
+                return url;
+            }
+            const urlObj = new URL(url);
+            // Merge our query params with any that might be in the URL already
+            this.queryParams.forEach((value, key) => {
+                urlObj.searchParams.append(key, value);
+            });
+            return urlObj.toString();
+        }
+        /**
+         * Executes a request with configured retry logic
+         * @param url The formatted URL to send the request to
+         * @param fetchOptions The fetch options to use
+         * @returns A wrapped response object
+         */
+        async executeWithRetries(url, fetchOptions) {
+            let retryCount = 0;
+            const maxRetries = this.requestOptions.retries || 0;
+            // eslint-disable-next-line no-constant-condition
+            while (true) {
+                try {
+                    return await this.executeRequest(url, fetchOptions);
+                }
+                catch (error) {
+                    const requestError = error instanceof RequestError
+                        ? error
+                        : RequestError.networkError(url, fetchOptions.method, error);
+                    if (retryCount >= maxRetries || requestError.timeoutError) {
+                        throw requestError;
+                    }
+                    retryCount++;
+                    if (this.requestOptions.onRetry) {
+                        await this.requestOptions.onRetry({ retryCount, error: requestError });
+                    }
+                }
+            }
+        }
+        async executeRequest(url, fetchOptions) {
+            // Create a request controller for timeout if needed, or use the provided one
+            const controller = this.abortController || new AbortController();
+            const { signal } = controller;
+            // Use the controller signal for the fetch request, but don't overwrite an existing signal
+            // that might have been set in requestOptions if it exists
+            fetchOptions.signal = fetchOptions.signal || signal;
+            let timeoutId;
+            // If we have a timeout and we're using our own controller (not provided externally)
+            if (this.requestOptions.timeout && !this.abortController) {
+                timeoutId = setTimeout(() => {
+                    controller.abort();
+                }, this.requestOptions.timeout);
+            }
+            try {
+                let response;
+                try {
+                    response = await fetch(url, fetchOptions);
+                }
+                catch (error) {
+                    // Check if this is an abort error from our timeout
+                    if (error instanceof DOMException && error.name === "AbortError" && timeoutId) {
+                        throw RequestError.timeout(url, fetchOptions.method, this.requestOptions.timeout);
+                    }
+                    // Otherwise it's a network error
+                    throw RequestError.networkError(url, fetchOptions.method, error);
+                }
+                if (!response.ok) {
+                    throw RequestError.fromResponse(response, url, fetchOptions.method);
+                }
+                // Return a wrapped response instead of parsing it
+                return new ResponseWrapper(response);
+            }
+            finally {
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                }
+            }
+        }
+    }
+
+    // An extension of BaseRequest for methods that support request bodies
+    class BodyRequest extends BaseRequest {
+        /**
+         * Sets the request body with appropriate content type handling
+         */
+        withBody(body) {
+            if (body === undefined || body === null) {
+                this.requestOptions.body = null;
+                return this;
+            }
+            // Handle special body types that don't need transformation
+            if (body instanceof Blob ||
+                body instanceof FormData ||
+                body instanceof URLSearchParams ||
+                body instanceof ArrayBuffer ||
+                body instanceof ReadableStream) {
+                this.requestOptions.body = body;
+                // For FormData, make sure to NOT explicitly set Content-Type
+                // The browser will set it automatically with the correct boundary
+                // If we set it manually, it would be missing the boundary parameter
+                return this;
+            }
+            // Handle strings
+            if (typeof body === "string") {
+                this.requestOptions.body = body;
+                return this;
+            }
+            // For objects and other types, stringify and set JSON content-type
+            try {
+                this.requestOptions.body = JSON.stringify(body);
+                this.requestOptions.headers = {
+                    "Content-Type": "application/json",
+                    ...(this.requestOptions.headers || {}),
+                };
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                throw new Error(`Failed to stringify request body: ${errorMessage}`);
+            }
+            return this;
+        }
+    }
+
+    // Methods without body
+    class GetRequest extends BaseRequest {
+        constructor() {
+            super(...arguments);
+            this.method = exports.HttpMethod.GET;
+        }
+    }
+    class HeadRequest extends BaseRequest {
+        constructor() {
+            super(...arguments);
+            this.method = exports.HttpMethod.HEAD;
+        }
+    }
+    class OptionsRequest extends BaseRequest {
+        constructor() {
+            super(...arguments);
+            this.method = exports.HttpMethod.OPTIONS;
+        }
+    }
+    class DeleteRequest extends BaseRequest {
+        constructor() {
+            super(...arguments);
+            this.method = exports.HttpMethod.DELETE;
+        }
+    }
+    // Methods with body
+    class PostRequest extends BodyRequest {
+        constructor() {
+            super(...arguments);
+            this.method = exports.HttpMethod.POST;
+        }
+    }
+    class PutRequest extends BodyRequest {
+        constructor() {
+            super(...arguments);
+            this.method = exports.HttpMethod.PUT;
+        }
+    }
+    class PatchRequest extends BodyRequest {
+        constructor() {
+            super(...arguments);
+            this.method = exports.HttpMethod.PATCH;
+        }
+    }
+
+    /**
+     * Create a GET request
+     */
+    function get() {
+        return new GetRequest();
+    }
+    /**
+     * Create a POST request
+     */
+    function post() {
+        return new PostRequest();
+    }
+    /**
+     * Create a PUT request
+     */
+    function put() {
+        return new PutRequest();
+    }
+    /**
+     * Create a DELETE request
+     * Note: We use 'del' to avoid JS keyword conflict
+     */
+    function del() {
+        return new DeleteRequest();
+    }
+    /**
+     * Create a PATCH request
+     */
+    function patch() {
+        return new PatchRequest();
+    }
+    /**
+     * Create a HEAD request
+     */
+    function head() {
+        return new HeadRequest();
+    }
+    /**
+     * Create an OPTIONS request
+     */
+    function options() {
+        return new OptionsRequest();
+    }
+
+    // Create the main API object
+    const create = {
+        get,
+        post,
+        put,
+        del,
+        patch,
+        head,
+        options,
+    };
+
+    exports.DeleteRequest = DeleteRequest;
+    exports.GetRequest = GetRequest;
+    exports.HeadRequest = HeadRequest;
+    exports.OptionsRequest = OptionsRequest;
+    exports.PatchRequest = PatchRequest;
+    exports.PostRequest = PostRequest;
+    exports.PutRequest = PutRequest;
+    exports.RequestError = RequestError;
+    exports.ResponseWrapper = ResponseWrapper;
+    exports["default"] = create;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));

package/dist/library/requestFactories.d.ts

@@ -0,0 +1,30 @@
+import { GetRequest, PostRequest, PutRequest, DeleteRequest, PatchRequest, HeadRequest, OptionsRequest } from "./requestMethods";
+/**
+ * Create a GET request
+ */
+export declare function get(): GetRequest;
+/**
+ * Create a POST request
+ */
+export declare function post(): PostRequest;
+/**
+ * Create a PUT request
+ */
+export declare function put(): PutRequest;
+/**
+ * Create a DELETE request
+ * Note: We use 'del' to avoid JS keyword conflict
+ */
+export declare function del(): DeleteRequest;
+/**
+ * Create a PATCH request
+ */
+export declare function patch(): PatchRequest;
+/**
+ * Create a HEAD request
+ */
+export declare function head(): HeadRequest;
+/**
+ * Create an OPTIONS request
+ */
+export declare function options(): OptionsRequest;

package/dist/library/requestMethods.d.ts

@@ -0,0 +1,24 @@
+import { BaseRequest } from "./BaseRequest";
+import { BodyRequest } from "./BodyRequest";
+import { HttpMethod } from "./enums";
+export declare class GetRequest extends BaseRequest {
+    protected method: HttpMethod;
+}
+export declare class HeadRequest extends BaseRequest {
+    protected method: HttpMethod;
+}
+export declare class OptionsRequest extends BaseRequest {
+    protected method: HttpMethod;
+}
+export declare class DeleteRequest extends BaseRequest {
+    protected method: HttpMethod;
+}
+export declare class PostRequest extends BodyRequest {
+    protected method: HttpMethod;
+}
+export declare class PutRequest extends BodyRequest {
+    protected method: HttpMethod;
+}
+export declare class PatchRequest extends BodyRequest {
+    protected method: HttpMethod;
+}