aspi 1.1.0-beta.0

package/dist/index.js

@@ -0,0 +1,1210 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/http.ts
+var httpErrors = {
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  CONFLICT: 409,
+  PAYLOAD_TOO_LARGE: 413,
+  UNSUPPORTED_MEDIA_TYPE: 415,
+  UNPROCESSABLE_ENTITY: 422,
+  TOO_MANY_REQUESTS: 429,
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504
+};
+var getHttpErrorStatus = (status) => {
+  return Object.keys(httpErrors).find(
+    (key) => httpErrors[key] === status
+  );
+};
+
+// src/error.ts
+var AspiError = class extends Error {
+  tag = "aspiError";
+  request;
+  response;
+  /**
+   * Creates an instance of AspiError
+   * @param {string} message - The error message
+   * @param {AspiRe} request - The request configuration
+   * @param {AspiResponse} response - The error response
+   */
+  constructor(message, request, response) {
+    super(message);
+    this.request = request;
+    this.response = response;
+  }
+  /**
+   * Conditionally executes callback if status matches
+   * @template T
+   * @param {HttpErrorStatus} status - The status to match against
+   * @param {(args: { request: AspiRequest; response: AspiResponse }) => T} cb - Callback to execute on match
+   * @returns {T | undefined} Result of callback if status matches, undefined otherwise
+   */
+  ifMatch(status, cb) {
+    if (this.response.statusText === status) {
+      return cb({
+        request: this.request,
+        response: this.response
+      });
+    }
+  }
+};
+var CustomError = class extends Error {
+  tag;
+  data;
+  /**
+   * Creates an instance of CustomError
+   * @param {Tag} tag - Tag identifying the error type
+   * @param {A} data - Additional error data
+   */
+  constructor(tag, data) {
+    super(tag);
+    this.tag = tag;
+    this.data = data;
+  }
+};
+
+// src/result.ts
+var result_exports = {};
+__export(result_exports, {
+  catchAllErrors: () => catchAllErrors,
+  catchError: () => catchError,
+  catchErrors: () => catchErrors,
+  err: () => err,
+  getErrorOrNull: () => getErrorOrNull,
+  getOrElse: () => getOrElse,
+  getOrNull: () => getOrNull,
+  getOrThrow: () => getOrThrow,
+  getOrThrowWith: () => getOrThrowWith,
+  isErr: () => isErr,
+  isOk: () => isOk,
+  map: () => map,
+  mapErr: () => mapErr,
+  match: () => match,
+  ok: () => ok,
+  pipe: () => pipe
+});
+var ok = (value) => ({ __tag: "ok", value });
+var err = (error) => ({ __tag: "err", error });
+var isOk = (result) => result.__tag === "ok";
+var isErr = (result) => !isOk(result);
+function map(selfOrFn, fn) {
+  if (fn) {
+    const self = selfOrFn;
+    return isOk(self) ? ok(fn(self.value)) : self;
+  } else {
+    const mappingFn = selfOrFn;
+    return (self) => isOk(self) ? ok(mappingFn(self.value)) : self;
+  }
+}
+function mapErr(selfOrFn, fn) {
+  if (fn) {
+    const self = selfOrFn;
+    return isErr(self) ? err(fn(self.error)) : self;
+  } else {
+    const mappingFn = selfOrFn;
+    return (self) => isErr(self) ? err(mappingFn(self.error)) : self;
+  }
+}
+function match(selfOrHandlers, handlers) {
+  if (handlers) {
+    const self = selfOrHandlers;
+    return isOk(self) ? handlers.onOk(self.value) : handlers.onErr(self.error);
+  } else {
+    const handlersObj = selfOrHandlers;
+    return (self) => isOk(self) ? handlersObj.onOk(self.value) : handlersObj.onErr(self.error);
+  }
+}
+var getOrNull = (result) => {
+  if (isOk(result)) {
+    return result.value;
+  } else {
+    return null;
+  }
+};
+var getErrorOrNull = (result) => {
+  if (isErr(result)) {
+    return result.error;
+  } else {
+    return null;
+  }
+};
+var getOrElse = (result, fallback) => isOk(result) ? result.value : fallback;
+var getOrThrow = (result) => {
+  if (isOk(result)) {
+    return result.value;
+  } else {
+    throw result.error;
+  }
+};
+function getOrThrowWith(selfOrFn, fn) {
+  if (fn) {
+    const self = selfOrFn;
+    if (isOk(self)) {
+      return self.value;
+    } else {
+      throw fn(self.error);
+    }
+  } else {
+    const throwFn = selfOrFn;
+    return (self) => {
+      if (isOk(self)) {
+        return self.value;
+      } else {
+        throw throwFn(self.error);
+      }
+    };
+  }
+}
+function catchError(resultOrErrorOrTag, tagOrFn, fnOrUndefined) {
+  if (typeof resultOrErrorOrTag === "string") {
+    const tag = resultOrErrorOrTag;
+    const fn = tagOrFn;
+    return (resultOrError) => {
+      if ("__tag" in resultOrError) {
+        const result = resultOrError;
+        if (isErr(result) && result.error.tag === tag) {
+          fn(result.error);
+          return ok(null);
+        }
+        return result;
+      }
+      const error = resultOrError;
+      if (error.tag === tag) {
+        fn(error);
+      }
+    };
+  } else {
+    const resultOrError = resultOrErrorOrTag;
+    const tag = tagOrFn;
+    const fn = fnOrUndefined;
+    if ("__tag" in resultOrError) {
+      const result = resultOrError;
+      if (isErr(result) && result.error.tag === tag) {
+        fn(result.error);
+        return ok(null);
+      }
+      return result;
+    }
+    const error = resultOrError;
+    if (error.tag === tag) {
+      fn(error);
+    }
+  }
+}
+function catchAllErrors(resultOrFn, fnOrUndefined) {
+  if ("__tag" in resultOrFn) {
+    const result = resultOrFn;
+    if (isErr(result)) {
+      fnOrUndefined(result.error);
+    }
+    return result;
+  }
+  return (result) => {
+    if (isErr(result)) {
+      fnOrUndefined(result.error);
+    }
+    return result;
+  };
+}
+function catchErrors(resultOrHandlers, handlersOrUndefined) {
+  if ("__tag" in resultOrHandlers) {
+    const result = resultOrHandlers;
+    if (isErr(result)) {
+      const handler = handlersOrUndefined[result.error.tag];
+      if (handler) {
+        handler(result.error);
+      }
+    }
+    return result;
+  } else {
+    return (result) => {
+      if (isErr(result)) {
+        const handler = handlersOrUndefined[result.error.tag];
+        if (handler) {
+          handler(result.error);
+        }
+      }
+      return result;
+    };
+  }
+}
+var pipe = (result, ab) => {
+  function run(a) {
+    return ab(a);
+  }
+  run.pipe = (bc) => pipe(result, (a) => bc(ab(a)));
+  run.execute = () => run(result);
+  return run;
+};
+
+// src/request.ts
+var Request = class {
+  #path;
+  #localRequestInit;
+  #customErrorCbs = {};
+  #queryParams;
+  #middlewares;
+  #schema = null;
+  #bodySchema = null;
+  #retryConfig;
+  #shouldBeResult = false;
+  #bodySchemaIssues = [];
+  constructor(method, path, {
+    requestConfig,
+    retryConfig,
+    middlewares,
+    errorCbs
+  }) {
+    this.#path = path;
+    this.#middlewares = middlewares || [];
+    this.#localRequestInit = { ...requestConfig, method };
+    this.#retryConfig = retryConfig;
+    this.#customErrorCbs = errorCbs || {};
+  }
+  /**
+   * Sets the base URL for the request.
+   * @param url The base URL to set
+   * @returns The request instance for chaining
+   * @example
+   * const request = new Request('/users', config);
+   * request.setBaseUrl('https://api.example.com');
+   */
+  setBaseUrl(url) {
+    this.#localRequestInit.baseUrl = url;
+    return this;
+  }
+  /**
+   * Sets the retry configuration for the request.
+   * @param retry The retry configuration object
+   * @returns The request instance for chaining
+   * @example
+   * const request = new Request('/users', config);
+   * request.setRetry({
+   *   retries: 3, // Number of retry attempts
+   *   retryDelay: 1000, // Delay between retries in ms
+   *   retryOn: [500, 502, 503], // Status codes to retry on
+   *   retryWhile: (request, response) => response.status >= 500 // Custom retry condition
+   * });
+   */
+  setRetry(retry) {
+    this.#retryConfig = {
+      ...this.#retryConfig,
+      ...retry
+    };
+    return this;
+  }
+  /**
+   * Sets multiple headers for the request.
+   * @param headers An object containing header key-value pairs
+   * @returns The request instance for chaining
+   * @example
+   * const request = new Request('/users', config);
+   * request.setHeaders({
+   *   'Content-Type': 'application/json',
+   *   'Accept': 'application/json'
+   * });
+   */
+  setHeaders(headers) {
+    this.#localRequestInit.headers = headers;
+    return this;
+  }
+  /**
+   * Sets a single header for the request.
+   * @param key The header key
+   * @param value The header value
+   * @returns The request instance for chaining
+   * @example
+   * const request = new Request('/users', config);
+   * request.setHeader('Content-Type', 'application/json');
+   */
+  setHeader(key, value) {
+    this.#localRequestInit.headers = {
+      ...this.#localRequestInit.headers,
+      [key]: value
+    };
+    return this;
+  }
+  /**
+   * Sets the Authorization header with a bearer token.
+   * @param token The bearer token to set
+   * @returns The request instance for chaining
+   * @example
+   * const request = new Request('/users', config);
+   * request.setBearer('my-auth-token');
+   */
+  setBearer(token) {
+    return this.setHeader("Authorization", `Bearer ${token}`);
+  }
+  /**
+   * Sets a validation schema for the request body using a StandardSchemaV1 schema.
+   * @template TSchema Type parameter extending StandardSchemaV1
+   * @param schema The schema to validate the body against
+   * @returns The request instance for chaining with updated error type
+   * @example
+   * const userSchema = z.object({
+   *   name: z.string(),
+   *   email: z.string().email()
+   * });
+   *
+   * const request = new Request('/users', config);
+   * request
+   *   .bodySchema(userSchema)
+   *   .bodyJson({
+   *     name: 'John',
+   *     email: 'john@example.com'
+   *   });
+   */
+  bodySchema(schema) {
+    this.#bodySchema = schema;
+    return this;
+  }
+  /**
+   * Sets the request body as JSON by automatically stringifying the provided object.
+   * @param body The object to be stringified and sent as the request body
+   * @returns The request instance for chaining
+   * @example
+   * const request = new Request('/users', config);
+   * request.bodyJson({
+   *   name: 'John Doe',
+   *   email: 'john@example.com',
+   *   age: 30
+   * });
+   */
+  bodyJson(body) {
+    if (this.#bodySchema) {
+      const data = this.#bodySchema["~standard"].validate(body);
+      if (data instanceof Promise) {
+        throw new Error("Schema validation should not return a promise");
+      }
+      if (data.issues) {
+        this.#bodySchemaIssues = data.issues;
+      } else {
+        this.#localRequestInit.body = JSON.stringify(body);
+      }
+    }
+    return this;
+  }
+  /**
+   * Sets the raw request body (unsafe, use with caution).
+   * @param body The body content to send with the request
+   * @returns The request instance for chaining
+   * @example
+   * const request = new Request('/users', config);
+   * request.unsafeBody(new FormData());
+   *
+   * // or with raw text
+   * request.unsafeBody('Hello World');
+   *
+   * // or with URLSearchParams
+   * request.unsafeBody(new URLSearchParams({ key: 'value' }));
+   */
+  unsafeBody(body) {
+    this.#localRequestInit.body = body;
+    return this;
+  }
+  /**
+   * Handles 404 Not Found errors with a custom callback.
+   * @param cb The callback function to handle the error
+   * @returns The request instance for chaining
+   * @example
+   * const request = new Request('/users', config);
+   * request.notFound((error) => {
+   *   console.log('Resource not found:', error);
+   *   return { message: 'Custom not found message' };
+   * });
+   */
+  notFound(cb) {
+    return this.error("notFoundError", "NOT_FOUND", cb);
+  }
+  /**
+   * Handles 429 Too Many Requests errors with a custom callback.
+   * @param cb The callback function to handle the error
+   * @returns The request instance for chaining
+   * @example
+   * const request = new Request('/users', config);
+   * request.tooManyRequests((error) => {
+   *   console.log('Rate limited:', error);
+   *   return { message: 'Please try again later' };
+   * });
+   */
+  tooManyRequests(cb) {
+    return this.error("tooManyRequestsError", "TOO_MANY_REQUESTS", cb);
+  }
+  /**
+   * Handles 400 Bad Request errors with a custom callback.
+   * @param cb The callback function to handle the error
+   * @returns The request instance for chaining
+   * @example
+   * const request = new Request('/users', config);
+   * request.badRequest((error) => {
+   *   console.log('Bad request error:', error);
+   *   return { message: 'Invalid request parameters' };
+   * });
+   */
+  badRequest(cb) {
+    return this.error("badRequestError", "BAD_REQUEST", cb);
+  }
+  /**
+   * Handles 409 Conflict errors with a custom callback.
+   * @param cb The callback function to handle the error
+   * @returns The request instance for chaining
+   * @example
+   * const request = new Request('/users', config);
+   * request.conflict((error) => {
+   *   console.log('Conflict error:', error);
+   *   return { message: 'Resource conflict detected' };
+   * });
+   */
+  conflict(cb) {
+    return this.error("conflictError", "CONFLICT", cb);
+  }
+  /**
+   * Handles 401 Unauthorized errors with a custom callback.
+   * @param cb The callback function to handle the error
+   * @returns The request instance for chaining
+   * @example
+   * const request = new Request('/users', config);
+   * request.unauthorised((error) => {
+   *   console.log('Unauthorized access:', error);
+   *   return { message: 'Please login first' };
+   * });
+   */
+  unauthorised(cb) {
+    return this.error("unauthorisedError", "UNAUTHORIZED", cb);
+  }
+  /**
+   * Handles 403 Forbidden errors with a custom callback.
+   * @param cb The callback function to handle the error
+   * @returns The request instance for chaining
+   * @example
+   * const request = new Request('/users', config);
+   * request.forbidden((error) => {
+   *   console.log('Access forbidden:', error);
+   *   return { message: 'You do not have permission' };
+   * });
+   */
+  forbidden(cb) {
+    return this.error("forbiddenError", "FORBIDDEN", cb);
+  }
+  /**
+   * Handles 501 Not Implemented errors with a custom callback.
+   * @param cb The callback function to handle the error
+   * @returns The request instance for chaining
+   * @example
+   * const request = new Request('/users', config);
+   * request.notImplemented((error) => {
+   *   console.log('Not implemented:', error);
+   *   return { message: 'This feature is not implemented yet' };
+   * });
+   */
+  notImplemented(cb) {
+    return this.error("notImplementedError", "NOT_IMPLEMENTED", cb);
+  }
+  /**
+   * Handles 500 Internal Server Error errors with a custom callback.
+   * @param cb The callback function to handle the error
+   * @returns The request instance for chaining
+   * @example
+   * const request = new Request('/users', config);
+   * request.internalServerError((error) => {
+   *   console.log('Server error:', error);
+   *   return { message: 'An unexpected error occurred' };
+   * });
+   */
+  internalServerError(cb) {
+    return this.error("internalServerError", "INTERNAL_SERVER_ERROR", cb);
+  }
+  /**
+   * Sets a custom error handler for a specific HTTP status code.
+   * @param tag A string identifier for the error type
+   * @param status The HTTP error status to handle
+   * @param cb The callback function to handle the error
+   * @returns The request instance for chaining
+   * @example
+   * const request = new Request('/users', config);
+   * request
+      .withResult()
+      .error('customError', 'BAD_REQUEST', (error) => {
+   *   console.log('Bad request error:', error);
+   *   return {
+   *     message: 'Invalid input',
+   *     details: error.response.responseData
+   *   };
+   * });
+   *
+   * // Later when making the request:
+   * const result = await request.json();
+   * if (Result.isErr(result)) {
+   *   if(result.tag === 'customError') {
+   *   console.log(result.error.data.message); // 'Invalid input'
+   * }
+   */
+  error(tag, status, cb) {
+    this.#customErrorCbs[httpErrors[status]] = {
+      cb,
+      tag
+    };
+    return this;
+  }
+  /**
+   * Sets query parameters for the request URL.
+   * @param params An object containing query parameter key-value pairs
+   * @returns The request instance for chaining
+   * @example
+   * const request = new Request('/users', config);
+   * request.setQueryParams({
+   *   page: '1',
+   *   limit: '10',
+   *   sort: 'desc'
+   * });
+   */
+  setQueryParams(params) {
+    this.#queryParams = new URLSearchParams(params);
+    return this;
+  }
+  /**
+   * Sets the output schema for validating the response data using Zod.
+   * @param schema The Zod schema to validate the response
+   * @returns The request instance for chaining
+   * @example
+   * import { z } from 'zod';
+   *
+   * const userSchema = z.object({
+   *   id: z.number(),
+   *   name: z.string(),
+   *   email: z.string().email()
+   * });
+   *
+   * const request = new Request('/users', config);
+   * const result = await request
+   *   .withResult()
+   *   .output(userSchema)
+   *   .json();
+   *
+   * if (Result.isOk(result)) {
+   *   const user = result.value; // Typed and validated user data
+   * }
+   */
+  schema(schema) {
+    this.#schema = schema;
+    return this;
+  }
+  /**
+   * Executes the request and returns the JSON response.
+   * @returns A Promise containing the Result type with either successful data or error information
+   * @example
+   * const request = new Request('/users', config);
+   * const result = await request
+   *   .setQueryParams({ id: '123' })
+   *   .withResult()
+   *   .notFound((error) => ({ message: 'User not found' }))
+   *   .json<User>();
+   *
+   * if (Result.isOk(result)) {
+   *   const user = result.value; // User data
+   * } else {
+   *   console.error(result.error); // Error handling
+   * }
+   */
+  async json() {
+    const output = await this.#makeRequest(
+      async (response) => response.json().catch(
+        (e) => new CustomError("jsonParseError", {
+          message: e instanceof Error ? e.message : "Failed to parse JSON"
+        })
+      ),
+      true
+    );
+    return this.#mapResponse(output);
+  }
+  /**
+   * Executes the request and returns the response as plain text.
+   * @returns A Promise containing the Result type with either successful text data or error information
+   * @example
+   * const request = new Request('/data.txt', config);
+   * const result = await request
+   *   .setQueryParams({ version: '1' })
+   *   .withResult()
+   *   .notFound((error) => ({ message: 'Text file not found' }))
+   *   .text();
+   *
+   * if (Result.isOk(result)) {
+   *   const text = result.value; // Plain text content
+   * } else {
+   *   console.error(result.error); // Error handling
+   * }
+   */
+  async text() {
+    const output = await this.#makeRequest(
+      (response) => response.text()
+    );
+    return this.#mapResponse(output);
+  }
+  /**
+   * Executes the request and returns the response as a Blob.
+   * @returns A Promise containing the Result type with either successful Blob data or error information
+   * @example
+   * const request = new Request('/image.jpg', config);
+   * const result = await request
+   *   .setQueryParams({ size: 'large' })
+   *   .withResult()
+   *   .notFound((error) => ({ message: 'Image not found' }))
+   *   .blob();
+   *
+   * if (Result.isOk(result)) {
+   *   const imageBlob = result.value; // Blob data
+   * } else {
+   *   console.error(result.error); // Error handling
+   * }
+   */
+  async blob() {
+    const output = await this.#makeRequest((response) => response.blob());
+    return this.#mapResponse(output);
+  }
+  #url() {
+    const baseUrl = this.#localRequestInit.baseUrl?.replace(/\/+$/, "") ?? "";
+    const path = this.#path.replace(/^\/+/, "/");
+    const queryString = this.#queryParams ? `?${this.#queryParams.toString()}` : "";
+    const url = [baseUrl, path, queryString].filter(Boolean).join("");
+    return url;
+  }
+  /**
+   * Returns the complete URL for the request including base URL, path, and query parameters.
+   * @returns The complete URL string
+   * @example
+   * const request = new Request('/users', config);
+   * request.setBaseUrl('https://api.example.com');
+   * request.setQueryParams({ id: '123' });
+   * console.log(request.url()); // 'https://api.example.com/users?id=123'
+   */
+  url() {
+    return this.#url();
+  }
+  /**
+   * Configures the request to return a Result type instead of a tuple.
+   * @returns The request instance for chaining with Result type return value
+   * @example
+   * const request = new Request('/users', config);
+   * const result = await request
+   *   .withResult()
+   *   .json<User>();
+   *
+   * // Returns Result type instead of tuple
+   * if (Result.isOk(result)) {
+   *   const user = result.value;
+   * }
+   */
+  withResult() {
+    this.#shouldBeResult = true;
+    return this;
+  }
+  #mapResponse(value) {
+    if (this.#shouldBeResult) {
+      return value;
+    }
+    if (isOk(value)) {
+      return [getOrNull(value), null];
+    } else {
+      return [null, getErrorOrNull(value)];
+    }
+  }
+  async #makeRequest(responseParser, isJson = false) {
+    if (this.#bodySchemaIssues.length) {
+      return err(new CustomError("parseError", this.#bodySchemaIssues));
+    }
+    const request = this.#request();
+    const { retries, retryDelay, retryOn, retryWhile, onRetry } = this.#sanitisedRetryConfig();
+    try {
+      const requestInit = request.requestInit;
+      const url = this.#url();
+      let attempts = 1;
+      let response;
+      let responseData;
+      while (attempts <= retries) {
+        try {
+          response = await fetch(url, requestInit);
+          responseData = await responseParser(response);
+          if (responseData instanceof CustomError) {
+            return err(responseData);
+          }
+          const retryWhileCondition = retryWhile ? await retryWhile(
+            request,
+            this.#makeResponse(response, responseData)
+          ) : false;
+          if (response.ok || !retryOn.includes(response.status) && !retryWhileCondition) {
+            break;
+          }
+          if (response.status in this.#customErrorCbs && attempts === retries) {
+            const result = this.#customErrorCbs[response.status].cb({
+              request,
+              response: this.#makeResponse(response, responseData)
+            });
+            return err(
+              new CustomError(
+                // @ts-ignore
+                this.#customErrorCbs[response.status].tag,
+                result
+              )
+            );
+          }
+          if (attempts < retries) {
+            const delay = typeof retryDelay === "function" ? await retryDelay(
+              retries - attempts - 1,
+              retries,
+              request,
+              this.#makeResponse(response, responseData)
+            ) : retryDelay;
+            await new Promise((resolve) => setTimeout(resolve, delay));
+          }
+        } catch (e) {
+          if (attempts === retries) throw e;
+          const delay = typeof retryDelay === "function" ? await retryDelay(
+            retries - attempts - 1,
+            retries,
+            request,
+            this.#makeResponse(response, responseData)
+          ) : retryDelay;
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+        if (onRetry) {
+          onRetry(request, this.#makeResponse(response, responseData));
+        }
+        attempts++;
+      }
+      if (!response.ok) {
+        if (response.status in this.#customErrorCbs) {
+          const result = this.#customErrorCbs[response.status].cb({
+            request,
+            response: this.#makeResponse(response, responseData)
+          });
+          return err(
+            new CustomError(
+              // @ts-ignore
+              this.#customErrorCbs[response.status].tag,
+              result
+            )
+          );
+        }
+        return err(
+          new AspiError(
+            response.statusText,
+            this.#request(),
+            this.#makeResponse(response, responseData)
+          )
+        );
+      }
+      if (isJson && this.#schema) {
+        const data = this.#schema["~standard"].validate(responseData);
+        if (data instanceof Promise) {
+          throw new Error("Schema validation should not return a promise");
+        }
+        if (data.issues) {
+          return err(new CustomError("parseError", data.issues));
+        }
+        return ok({
+          data: data.value,
+          request,
+          response: this.#makeResponse(response, responseData)
+        });
+      }
+      return ok({
+        data: responseData,
+        request,
+        response: this.#makeResponse(response, responseData)
+      });
+    } catch (error) {
+      if (500 in this.#customErrorCbs) {
+        const result = this.#customErrorCbs[500].cb({
+          request,
+          response: {
+            status: 500,
+            statusText: "INTERNAL_SERVER_ERROR"
+          }
+        });
+        return err(
+          new CustomError(
+            // @ts-ignore
+            this.#customErrorCbs[500].tag,
+            result
+          )
+        );
+      }
+      return err(
+        new AspiError(
+          error instanceof Error ? error.message : "Something went wrong",
+          request,
+          {
+            status: 500,
+            statusText: "INTERNAL_SERVER_ERROR"
+          }
+        )
+      );
+    }
+  }
+  #request() {
+    let requestInit = this.#localRequestInit;
+    for (const middleware of this.#middlewares) {
+      requestInit = middleware(this.#localRequestInit);
+    }
+    return {
+      requestInit,
+      baseUrl: this.#localRequestInit.baseUrl,
+      path: this.#path,
+      queryParams: this.#queryParams || null,
+      retryConfig: this.#sanitisedRetryConfig()
+    };
+  }
+  #sanitisedRetryConfig() {
+    const retries = this.#retryConfig?.retries || 1;
+    const retryDelay = this.#retryConfig?.retryDelay || 0;
+    const retryOn = this.#retryConfig?.retryOn || [];
+    const retryWhile = this.#retryConfig?.retryWhile;
+    const onRetry = this.#retryConfig?.onRetry;
+    return {
+      retries,
+      retryDelay,
+      retryOn,
+      retryWhile,
+      onRetry
+    };
+  }
+  #makeResponse(response, responseData) {
+    return {
+      response,
+      status: response.status,
+      statusText: getHttpErrorStatus(response.status),
+      responseData
+    };
+  }
+};
+
+// src/aspi.ts
+var Aspi = class {
+  #globalRequestInit;
+  #middlewares = [];
+  #retryConfig;
+  #customErrorCbs = {};
+  constructor(config) {
+    const { retryConfig, ...requestConfig } = config;
+    this.#globalRequestInit = requestConfig;
+    this.#retryConfig = retryConfig;
+  }
+  /**
+   * Sets the base URL for all API requests
+   * @param {string} url - The base URL to be set
+   * @returns {Aspi} The Aspi instance for chaining
+   * @example
+   * const api = new Aspi({ baseUrl: 'https://api.example.com' });
+   * api.setBaseUrl('https://api.newdomain.com');
+   */
+  setBaseUrl(url) {
+    this.#globalRequestInit.baseUrl = url;
+    return this;
+  }
+  /**
+   * Sets the retry configuration for failed requests
+   * @param {AspiRetryConfig<TRequest>} retry - The retry configuration object
+   * @returns {Aspi} The Aspi instance for chaining
+   * @example
+   * const api = new Aspi({ baseUrl: 'https://api.example.com' });
+   * api.setRetry({
+   *   retries: 3,
+   *   retryDelay: 1000,
+   *   retryOn: [500, 502],
+   *   retryWhile: (req, res) => res.status === 500
+   * });
+   */
+  setRetry(retry) {
+    this.#retryConfig = {
+      ...this.#retryConfig,
+      ...retry
+    };
+    return this;
+  }
+  #createRequest(method, path, body) {
+    return new Request(method, path, {
+      requestConfig: {
+        ...this.#globalRequestInit,
+        method,
+        body
+      },
+      retryConfig: this.#retryConfig,
+      middlewares: this.#middlewares,
+      errorCbs: this.#customErrorCbs
+    });
+  }
+  /**
+   * Makes a GET request to the specified path
+   * @param {string} path - The path to make the request to
+   * @returns {Request} A Request instance for chaining
+   * @example
+   * const api = new Aspi({ baseUrl: 'https://api.example.com' });
+   * const response = await api.get('/users').json();
+   */
+  get(path) {
+    return this.#createRequest("GET", path);
+  }
+  /**
+   * Makes a POST request to the specified path with an optional body
+   * @param {string} path - The path to make the request to
+   * @param {BodyInit} [body] - The body of the request
+   * @returns {Request} A Request instance for chaining
+   * @example
+   * const api = new Aspi({ baseUrl: 'https://api.example.com' });
+   * const response = await api.post('/users', { name: 'John' }).json();
+   */
+  post(path, body) {
+    return this.#createRequest("POST", path, body);
+  }
+  /**
+   * Makes a PUT request to the specified path with an optional body
+   * @param {string} path - The path to make the request to
+   * @param {BodyInit} [body] - The body of the request
+   * @returns {Request} A Request instance for chaining
+   * @example
+   * const api = new Aspi({ baseUrl: 'https://api.example.com' });
+   * const response = await api.put('/users/1', { name: 'John' }).json();
+   */
+  put(path, body) {
+    return this.#createRequest("PUT", path, body);
+  }
+  /**
+   * Makes a PATCH request to the specified path with an optional body
+   * @param {string} path - The path to make the request to
+   * @param {BodyInit} [body] - The body of the request
+   * @returns {Request} A Request instance for chaining
+   * @example
+   * const api = new Aspi({ baseUrl: 'https://api.example.com' });
+   * const response = await api.patch('/users/1', { name: 'John' }).json();
+   */
+  patch(path, body) {
+    return this.#createRequest("PATCH", path, body);
+  }
+  /**
+   * Makes a DELETE request to the specified path
+   * @param {string} path - The path to make the request to
+   * @returns {Request} A Request instance for chaining
+   * @example
+   * const api = new Aspi({ baseUrl: 'https://api.example.com' });
+   * const response = await api.delete('/users/1').json();
+   */
+  delete(path) {
+    return this.#createRequest("DELETE", path);
+  }
+  /**
+   * Makes a HEAD request to the specified path
+   * @param {string} path - The path to make the request to
+   * @returns {Request} A Request instance for chaining
+   * @example
+   * const api = new Aspi({ baseUrl: 'https://api.example.com' });
+   * const response = await api.head('/users').json();
+   */
+  head(path) {
+    return this.#createRequest("HEAD", path);
+  }
+  /**
+   * Makes an OPTIONS request to the specified path
+   * @param {string} path - The path to make the request to
+   * @returns {Request} A Request instance for chaining
+   * @example
+   * const api = new Aspi({ baseUrl: 'https://api.example.com' });
+   * const response = await api.options('/users').json();
+   */
+  options(path) {
+    return this.#createRequest("OPTIONS", path);
+  }
+  /**
+   * Sets multiple headers for all API requests
+   * @param {Record<string, string>} headers - An object containing header key-value pairs
+   * @returns {Aspi} The Aspi instance for chaining
+   * @example
+   * const api = new Aspi({ baseUrl: 'https://api.example.com' });
+   * api.setHeaders({
+   *   'Content-Type': 'application/json',
+   *   'Accept': 'application/json'
+   * });
+   */
+  setHeaders(headers) {
+    this.#globalRequestInit.headers = headers;
+    return this;
+  }
+  /**
+   * Sets a single header for all API requests
+   * @param {string} key - The header key
+   * @param {string} value - The header value
+   * @returns {Aspi} The Aspi instance for chaining
+   * @example
+   * const api = new Aspi({ baseUrl: 'https://api.example.com' });
+   * api.setHeader('Content-Type', 'application/json');
+   */
+  setHeader(key, value) {
+    this.#globalRequestInit.headers = {
+      ...this.#globalRequestInit.headers,
+      [key]: value
+    };
+    return this;
+  }
+  /**
+   * Sets the Authorization header with a Bearer token
+   * @param {string} token - The Bearer token
+   * @returns {Aspi} The Aspi instance for chaining
+   * @example
+   * const api = new Aspi({ baseUrl: 'https://api.example.com' });
+   * api.setBearer('myAuthToken123');
+   */
+  setBearer(token) {
+    return this.setHeader("Authorization", `Bearer ${token}`);
+  }
+  /**
+   * Use a middleware function to transform requests
+   * @param {Middleware<T, U>} fn - The middleware function to apply
+   * @returns {Aspi<U>} A new Aspi instance with the applied middleware
+   * @example
+   * const api = new Aspi({ baseUrl: 'https://api.example.com' });
+   * api.use((req) => {
+   *   // Add custom headers
+   *   req.headers = {
+   *     ...req.headers,
+   *     'x-custom-header': 'custom-value'
+   *   };
+   *   return req;
+   * });
+   */
+  use(fn) {
+    this.#middlewares = [...this.#middlewares, fn];
+    return this;
+  }
+  /**
+   * Registers a custom error handler for a specific HTTP status
+   * @param {string} tag - The error tag identifier
+   * @param {HttpErrorStatus} status - The HTTP status code to handle
+   * @param {CustomErrorCb<TRequest, A>} cb - The callback function to handle the error
+   * @returns {Aspi} The Aspi instance for chaining
+   * @example
+   * const api = new Aspi({ baseUrl: 'https://api.example.com' });
+   * api.error('customError', 'BAD_REQUEST', (req, res) => {
+   *   console.log('Bad request error occurred');
+   *   return { message: 'Invalid input' };
+   * });
+   */
+  error(tag, status, cb) {
+    this.#customErrorCbs[httpErrors[status]] = {
+      cb,
+      tag
+    };
+    return this;
+  }
+  /**
+   * Handles 404 Not Found errors with a custom callback.
+   * @param cb The callback function to handle the error
+   * @returns The request instance for chaining
+   * @example
+   * const request = new Request('/users', config);
+   * request.notFound((error) => {
+   *   console.log('Not found:', error);
+   *   return { message: 'Resource not found' };
+   * });
+   */
+  notFound(cb) {
+    return this.error("notFoundError", "NOT_FOUND", cb);
+  }
+  /**
+   * Handles 429 Too Many Requests errors with a custom callback.
+   * @param cb The callback function to handle the error
+   * @returns The request instance for chaining
+   * @example
+   * const request = new Request('/users', config);
+   * request.tooManyRequests((error) => {
+   *   console.log('Rate limited:', error);
+   *   return { message: 'Please try again later' };
+   * });
+   */
+  tooManyRequests(cb) {
+    return this.error("tooManyRequestsError", "TOO_MANY_REQUESTS", cb);
+  }
+  /**
+   * Handles 409 Conflict errors with a custom callback.
+   * @param cb The callback function to handle the error
+   * @returns The request instance for chaining
+   * @example
+   * const request = new Request('/users', config);
+   * request.conflict((error) => {
+   *   console.log('Conflict error:', error);
+   *   return { message: 'Resource conflict detected' };
+   * });
+   */
+  conflict(cb) {
+    return this.error("conflictError", "CONFLICT", cb);
+  }
+  /**
+   * Registers a handler for 400 Bad Request errors
+   * @param {CustomErrorCb<TRequest, A>} cb - The callback function to handle the error
+   * @returns {Aspi} The Aspi instance for chaining
+   * @example
+   * api.badRequest((req, res) => ({ message: 'Invalid request parameters' }));
+   */
+  badRequest(cb) {
+    return this.error("badRequestError", "BAD_REQUEST", cb);
+  }
+  /**
+   * Registers a handler for 401 Unauthorized errors
+   * @param {CustomErrorCb<TRequest, A>} cb - The callback function to handle the error
+   * @returns {Aspi} The Aspi instance for chaining
+   * @example
+   * api.unauthorized((req, res) => ({ message: 'Authentication required' }));
+   */
+  unauthorized(cb) {
+    return this.error("unauthorizedError", "UNAUTHORIZED", cb);
+  }
+  /**
+   * Registers a handler for 403 Forbidden errors
+   * @param {CustomErrorCb<TRequest, A>} cb - The callback function to handle the error
+   * @returns {Aspi} The Aspi instance for chaining
+   * @example
+   * api.forbidden((req, res) => ({ message: 'Access denied' }));
+   */
+  forbidden(cb) {
+    return this.error("forbiddenError", "FORBIDDEN", cb);
+  }
+  /**
+   * Registers a handler for 501 Not Implemented errors
+   * @param {CustomErrorCb<TRequest, A>} cb - The callback function to handle the error
+   * @returns {Aspi} The Aspi instance for chaining
+   * @example
+   * api.notImplemented((req, res) => ({ message: 'Feature not implemented' }));
+   */
+  notImplemented(cb) {
+    return this.error("notImplementedError", "NOT_IMPLEMENTED", cb);
+  }
+  /**
+   * Registers a handler for 500 Internal Server errors
+   * @param {CustomErrorCb<TRequest, A>} cb - The callback function to handle the error
+   * @returns {Aspi} The Aspi instance for chaining
+   * @example
+   * api.internalServerError((req, res) => ({ message: 'Server error occurred' }));
+   */
+  internalServerError(cb) {
+    return this.error("internalServerErrorError", "INTERNAL_SERVER_ERROR", cb);
+  }
+};
+export {
+  Aspi,
+  AspiError,
+  CustomError,
+  Request,
+  result_exports as Result,
+  getHttpErrorStatus,
+  httpErrors
+};