create-request 0.0.1-beta.23 → 0.0.1-beta.24

package/dist/library/BaseRequest.d.ts

@@ -1,21 +1,27 @@
-import { type HttpMethod, type RedirectMode, type RequestMode, type RequestPriority, CredentialsPolicy } from "./enums.js";
-import type { RequestOptions, RetryCallback, CookiesRecord, CookieOptions } from "./types.js";
-import { type ResponsePromise } from "./ResponseWrapper.js";
-import type { CacheOptions } from "./types/cache.js";
-import { CacheManager } from "./utils/CacheManager.js";
+import { type HttpMethod, RedirectMode, RequestMode, RequestPriority, ReferrerPolicy, CredentialsPolicy } from "./enums.js";
+import type { RequestOptions, RetryCallback, CookiesRecord, CookieOptions, RequestInterceptor, ResponseInterceptor, ErrorInterceptor } from "./types.js";
+import { ResponseWrapper } from "./ResponseWrapper.js";
 /**
  * Base class with common functionality for all request types
  * Provides the core request building and execution capabilities.
  */
 export declare abstract class BaseRequest {
     protected abstract method: HttpMethod;
+    protected url: string;
     protected requestOptions: RequestOptions;
     protected abortController?: AbortController;
     protected queryParams: URLSearchParams;
     protected autoApplyCsrfProtection: boolean;
-    protected cacheManager?: CacheManager;
-    protected cacheEnabled: boolean;
-    constructor();
+    private requestInterceptors;
+    private responseInterceptors;
+    private errorInterceptors;
+    constructor(url: string);
+    /**
+     * Creates a fluent API for setting enum-based options
+     * Combines direct setter with convenience methods
+     */
+    private createFluentSetter;
+    private validateUrl;
     /**
      * Add multiple HTTP headers to the request
      *
@@ -78,11 +84,17 @@ export declare abstract class BaseRequest {
      */
     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
+     * Sets credentials policy - supports both direct call and fluent API
+     * @example
+     * request.withCredentials("include")
+     * request.withCredentials(CredentialsPolicy.INCLUDE)
+     * request.withCredentials.INCLUDE()
      */
-    withCredentials(credentialsPolicy?: CredentialsPolicy): this;
+    get withCredentials(): ((credentialsPolicy: CredentialsPolicy | string) => BaseRequest) & {
+        INCLUDE: () => BaseRequest;
+        OMIT: () => BaseRequest;
+        SAME_ORIGIN: () => BaseRequest;
+    };
     /**
      * Allows providing an external AbortController to cancel the request
      * @param controller - The AbortController to use for this request
@@ -96,17 +108,34 @@ export declare abstract class BaseRequest {
      */
     withReferrer(referrer: string): this;
     /**
-     * Sets the referrer policy for the request
-     * @param policy - The referrer policy to use
-     * @returns The instance for chaining
+     * Sets referrer policy - supports both direct call and fluent API
+     * @example
+     * request.withReferrerPolicy("no-referrer")
+     * request.withReferrerPolicy(ReferrerPolicy.NO_REFERRER)
+     * request.withReferrerPolicy.NO_REFERRER()
      */
-    withReferrerPolicy(policy: ReferrerPolicy): this;
+    get withReferrerPolicy(): ((policy: ReferrerPolicy | string) => BaseRequest) & {
+        ORIGIN: () => BaseRequest;
+        UNSAFE_URL: () => BaseRequest;
+        SAME_ORIGIN: () => BaseRequest;
+        NO_REFERRER: () => BaseRequest;
+        STRICT_ORIGIN: () => BaseRequest;
+        ORIGIN_WHEN_CROSS_ORIGIN: () => BaseRequest;
+        NO_REFERRER_WHEN_DOWNGRADE: () => BaseRequest;
+        STRICT_ORIGIN_WHEN_CROSS_ORIGIN: () => BaseRequest;
+    };
     /**
-     * Sets the redirect policy for the request
-     * @param redirect - Can be 'follow', 'error', or 'manual'
-     * @returns The instance for chaining
+     * Sets redirect mode - supports both direct call and fluent API
+     * @example
+     * request.withRedirect("follow")
+     * request.withRedirect(RedirectMode.FOLLOW)
+     * request.withRedirect.FOLLOW()
      */
-    withRedirect(redirect: RedirectMode): this;
+    get withRedirect(): ((redirect: RedirectMode | string) => BaseRequest) & {
+        FOLLOW: () => BaseRequest;
+        ERROR: () => BaseRequest;
+        MANUAL: () => BaseRequest;
+    };
     /**
      * Sets the keepalive flag for the request
      * @param keepalive - Whether to allow the request to outlive the page
@@ -114,11 +143,17 @@ export declare abstract class BaseRequest {
      */
     withKeepAlive(keepalive: boolean): this;
     /**
-     * Sets the priority of the request
-     * @param priority - Can be 'high', 'low', or 'auto'
-     * @returns The instance for chaining
+     * Sets request priority - supports both direct call and fluent API
+     * @example
+     * request.withPriority("high")
+     * request.withPriority(RequestPriority.HIGH)
+     * request.withPriority.HIGH()
      */
-    withPriority(priority: RequestPriority): this;
+    get withPriority(): ((priority: RequestPriority | string) => BaseRequest) & {
+        HIGH: () => BaseRequest;
+        LOW: () => BaseRequest;
+        AUTO: () => BaseRequest;
+    };
     /**
      * Adds query parameters to the request URL
      * @param params - An object containing the query parameters
@@ -133,11 +168,18 @@ export declare abstract class BaseRequest {
      */
     withQueryParam(key: string, value: string | 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
+     * Sets request mode - supports both direct call and fluent API
+     * @example
+     * request.withMode("cors")
+     * request.withMode(RequestMode.CORS)
+     * request.withMode.CORS()
      */
-    withMode(mode: RequestMode): this;
+    get withMode(): ((mode: RequestMode | string) => BaseRequest) & {
+        CORS: () => BaseRequest;
+        NO_CORS: () => BaseRequest;
+        SAME_ORIGIN: () => BaseRequest;
+        NAVIGATE: () => BaseRequest;
+    };
     /**
      * Shorthand for setting the Content-Type header
      * @param contentType - The content type
@@ -168,9 +210,13 @@ export declare abstract class BaseRequest {
      * @returns The instance for chaining
      */
     withBearerToken(token: string): this;
+    /**
+     * Safely get headers as a Record<string, string>
+     * @returns The headers object
+     */
+    private getHeadersRecord;
     /**
      * Helper function to check for header presence in a case-insensitive way
-     * @param headers Headers object
      * @param headerName Header name to check
      * @returns Boolean indicating if the header exists (case-insensitive)
      */
@@ -207,32 +253,113 @@ export declare abstract class BaseRequest {
      */
     withAntiCsrfHeaders(): this;
     /**
-     * Configure request caching behavior
-     * When enabled, responses will be cached and reused for subsequent identical requests.
+     * Add a request interceptor for this specific request
+     * Request interceptors can modify the request configuration or return an early response
      *
-     * @param options - Cache configuration options
-     * @returns The request instance for chaining
+     * @param interceptor - The request interceptor function
+     * @returns The instance for chaining
      *
      * @example
-     * request.withCache({
-     *   ttl: 60000, // Cache for 1 minute
-     *   maxEntries: 100,
-     *   storage: localStorage
+     * request.withRequestInterceptor((config) => {
+     *   config.headers['X-Custom'] = 'value';
+     *   return config;
      * });
      */
-    withCache(options?: CacheOptions): this;
+    withRequestInterceptor(interceptor: RequestInterceptor): this;
+    /**
+     * Add a response interceptor for this specific request
+     * Response interceptors can transform the response
+     *
+     * @param interceptor - The response interceptor function
+     * @returns The instance for chaining
+     *
+     * @example
+     * request.withResponseInterceptor((response) => {
+     *   console.log('Status:', response.status);
+     *   return response;
+     * });
+     */
+    withResponseInterceptor(interceptor: ResponseInterceptor): this;
+    /**
+     * Add an error interceptor for this specific request
+     * Error interceptors can handle or transform errors
+     *
+     * @param interceptor - The error interceptor function
+     * @returns The instance for chaining
+     *
+     * @example
+     * request.withErrorInterceptor((error) => {
+     *   console.error('Request failed:', error);
+     *   throw error;
+     * });
+     */
+    withErrorInterceptor(interceptor: ErrorInterceptor): this;
+    /**
+     * Execute the request and return the ResponseWrapper
+     * This is the base method for getting the full response.
+     *
+     * @returns A promise that resolves to the ResponseWrapper
+     *
+     * @example
+     * const response = await request.getResponse();
+     * console.log(response.status);
+     */
+    getResponse(): Promise<ResponseWrapper>;
+    /**
+     * Execute the request and parse the response as JSON
+     *
+     * @returns A promise that resolves to the parsed JSON data
+     *
+     * @example
+     * const users = await request.getJson<User[]>();
+     */
+    getJson<T = unknown>(): Promise<T>;
+    /**
+     * Execute the request and get the response as text
+     *
+     * @returns A promise that resolves to the response text
+     *
+     * @example
+     * const text = await request.getText();
+     */
+    getText(): Promise<string>;
     /**
-     * Send the request to the specified URL
-     * This is the final method in the chain that executes the request.
+     * Execute the request and get the response as a Blob
      *
-     * @param url - The URL to send the request to
-     * @returns A promise with additional methods for processing the response
+     * @returns A promise that resolves to the response Blob
      *
      * @example
-     * const response = await request.sendTo('/api/users');
-     * const data = await response.getJson();
+     * const blob = await request.getBlob();
+     */
+    getBlob(): Promise<Blob>;
+    /**
+     * Execute the request and get the response body as a ReadableStream
+     *
+     * @returns A promise that resolves to the response body stream
+     *
+     * @example
+     * const stream = await request.getBody();
+     */
+    getBody(): Promise<ReadableStream<Uint8Array> | null>;
+    /**
+     * Execute the request and extract specific data using a selector function
+     * If no selector is provided, returns the full JSON response.
+     *
+     * @param selector - Optional function to extract and transform data
+     * @returns A promise that resolves to the selected data
+     *
+     * @example
+     * // Get full response
+     * const data = await request.getData();
+     *
+     * // Extract specific data
+     * const users = await request.getData(data => data.results.users);
      */
-    sendTo(url: string): ResponsePromise;
+    getData<T = unknown, R = T>(selector?: (data: T) => R): Promise<T | R>;
+    /**
+     * Apply CSRF protection headers based on configuration
+     */
+    private applyCsrfProtection;
     /**
      * Formats the URL with any query parameters
      * @param url The base URL
@@ -247,12 +374,41 @@ export declare abstract class BaseRequest {
      * @throws RequestError if the request fails after all retries
      */
     private executeWithRetries;
-    private executeRequest;
     /**
-     * Executes a request using cache when possible
-     * @param url The formatted URL to send the request to
-     * @param fetchOptions The fetch options to use
-     * @param cacheKey The cache key for this request
+     * Run request interceptors in order: global interceptors first, then per-request
+     * @param configParam - The request configuration
+     * @returns Modified config or a Response to short-circuit
+     */
+    private runRequestInterceptors;
+    /**
+     * Run response interceptors in reverse order: per-request interceptors first, then global in reverse
+     * @param response - The response wrapper
+     * @returns Modified response wrapper
+     */
+    private runResponseInterceptors;
+    /**
+     * Run error interceptors in reverse order: per-request interceptors first, then global in reverse
+     * @param error - The error that occurred
+     * @returns Modified error or a ResponseWrapper to recover
      */
-    private executeWithCache;
+    private runErrorInterceptors;
+    /**
+     * Helper to create an abort signal with timeout support
+     * Handles various AbortSignal API levels gracefully
+     */
+    private createAbortSignal;
+    /**
+     * Manually combine two abort signals for older environments
+     * Returns the first signal and listens to the second
+     */
+    private combineSignalsManually;
+    /**
+     * Convert fetchOptions to RequestConfig with proper typing
+     */
+    private createRequestConfig;
+    /**
+     * Apply interceptor results back to fetchOptions
+     */
+    private applyRequestConfig;
+    private executeRequest;
 }

package/dist/library/BodyRequest.d.ts

@@ -1,20 +1,43 @@
 import { BaseRequest } from "./BaseRequest.js";
 import type { Body } from "./types.js";
+import type { ResponseWrapper } from "./ResponseWrapper.js";
 /**
  * Base class for requests that can have a body (POST, PUT, PATCH)
  */
 export declare abstract class BodyRequest extends BaseRequest {
     protected body?: Body;
     private bodyType?;
+    constructor(url: string);
     /**
      * Sets the body of the request
      * @param body - The request body
      */
     withBody(body: Body): this;
+    /**
+     * Sets a GraphQL query or mutation as the request body
+     * Automatically formats the body as JSON and sets Content-Type to application/json
+     *
+     * @param query - The GraphQL query or mutation string
+     * @param variables - Optional variables object to pass with the query
+     * @returns The request instance for chaining
+     *
+     * @example
+     * const request = new PostRequest('/graphql')
+     *   .withGraphQL('query { user(id: $id) { name email } }', { id: '123' });
+     *
+     * @example
+     * const request = new PostRequest('/graphql')
+     *   .withGraphQL('mutation { createUser(name: $name) { id } }', { name: 'John' });
+     */
+    withGraphQL(query: string, variables?: Record<string, unknown>): this;
+    /**
+     * Check if Content-Type header is already set (case-insensitive)
+     */
+    private hasContentType;
     private setContentTypeIfNeeded;
     /**
-     * Send the request to the specified URL
+     * Execute the request and return the ResponseWrapper
      * Overrides the base implementation to add body handling
      */
-    sendTo(url: string): ReturnType<BaseRequest["sendTo"]>;
+    getResponse(): Promise<ResponseWrapper>;
 }

package/dist/library/RequestError.d.ts

@@ -3,11 +3,13 @@ export declare class RequestError extends Error {
     readonly response?: Response;
     readonly url: string;
     readonly method: string;
-    readonly timeoutError?: boolean;
+    readonly isTimeout?: boolean;
+    readonly isAborted?: boolean;
     constructor(message: string, url: string, method: string, options?: {
         status?: number;
         response?: Response;
-        timeoutError?: boolean;
+        isTimeout?: boolean;
+        isAborted?: boolean;
     });
     /**
      * Static methods for creating specific types of RequestError
@@ -15,4 +17,5 @@ export declare class RequestError extends Error {
     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;
+    static abortError(url: string, method: string): RequestError;
 }

package/dist/library/ResponseWrapper.d.ts

@@ -4,12 +4,13 @@
  */
 export declare class ResponseWrapper {
     private readonly response;
+    readonly url?: string;
+    readonly method?: string;
     private textCache;
     private jsonCache;
     private blobCache;
-    private arrayBufferCache;
     private bodyUsed;
-    constructor(response: Response);
+    constructor(response: Response, url?: string, method?: string);
     get status(): number;
     get statusText(): string;
     get headers(): Headers;
@@ -52,18 +53,6 @@ export declare class ResponseWrapper {
      * const url = URL.createObjectURL(blob);
      */
     getBlob(): Promise<Blob>;
-    /**
-     * Get the response body as an ArrayBuffer
-     * Caches the result for subsequent calls. Attempts to convert from text or Blob
-     * if the body has already been consumed in those formats.
-     *
-     * @returns The response as an ArrayBuffer
-     * @throws Error if the response has already been consumed in an incompatible format
-     *
-     * @example
-     * const buffer = await response.getArrayBuffer();
-     */
-    getArrayBuffer(): Promise<ArrayBuffer>;
     /**
      * Get the raw response body as a ReadableStream
      * This method consumes the body and should only be called once.
@@ -79,15 +68,19 @@ export declare class ResponseWrapper {
      * }
      */
     getBody(): ReadableStream<Uint8Array> | null;
-}
-/**
- * Type for Promise with response data transformation methods
- */
-export interface ResponsePromise<T = ResponseWrapper> extends Promise<T> {
-    getJson<R = unknown>(): Promise<R>;
-    getText(): Promise<string>;
-    getBlob(): Promise<Blob>;
-    getArrayBuffer(): Promise<ArrayBuffer>;
-    getBody(): Promise<ReadableStream<Uint8Array> | null>;
+    /**
+     * Extract specific data using a selector function
+     * If no selector is provided, returns the full JSON response.
+     *
+     * @param selector - Optional function to extract and transform data
+     * @returns A promise that resolves to the selected data
+     *
+     * @example
+     * // Get full response
+     * const data = await response.getData();
+     *
+     * // Extract specific data
+     * const users = await response.getData(data => data.results.users);
+     */
     getData<T = unknown, R = T>(selector?: (data: T) => R): Promise<T | R>;
 }

package/dist/library/enums.d.ts

@@ -43,17 +43,6 @@ export declare enum RedirectMode {
     FOLLOW = "follow",
     MANUAL = "manual"
 }
-/**
- * Enum for cache modes
- */
-export declare enum CacheMode {
-    DEFAULT = "default",
-    RELOAD = "reload",
-    NO_STORE = "no-store",
-    NO_CACHE = "no-cache",
-    FORCE_CACHE = "force-cache",
-    ONLY_IF_CACHED = "only-if-cached"
-}
 /**
  * Enum for cookie SameSite policies
  */