@fuman/fetch 0.0.1

package/ffetch.cjs

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils = require("@fuman/utils");
+const OCTET_STREAM_CONTENT_TYPE = "application/octet-stream";
+class HttpError extends Error {
+  constructor(response) {
+    super(`HTTP Error ${response.status} ${response.statusText}`);
+    this.response = response;
+  }
+}
+function headersToObject(headers) {
+  if (!headers) return {};
+  if (Array.isArray(headers) || headers instanceof Headers) return Object.fromEntries(headers);
+  if (Symbol.iterator in headers) {
+    return Object.fromEntries(headers);
+  }
+  return headers;
+}
+class FfetchResultImpl {
+  #fetch;
+  _url;
+  _init;
+  _options;
+  _headers;
+  #stack;
+  constructor(fetch2, url, init, headers, options, stack) {
+    this.#fetch = fetch2;
+    this._init = init;
+    this._url = url;
+    this._options = options;
+    this._headers = headers;
+    this.#stack = stack;
+  }
+  then(onfulfilled, onrejected) {
+    return this.raw().then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return this.raw().catch(onrejected);
+  }
+  finally(onfinally) {
+    return this.raw().finally(onfinally);
+  }
+  get [Symbol.toStringTag]() {
+    return "FfetchResult";
+  }
+  async #fetchAndValidate() {
+    const res = await this.#fetch(new Request(this._url, this._init));
+    if (this._options.validateResponse === void 0 || this._options.validateResponse !== false) {
+      if (typeof this._options.validateResponse === "function") {
+        if (!await this._options.validateResponse(res)) {
+          throw new HttpError(res);
+        }
+      } else if (!res.ok) {
+        throw new HttpError(res);
+      }
+    }
+    return res;
+  }
+  async raw() {
+    if (this.#stack == null) return this.#fetchAndValidate();
+    try {
+      return await this.#fetchAndValidate();
+    } catch (err_) {
+      const err = utils.unknownToError(err_);
+      const errCopy = structuredClone(err_);
+      const stack = this.#stack.split("\n").slice(2).join("\n");
+      err.stack = `${err.name}: ${err.message}
+${stack}`;
+      err.cause = errCopy;
+      throw err;
+    }
+  }
+  async stream() {
+    const res = await this.raw();
+    if (res.body == null) {
+      throw new Error("Response body is null");
+    }
+    return res.body;
+  }
+  async json() {
+    this._headers ??= {};
+    this._headers.Accept ??= "application/json";
+    const res = await this.raw();
+    return res.json();
+  }
+  async text() {
+    const res = await this.raw();
+    return res.text();
+  }
+  async arrayBuffer() {
+    this._headers ??= {};
+    this._headers.Accept ??= OCTET_STREAM_CONTENT_TYPE;
+    const res = await this.raw();
+    return res.arrayBuffer();
+  }
+  async blob() {
+    this._headers ??= {};
+    this._headers.Accept ??= OCTET_STREAM_CONTENT_TYPE;
+    const res = await this.raw();
+    return res.blob();
+  }
+}
+function _wrapMethod(method, fn) {
+  return (url, options) => {
+    return fn(url, { ...options, method });
+  };
+}
+function createFfetch(baseOptions = {}) {
+  const captureStackTrace = baseOptions.captureStackTrace ?? true;
+  const baseFetch = baseOptions.fetch ?? fetch;
+  const wrappedFetch = baseOptions.middlewares !== void 0 && baseOptions.middlewares.length > 0 ? utils.composeMiddlewares(baseOptions.middlewares, baseFetch) : baseFetch;
+  const addons = baseOptions.addons ?? [];
+  let FfetchResultInner;
+  if (addons.length) {
+    FfetchResultInner = class extends FfetchResultImpl {
+    };
+    for (let i = 0; i < addons.length; i++) {
+      const addon = addons[i];
+      for (const key in addon.response) {
+        FfetchResultInner.prototype[key] = addon.response[key];
+      }
+    }
+  } else {
+    FfetchResultInner = FfetchResultImpl;
+  }
+  const fn_ = (url, options = {}) => {
+    let stack;
+    if (captureStackTrace) {
+      stack = new Error().stack;
+    }
+    if (addons.length) {
+      const ctx = { url, options, baseOptions };
+      for (let i = 0; i < addons.length; i++) {
+        const addon = addons[i];
+        addon.beforeRequest?.(ctx);
+      }
+      url = ctx.url;
+      options = ctx.options;
+    }
+    let fetcher = wrappedFetch;
+    if (options.middlewares !== void 0 && options.middlewares.length > 0) {
+      fetcher = utils.composeMiddlewares(options.middlewares, wrappedFetch);
+    }
+    if (baseOptions?.baseUrl != null || options.baseUrl != null) {
+      url = new URL(url, options.baseUrl ?? baseOptions?.baseUrl).href;
+    }
+    let init;
+    let headers;
+    if (baseOptions != null) {
+      init = { ...baseOptions.extra, ...options.extra };
+      headers = { ...headersToObject(baseOptions.headers), ...headersToObject(options.headers) };
+    } else {
+      init = options.extra ?? {};
+      headers = headersToObject(options.headers);
+    }
+    if (options.json !== void 0) {
+      if (options.body != null) {
+        throw new Error("Cannot set both json and body");
+      }
+      init.body = JSON.stringify(options.json);
+      init.method = options.method ?? "POST";
+      headers["Content-Type"] ??= "application/json";
+    } else {
+      init.body = options.body;
+      init.method = options.method ?? baseOptions.method ?? "GET";
+    }
+    init.headers = headers;
+    return new FfetchResultInner(fetcher, url, init, headers, options, stack);
+  };
+  const fn = fn_;
+  fn.get = _wrapMethod("GET", fn);
+  fn.post = _wrapMethod("POST", fn);
+  fn.put = _wrapMethod("PUT", fn);
+  fn.delete = _wrapMethod("DELETE", fn);
+  fn.patch = _wrapMethod("PATCH", fn);
+  fn.head = _wrapMethod("HEAD", fn);
+  fn.options = _wrapMethod("OPTIONS", fn);
+  fn.extend = (otherOptions) => {
+    return createFfetch({
+      ...baseOptions,
+      ...otherOptions,
+      addons: [
+        ...baseOptions.addons ?? [],
+        // eslint-disable-next-line ts/no-unsafe-assignment
+        ...otherOptions.addons ?? []
+      ],
+      middlewares: [
+        ...baseOptions.middlewares ?? [],
+        ...otherOptions.middlewares ?? []
+      ],
+      headers: {
+        ...baseOptions.headers,
+        ...otherOptions.headers
+      }
+    });
+  };
+  return fn;
+}
+exports.HttpError = HttpError;
+exports.createFfetch = createFfetch;

package/ffetch.d.ts

@@ -0,0 +1,101 @@
+import { CombineAddons, FfetchMiddleware } from './_types.js';
+import { FfetchAddon } from './addons/types.js';
+export interface FfetchOptions {
+    /**
+     * http method
+     * @default 'GET'
+     */
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | 'CONNECT' | (string & {});
+    /**
+     * whether to throw HttpError on non-2xx responses
+     *
+     * when a function is provided, it will be called with the response
+     * and should return whether the response is valid.
+     * if it returns false, the response will be thrown as an HttpError
+     *
+     * @default true
+     */
+    validateResponse?: false | ((res: Response) => boolean | Promise<boolean>);
+    /** base url to be prepended to the url */
+    baseUrl?: string;
+    /** body to be passed to fetch() */
+    body?: BodyInit;
+    /**
+     * shorthand for sending json body.
+     * mutually exclusive with `body`
+     */
+    json?: unknown;
+    /** headers to be passed to fetch() */
+    headers?: HeadersInit;
+    /** middlewares for the requests */
+    middlewares?: FfetchMiddleware[];
+    /** any additional options to be passed to fetch() */
+    extra?: RequestInit;
+}
+export interface FfetchBaseOptions<Addons extends FfetchAddon<any, any>[] = FfetchAddon<any, any>[]> extends FfetchOptions {
+    /** implementation of fetch() */
+    fetch?: typeof fetch;
+    /** addons for the request */
+    addons?: Addons;
+    /**
+     * whether to capture stack trace for errors
+     * may slightly impact performance
+     *
+     * @default true
+     */
+    captureStackTrace?: boolean;
+}
+export interface FfetchResult extends Promise<Response> {
+    raw: () => Promise<Response>;
+    stream: () => Promise<ReadableStream<Uint8Array>>;
+    json: <T = unknown>() => Promise<T>;
+    text: () => Promise<string>;
+    arrayBuffer: () => Promise<ArrayBuffer>;
+    blob: () => Promise<Blob>;
+}
+/**
+ * the main function of the library
+ *
+ * @param url  url to fetch (or path, if baseUrl is set)
+ * @param params  options (note that the function may mutate the object, do not rely on its immutability)
+ */
+export interface Ffetch<RequestMixin, ResponseMixin> {
+    (url: string, params?: FfetchOptions & RequestMixin): FfetchResult & ResponseMixin;
+    /** shorthand for making a GET request */
+    get: (url: string, params?: FfetchOptions & RequestMixin) => FfetchResult & ResponseMixin;
+    /** shorthand for making a POST request */
+    post: (url: string, params?: FfetchOptions & RequestMixin) => FfetchResult & ResponseMixin;
+    /** shorthand for making a PUT request */
+    put: (url: string, params?: FfetchOptions & RequestMixin) => FfetchResult & ResponseMixin;
+    /** shorthand for making a DELETE request */
+    delete: (url: string, params?: FfetchOptions & RequestMixin) => FfetchResult & ResponseMixin;
+    /** shorthand for making a PATCH request */
+    patch: (url: string, params?: FfetchOptions & RequestMixin) => FfetchResult & ResponseMixin;
+    /** shorthand for making a HEAD request */
+    head: (url: string, params?: FfetchOptions & RequestMixin) => FfetchResult & ResponseMixin;
+    /** shorthand for making an OPTIONS request */
+    options: (url: string, params?: FfetchOptions & RequestMixin) => FfetchResult & ResponseMixin;
+    /**
+     * extend the base options with the given options
+     *
+     * note: addons, middlewares and headers will be merged with the base options,
+     * the rest of the options will be overridden
+     */
+    extend: <const Addons extends FfetchAddon<any, any>[], Combined extends {
+        request: object;
+        response: object;
+    } = CombineAddons<Addons>>(baseOptions: FfetchBaseOptions<Addons> & Combined['request']) => Ffetch<RequestMixin & Combined['request'], ResponseMixin & Combined['response']>;
+}
+/**
+ * an error that is thrown when the response status is not 2xx,
+ * or `validateResponse` returns false
+ */
+export declare class HttpError extends Error {
+    readonly response: Response;
+    constructor(response: Response);
+}
+/** create a new ffetch function with the given base options */
+export declare function createFfetch<const Addons extends FfetchAddon<any, any>[], Combined extends {
+    request: object;
+    response: object;
+} = CombineAddons<Addons>>(baseOptions?: FfetchBaseOptions<Addons> & Combined['request']): Ffetch<Combined['request'], Combined['response']>;

package/ffetch.js

@@ -0,0 +1,200 @@
+import { composeMiddlewares, unknownToError } from "@fuman/utils";
+const OCTET_STREAM_CONTENT_TYPE = "application/octet-stream";
+class HttpError extends Error {
+  constructor(response) {
+    super(`HTTP Error ${response.status} ${response.statusText}`);
+    this.response = response;
+  }
+}
+function headersToObject(headers) {
+  if (!headers) return {};
+  if (Array.isArray(headers) || headers instanceof Headers) return Object.fromEntries(headers);
+  if (Symbol.iterator in headers) {
+    return Object.fromEntries(headers);
+  }
+  return headers;
+}
+class FfetchResultImpl {
+  #fetch;
+  _url;
+  _init;
+  _options;
+  _headers;
+  #stack;
+  constructor(fetch2, url, init, headers, options, stack) {
+    this.#fetch = fetch2;
+    this._init = init;
+    this._url = url;
+    this._options = options;
+    this._headers = headers;
+    this.#stack = stack;
+  }
+  then(onfulfilled, onrejected) {
+    return this.raw().then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return this.raw().catch(onrejected);
+  }
+  finally(onfinally) {
+    return this.raw().finally(onfinally);
+  }
+  get [Symbol.toStringTag]() {
+    return "FfetchResult";
+  }
+  async #fetchAndValidate() {
+    const res = await this.#fetch(new Request(this._url, this._init));
+    if (this._options.validateResponse === void 0 || this._options.validateResponse !== false) {
+      if (typeof this._options.validateResponse === "function") {
+        if (!await this._options.validateResponse(res)) {
+          throw new HttpError(res);
+        }
+      } else if (!res.ok) {
+        throw new HttpError(res);
+      }
+    }
+    return res;
+  }
+  async raw() {
+    if (this.#stack == null) return this.#fetchAndValidate();
+    try {
+      return await this.#fetchAndValidate();
+    } catch (err_) {
+      const err = unknownToError(err_);
+      const errCopy = structuredClone(err_);
+      const stack = this.#stack.split("\n").slice(2).join("\n");
+      err.stack = `${err.name}: ${err.message}
+${stack}`;
+      err.cause = errCopy;
+      throw err;
+    }
+  }
+  async stream() {
+    const res = await this.raw();
+    if (res.body == null) {
+      throw new Error("Response body is null");
+    }
+    return res.body;
+  }
+  async json() {
+    this._headers ??= {};
+    this._headers.Accept ??= "application/json";
+    const res = await this.raw();
+    return res.json();
+  }
+  async text() {
+    const res = await this.raw();
+    return res.text();
+  }
+  async arrayBuffer() {
+    this._headers ??= {};
+    this._headers.Accept ??= OCTET_STREAM_CONTENT_TYPE;
+    const res = await this.raw();
+    return res.arrayBuffer();
+  }
+  async blob() {
+    this._headers ??= {};
+    this._headers.Accept ??= OCTET_STREAM_CONTENT_TYPE;
+    const res = await this.raw();
+    return res.blob();
+  }
+}
+function _wrapMethod(method, fn) {
+  return (url, options) => {
+    return fn(url, { ...options, method });
+  };
+}
+function createFfetch(baseOptions = {}) {
+  const captureStackTrace = baseOptions.captureStackTrace ?? true;
+  const baseFetch = baseOptions.fetch ?? fetch;
+  const wrappedFetch = baseOptions.middlewares !== void 0 && baseOptions.middlewares.length > 0 ? composeMiddlewares(baseOptions.middlewares, baseFetch) : baseFetch;
+  const addons = baseOptions.addons ?? [];
+  let FfetchResultInner;
+  if (addons.length) {
+    FfetchResultInner = class extends FfetchResultImpl {
+    };
+    for (let i = 0; i < addons.length; i++) {
+      const addon = addons[i];
+      for (const key in addon.response) {
+        FfetchResultInner.prototype[key] = addon.response[key];
+      }
+    }
+  } else {
+    FfetchResultInner = FfetchResultImpl;
+  }
+  const fn_ = (url, options = {}) => {
+    let stack;
+    if (captureStackTrace) {
+      stack = new Error().stack;
+    }
+    if (addons.length) {
+      const ctx = { url, options, baseOptions };
+      for (let i = 0; i < addons.length; i++) {
+        const addon = addons[i];
+        addon.beforeRequest?.(ctx);
+      }
+      url = ctx.url;
+      options = ctx.options;
+    }
+    let fetcher = wrappedFetch;
+    if (options.middlewares !== void 0 && options.middlewares.length > 0) {
+      fetcher = composeMiddlewares(options.middlewares, wrappedFetch);
+    }
+    if (baseOptions?.baseUrl != null || options.baseUrl != null) {
+      url = new URL(url, options.baseUrl ?? baseOptions?.baseUrl).href;
+    }
+    let init;
+    let headers;
+    if (baseOptions != null) {
+      init = { ...baseOptions.extra, ...options.extra };
+      headers = { ...headersToObject(baseOptions.headers), ...headersToObject(options.headers) };
+    } else {
+      init = options.extra ?? {};
+      headers = headersToObject(options.headers);
+    }
+    if (options.json !== void 0) {
+      if (options.body != null) {
+        throw new Error("Cannot set both json and body");
+      }
+      init.body = JSON.stringify(options.json);
+      init.method = options.method ?? "POST";
+      headers["Content-Type"] ??= "application/json";
+    } else {
+      init.body = options.body;
+      init.method = options.method ?? baseOptions.method ?? "GET";
+    }
+    init.headers = headers;
+    return new FfetchResultInner(fetcher, url, init, headers, options, stack);
+  };
+  const fn = fn_;
+  fn.get = _wrapMethod("GET", fn);
+  fn.post = _wrapMethod("POST", fn);
+  fn.put = _wrapMethod("PUT", fn);
+  fn.delete = _wrapMethod("DELETE", fn);
+  fn.patch = _wrapMethod("PATCH", fn);
+  fn.head = _wrapMethod("HEAD", fn);
+  fn.options = _wrapMethod("OPTIONS", fn);
+  fn.extend = (otherOptions) => {
+    return createFfetch({
+      ...baseOptions,
+      ...otherOptions,
+      addons: [
+        ...baseOptions.addons ?? [],
+        // eslint-disable-next-line ts/no-unsafe-assignment
+        ...otherOptions.addons ?? []
+      ],
+      middlewares: [
+        ...baseOptions.middlewares ?? [],
+        ...otherOptions.middlewares ?? []
+      ],
+      headers: {
+        ...baseOptions.headers,
+        ...otherOptions.headers
+      }
+    });
+  };
+  return fn;
+}
+export {
+  HttpError,
+  createFfetch
+};

package/index.cjs

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const _default = require("./default.cjs");
+const ffetch = require("./ffetch.cjs");
+const bundle = require("./addons/bundle.cjs");
+exports.ffetchBase = _default.ffetchBase;
+exports.ffetchDefaultAddons = _default.ffetchDefaultAddons;
+exports.HttpError = ffetch.HttpError;
+exports.createFfetch = ffetch.createFfetch;
+exports.ffetchAddons = bundle;

package/index.d.ts

@@ -0,0 +1,4 @@
+export type { FfetchMiddleware } from './_types.js';
+export * from './addons/index.js';
+export * from './default.js';
+export * from './ffetch.js';

package/index.js

@@ -0,0 +1,10 @@
+import { ffetchBase, ffetchDefaultAddons } from "./default.js";
+import { HttpError, createFfetch } from "./ffetch.js";
+import * as bundle from "./addons/bundle.js";
+export {
+  HttpError,
+  createFfetch,
+  bundle as ffetchAddons,
+  ffetchBase,
+  ffetchDefaultAddons
+};

package/package.json

@@ -0,0 +1,89 @@
+{
+    "name": "@fuman/fetch",
+    "type": "module",
+    "version": "0.0.1",
+    "description": "tiny wrapper over fetch",
+    "license": "MIT",
+    "dependencies": {
+        "@fuman/utils": "^0.0.1"
+    },
+    "peerDependencies": {
+        "tough-cookie": "^5.0.0 || ^4.0.0",
+        "valibot": "^0.42.0",
+        "yup": "^1.0.0",
+        "zod": "^3.0.0"
+    },
+    "exports": {
+        ".": {
+            "import": {
+                "types": "./index.d.ts",
+                "default": "./index.js"
+            },
+            "require": {
+                "types": "./index.d.cts",
+                "default": "./index.cjs"
+            }
+        },
+        "./zod": {
+            "import": {
+                "types": "./zod.d.ts",
+                "default": "./zod.js"
+            },
+            "require": {
+                "types": "./zod.d.cts",
+                "default": "./zod.cjs"
+            }
+        },
+        "./valibot": {
+            "import": {
+                "types": "./valibot.d.ts",
+                "default": "./valibot.js"
+            },
+            "require": {
+                "types": "./valibot.d.cts",
+                "default": "./valibot.cjs"
+            }
+        },
+        "./yup": {
+            "import": {
+                "types": "./yup.d.ts",
+                "default": "./yup.js"
+            },
+            "require": {
+                "types": "./yup.d.cts",
+                "default": "./yup.cjs"
+            }
+        },
+        "./tough": {
+            "import": {
+                "types": "./tough.d.ts",
+                "default": "./tough.js"
+            },
+            "require": {
+                "types": "./tough.d.cts",
+                "default": "./tough.cjs"
+            }
+        }
+    },
+    "sideEffects": false,
+    "peerDependenciesMeta": {
+        "tough-cookie": {
+            "optional": true
+        },
+        "valibot": {
+            "optional": true
+        },
+        "yup": {
+            "optional": true
+        },
+        "zod": {
+            "optional": true
+        }
+    },
+    "author": "",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/teidesu/fuman.git"
+    },
+    "scripts": {}
+}

package/tough.cjs

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function cookieJarMiddleware(jar) {
+  return async (ctx, next) => {
+    ctx.headers.append("Cookie", await jar.getCookieString(ctx.url));
+    const res = await next(ctx);
+    for (const header of res.headers.getSetCookie()) {
+      await jar.setCookie(header, res.url);
+    }
+    return res;
+  };
+}
+function toughCookieAddon() {
+  return {
+    beforeRequest(ctx) {
+      if (ctx.options.cookies != null || ctx.baseOptions.cookies != null) {
+        const jar = ctx.options.cookies ?? ctx.baseOptions.cookies;
+        ctx.options.middlewares ??= [];
+        ctx.options.middlewares.push(cookieJarMiddleware(jar));
+      }
+    }
+  };
+}
+exports.toughCookieAddon = toughCookieAddon;

package/tough.d.ts

@@ -0,0 +1 @@
+export * from "./addons/tough-cookie.js"

package/tough.js

@@ -0,0 +1,24 @@
+function cookieJarMiddleware(jar) {
+  return async (ctx, next) => {
+    ctx.headers.append("Cookie", await jar.getCookieString(ctx.url));
+    const res = await next(ctx);
+    for (const header of res.headers.getSetCookie()) {
+      await jar.setCookie(header, res.url);
+    }
+    return res;
+  };
+}
+function toughCookieAddon() {
+  return {
+    beforeRequest(ctx) {
+      if (ctx.options.cookies != null || ctx.baseOptions.cookies != null) {
+        const jar = ctx.options.cookies ?? ctx.baseOptions.cookies;
+        ctx.options.middlewares ??= [];
+        ctx.options.middlewares.push(cookieJarMiddleware(jar));
+      }
+    }
+  };
+}
+export {
+  toughCookieAddon
+};

package/valibot.cjs

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const valibot = require("valibot");
+function ffetchValibotAdapter({ async, ...rest } = {}) {
+  const _provider = null;
+  const parser = async ? async function(schema, value) {
+    return valibot.parseAsync(schema, value, rest);
+  } : function(schema, value) {
+    return valibot.parse(schema, value, rest);
+  };
+  return {
+    _provider,
+    parse: parser
+  };
+}
+exports.ffetchValibotAdapter = ffetchValibotAdapter;

package/valibot.d.ts

@@ -0,0 +1 @@
+export * from "./addons/parse/adapters/valibot.js"