fch 1.0.0 → 2.0.0

package/fetch.js

@@ -1,34 +1,25 @@
-import swear from './node_modules/swear/swear.js';
-
-if (typeof require !== 'undefined') {
-  require('isomorphic-fetch');
-}
+import swear from "swear";
 
 // To avoid making parallel requests to the same url if one is ongoing
 const ongoing = new Map();
 
 // Plain-ish object
-const hasPlainBody = options => {
-  if (options.headers['content-type']) return;
-  if (typeof options.body !== 'object') return;
+const hasPlainBody = (options) => {
+  if (options.headers["content-type"]) return;
+  if (typeof options.body !== "object") return;
   if (options.body instanceof FormData) return;
   return true;
 };
 
-const fch = (url, options = {}) => {
-
-  options = {
-    method: 'get',
-    headers: {},
-    ...(typeof options === 'object' ? options : {})
-  };
-
-  // GET requests should not have race conditions
-  if (options.method.toLowerCase() === 'get') {
-    if (ongoing.get(url)) return ongoing.get(url);
-  }
+const createUrl = (path, base) => {
+  if (!base) return path;
+  const url = new URL(path, base);
+  return url.href;
+};
 
-  const headers = options.headers;
+const createHeaders = (user, base) => {
+  // User-set headers overwrite the base headers
+  const headers = { ...base, ...user };
 
   // Make the headers lowercase
   for (let key in headers) {
@@ -37,44 +28,132 @@ const fch = (url, options = {}) => {
     headers[key.toLowerCase()] = value;
   }
 
-  // JSON-encode plain objects
-  if (hasPlainBody(options)) {
-    options.body = JSON.stringify(options.body);
-    headers['content-type'] = 'application/json; charset=utf-8';
-  }
+  return headers;
+};
 
-  ongoing.set(url, swear(fetch(url, { ...options, headers }).then(res => {
+const createFetch = (request, { after, dedupe, error, output }) => {
+  return fetch(request.url, request).then(async (res) => {
     // No longer ongoing at this point
-    ongoing.delete(url);
+    if (dedupe) dedupe.clear();
+
+    // Need to manually create it to set some things like the proper response
+    let response = {
+      status: res.status,
+      statusText: res.statusText,
+      headers: {},
+    };
+    for (let key of res.headers.keys()) {
+      response.headers[key.toLowerCase()] = res.headers.get(key);
+    }
 
-    // Everything is good, just keep going
+    // Oops, throw it
     if (!res.ok) {
-      // Oops, throw it
-      const error = new Error(res.statusText);
-      error.response = res;
-      return Promise.reject(error);
+      const err = new Error(res.statusText);
+      err.response = response;
+      return error(err);
     }
 
-    const mem = new Map();
-    return new Proxy(res, { get: (target, key) => {
-      if (['then', 'catch', 'finally'].includes(key)) return res[key];
-      return () => {
-        if (!mem.get(key)) {
-          mem.set(key, target[key]());
-        }
-        return mem.get(key);
-      };
-    }});
-  })));
-
-  return ongoing.get(url);
+    // Automatically parse the response
+    const isJson = res.headers.get("content-type").includes("application/json");
+    response.body = await (isJson ? res.json() : res.text());
+
+    // Hijack the response and modify it
+    if (after) {
+      response = after(response);
+    }
+
+    if (output === "body") {
+      return response.body;
+    } else {
+      return response;
+    }
+  });
 };
 
-fch.head = (url, options = {}) => fch(url, { ...options, method: 'head' });
-fch.get = (url, options = {}) => fch(url, { ...options, method: 'get' });
-fch.post = (url, options = {}) => fch(url, { ...options, method: 'post' });
-fch.patch = (url, options = {}) => fch(url, { ...options, method: 'patch' });
-fch.put = (url, options = {}) => fch(url, { ...options, method: 'put' });
-fch.del = (url, options = {}) => fch(url, { ...options, method: 'delete' });
+const fch = swear((url, options = {}) => {
+  // Second parameter always has to be an object, even when it defaults
+  if (typeof options !== "object") options = {};
+
+  // Accept either fch(options) or fch(url, options)
+  options = typeof url === "string" ? { url, ...options } : url;
+
+  // Absolute URL if possible; Default method; merge the default headers
+  options.url = createUrl(options.url, fch.baseUrl);
+  options.method = (options.method ?? fch.method).toLowerCase();
+  options.headers = createHeaders(options.headers, fch.headers);
+
+  let {
+    dedupe = fch.dedupe,
+    output = fch.output,
+
+    before = fch.before,
+    after = fch.after,
+    error = fch.error,
+
+    ...request
+  } = options; // Local option OR global value (including defaults)
+
+  if (request.method !== "get") {
+    dedupe = false;
+  }
+  if (dedupe) {
+    dedupe = {
+      save: (prom) => {
+        ongoing.set(request.url, prom);
+        return prom;
+      },
+      get: () => ongoing.get(request.url),
+      clear: () => ongoing.delete(request.url),
+    };
+  }
+
+  if (!["body", "response"].includes(output)) {
+    const msg = `options.output needs to be either "body" (default) or "response", not "${output}"`;
+    throw new Error(msg);
+  }
+
+  // JSON-encode plain objects
+  if (hasPlainBody(request)) {
+    request.body = JSON.stringify(request.body);
+    request.headers["content-type"] = "application/json; charset=utf-8";
+  }
+
+  // Hijack the requeset and modify it
+  if (before) {
+    request = before(request);
+  }
+
+  // It should be cached
+  if (dedupe) {
+    // It's already cached! Just return it
+    if (dedupe.get()) return dedupe.get();
+
+    // Otherwise, save it in the cache and return the promise
+    return dedupe.save(createFetch(request, { dedupe, output, error, after }));
+  } else {
+    // PUT, POST, etc should never dedupe and just return the plain request
+    return createFetch(request, { output, error, after });
+  }
+});
+
+fch.get = (url, options = {}) => fch(url, { ...options, method: "get" });
+fch.head = (url, options = {}) => fch(url, { ...options, method: "head" });
+fch.post = (url, options = {}) => fch(url, { ...options, method: "post" });
+fch.patch = (url, options = {}) => fch(url, { ...options, method: "patch" });
+fch.put = (url, options = {}) => fch(url, { ...options, method: "put" });
+fch.del = (url, options = {}) => fch(url, { ...options, method: "delete" });
+
+// Default values
+fch.method = "get";
+fch.headers = {};
+
+// Default options
+fch.dedupe = true;
+fch.output = "body";
+
+// Interceptors
+fch.before = (request) => request;
+fch.after = (response) => response;
+fch.error = (error) => Promise.reject(error);
 
 export default fch;

package/fetch.test.js

@@ -1,146 +1,370 @@
-import fch, { get } from './fetch.min';
-global.fetch = require('jest-fetch-mock');
+import fch from "./fetch.js";
+import mock from "jest-fetch-mock";
 
-describe('fetch()', () => {
+mock.enableMocks();
+
+const jsonHeaders = { headers: { "Content-Type": "application/json" } };
+
+describe("fetch()", () => {
   beforeEach(() => {
     fetch.resetMocks();
   });
 
-  it('works', async () => {
-    fetch.once(JSON.stringify({ secret: '12345' }));
-    const res = await fch('https://google.com/').json();
+  it("can create a basic request", async () => {
+    fetch.once("hello");
+    const data = await fch("/");
+
+    expect(data).toEqual("hello");
+    expect(fetch.mock.calls.length).toEqual(1);
+    expect(fetch.mock.calls[0][0]).toEqual("/");
+    expect(fetch.mock.calls[0][1].method).toEqual("get");
+    expect(fetch.mock.calls[0][1].headers).toEqual({});
+  });
+
+  it("accepts Axios syntax as well", async () => {
+    fetch.once("hello");
+    const data = await fch({ url: "/" });
+
+    expect(data).toEqual("hello");
+    expect(fetch.mock.calls.length).toEqual(1);
+    expect(fetch.mock.calls[0][0]).toEqual("/");
+    expect(fetch.mock.calls[0][1].method).toEqual("get");
+    expect(fetch.mock.calls[0][1].headers).toEqual({});
+  });
+
+  it("can receive a full response", async () => {
+    fetch.once("hello", { status: 200, headers: { hello: "world" } });
+    const res = await fch("/", { output: "response" });
+
+    expect(res.body).toEqual("hello");
+    expect(res.status).toEqual(200);
+    expect(res.statusText).toEqual("OK");
+    expect(res.headers.hello).toEqual("world");
+    expect(fetch.mock.calls.length).toEqual(1);
+  });
+
+  it("works with JSON", async () => {
+    fetch.once(JSON.stringify({ secret: "12345" }), jsonHeaders);
+    const data = await fch("https://google.com/");
 
-    expect(res).toEqual({ secret: '12345' });
+    expect(data).toEqual({ secret: "12345" });
     expect(fetch.mock.calls.length).toEqual(1);
-    expect(fetch.mock.calls[0][0]).toEqual('https://google.com/');
+    expect(fetch.mock.calls[0][0]).toEqual("https://google.com/");
   });
 
-  it('can use the `fetch.get()` shorthand', async () => {
-    fetch.once('get');
-    expect(await fch.get('/').text()).toBe('get');
-    expect(fetch.mock.calls[0][1].method).toEqual('get');
+  it("can use the swear interface", async () => {
+    fetch.once(JSON.stringify({ secret: "12345" }), jsonHeaders);
+    const hello = await fch("/").secret;
+    expect(hello).toEqual("12345");
   });
 
-  it('can use the `fetch.patch()` shorthand', async () => {
-    fetch.once('patch');
-    expect(await fch.patch('/').text()).toBe('patch');
-    expect(fetch.mock.calls[0][1].method).toEqual('patch');
+  it("can use the baseUrl", async () => {
+    fetch.once("hi");
+    fch.baseUrl = "https://google.com/";
+    const data = await fch.get("/hello");
+    expect(data).toBe("hi");
+    expect(fetch.mock.calls[0][0]).toBe("https://google.com/hello");
+    expect(fetch.mock.calls[0][1].method).toEqual("get");
+    fch.baseUrl = null;
   });
 
-  it('can use the `fetch.put()` shorthand', async () => {
-    fetch.once('put');
-    expect(await fch.put('/').text()).toBe('put');
-    expect(fetch.mock.calls[0][1].method).toEqual('put');
+  it("can use the `fetch.get()` shorthand", async () => {
+    fetch.once("my-data");
+    const data = await fch.get("/");
+    expect(data).toBe("my-data");
+    expect(fetch.mock.calls[0][1].method).toEqual("get");
   });
 
-  it('can use the `fetch.head()` shorthand', async () => {
-    fetch.once('head');
-    expect(await fch.head('/').text()).toBe('head');
-    expect(fetch.mock.calls[0][1].method).toEqual('head');
+  it("can use the `fetch.patch()` shorthand", async () => {
+    fetch.once("my-data");
+    expect(await fch.patch("/")).toBe("my-data");
+    expect(fetch.mock.calls[0][1].method).toEqual("patch");
   });
 
-  it('can use the `fetch.post()` shorthand', async () => {
-    fetch.once('post');
-    expect(await fch.post('/').text()).toBe('post');
-    expect(fetch.mock.calls[0][1].method).toEqual('post');
+  it("can use the `fetch.put()` shorthand", async () => {
+    fetch.once("my-data");
+    expect(await fch.put("/")).toBe("my-data");
+    expect(fetch.mock.calls[0][1].method).toEqual("put");
   });
 
-  it('can use the `fetch.del()` shorthand', async () => {
-    fetch.once('del');
-    expect(await fch.del('/').text()).toBe('del');
-    expect(fetch.mock.calls[0][1].method).toEqual('delete');
+  it("can use the `fetch.post()` shorthand", async () => {
+    fetch.once("my-data");
+    expect(await fch.post("/")).toBe("my-data");
+    expect(fetch.mock.calls[0][1].method).toEqual("post");
   });
 
-  it('ignores invalid options', async () => {
-    fetch.once(JSON.stringify({ secret: '12345' }));
-    const res = await fch('https://google.com/', 10).json();
+  it("can use the `fetch.del()` shorthand", async () => {
+    fetch.once("my-data");
+    expect(await fch.del("/")).toBe("my-data");
+    expect(fetch.mock.calls[0][1].method).toEqual("delete");
+  });
+
+  it("ignores invalid options", async () => {
+    fetch.once(JSON.stringify({ secret: "12345" }), jsonHeaders);
+    const res = await fch("https://google.com/", 10);
 
-    expect(res).toEqual({ secret: '12345' });
+    expect(res).toEqual({ secret: "12345" });
     expect(fetch.mock.calls.length).toEqual(1);
-    expect(fetch.mock.calls[0][0]).toEqual('https://google.com/');
+    expect(fetch.mock.calls[0][0]).toEqual("https://google.com/");
   });
 
-  it('will not overwrite if it is FormData', async () => {
-    fetch.once(JSON.stringify({ secret: '12345' }));
-    const res = await fch('/', { method: 'POST', body: new FormData() }).json();
+  it("will not overwrite if it is FormData", async () => {
+    fetch.once(JSON.stringify({ secret: "12345" }), jsonHeaders);
+    const res = await fch("/", { method: "post", body: new FormData() });
 
-    expect(res).toEqual({ secret: '12345' });
+    expect(res).toEqual({ secret: "12345" });
     expect(fetch.mock.calls.length).toEqual(1);
     const [url, opts] = fetch.mock.calls[0];
     expect(opts).toMatchObject({ body: expect.any(FormData) });
   });
 
-  it('will not overwrite if content-type is set', async () => {
-    fetch.once(JSON.stringify({ secret: '12345' }));
-    const res = await fch('/', {
-      method: 'POST',
-      body: { a: 'b'},
-      headers: { 'Content-Type': 'xxx' }
-    }).json();
+  it("will not overwrite if content-type is set", async () => {
+    fetch.once(JSON.stringify({ secret: "12345" }), jsonHeaders);
+    const res = await fch("/", {
+      method: "POST",
+      body: { a: "b" },
+      headers: { "Content-Type": "xxx" },
+    });
 
-    expect(res).toEqual({ secret: '12345' });
+    expect(res).toEqual({ secret: "12345" });
     expect(fetch.mock.calls.length).toEqual(1);
     const [url, opts] = fetch.mock.calls[0];
-    expect(url).toEqual('/');
+    expect(url).toEqual("/");
     expect(opts).toMatchObject({
-      method: 'POST',
-      body: { a: 'b' },
-      headers: { 'content-type': 'xxx' }
+      method: "post",
+      body: { a: "b" },
+      headers: { "content-type": "xxx" },
     });
   });
 
-  it('will send JSON', async () => {
-    fetch.once(JSON.stringify({ secret: '12345' }));
-    const res = await fch('/', { method: 'POST', body: { a: 'b'} }).json();
+  it("will send JSON", async () => {
+    fetch.once(JSON.stringify({ secret: "12345" }), jsonHeaders);
+    const res = await fch("/", { method: "POST", body: { a: "b" } });
 
-    expect(res).toEqual({ secret: '12345' });
+    expect(res).toEqual({ secret: "12345" });
     expect(fetch.mock.calls.length).toEqual(1);
     const [url, opts] = fetch.mock.calls[0];
-    expect(url).toEqual('/');
+    expect(url).toEqual("/");
     expect(opts).toMatchObject({
-      method: 'POST',
+      method: "post",
       body: '{"a":"b"}',
-      headers: { 'content-type': 'application/json; charset=utf-8' }
+      headers: { "content-type": "application/json; charset=utf-8" },
     });
   });
 
-  it('can run in parallel', async () => {
-    fetch.once(JSON.stringify('a')).once(JSON.stringify('b'));
-    const res = await Promise.all(['/a', '/b'].map(url => fch(url).json()));
+  it("can run in parallel", async () => {
+    fetch.once("a").once("b");
+    const res = await Promise.all([fch("/a"), fch("/b")]);
 
-    expect(res).toEqual(['a', 'b']);
+    expect(res).toEqual(["a", "b"]);
     expect(fetch.mock.calls.length).toEqual(2);
   });
 
-  // There is a bug with node-fetch so this is difficult to test right now
-  //   https://github.com/bitinn/node-fetch/issues/386
-  it.skip('will not trigger race conditions on get for the same url', async () => {
-    fetch.once(JSON.stringify('a')).once(JSON.stringify('b'));
-    const res = await Promise.all(['/', '/'].map(url => fch(url).json()));
+  it("can set `accepts` insensitively", async () => {
+    fetch.once(JSON.stringify({ secret: "12345" }), jsonHeaders);
+    const res = await fch("/", { headers: { Accepts: "text/xml" } });
 
-    expect(res).toEqual(['a', 'a']);
-    expect(fetch.mock.calls.length).toEqual(1);
+    expect(fetch.mock.calls[0][1].headers).toEqual({ accepts: "text/xml" });
   });
 
-  it('can set `accepts` insensitively', async () => {
-    fetch.once(JSON.stringify({ secret: '12345' }));
-    const res = await fch('/', { headers: { 'Accepts': 'text/xml' } }).json();
+  it("can accept network rejections", async () => {
+    fetch.mockResponseOnce(JSON.stringify("unauthorized"), {
+      status: 401,
+      ok: false,
+    });
+    await expect(fch("/")).rejects.toMatchObject({
+      message: "Unauthorized",
+    });
+  });
 
-    const [url, opts] = fetch.mock.calls[0];
-    expect(opts.headers).toEqual({ 'accepts': 'text/xml' });
+  it("throws with the wrong 'output' option", async () => {
+    fetch.once("hello");
+    await expect(fch("/", { output: "abc" })).rejects.toMatchObject({
+      message: `options.output needs to be either "body" (default) or "response", not "abc"`,
+    });
   });
 
-  it('can accept network rejections', async () => {
-    fetch.mockResponseOnce(JSON.stringify("unauthorized"), { status: 401, ok: false });
-    await expect(fch('/')).rejects.toMatchObject({
-      message: 'Unauthorized'
+  it("can accept rejections", async () => {
+    fetch.mockRejectOnce(new Error("fake error message"));
+    await expect(fch("/error")).rejects.toMatchObject({
+      message: "fake error message",
     });
   });
+});
 
-  it('can accept rejections', async () => {
-    fetch.mockRejectOnce(new Error('fake error message'));
-    await expect(fch('/')).rejects.toMatchObject({
-      message: 'fake error message'
+describe("interceptors", () => {
+  beforeEach(() => {
+    fetch.resetMocks();
+  });
+  afterEach(() => {
+    fetch.resetMocks();
+    delete fch.before;
+    delete fch.after;
+  });
+
+  it("can create a before interceptor", async () => {
+    fetch.once("hello");
+    const data = await fch("/", {
+      before: (req) => {
+        req.url = "/hello";
+        req.method = "put";
+        return req;
+      },
     });
+
+    expect(data).toEqual("hello");
+    expect(fetch.mock.calls.length).toEqual(1);
+    expect(fetch.mock.calls[0][0]).toEqual("/hello");
+    expect(fetch.mock.calls[0][1].method).toEqual("put");
+    expect(fetch.mock.calls[0][1].headers).toEqual({});
+  });
+
+  it("can create a global before interceptor", async () => {
+    fetch.once("hello");
+    fch.before = (req) => {
+      req.url = "/hello";
+      req.method = "put";
+      return req;
+    };
+    const data = await fch("/");
+
+    expect(data).toEqual("hello");
+    expect(fetch.mock.calls.length).toEqual(1);
+    expect(fetch.mock.calls[0][0]).toEqual("/hello");
+    expect(fetch.mock.calls[0][1].method).toEqual("put");
+    expect(fetch.mock.calls[0][1].headers).toEqual({});
+
+    delete fch.before;
+  });
+
+  it("can create an after interceptor", async () => {
+    fetch.once("hello", { status: 201, headers: { hello: "world" } });
+    const res = await fch("/", {
+      output: "response",
+      after: (res) => {
+        res.body = "bye";
+        res.status = 200;
+        res.headers.hello = "world";
+        return res;
+      },
+    });
+
+    expect(res.body).toEqual("bye");
+    expect(res.status).toEqual(200);
+    expect(res.statusText).toEqual("Created");
+    expect(res.headers.hello).toEqual("world");
+    expect(fetch.mock.calls.length).toEqual(1);
+    expect(fetch.mock.calls[0][0]).toEqual("/");
+    expect(fetch.mock.calls[0][1].method).toEqual("get");
+    expect(fetch.mock.calls[0][1].headers).toEqual({});
+  });
+
+  it("can create a global after interceptor", async () => {
+    fetch.once("hello", { status: 201, headers: { hello: "world" } });
+    fch.after = (res) => {
+      res.body = "bye";
+      res.status = 200;
+      res.headers.hello = "world";
+      return res;
+    };
+    const res = await fch("/", { output: "response" });
+
+    expect(res.body).toEqual("bye");
+    expect(res.status).toEqual(200);
+    expect(res.statusText).toEqual("Created");
+    expect(res.headers.hello).toEqual("world");
+    expect(fetch.mock.calls.length).toEqual(1);
+    expect(fetch.mock.calls[0][0]).toEqual("/");
+    expect(fetch.mock.calls[0][1].method).toEqual("get");
+    expect(fetch.mock.calls[0][1].headers).toEqual({});
+  });
+});
+
+describe("dedupe network calls", () => {
+  beforeEach(() => {
+    fetch.resetMocks();
+  });
+
+  it("dedupes ongoing/parallel calls", async () => {
+    fetch.once("a").once("b");
+    const res = await Promise.all([fch("/a"), fch("/a")]);
+
+    expect(res).toEqual(["a", "a"]);
+    expect(fetch.mock.calls.length).toEqual(1);
+  });
+
+  it("dedupes named calls", async () => {
+    fetch.once("a").once("b");
+    const res = await Promise.all([fch.get("/a"), fch.get("/a")]);
+
+    expect(res).toEqual(["a", "a"]);
+    expect(fetch.mock.calls.length).toEqual(1);
+  });
+
+  it("can opt out locally", async () => {
+    fetch.once("a").once("b");
+    const res = await Promise.all([fch("/a"), fch("/a", { dedupe: false })]);
+
+    expect(res).toEqual(["a", "b"]);
+    expect(fetch.mock.calls.length).toEqual(2);
+  });
+
+  it("cannot reuse an opted out call", async () => {
+    fetch.once("a").once("b");
+    const res = await Promise.all([fch("/a", { dedupe: false }), fch("/a")]);
+
+    expect(res).toEqual(["a", "b"]);
+    expect(fetch.mock.calls.length).toEqual(2);
+  });
+
+  it("will reuse the last opt-in call", async () => {
+    fetch.once("a").once("b").once("c");
+    const res = await Promise.all([
+      fch("/a"),
+      fch("/a", { dedupe: false }),
+      fch("/a"),
+    ]);
+
+    expect(res).toEqual(["a", "b", "a"]);
+    expect(fetch.mock.calls.length).toEqual(2);
+  });
+
+  it("can opt out globally", async () => {
+    fetch.once("a").once("b").once("c");
+    fch.dedupe = false;
+    const res = await Promise.all([fch("/a"), fch("/a"), fch("/a")]);
+
+    expect(res).toEqual(["a", "b", "c"]);
+    expect(fetch.mock.calls.length).toEqual(3);
+    fch.dedupe = true;
+  });
+
+  it("does NOT dedupe/cache serial requests", async () => {
+    fetch.once("a").once("b");
+    const resa = await fch("/a");
+    const resb = await fch("/a");
+
+    expect([resa, resb]).toEqual(["a", "b"]);
+    expect(fetch.mock.calls.length).toEqual(2);
+  });
+
+  it("does NOT dedupe/cache other request types", async () => {
+    fetch.once("a").once("b");
+    const res = await Promise.all([fch.get("/a"), fch.post("/a")]);
+
+    expect(res).toEqual(["a", "b"]);
+    expect(fetch.mock.calls.length).toEqual(2);
+  });
+
+  it("NOT deduping are invisible for other request", async () => {
+    fetch.once("a").once("b").once("c");
+    const res = await Promise.all([
+      fch.get("/a"),
+      fch.post("/a"),
+      fch.get("/a"),
+    ]);
+
+    expect(res).toEqual(["a", "b", "a"]);
+    expect(fetch.mock.calls.length).toEqual(2);
   });
 });

package/package.json

@@ -1,36 +1,40 @@
 {
   "name": "fch",
-  "version": "1.0.0",
-  "description": "Fetch interface with get queue, credentials, reject on http error and better promises",
-  "main": "fetch.min.js",
-  "scripts": {
-    "start": "npm run watch # Start ~= Start dev",
-    "build": "rollup fetch.js --name fch --output.format umd | uglifyjs -o fetch.min.js",
-    "test": "npm run build && jest --coverage --detectOpenHandles",
-    "watch": "nodemon --exec \"npm run build && npm test && npm run gzip\" --watch src --watch test --watch webpack.config.js --watch package.json",
-    "gzip": "gzip -c fetch.min.js | wc -c && echo 'bytes' # Only for Unix"
-  },
-  "keywords": [],
+  "version": "2.0.0",
+  "description": "Fetch interface with better promises, deduplication, defaults, etc.",
+  "homepage": "https://github.com/franciscop/fetch",
+  "repository": "https://github.com/franciscop/fetch.git",
+  "bugs": "https://github.com/franciscop/fetch/issues",
+  "funding": "https://www.paypal.me/franciscopresencia/19",
   "author": "Francisco Presencia <public@francisco.io> (https://francisco.io/)",
   "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/franciscop/fetch.git"
+  "scripts": {
+    "start": "npm run watch # Start ~= Start dev",
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js --coverage --detectOpenHandles",
+    "watch": "node --experimental-vm-modules node_modules/jest/bin/jest.js --watch --coverage --detectOpenHandles"
   },
-  "bugs": {
-    "url": "https://github.com/franciscop/fetch/issues"
+  "keywords": [
+    "fetch",
+    "axios",
+    "http",
+    "https",
+    "async",
+    "ajax"
+  ],
+  "main": "fetch.js",
+  "type": "module",
+  "engines": {
+    "node": ">=18.0.0"
   },
   "dependencies": {
-    "isomorphic-fetch": "^2.2.1",
-    "swear": "^1.0.0"
+    "swear": "^1.1.0"
   },
   "devDependencies": {
-    "babel-core": "^6.26.0",
-    "babel-jest": "^21.2.0",
-    "babel-preset-env": "^1.7.0",
-    "jest": "^23.5.0",
-    "jest-fetch-mock": "^1.6.6",
-    "rollup": "^1.1.2",
-    "uglify-es": "^3.3.9"
+    "jest": "^28.0.1",
+    "jest-fetch-mock": "^3.0.3"
+  },
+  "jest": {
+    "testEnvironment": "jest-environment-node",
+    "transform": {}
   }
 }

package/readme.md

@@ -1,81 +1,256 @@
-# Fetch [![npm install fch](https://img.shields.io/badge/npm%20install-fch-blue.svg)](https://www.npmjs.com/package/fch) [![gzip size](https://img.badgesize.io/franciscop/fetch/master/fetch.min.js.svg?compression=gzip)](https://github.com/franciscop/fetch/blob/master/fetch.min.js)
+# Fch [![npm install fch](https://img.shields.io/badge/npm%20install-fch-blue.svg)](https://www.npmjs.com/package/fch) [![gzip size](https://img.badgesize.io/franciscop/fetch/master/fetch.js.svg?compression=gzip)](https://github.com/franciscop/fetch/blob/master/fetch.js)
 
-`fetch()` greatly improved:
+A library to make API calls easier. Similar to Axios, but tiny size and simpler API:
 
 ```js
-import fch from 'fch';
-
-// Example data: { "name": "Francisco" }
-const url = 'https://api.jsonbin.io/b/5bc69ae7716f9364f8c58651';
+import api from "fch";
 
-(async () => {
-  // Using the Swear interface
-  const name = await fch(url).json().name;
-  console.log(name);  // "Francisco"
+api.baseUrl = "https://pokeapi.co/";
 
-  // Using plain-old promises
-  const data = await fch(url).then(res => res.json());
-  console.log(data.name);  // "Francisco"
-})();
+const mew = await api("/pokemon/150");
+console.log(mew);
 ```
 
+`fch` is a better `fetch()`:
 
-
-## Better `fetch()`
-
-- Isomorphic fetch() so it works the same in the server as the browser.
-- Automatic `JSON.stringify()` and `Content-Type: 'application/json'` for plain objects.
+- Automatically `JSON.stringify()` and `Content-Type: 'application/json'` for plain objects.
+- Automatically parse server response as json if it includes the headers, or text otherwise.
+- Isomorphic fetch(); it works the same way in the browser and server.
 - Await/Async Promise interface works as you know and love.
-- Better error handling. `>= 400 and <= 100` will _reject_ the promise with an error instance. Can be caught as normal with `.catch()` or `try {} catch (error) {}`.
-- Advanced [promises interface](https://github.com/franciscop/swear) so you can chain operations easily.
+- Better error handling. `>= 400 and <= 100` will _reject_ the promise with an error instance.
+- Advanced [Promise interface](https://www.npmjs.com/swear) for better scripting.
 - Import with the shorthand for tighter syntax. `import { get, post } from 'fch';`.
+- Easily define shared options straight on the root `fetch.baseUrl = "https://...";`.
+- Interceptors: `before` (the request), `after` (the response) and `error` (it fails).
+- Deduplicates parallel GET requests.
+- Configurable to return either just the body, or the full response.
+- [TODO]: cache engine with "highs" and "lows", great for scrapping
+- [TODO]: rate-limiting of requests (N-second, or N-parallel), great for scrapping
 
-
-## Getting started
+## Getting Started
 
 Install it in your project:
 
-```
+```bash
 npm install fch
 ```
 
 Then import it to be able to use it in your code:
 
 ```js
-const { get, post, ... } = require('fch');  // Old school
-import fch, { get, post, ... } from 'fch';       // New wave
+import api from 'fch';
+
+const data = await api.get('/');
 ```
 
-Alternatively, include it straight from the CDN for front-end:
 
-```html
-<script src="https://cdn.jsdelivr.net/npm/fch"></script>
-<script>
-  const { get, post, ... } = fch;
-</script>
+### Advanced promise interface
+
+This library has a couple of aces up its sleeve. First, it [has a better Promise interface](https://www.npmjs.com/swear):
+
+```js
+import api from "fch";
+
+// You can keep performing actions like it was sync
+const firstFriendName = await api.get("/friends")[0].name;
+console.log(firstFriendName);
 ```
 
+### Define shared options
 
+You can also define values straight away:
 
-## Examples
+```js
+import api from "fch";
 
-Posting some data as JSON and reading the JSON response:
+api.baseUrl = "https://pokeapi.co/";
+
+const mew = await api.get("/pokemon/150");
+console.log(mew);
+```
+
+If you prefer Axios' style of outputting the whole response, you can do:
 
 ```js
-// With this library fetch
-import { post } from 'fch';
-const data = await post('/url', { body: { a: 'b' } }).json();
-console.log(data);
+// Default, already only returns the data on a successful call
+api.output = "data";
+const name = await api.get("/users/1").name;
+
+// Axios-like
+api.output = "response";
+const name = await api.get("/users/1").data.name;
 ```
 
+### Interceptors
+
+You can also easily add the interceptors `before`, `after` and `error`:
+
 ```js
-// Native example, much longer and cumbersome:
-const res = await fetch('/url', {
-  method: 'POST',
-  body: JSON.stringify({ a: 'b' }),
-  headers: { 'content-type': 'application/json; charset=utf-8' }
+// Perform an action or request transformation before the request is sent
+fch.before = async req => {
+  // Normalized request ready to be sent
+  ...
+  return req;
+};
+
+// Perform an action or data transformation after the request is finished
+fch.after = async res => {
+  // Full response as just after the request is made
+  ...
+  return res;
+};
+
+// Perform an action or data transformation when an error is thrown
+fch.error = async err => {
+  // Need to re-throw if we want to throw on error
+  ...
+  throw err;
+
+  // OR, resolve it as if it didn't fail
+  return err.response;
+
+  // OR, resolve it with a custom value
+  return { message: 'Request failed with a code ' + err.response.status };
+};
+```
+
+
+## Dedupe
+
+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:
+
+```js
+fetch.mockOnce("a").mockOnce("b");
+const res = await Promise.all([fch("/a"), fch("/a")]);
+
+// Reuses the first response if two are launched in parallel
+expect(res).toEqual(["a", "a"]);
+```
+
+You can disable this by setting either the global `fch.dedupe` option to `false` or by passing an option per request:
+
+```js
+// Globally set it for all calls
+fch.dedupe = true;  // [DEFAULT] Dedupes GET requests
+fch.dedupe = false; // All fetch() calls trigger a network call
+
+// 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
+```
+
+> We do not support deduping other methods right now besides `GET` right now
+
+Note that opting out of deduping a request will _also_ make that request not be reusable, see this test for details:
+
+```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
+  ]);
+
+  expect(res).toEqual(["a", "b", "a"]);
+  expect(fetch.mock.calls.length).toEqual(2);
 });
-if (!res.ok) throw new Error(res.statusText);
-const data = await res.json();
-console.log(data);
+```
+
+
+## How to
+
+### Stop errors from throwing
+
+While you can handle this on a per-request basis, if you want to overwrite the global behavior you can just do:
+
+```js
+import fch from 'fch';
+fch.error = error => error.response;
+
+const res = fch('/notfound');
+expect(res.status).toBe(404);
+```
+
+Just that, then when there's an error it'll just return as usual, e.g.:
+
+```js
+import fch from 'fch';
+fch.error = error => error.response;
+
+const res = fch('/notfound');
+expect(res.status).toBe(404);
+```
+
+### Return the full response
+
+By default a successful request will just return the data. However this one is configurable on a global level:
+
+```js
+import fch from 'fch';
+fch.output = 'response';  // Valid values are 'body' (default) or 'response'
+
+const res = await fch('/hello');
+```
+
+Or on a per-request level:
+
+```js
+import fch from 'fch';
+
+// Valid values are 'body' (default) or 'response'
+const res = await fch('/hello', { output: 'response' });
+
+// Does not affect others
+const body = await fch('/hello');
+```
+
+
+### Set a base URL
+
+There's a configuration parameter for that:
+
+```js
+import fch from 'fch';
+fch.baseUrl = 'https://api.filemon.io/';
+
+// Calls "https://api.filemon.io/blabla/"
+const body = await fch.get('/blabla/');
+```
+
+
+### Set the authorization headers
+
+You can set that globally as a header:
+
+```js
+import fch from 'fch';
+fch.headers.Authorization = 'bearer abc';
+
+const me = await fch('/users/me');
+```
+
+Globally on a per-request basis, for example if you take the value from localStorage:
+
+```js
+import fch from 'fch';
+
+// All the requests will add the Authorization header when the token is
+// in localStorage
+fch.before = req => {
+  if (localStorage.get('token')) {
+    req.headers.Authorization = 'bearer ' + localStorage.get('token');
+  }
+  return req;
+};
+
+const me = await fch('/users/me');
+```
+
+Or on a per-request basis, though we wouldn't recommend this:
+
+```js
+import fch from 'fch';
+
+const me = await fch('/users/me', { headers: { Authorization: 'bearer abc' } });
 ```

package/.babelrc

@@ -1,3 +0,0 @@
-{
-  "presets": ["env"]
-}

package/fetch.min.js

@@ -1 +0,0 @@
-(function(global,factory){typeof exports==="object"&&typeof module!=="undefined"?module.exports=factory():typeof define==="function"&&define.amd?define(factory):(global=global||self,global.fch=factory())})(this,function(){"use strict";const resolve=async value=>{value=await value;if(Array.isArray(value)){return await Promise.all(value.map(resolve))}return value};const reject=message=>Promise.reject(new Error(message));const regexpCallback=cb=>cb instanceof RegExp?cb.test.bind(cb):cb;const callback=(cb,self)=>(...args)=>regexpCallback(cb).call(self,...args);const extend=(cb,self)=>async(value,i,all)=>({value:value,extra:await callback(cb,self)(value,i,all)});const extraUp=({extra:extra})=>extra;const valueUp=({value:value})=>value;const extendArray={every:async(obj,cb,self)=>{for(let i=0;i<obj.length;i++){const found=await callback(cb,self)(obj[i],i,obj);if(!found)return false}return true},filter:async(obj,cb,self)=>{const data=await resolve(obj.map(extend(cb,self)));return data.filter(extraUp).map(valueUp)},find:async(obj,cb,self)=>{for(let i=0;i<obj.length;i++){const found=await callback(cb,self)(obj[i],i,obj);if(found)return obj[i]}},findIndex:async(obj,cb,self)=>{for(let i=0;i<obj.length;i++){const found=await callback(cb,self)(obj[i],i,obj);if(found)return i}return-1},forEach:async(obj,cb,self)=>{await resolve(obj.map(extend(cb,self)));return obj},reduce:async(obj,cb,init)=>{const hasInit=typeof init!=="undefined";if(!hasInit)init=obj[0];for(let i=hasInit?0:1;i<obj.length;i++){init=await callback(cb)(init,obj[i],i,obj)}return init},reduceRight:async(obj,cb,init)=>{const hasInit=typeof init!=="undefined";if(!hasInit)init=obj[obj.length-1];for(let i=obj.length-(hasInit?1:2);i>=0;i--){init=await callback(cb)(init,obj[i],i,obj)}return init},some:async(obj,cb,self)=>{for(let i=0;i<obj.length;i++){const found=await callback(cb,self)(obj[i],i,obj);if(found)return true}return false}};const getter=(obj,extend)=>(target,key)=>{if(key==="then")return(...args)=>{return resolve(obj).then(...args)};if(key==="catch")return(...args)=>{return root(resolve(obj).catch(...args))};return func(resolve(obj).then(obj=>{if(typeof key==="symbol")return obj[key];if(key in extend){return func((...args)=>extend[key](obj,...args),extend)}if(typeof obj==="number"&&key in extend.number){return func((...args)=>extend.number[key](obj,...args),extend)}if(typeof obj==="string"&&key in extend.string){return func((...args)=>extend.string[key](obj,...args),extend)}if(Array.isArray(obj)&&key in extend.array){return func((...args)=>extend.array[key](obj,...args),extend)}if(obj[key]&&obj[key].bind){return func(obj[key].bind(obj),extend)}return func(obj[key],extend)}),extend)};const applier=(obj,extend)=>(target,self,args)=>{return func(resolve(obj).then(obj=>{if(typeof obj!=="function"){return reject(`You tried to call "${JSON.stringify(obj)}" (${typeof obj}) as a function, but it is not.`)}return obj(...args)}),extend)};const func=(obj,extend)=>new Proxy(()=>{},{get:getter(obj,extend),apply:applier(obj,extend)});const root=(obj,{number:number,string:string,array:array,...others}={})=>new Proxy({},{get:getter(obj,{number:{...number},string:{...string},array:{...extendArray,...array},...others})});if(typeof require!=="undefined"){require("isomorphic-fetch")}const ongoing=new Map;const hasPlainBody=options=>{if(options.headers["content-type"])return;if(typeof options.body!=="object")return;if(options.body instanceof FormData)return;return true};const fch=(url,options={})=>{options={method:"get",headers:{},...typeof options==="object"?options:{}};if(options.method.toLowerCase()==="get"){if(ongoing.get(url))return ongoing.get(url)}const headers=options.headers;for(let key in headers){const value=headers[key];delete headers[key];headers[key.toLowerCase()]=value}if(hasPlainBody(options)){options.body=JSON.stringify(options.body);headers["content-type"]="application/json; charset=utf-8"}ongoing.set(url,root(fetch(url,{...options,headers:headers}).then(res=>{ongoing.delete(url);if(!res.ok){const error=new Error(res.statusText);error.response=res;return Promise.reject(error)}const mem=new Map;return new Proxy(res,{get:(target,key)=>{if(["then","catch","finally"].includes(key))return res[key];return()=>{if(!mem.get(key)){mem.set(key,target[key]())}return mem.get(key)}}})})));return ongoing.get(url)};fch.head=((url,options={})=>fch(url,{...options,method:"head"}));fch.get=((url,options={})=>fch(url,{...options,method:"get"}));fch.post=((url,options={})=>fch(url,{...options,method:"post"}));fch.patch=((url,options={})=>fch(url,{...options,method:"patch"}));fch.put=((url,options={})=>fch(url,{...options,method:"put"}));fch.del=((url,options={})=>fch(url,{...options,method:"delete"}));return fch});