create-request 0.0.1-beta.2

package/dist/library/index.esm.js

@@ -0,0 +1,616 @@
+/**
+ * Enum for HTTP methods
+ */
+var HttpMethod;
+(function (HttpMethod) {
+    HttpMethod["GET"] = "GET";
+    HttpMethod["POST"] = "POST";
+    HttpMethod["PUT"] = "PUT";
+    HttpMethod["DELETE"] = "DELETE";
+    HttpMethod["PATCH"] = "PATCH";
+    HttpMethod["HEAD"] = "HEAD";
+    HttpMethod["OPTIONS"] = "OPTIONS";
+})(HttpMethod || (HttpMethod = {}));
+/**
+ * Enum for request priorities
+ */
+var RequestPriority;
+(function (RequestPriority) {
+    RequestPriority["HIGH"] = "high";
+    RequestPriority["LOW"] = "low";
+    RequestPriority["AUTO"] = "auto";
+})(RequestPriority || (RequestPriority = {}));
+/**
+ * Enum for credentials policies
+ */
+var CredentialsPolicy;
+(function (CredentialsPolicy) {
+    CredentialsPolicy["INCLUDE"] = "include";
+    CredentialsPolicy["SAME_ORIGIN"] = "same-origin";
+    CredentialsPolicy["OMIT"] = "omit";
+})(CredentialsPolicy || (CredentialsPolicy = {}));
+/**
+ * Enum for request modes
+ */
+var RequestMode;
+(function (RequestMode) {
+    RequestMode["CORS"] = "cors";
+    RequestMode["NO_CORS"] = "no-cors";
+    RequestMode["SAME_ORIGIN"] = "same-origin";
+    RequestMode["NAVIGATE"] = "navigate";
+})(RequestMode || (RequestMode = {}));
+/**
+ * Enum for redirect modes
+ */
+var RedirectMode;
+(function (RedirectMode) {
+    RedirectMode["FOLLOW"] = "follow";
+    RedirectMode["ERROR"] = "error";
+    RedirectMode["MANUAL"] = "manual";
+})(RedirectMode || (RedirectMode = {}));
+/**
+ * Enum for cache modes
+ */
+var CacheMode;
+(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";
+})(CacheMode || (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 = 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 = HttpMethod.GET;
+    }
+}
+class HeadRequest extends BaseRequest {
+    constructor() {
+        super(...arguments);
+        this.method = HttpMethod.HEAD;
+    }
+}
+class OptionsRequest extends BaseRequest {
+    constructor() {
+        super(...arguments);
+        this.method = HttpMethod.OPTIONS;
+    }
+}
+class DeleteRequest extends BaseRequest {
+    constructor() {
+        super(...arguments);
+        this.method = HttpMethod.DELETE;
+    }
+}
+// Methods with body
+class PostRequest extends BodyRequest {
+    constructor() {
+        super(...arguments);
+        this.method = HttpMethod.POST;
+    }
+}
+class PutRequest extends BodyRequest {
+    constructor() {
+        super(...arguments);
+        this.method = HttpMethod.PUT;
+    }
+}
+class PatchRequest extends BodyRequest {
+    constructor() {
+        super(...arguments);
+        this.method = 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,
+};
+
+export { CacheMode, CredentialsPolicy, DeleteRequest, GetRequest, HeadRequest, HttpMethod, OptionsRequest, PatchRequest, PostRequest, PutRequest, RedirectMode, RequestError, RequestMode, RequestPriority, ResponseWrapper, create as default };