create-request 0.0.1-beta.2

package/dist/library/BaseRequest.d.ts

@@ -0,0 +1,119 @@
+import { type HttpMethod, type RedirectMode, type RequestMode, type RequestPriority, CredentialsPolicy } from "./enums";
+import { type ResponsePromise } from "./ResponseWrapper";
+import type { RequestOptions, RetryCallback } from "./types";
+export declare abstract class BaseRequest {
+    protected abstract method: HttpMethod;
+    protected requestOptions: RequestOptions;
+    protected abortController?: AbortController;
+    protected queryParams: URLSearchParams;
+    constructor();
+    withHeaders(headers: Record<string, string>): this;
+    withTimeout(timeout: number): this;
+    withRetries(retries: number): this;
+    onRetry(callback: RetryCallback): 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): 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: AbortController): this;
+    /**
+     * Sets the referrer for the request
+     * @param referrer - The referrer URL or policy
+     * @returns The instance for chaining
+     */
+    withReferrer(referrer: string): this;
+    /**
+     * Sets the redirect policy for the request
+     * @param redirect - Can be 'follow', 'error', or 'manual'
+     * @returns The instance for chaining
+     */
+    withRedirect(redirect: RedirectMode): 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: boolean): this;
+    /**
+     * Sets the priority of the request
+     * @param priority - Can be 'high', 'low', or 'auto'
+     * @returns The instance for chaining
+     */
+    withPriority(priority: RequestPriority): this;
+    /**
+     * Adds query parameters to the request URL
+     * @param params - An object containing the query parameters
+     * @returns The instance for chaining
+     */
+    withQueryParams(params: Record<string, string | string[] | number | boolean | null | undefined>): this;
+    /**
+     * Adds a single query parameter
+     * @param key - The parameter name
+     * @param value - The parameter value
+     * @returns The instance for chaining
+     */
+    withQueryParam(key: string, value: string | number | boolean | null | undefined): 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: RequestMode): this;
+    /**
+     * Shorthand for setting the Content-Type header
+     * @param contentType - The content type
+     * @returns The instance for chaining
+     */
+    withContentType(contentType: string): this;
+    /**
+     * Shorthand for setting the Authorization header
+     * @param authValue - The authorization value
+     * @returns The instance for chaining
+     */
+    withAuthorization(authValue: string): this;
+    /**
+     * Shorthand for setting up Basic authentication
+     * @param username - The username
+     * @param password - The password
+     * @returns The instance for chaining
+     */
+    withBasicAuth(username: string, password: string): this;
+    /**
+     * Sets the bearer token for authentication
+     * @param token - The bearer token
+     * @returns The instance for chaining
+     */
+    withBearerToken(token: string): this;
+    /**
+     * Sets cookies for the request
+     * @param cookies - An object containing cookie name-value pairs
+     * @returns The instance for chaining
+     */
+    withCookies(cookies: Record<string, string>): this;
+    /**
+     * Send the request to the specified URL
+     * @param url The URL to send the request to
+     */
+    sendTo(url: string): ResponsePromise;
+    /**
+     * Formats the URL with any query parameters
+     * @param url The base URL
+     * @returns The URL with query parameters appended
+     */
+    private formatUrlWithQueryParams;
+    /**
+     * 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
+     */
+    private executeWithRetries;
+    private executeRequest;
+}

package/dist/library/BodyRequest.d.ts

@@ -0,0 +1,8 @@
+import { BaseRequest } from "./BaseRequest";
+import type { Body } from "./types";
+export declare abstract class BodyRequest extends BaseRequest {
+    /**
+     * Sets the request body with appropriate content type handling
+     */
+    withBody(body: Body): this;
+}

package/dist/library/RequestError.d.ts

@@ -0,0 +1,18 @@
+export declare class RequestError extends Error {
+    readonly status?: number;
+    readonly response?: Response;
+    readonly url: string;
+    readonly method: string;
+    readonly timeoutError?: boolean;
+    constructor(message: string, url: string, method: string, options?: {
+        status?: number;
+        response?: Response;
+        timeoutError?: boolean;
+    });
+    /**
+     * Static methods for creating specific types of RequestError
+     */
+    static timeout(url: string, method: string, timeoutMs: number): RequestError;
+    static fromResponse(response: Response, url: string, method: string): RequestError;
+    static networkError(url: string, method: string, originalError: Error): RequestError;
+}

package/dist/library/ResponseWrapper.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Wrapper for HTTP responses with methods to transform the response data
+ */
+export declare class ResponseWrapper {
+    readonly ok: boolean;
+    private response;
+    constructor(response: Response);
+    /**
+     * Get the raw Response object
+     */
+    get raw(): Response;
+    /**
+     * Get the HTTP status code
+     */
+    get status(): number;
+    /**
+     * Get the HTTP status text
+     */
+    get statusText(): string;
+    /**
+     * Get response headers
+     */
+    get headers(): Headers;
+    /**
+     * Parse response as JSON
+     */
+    json<T = unknown>(): Promise<T>;
+    /**
+     * Get response as text
+     */
+    text(): Promise<string>;
+    /**
+     * Get response as Blob
+     */
+    blob(): Promise<Blob>;
+    /**
+     * Get response as ArrayBuffer
+     */
+    arrayBuffer(): Promise<ArrayBuffer>;
+    /**
+     * Get response as ReadableStream
+     */
+    body(): ReadableStream<Uint8Array> | null;
+}
+/**
+ * Type for Promise with response data transformation methods
+ */
+export interface ResponsePromise<T = ResponseWrapper> extends Promise<T> {
+    json<R = unknown>(): Promise<R>;
+    text(): Promise<string>;
+    blob(): Promise<Blob>;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    body(): Promise<ReadableStream<Uint8Array> | null>;
+}

package/dist/library/enums.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Enum for HTTP methods
+ */
+export declare enum HttpMethod {
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    DELETE = "DELETE",
+    PATCH = "PATCH",
+    HEAD = "HEAD",
+    OPTIONS = "OPTIONS"
+}
+/**
+ * Enum for request priorities
+ */
+export declare enum RequestPriority {
+    HIGH = "high",
+    LOW = "low",
+    AUTO = "auto"
+}
+/**
+ * Enum for credentials policies
+ */
+export declare enum CredentialsPolicy {
+    INCLUDE = "include",
+    SAME_ORIGIN = "same-origin",
+    OMIT = "omit"
+}
+/**
+ * Enum for request modes
+ */
+export declare enum RequestMode {
+    CORS = "cors",
+    NO_CORS = "no-cors",
+    SAME_ORIGIN = "same-origin",
+    NAVIGATE = "navigate"
+}
+/**
+ * Enum for redirect modes
+ */
+export declare enum RedirectMode {
+    FOLLOW = "follow",
+    ERROR = "error",
+    MANUAL = "manual"
+}
+/**
+ * Enum for cache modes
+ */
+export declare enum CacheMode {
+    DEFAULT = "default",
+    NO_STORE = "no-store",
+    RELOAD = "reload",
+    NO_CACHE = "no-cache",
+    FORCE_CACHE = "force-cache",
+    ONLY_IF_CACHED = "only-if-cached"
+}

package/dist/library/index.d.ts

@@ -0,0 +1,16 @@
+import { get, put, head, post, patch, del, options } from "./requestFactories";
+export { HttpMethod, RequestPriority, CredentialsPolicy, RequestMode, RedirectMode, CacheMode, } from "./enums";
+export type { RetryCallback, RequestOptions } from "./types";
+export { RequestError } from "./RequestError";
+export { ResponseWrapper } from "./ResponseWrapper";
+export { GetRequest, PostRequest, PutRequest, DeleteRequest, PatchRequest, HeadRequest, OptionsRequest, } from "./requestMethods";
+declare const create: {
+    readonly get: typeof get;
+    readonly post: typeof post;
+    readonly put: typeof put;
+    readonly del: typeof del;
+    readonly patch: typeof patch;
+    readonly head: typeof head;
+    readonly options: typeof options;
+};
+export default create;