feat(fetch): alias fetch response method to type

Author: TimeRaider

README.md

@@ -62,10 +62,12 @@ Query-like object.
 
 `fetch` [options](https://developer.mozilla.org/en-US/docs/Web/API/GlobalFetch/fetch#Parameters).
 
-##### method {string} *Optional*
+##### type {string} *Optional*
 **Default:** `'json'`
 
-Method to be called on `fetch`'s response.
+**Alias:** `method`
+
+Type of reponse data / method to be called on `fetch`'s response (ex: `'json'`, `'text'`, `'blob'`) 
 
 ##### headers {Object|Headers}
 
@@ -187,6 +189,7 @@ const resources = {
     methods: {
       get: ({ id }) => ({ path: id }),
       delete: ({ id }) => ({ path: id, options: { method: 'DELETE' } }),
+      getAsText: ({ id }) => ({ path: id, type: 'text' }),
     }
   }
 }

src/applyMiddleware.js

@@ -1,4 +1,11 @@
-export default function applyMiddleware(applyTo, middlewares = [], options = {}, params = {}, resourceId = '', method = '') {
+export default function applyMiddleware(
+    applyTo,
+    middlewares = [],
+    options = {},
+    params = {},
+    resourceId = '',
+    type = ''
+) {
 
     middlewares = [].concat(middlewares).filter(func => typeof func === 'function');
 
@@ -10,10 +17,10 @@ export default function applyMiddleware(applyTo, middlewares = [], options = {},
 
         const next = index === middlewares.length - 1
             ? prev.bind(null, params)
-            : prev.bind(null, options, params, resourceId, method);
+            : prev.bind(null, options, params, resourceId, type);
 
         return index === 0
-            ? middleware(next)(options, params, resourceId, method)
+            ? middleware(next)(options, params, resourceId, type)
             : middleware(next);
     }, applyTo);
 

src/callAPIMethod.js

@@ -20,7 +20,15 @@ export default function callAPI(
     methodOptions = {}
 ) {
 
-    const { path=[], query={}, options={}, method='json', headers, body } = methodOptions;
+    const {
+        path=[],
+        query={},
+        options={},
+        type,
+        method='json',
+        headers,
+        body
+    } = methodOptions;
 
     const url = formatURL(APINamespace, namespace, path, query);
 
@@ -33,7 +41,7 @@ export default function callAPI(
     if (body) accumulatedFetchOptions.body = body;
 
     return fetch(url, accumulatedFetchOptions)
-        .then( response => response[method]()
+        .then( response => response[type || method]()
                 .catch( () => {
                     if (!response.ok) throw new APIError(response.status, response.statusText);
 

test/callAPIMethod.spec.js

@@ -105,7 +105,7 @@ test.serial('fetch options', async t => {
         },
         method: 'text'
     };
-    const spyResponse200 = sinon.spy(Response200, 'text');
+    const spyResponse200Text = sinon.spy(Response200, 'text');
 
     fetchMock.post(matcher, {});
 
@@ -118,15 +118,18 @@ test.serial('fetch options', async t => {
         method: 'POST',
         mode: 'cors'
     }, 'correct options');
-    t.true(spyResponse200.calledOnce);
+    t.true(spyResponse200Text.calledOnce);
 
     const newMethodOptions = {
         ...methodOptions,
+        type: 'json',
         headers: new Headers(),
         body: 'body'
     };
+    const spyResponse200Json = sinon.spy(Response200, 'json');
     await callAPIMethod(APINamespace, fetchOptions, namespace, newMethodOptions);
 
+    t.true(spyResponse200Json.calledOnce);
     t.deepEqual(fetchMock.lastOptions(matcher), {
         cache: 'default',
         credentials: 'omit',
@@ -136,7 +139,8 @@ test.serial('fetch options', async t => {
         body: newMethodOptions.body
     }, 'correct options');
 
-    spyResponse200.restore();
+    spyResponse200Text.restore();
+    spyResponse200Json.restore();
     fetchMock.restore();
 });
 

test/error.spec.js

@@ -2,19 +2,25 @@ import test from 'ava';
 import APIError from '../src/error';
 
 test.beforeEach(t => {
-    t.context.error = new APIError(404, 'Not Found');
+    t.context.error = new APIError(404, 'Not Found', { body: 'body'});
     t.context.errorNoMessage = new APIError(404);
 });
 
 test('instance of Error', t => {
-    t.true(t.context.error instanceof Error)
+    t.true(t.context.error instanceof Error);
 });
 
 test('instance of APIError', t => {
-    t.true(t.context.error instanceof APIError)
+    t.true(t.context.error instanceof APIError);
 });
 
 test('to string', t => {
     t.is(t.context.error.toString(), '404 - Not Found', 'has message');
     t.is(t.context.errorNoMessage.toString(), '404', 'No message');
+});
+
+test('has correct attributes', t => {
+    t.is(t.context.error.code, 404);
+    t.is(t.context.error.message, 'Not Found');
+    t.deepEqual(t.context.error.body, { body: 'body'});
 });

test/shortcuts.spec.js

@@ -15,63 +15,63 @@ const dummy = {
     path: ['path', 'to', 'resource'],
     query: { param: 'value' },
     options: { credentials: 'include' },
-    method: 'text'
+    type: 'text'
 };
 
 test('should set correct HTTP method', t => {
     t.deepEqual(GET(dummy), {
         path: ['path', 'to', 'resource'],
         query: { param: 'value' },
         options: { credentials: 'include', method: 'GET' },
-        method: 'text'
+        type: 'text'
     }, 'GET');
     t.deepEqual(HEAD(dummy), {
         path: ['path', 'to', 'resource'],
         query: { param: 'value' },
         options: { credentials: 'include', method: 'HEAD' },
-        method: 'text'
+        type: 'text'
     }, 'HEAD');
     t.deepEqual(POST(dummy), {
         path: ['path', 'to', 'resource'],
         query: { param: 'value' },
         options: { credentials: 'include', method: 'POST' },
-        method: 'text'
+        type: 'text'
     }, 'POST');
     t.deepEqual(PUT(dummy), {
         path: ['path', 'to', 'resource'],
         query: { param: 'value' },
         options: { credentials: 'include', method: 'PUT' },
-        method: 'text'
+        type: 'text'
     }, 'PUT');
     t.deepEqual(DELETE(dummy), {
         path: ['path', 'to', 'resource'],
         query: { param: 'value' },
         options: { credentials: 'include', method: 'DELETE' },
-        method: 'text'
+        type: 'text'
     }, 'DELETE');
     t.deepEqual(CONNECT(dummy), {
         path: ['path', 'to', 'resource'],
         query: { param: 'value' },
         options: { credentials: 'include', method: 'CONNECT' },
-        method: 'text'
+        type: 'text'
     }, 'CONNECT');
     t.deepEqual(OPTIONS(dummy), {
         path: ['path', 'to', 'resource'],
         query: { param: 'value' },
         options: { credentials: 'include', method: 'OPTIONS' },
-        method: 'text'
+        type: 'text'
     }, 'OPTIONS');
     t.deepEqual(TRACE(dummy), {
         path: ['path', 'to', 'resource'],
         query: { param: 'value' },
         options: { credentials: 'include', method: 'TRACE' },
-        method: 'text'
+        type: 'text'
     }, 'TRACE');
     t.deepEqual(PATCH(dummy), {
         path: ['path', 'to', 'resource'],
         query: { param: 'value' },
         options: { credentials: 'include', method: 'PATCH' },
-        method: 'text'
+        type: 'text'
     }, 'PATCH');
 });