fch 4.1.4 → 5.0.0

package/index.min.js

@@ -1 +1,2 @@
-const e=async r=>(r=await r,Array.isArray(r)?await Promise.all(r.map(e)):r),r=(e,r)=>(...t)=>(e=>e instanceof RegExp?e.test.bind(e):e)(e).call(r,...t),t=(e,t)=>async(n,a,o)=>({value:n,extra:await r(e,t)(n,a,o)}),n=({extra:e})=>e,a=({value:e})=>e,o={every:async(e,t,n)=>{for(let a=0;a<e.length;a++)if(!await r(t,n)(e[a],a,e))return!1;return!0},filter:async(r,o,s)=>(await e(r.map(t(o,s)))).filter(n).map(a),find:async(e,t,n)=>{for(let a=0;a<e.length;a++)if(await r(t,n)(e[a],a,e))return e[a]},findIndex:async(e,t,n)=>{for(let a=0;a<e.length;a++)if(await r(t,n)(e[a],a,e))return a;return-1},forEach:async(r,n,a)=>(await e(r.map(t(n,a))),r),reduce:async(e,t,n)=>{const a=void 0!==n;a||(n=e[0]);for(let o=a?0:1;o<e.length;o++)n=await r(t)(n,e[o],o,e);return n},reduceRight:async(e,t,n)=>{const a=void 0!==n;a||(n=e[e.length-1]);for(let o=e.length-(a?1:2);o>=0;o--)n=await r(t)(n,e[o],o,e);return n},some:async(e,t,n)=>{for(let a=0;a<e.length;a++)if(await r(t,n)(e[a],a,e))return!0;return!1}},s=(r,t)=>(n,a)=>"then"===a?(...t)=>e(r).then(...t):"catch"===a?(...t)=>l(e(r).catch(...t)):u(e(r).then(e=>"symbol"==typeof a?e[a]:a in t?u((...r)=>t[a](e,...r),t):"number"==typeof e&&a in t.number?u((...r)=>t.number[a](e,...r),t):"string"==typeof e&&a in t.string?u((...r)=>t.string[a](e,...r),t):Array.isArray(e)&&a in t.array?u((...r)=>t.array[a](e,...r),t):e[a]&&e[a].bind?u(e[a].bind(e),t):u(e[a],t)),t),i=(r,t)=>(n,a,o)=>u(e(r).then(e=>{return"function"!=typeof e?(r=`You tried to call "${JSON.stringify(e)}" (${typeof e}) as a function, but it is not.`,Promise.reject(new Error(r))):e(...o);var r}),t),u=(e,r)=>new Proxy(()=>{},{get:s(e,r),apply:i(e,r)});function l(e,{number:r,string:t,array:n,...a}={}){return"function"==typeof e?(...o)=>l(Promise.all(o).then(r=>e(...r)),{number:r,string:t,array:n,...a}):new Proxy({},{get:s(e,{number:{...r},string:{...t},array:{...o,...n},...a})})}const c=e=>{if("object"!=typeof e)return e;for(let r in e)void 0===e[r]&&delete e[r];return e};class d extends Error{constructor(e){const r="Error "+e.status;super(r),this.response=e,this.message=r}}const f=async e=>{const r=e.headers.get("content-type"),t=r&&r.includes("application/json"),n=await e.clone().text();return t?JSON.parse(n):n},y=async(e,r)=>{let t={status:e.status,statusText:e.statusText,headers:{}};for(let r of e.headers.keys())t.headers[r.toLowerCase()]=e.headers.get(r);if(!e.ok)throw new d(e);return t.body=await f(e),t},p=(e,{after:r,cache:t,error:n,output:a})=>{const o={},s={text:()=>o.res.text(),json:()=>o.res.json(),blob:()=>o.res.blob(),stream:()=>o.res.body,arrayBuffer:()=>o.res.arrayBuffer(),formData:()=>o.res.formData(),body:()=>f(o.res),clone:()=>o.res.clone(),raw:()=>o.res.clone(),response:()=>y(o.res.clone())};return l(fetch(e.url,e).then(async e=>{if(o.res=e,t&&t.clear(),e.ok&&"stream"===a)return e.body;if(e.ok&&e[a]&&"function"==typeof e[a])return e[a]();const n=r(await y(e));if("body"===a)return n.body;if("response"===a)return n;if("raw"===a)return e.clone();throw new Error(`Invalid option output="${a}"`)}),s)},h=(e={})=>{var r,t,n,a,o,s,i,u,l,d,f,y;const b=(()=>{const e=new Map;return r=>({save:t=>(e.set(r,t),t),get:()=>e.get(r),clear:()=>e.delete(r)})})(),w=(e="/",r={})=>{var t;"object"!=typeof r&&(r={}),r="string"==typeof e?{url:e,...r}:e;let{dedupe:n,output:a,before:o,after:s,error:i,...u}={...w,...r};u.url=((e,r,t)=>{let[n,a={}]=e.split("?");const o=new URLSearchParams(Object.fromEntries([...new URLSearchParams(c(r)),...new URLSearchParams(c(a))])).toString();if(o&&(n=n+"?"+o),!t)return n;return new URL(n.replace(/^\//,""),t).href})(u.url,{...w.query,...r.query},null!==(t=u.baseUrl)&&void 0!==t?t:u.baseURL),u.method=u.method.toLowerCase(),u.headers=(e=>{const r={};for(let[t,n]of Object.entries(e))r[t.toLowerCase()]=n;return r})({...w.headers,...r.headers});const l=!(!n||"get"!==u.method)&&b(u.url);var d;return!(d=u.body)||d.pipeTo||d instanceof FormData||"object"!=typeof d&&!Array.isArray(d)||(u.body=JSON.stringify(c(u.body)),u.headers["content-type"]="application/json"),u=o(u),l&&!u.signal?l.get()?l.get():l.save(p(u,{cache:l,output:a,error:i,after:s})):p(u,{output:a,error:i,after:s})};return w.url=null!==(r=e.url)&&void 0!==r?r:"/",w.method=null!==(t=e.method)&&void 0!==t?t:"get",w.query=null!==(n=e.query)&&void 0!==n?n:{},w.headers=null!==(a=e.headers)&&void 0!==a?a:{},w.baseUrl=null!==(o=null!==(s=e.baseUrl)&&void 0!==s?s:e.baseURL)&&void 0!==o?o:null,w.dedupe=null===(i=e.dedupe)||void 0===i||i,w.output=null!==(u=e.output)&&void 0!==u?u:"body",w.credentials=null!==(l=e.credentials)&&void 0!==l?l:"include",w.before=null!==(d=e.before)&&void 0!==d?d:e=>e,w.after=null!==(f=e.after)&&void 0!==f?f:e=>e,w.error=null!==(y=e.error)&&void 0!==y?y:e=>{throw e},["get","head","post","patch","put","delete","del"].map(e=>{w[e]=(r,t={})=>w(r,{...t,method:e})}),w.create=h,w};"undefined"!=typeof window&&(window.fch=h());var b=h();export default b;
+var d=async e=>(e=await e,Array.isArray(e)?await Promise.all(e.map(d)):e),y=(e,n)=>(...a)=>(r=>r instanceof RegExp?r.test.bind(r):r)(e).call(n,...a),k=(e,n)=>async(a,r,t)=>({value:a,extra:await y(e,n)(a,r,t)}),D=({extra:e})=>e,M=({value:e})=>e,T={every:async(e,n,a)=>{for(let r=0;r<e.length;r++)if(!await y(n,a)(e[r],r,e))return!1;return!0},filter:async(e,n,a)=>(await d(e.map(k(n,a)))).filter(D).map(M),find:async(e,n,a)=>{for(let r=0;r<e.length;r++)if(await y(n,a)(e[r],r,e))return e[r]},findIndex:async(e,n,a)=>{for(let r=0;r<e.length;r++)if(await y(n,a)(e[r],r,e))return r;return-1},forEach:async(e,n,a)=>(await d(e.map(k(n,a))),e),reduce:async(e,n,a)=>{let r=a!==void 0;r||(a=e[0]);for(let t=r?0:1;t<e.length;t++)a=await y(n)(a,e[t],t,e);return a},reduceRight:async(e,n,a)=>{let r=a!==void 0;r||(a=e[e.length-1]);for(let t=e.length-(r?1:2);t>=0;t--)a=await y(n)(a,e[t],t,e);return a},some:async(e,n,a)=>{for(let r=0;r<e.length;r++)if(await y(n,a)(e[r],r,e))return!0;return!1}},v=(e,n)=>(a,r)=>r==="then"?(...t)=>d(e).then(...t):r==="catch"?(...t)=>p(d(e).catch(...t)):h(d(e).then(t=>typeof r=="symbol"?t[r]:r in n?h((...o)=>n[r](t,...o),n):typeof t=="number"&&r in n.number?h((...o)=>n.number[r](t,...o),n):typeof t=="string"&&r in n.string?h((...o)=>n.string[r](t,...o),n):Array.isArray(t)&&r in n.array?h((...o)=>n.array[r](t,...o),n):t[r]&&t[r].bind?h(t[r].bind(t),n):h(t[r],n)),n),F=(e,n)=>(a,r,t)=>h(d(e).then(o=>{return typeof o!="function"?(c=`You tried to call "${JSON.stringify(o)}" (${typeof o}) as a function, but it is not.`,Promise.reject(new Error(c))):o(...t);var c}),n),h=(e,n)=>new Proxy(()=>{},{get:v(e,n),apply:F(e,n)});function p(e,{number:n,string:a,array:r,...t}={}){return typeof e=="function"?(...o)=>p(Promise.all(o).then(c=>e(...c)),{number:n,string:a,array:r,...t}):new Proxy({},{get:v(e,{number:{...n},string:{...a},array:{...T,...r},...t})})}function w(e){e.expire||(e.expire=0);let n=new Map,a=async r=>{if(!n.has(r))return!1;let{time:t,expire:o}=n.get(r);return!(!o||new Date().getTime()-t>o*1e3)};return{get:async r=>{if(!await a(r))return null;let{data:o}=n.get(r);return o},set:async(r,t,o={})=>{let c=new Date().getTime(),f=o.EX||o.expire||e.expire;return n.set(r,{time:c,expire:f,data:t})},keys:async()=>[...await n.keys()],del:async r=>n.delete(r),exists:a,flushAll:()=>n.clear()}}var O=/(-?(?:\d+\.?\d*|\d*\.?\d+)(?:e[-+]?\d+)?)\s*([\p{L}]*)/giu;s.nanosecond=s.ns=1/1e6;s.\u00B5s=s.\u03BCs=s.us=s.microsecond=1/1e3;s.millisecond=s.ms=1;s.second=s.sec=s.s=s[""]=s.ms*1e3;s.minute=s.min=s.m=s.s*60;s.hour=s.hr=s.h=s.m*60;s.day=s.d=s.h*24;s.week=s.wk=s.w=s.d*7;s.month=s.b=s.d*(365.25/12);s.year=s.yr=s.y=s.d*365.25;function C(e){return s[e]||s[e.toLowerCase().replace(/s$/,"")]}function s(e="",n="ms"){if(!e)return 0;if(typeof e=="boolean")return e?60*60:0;if(typeof e=="number")return e;var a=null;e=(e+"").replace(/(\d)[,_](\d)/g,"$1$2");var r=e[0]==="-";return e.replace(O,function(t,o,c){c=C(c),c&&(a=(a||0)+Math.abs(parseFloat(o,10))*c)}),Math.max(1,Math.round((a&&a/(C(n)||1)*(r?-1:1))/1e3))}var $=e=>!e||e instanceof FormData||typeof(e.pipe||e.pipeTo)=="function"?!1:typeof e=="object"||Array.isArray(e),g=e=>{if(typeof e!="object")return e;for(let n in e)e[n]===void 0&&delete e[n];return e},b=class extends Error{constructor(n){let a="Error "+n.status;super(a),this.response=n,this.message=a}},j=(e,n,a)=>{let[r,t={}]=e.split("?"),o=new URLSearchParams(Object.fromEntries([...new URLSearchParams(g(n)),...new URLSearchParams(g(t))])).toString();return o&&(r=r+"?"+o),a?new URL(r.replace(/^\//,""),a).href:r},B=e=>{let n={};for(let[a,r]of Object.entries(e))n[a.toLowerCase()]=r;return n},R=async e=>{let n=e.headers.get("content-type"),a=n&&n.includes("application/json"),r=await e.clone().text();return a?JSON.parse(r):r},S=async(e,n)=>{let a={status:e.status,statusText:e.statusText,headers:{}};for(let r of e.headers.keys())a.headers[r.toLowerCase()]=e.headers.get(r);if(!e.ok)throw new b(e);return a.body=await R(e),a},L=(e,{ref:n,after:a,error:r,output:t})=>fetch(e.url,e).then(async o=>{if(n.res=o,o.ok&&t==="stream")return o.body;if(o.ok&&o[t]&&typeof o[t]=="function")return o[t]();let c=a(await S(o,r));if(t==="body")return c.body;if(t==="response")return c;if(t==="raw")return o.clone();throw new Error(`Invalid option output="${t}"`)}),J=e=>e.method==="get",N=e=>e.method+":"+e.url,q=(e={},n)=>{let a={store:w({expire:s(e.expire)}),shouldCache:J,createKey:N,...e};return a.clear=()=>a.store?.flushAll(),n&&(a.shouldCache=()=>!1),a};function x(e={}){let n={},a={},t=p(async(o="/",c={})=>{let{output:f,before:A,after:E,error:U,...i}={...t,...c},l={...t.cache},P=u=>["number","string","boolean"].includes(typeof u);if(l.expire=s([c.cache?.expire,c.cache,l?.expire,l].find(P)),i.url=j(o,{...t.query,...c.query},i.baseUrl??i.baseURL),i.method=i.method.toLowerCase()||"GET",i.headers=B({...t.headers,...c.headers}),i.body instanceof SubmitEvent&&(i.body=new FormData(i.body.target)),i.body instanceof HTMLFormElement&&(i.body=new FormData(i.body)),$(i.body)&&(i.body=JSON.stringify(g(i.body)),i.headers["content-type"]="application/json"),i=A(i),l.shouldCache(i)&&l.expire){let u=l.createKey(i);if(await l.store.exists(u))return l.store.get(u);if(n[u])return n[u];let m;try{n[u]=L(i,{ref:a,cache:l,output:f,error:U,after:E}),m=await n[u]}finally{delete n[u]}return await l.store.set(u,m,{EX:l.expire}),m}return L(i,{ref:a,output:f,error:U,after:E})},{text:()=>a.res.text(),json:()=>a.res.json(),blob:()=>a.res.blob(),stream:()=>a.res.body,arrayBuffer:()=>a.res.arrayBuffer(),formData:()=>a.res.formData(),body:()=>R(a.res),clone:()=>a.res.clone(),raw:()=>a.res.clone(),response:()=>S(a.res.clone())});return t.url=e.url??"/",t.method=e.method??"get",t.query=e.query??{},t.headers=e.headers??{},t.baseUrl=e.baseUrl??e.baseURL??null,["number","string","boolean"].includes(typeof e.cache)&&(e.cache={expire:e.cache}),t.cache=q(e.cache,e.cache?.expire===!1||e.cache?.expire===0),t.output=e.output??"body",t.credentials=e.credentials??"include",t.before=e.before??(o=>o),t.after=e.after??(o=>o),t.error=e.error??(o=>{throw o}),t.get=(o,c)=>t(o,{method:"get",...c}),t.head=(o,c)=>t(o,{method:"head",...c}),t.post=(o,c,f)=>t(o,{method:"post",body:c,...f}),t.patch=(o,c,f)=>t(o,{method:"patch",body:c,...f}),t.put=(o,c,f)=>t(o,{method:"put",body:c,...f}),t.delete=(o,c)=>t(o,{method:"delete",...c}),t.del=t.delete,t.create=x,t}typeof window<"u"&&(window.fch=x());var _=x();export{x as create,_ as default};
+//# sourceMappingURL=index.min.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fch",
-  "version": "4.1.4",
+  "version": "5.0.0",
   "description": "Fetch interface with better promises, deduplication, defaults, etc.",
   "homepage": "https://github.com/franciscop/fetch",
   "repository": "https://github.com/franciscop/fetch.git",
@@ -9,10 +9,10 @@
   "author": "Francisco Presencia <public@francisco.io> (https://francisco.io/)",
   "license": "MIT",
   "scripts": {
-    "build": "rollup -c",
+    "build": "esbuild src/index.js --bundle --minify --sourcemap --outfile=index.min.js --format=esm",
     "size": "echo $(gzip -c index.min.js | wc -c) bytes",
     "start": "node --experimental-vm-modules node_modules/jest/bin/jest.js --watch --coverage --detectOpenHandles",
-    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js --coverage --detectOpenHandles"
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js --coverage --detectOpenHandles && check-dts"
   },
   "keywords": [
     "fetch",
@@ -22,40 +22,29 @@
     "async",
     "ajax"
   ],
-  "main": "./index.min.js",
+  "main": "index.min.js",
   "files": [
-    "./index.min.js"
+    "index.min.js"
   ],
+  "types": "index.d.ts",
   "type": "module",
   "engines": {
     "node": ">=18.0.0"
   },
   "devDependencies": {
-    "@babel/core": "^7.15.0",
-    "@babel/preset-env": "^7.15.0",
-    "@babel/preset-react": "^7.14.5",
-    "babel-loader": "^8.2.2",
-    "babel-polyfill": "^6.26.0",
+    "check-dts": "^0.7.2",
+    "esbuild": "^0.19.2",
     "jest": "^28.1.0",
     "jest-environment-jsdom": "^28.1.0",
     "jest-fetch-mock": "^3.0.3",
-    "rollup": "^1.32.1",
-    "rollup-plugin-babel": "^4.4.0",
-    "rollup-plugin-node-resolve": "^5.2.0",
-    "rollup-plugin-terser": "^5.2.0",
+    "redis": "^4.6.7",
     "swear": "^1.1.2"
   },
   "jest": {
     "testEnvironment": "jest-environment-node",
     "transform": {},
     "setupFiles": [
-      "./setup.js"
-    ]
-  },
-  "babel": {
-    "presets": [
-      "@babel/preset-env",
-      "@babel/preset-react"
+      "./test/setup.js"
     ]
   }
 }

package/readme.md

@@ -11,31 +11,30 @@ console.log(mew);
 // As an API abstraction
 const api = fch.create({ baseUrl: "https://pokeapi.co/" });
 const mew = await api.get("/pokemon/150");
-await api.patch("/pokemon/150", { body: { type: "psychic" } });
+await api.patch("/pokemon/150", { type: "psychic" });
 ```
 
 - Create instances with shared options across requests.
-- Automatically encode object and array bodies as JSON.
-- Automatically decode JSON responses based on the headers.
-- Await/Async Promises; `>= 400 and <= 100` will _reject_ with an error.
+- Configurable **cache** that works in-memory, with redis, or others.
+- Automatically encode and decode JSON bodies.
+- Await/Async Promises; `>= 400 and <= 100` will throw an error.
 - Credentials: "include" by default
 - Interceptors: `before` the request, `after` the response and catch with `error`.
-- Deduplicates parallel GET requests.
-- Works the same way in Node.js and the browser.
+- Designed for both Node.js and the browser through its extensible cache system.
 - No dependencies; include it with a simple `<script>` on the browser.
+- Full Types definitions so you get nice autocomplete
 
 ```js
-import api from "fch";
+import fch from "fch";
+
+const api = fch.create({ baseUrl, headers, ...options });
 
 api.get(url, { headers, ...options });
 api.head(url, { headers, ...options });
-api.post(url, { body, headers, ...options });
-api.patch(url, { body, headers, ...options });
-api.put(url, { body, headers, ...options });
-api.del(url, { body, headers, ...options });
-api.delete(url, { body, headers, ...options });
-
-api.create({ url, body, headers, ...options });
+api.post(url, body, { headers, ...options });
+api.patch(url, body, { headers, ...options });
+api.put(url, body, { headers, ...options });
+api.del(url, { headers, ...options });
 ```
 
 | Options                   | Default            | Description                              |
@@ -47,7 +46,7 @@ api.create({ url, body, headers, ...options });
 | [`query`](#query)         | `{}`               | Add query parameters to the URL          |
 | [`headers`](#headers)     | `{}`               | Shared headers across all requests       |
 | [`output`](#output)       | `"body"`           | The return value of the API call         |
-| [`dedupe`](#dedupe)       | `true`             | Reuse concurrently GET requests          |
+| [`cache`](#cache)         | `{ expire: 0 }`    | How long to reuse the response body      |
 | [`before`](#interceptors) | `req => req`       | Process the request before sending it    |
 | [`after`](#interceptors)  | `res => res`       | Process the response before returning it |
 | [`error`](#interceptors)  | `err => throw err` | Process errors before returning them     |
@@ -93,12 +92,14 @@ api.headers = {}; // Merged with the headers on a per-request basis
 
 // Control simple variables
 api.output = "body"; // Return the parsed body; use 'response' or 'stream' otherwise
-api.dedupe = true; // Avoid sending concurrent GET requests to the same path
+api.cache = { expires: 0 }; // Avoid sending GET requests that were already sent recently
 
 // Interceptors
 api.before = (req) => req;
 api.after = (res) => res;
-api.error = (err) => Promise.reject(err);
+api.error = (err) => {
+  throw err;
+};
 ```
 
 They can all be defined globally as shown above, passed manually as the options argument, or be used when [creating a new instance](#create-an-instance).
@@ -111,8 +112,8 @@ The HTTP method to make the request. When using the shorthand, it defaults to `G
 import api from "fch";
 
 api.get("/cats");
-api.post("/cats", { body: { name: "snowball" } });
-api.put(`/cats/3`, { body: { name: "snowball" } });
+api.post("/cats", { name: "snowball" });
+api.put(`/cats/3`, { name: "snowball" });
 ```
 
 You can use it with the plain function as an option parameter. The methods are all lowercase but the option as a parameter is case insensitive; it can be either uppercase or lowercase:
@@ -136,24 +137,19 @@ import api from "fch";
 
 const cats = await api.get("/cats");
 console.log(cats);
-const { id } = await api.post("/cats", { body: { name: "snowbll" } });
-await api.put(`/cats/${id}`, { body: { name: "snowball" } });
+const { id } = await api.post("/cats", { name: "snowbll" });
+await api.patch(`/cats/${id}`, { name: "snowball" });
 ```
 
 ### Url
 
-Specify where to send the request to. It's normally the first argument, though technically you can use both styles:
+Specify where to send the request to. It must be the first argument in all methods and the base call:
 
 ```js
 import api from "fch";
 
-// Recommended way of specifying the Url
-await api.post("/hello", { body: "...", headers: {} });
-
-// These are also valid if you prefer their style; we won't judge
 await api("/hello", { method: "post", body: "...", headers: {} });
-await api({ url: "/hello", method: "post", headers: {}, body: "..." });
-await api.post({ url: "/hello", headers: {}, body: "..." });
+await api.post("/hello", body, { headers: {} });
 ```
 
 It can be either absolute or relative, in which case it'll use the local one in the page. It's recommending to set `baseUrl`:
@@ -169,82 +165,83 @@ api.get("/hello");
 
 ### Body
 
-The `body` can be a string, a plain object|array or a FormData instance. If it's an array or object, it'll be stringified and the header `application/json` will be added. Otherwise it'll be sent as plain text:
+> These docs refer to the REQUEST body, for the RESPONSE body see the [**Output docs**](#output).
+
+The `body` can be a string, a plain object|array, a FormData instance, a ReadableStream, a SubmitEvent or a HTMLFormElement. If it's a plain array or object, it'll be stringified and the header `application/json` will be added:
 
 ```js
-import api from 'api';
+import api from "api";
 
 // Sending plain text
-await api.post('/houses', { body: 'plain text' });
+await api.post("/houses", "plain text");
 
-// Will JSON.stringify it internally, and add the JSON headers
-await api.post('/houses', { body: { id: 1, name: 'Cute Cottage' } });
+// Will JSON.stringify it internally and add the JSON headers
+await api.post("/houses", { id: 1, name: "Cute Cottage" });
 
 // Send it as FormData
-form.onsubmit = e => {
-  await api.post('/houses', { body: new FormData(e.target) });
-};
-```
+form.onsubmit = (e) => api.post("/houses", new FormData(e.target));
 
-The methods `GET` and `HEAD` do not accept a body and it'll be ignored.
-
-The **response body** will be returned by default as the output of the call:
-
-> See more info in [**Output**](#output)
-
-```js
-const body = await api.get("/cats");
-console.log(body);
-// [{ id: 1, }, ...]
+// We have some helpers so you can just pass the Event or <form> itself!
+form.onsubmit = (e) => api.post("/houses", e); // does not work with jquery BTW
+form.onsubmit = (e) => api.post("/houses", e.target);
+form.onsubmit = (e) => api.post("/houses", new FormData(e.target));
 ```
 
-When the server specifies the header `Content-Type` as `application/json`, then we'll attempt to parse the response body and return that as the variable. Otherwise, the plain text will be returned.
-
-When the function returns the response (if you set `output: "response"` as an option), then the body can be accessed as `response.body`:
-
-```js
-const response = await api.get("/cats", { output: "response" });
-console.log(response.body);
-// [{ id: 1, }, ...]
-```
+The methods `GET`, `HEAD` and `DELETE` do not accept a body and it'll be ignored if you try to force it into the options.
 
 ### Query
 
-You can easily pass GET query parameters by using the option `query`:
+You can easily pass url query parameters by using the option `query`:
 
 ```js
 api.get("/cats", { query: { limit: 3 } });
 // /cats?limit=3
 ```
 
-While rare, some times you might want to persist a query parameter across requests and always include it; in that case, you can define it globally and it'll be added to every request:
+While rare, some times you might want to persist a query parameter across requests and always include it; in that case, you can define it globally and it'll be added to every request, or on an instance:
 
 ```js
-import api from "fch";
-api.query.myparam = "abc";
+import fch from "fch";
+fch.query.myparam = "abc";
 
-api.get("/cats", { query: { limit: 3 } });
+fch.get("/cats", { query: { limit: 3 } });
 // /cats?limit=3&myparam=abc
+
+const api = fch.create({ query: { sort: "asc" } });
+api.get("/cats");
+// /cats?sort=asc&myparam=abc
+```
+
+For POST or others, they go into the options as usual:
+
+```js
+fch.post("/cats", { my: "body" }, { query: { abc: "def" } });
+// /cats?abc=def
 ```
 
 ### Headers
 
-You can define headers globally, in which case they'll be added to every request, or locally, so that they are only added to the current request. You can also add them in the `before` callback:
+You can define headers in 4 ways:
+
+- Globally, in which case they'll be added to every request
+- On an instance, so they are added every time you use that instance
+- Per-request, so that they are only added to the current request.
+- In the `before` interceptor, which again can be globa, on an instance, or per-request
 
 ```js
-import api from "fch";
+import fch from "fch";
 
 // Globally, so they are reused across all requests
-api.headers.a = "b";
+fch.headers.a = "b";
 
 // With an interceptor, in case you need dynamic headers per-request
-api.before = (req) => {
+fch.before = (req) => {
   req.headers.c = "d";
   return req;
 };
 
 // Set them for this single request:
-api.get("/hello", { headers: { e: "f" } });
+fch.get("/hello", { headers: { e: "f" } });
 // Total headers on the request:
 // { a: 'b', c: 'd', e: 'f' }
 ```
@@ -252,6 +249,7 @@ api.get("/hello", { headers: { e: "f" } });
 When to use each?
 
 - If you need headers shared across all requests, like an API key, then the global one is the best place.
+- If it's all the requests to only certain endpoint, like we are communicating to multiple endpoints use the instance
 - When you need to extract them dynamically from somewhere it's better to use the .before() interceptor. An example would be the user Authorization token.
 - When it changes on each request, it's not consistent or it's an one-off, use the option argument.
 
@@ -264,6 +262,8 @@ const cats = await api.get("/cats");
 console.log(cats); // [{ id: 1, name: 'Whiskers', ... }, ...]
 ```
 
+> Note: for your typical API, we recommend sending the proper headers from the API and **not** using the more advanced options below.
+
 For more expressive control, you can use the **`output` option** (either as a default when [creating an instance](#create-an-instance) or with each call), or using a method:
 
 ```js
@@ -319,53 +319,143 @@ For example, return the raw body as a `ReadableStream` with the option `stream`:
 ```js
 const stream = await api.get('/cats', { output: 'stream' });
 stream.pipeTo(...);
+// or
+const stream = await api.get('/cats').stream();
+stream.pipeTo(...);
+```
+
+### Cache
+
+The cache (disabled by default) is a great method to reduce the number of API requests we make. While it's possible to modify the global fch to add a cache, we recommend to always use it per-instance or per-request. Options:
+
+- `expire`: the amount of time the cached data will be valid for, it can be a number (seconds) or a string such as `1hour`, `1week`, etc. (based on [parse-duration](https://github.com/jkroso/parse-duration))
+- `store`: the store where the cached data will be stored.
+- `shouldCache`: a function that returns a boolean to determine whether the current data should go through the cache process.
+- `createKey`: a function that takes the request and generates a unique key for that request, which will be the same for the next time that same request is made. Defaults to method+url.
+
+> Note: cache should only be used through `fch.create({ cache: ... })`, not through the global instance.
+
+To activate the cache, we just need to set a time as such:
+
+```js
+// This API has 1h by default:
+const api = fch.create({
+  baseUrl: 'https://api.myweb.com/'
+  cache: '1h'
+});
+
+// This specific call will be cached for 20s
+api.get('/somedata', { cache: '20s' });
 ```
 
-### Dedupe
+Your cache will have a `store`; by default we create an in-memory store, but you can also use `redis` and it's fully compatible. Note now `cache` is now an object:
+
+```js
+import fch from "fch";
+import { createClient } from "redis";
+
+// Create a redis client
+const store = createClient();
+await store.connect();
+
+const api = fch.create({
+  cache: {
+    store: store,
+    expire: "1h",
+  },
+});
+```
 
-When you perform a GET request to a given URL, but another GET request _to the same_ URL is ongoing, it'll **not** create a new request and instead reuse the response when the first one is finished:
+That's the basic usage, but "invalidating cache" is not one of the complex topics in CS for no reason. Let's dig deeper. To clear the cache, you can call `cache.clear()` at any time:
 
 ```js
-fetch.mockOnce("a").mockOnce("b");
-const res = await Promise.all([fch("/a"), fch("/a")]);
+const api = fch.create({ cache: "1h" });
 
-// Reuses the first response if two are launched in parallel
-expect(res).toEqual(["a", "a"]);
+// Remove them all
+await api.cache.clear();
 ```
 
-You can disable this by setting either the global `fch.dedupe` option to `false` or by passing an option per request:
+You can always access the store of the instance through `api.cache.store`, so we can do low-level operations on the store as such if needed:
 
 ```js
-// Globally set it for all calls
-fch.dedupe = true; // [DEFAULT] Dedupes GET requests
-fch.dedupe = false; // All fetch() calls trigger a network call
+import fch from "fch";
+import { createClient } from "redis";
+
+// Initialize it straight away
+const api = fch.create({
+  cache: {
+    store: createClient(),
+    expire: "1h",
+  },
+});
+
+// Connect it here now
+await api.cache.store.connect();
 
-// Set it on a per-call basis
-fch("/a", { dedupe: true }); // [DEFAULT] Dedupes GET requests
-fch("/a", { dedupe: false }); // All fetch() calls trigger a network call
+// Later on, maybe in a different place
+await api.cache.store.flushDB();
 ```
 
-> We do not support deduping other methods besides `GET` right now
+Finally, the other two bits that are relevant for cache are `shouldCache` and `createKey`. For the most basic examples the default probably works, but you might want more advanced configuration:
 
-Note that opting out of deduping a request will _also_ make that request not be reusable, see this test for details:
+```js
+const api = fch.create({
+  cache: {
+    // Default shouldCache; Note the lowercase
+    shouldCache: (request) => request.method === "get",
+
+    // Default createKey;
+    createKey: (request) => request.method + ":" + request.url,
+  },
+});
+```
+
+For example, if you want to differentiate the auth requests from the non-auth requests, you can do it so:
 
 ```js
-it("can opt out locally", async () => {
-  fetch.once("a").once("b").once("c");
-  const res = await Promise.all([
-    fch("/a"),
-    fch("/a", { dedupe: false }),
-    fch("/a"), // Reuses the 1st response, not the 2nd one
-  ]);
+import api from "./api";
+
+const onLogin = (user) => {
+  // ... Do some other stuff
+
+  // Remove the old requests since we were not auth'ed yet
+  api.cache.clear();
+
+  // Create a key unique for this user
+  api.cache.createKey = (req) => user.id + ":" + req.method + ":" + req.url;
+};
+```
+
+Or maybe you just want to NOT cache any of the requests that have an `Authorization` header, you can do so:
 
-  expect(res).toEqual(["a", "b", "a"]);
-  expect(fetch.mock.calls.length).toEqual(2);
+```js
+const api = fch.create({
+  cache: {
+    expire: "1week",
+
+    // Note the lowercase in both! we normalize them to be lowercase
+    shouldCache: (req) => req.method === "get" && !req.headers.authorization,
+  },
 });
 ```
 
+#### Creating a store.
+
+You might want to create a custom store. Please have a look at `src/store.js`, but basically you need an object that implements these methods:
+
+```js
+type Store = {
+  get: (key: string) => Promise<any>,
+  set: (key: string, value: any, options?: { EX: number }) => Promise<null>,
+  del: (key: string) => Promise<null>,
+  exists: (key: string) => Promise<boolean>,
+  flushAll: () => Promise<any>,
+};
+```
+
 ### Interceptors
 
-You can also easily add the interceptors `before`, `after` and `error`:
+You can also add the interceptors `before`, `after` and `error`:
 
 - `before`: Called when the request is fully formed, but before actually launching it.
 - `after`: Called just after the response is created and if there was no error, but before parsing anything else.