Adds a custom adapter (#5)

Fixes #1 and #2 

- Adds `onSync` which receives the current request promise.
- Removes the use of interceptor in favor of a custom (but similar) implementation of the interceptors in our new adaptor.

It's now possible to return a promise in any of the middleware handler functions.

Author: emileber

.eslintrc.js

@@ -2,11 +2,6 @@
 
 module.exports = {
     root: true,
-
-    parserOptions: {
-        parser: 'babel-eslint',
-        sourceType: 'module',
-    },
     env: {
         browser: true,
     },

.travis.yml

@@ -3,5 +3,12 @@ node_js:
   - node
 notifications:
   email: false
+before_install:
+  - npm i -g [email protected]
+install:
+  - npm ci
 before_script:
   - npm run build:dev
+cache:
+  directories:
+    - "$HOME/.npm"

README.md

@@ -16,49 +16,33 @@ npm install --save axios-middleware
 
 ## How to use
 
-### Create your middleware
-
-Here's a simple example of a locale middleware who sets a language header on each AJAX request.
-
-```javascript
-import { HttpMiddleware } from 'axios-middleware';
-
-export default class LocaleMiddleware extends HttpMiddleware {
-    constructor(i18n) {
-        super();
-        this.i18n = i18n;
-    }
-    
-    onRequest(config) {
-        config.headers = {
-            locale: this.i18n.lang,
-            ...config.headers
-        };
-        return config;
-    }
-}
-```
-
-### Use the middleware service
-
-Simplest use-case:
+A simple example using the [simplified middleware syntax](https://emileber.github.io/axios-middleware/#/simplified-syntax).
 
 ```javascript
 import axios from 'axios';
 import { HttpMiddlewareService } from 'axios-middleware';
-import i18n from './i18n';
-import { LocaleMiddleware, OtherMiddleware } from './middlewares';
 
 // Create a new service instance
 const service = new HttpMiddlewareService(axios);
 
 // Then register your middleware instances.
-service.register([
-    new LocaleMiddleware(i18n),
-    new OtherMiddleware()
-]);
+service.register({
+    onRequest(config) {
+        // handle the request config
+        return config;
+    },
+    onSync(promise) {
+        // handle the promsie
+        return promise;
+    },
+    onResponse(response) {
+        // handle the response
+        return response;
+    }
+});
 
 // We're good to go!
+export default { service };
 ```
 
 A common use-case would be to expose an instance of the service which consumes an _axios_ instance configured for an API. It's then possible to register middlewares for this API at different stages of the initialization process of an application.

build/configs.js

@@ -7,7 +7,7 @@ const version = process.env.VERSION || pkg.version;
 const name = 'axios-middleware';
 const banner =
     `/**
- * axios-middleware v${version}
+ * ${name} v${version}
  * (c) ${new Date().getFullYear()} Émile Bergeron
  * @license MIT
  */`;

docs/README.md

@@ -6,8 +6,8 @@ Simple [axios](https://github.com/axios/axios) HTTP middleware service to simpli
 
 There are two classes exposed in this module:
 
-- `HttpMiddleware`: the base class to extend from when creating your own middleware.
-- `HttpMiddlewareService` which manages the middleware stack and the hooking into the passed axios.
+- [`HttpMiddleware`](api/HttpMiddleware.md): the base class to extend from when creating your own middleware.
+- [`HttpMiddlewareService`](api/HttpMiddlewareService.md) which manages the middleware stack and the hooking into the passed axios.
 
 It works with either the global axios or a local instance.
 
@@ -30,11 +30,17 @@ const service = new HttpMiddlewareService(axios);
 
 // Then register your middleware instances.
 service.register({
-    onRequest() {
-        // handle the request
+    onRequest(config) {
+        // handle the request config
+        return config;
     },
-    onResponseError(error) {
-        // handle the response error
+    onSync(promise) {
+        // handle the promsie
+        return promise;
+    },
+    onResponse(response) {
+        // handle the response
+        return response;
     }
 });
 

docs/_sidebar.md

@@ -10,6 +10,7 @@
 - Examples
   - [Locale middleware](examples/locale-middleware.md)
   - [Service module](examples/service.md)
+  - [Returning promises](examples/promise.md)
   - [ES5 usage](examples/es5.md)
   - [Browser usage](examples/browser.md)
 

docs/api/HttpMiddleware.md

@@ -12,12 +12,20 @@ The constructor isn't used in the default middleware, leaving it totally availab
 
 Receives the configuration objects before the request is made. Useful to add headers, query parameters, validate data, etc.
 
-!> It must return the received `config` even if no changes were made to it.
+!> It must return the received `config` even if no changes were made to it. It can also return a promise that should resolve with the config to use for the request.
 
 ## `onRequestError(error)`
 
 No internet connection right now? You might end up in this function. Do what you need with the error.
 
+You can return a promise, or throw another error to keep the middleware chain going.
+
+## `onSync(promise)`
+
+The request is being made and its promise is being passed. Do what you want with it but be sure to **return a promise**, be it the one just received or a new one.
+
+?> Useful to implement a sort of loading indication based on all the unresolved requests being made.
+
 ## `onResponse(response)`
 
 Parsing the response can be done here. Say all responses from your API are returned nested within a `_data` property?
@@ -28,8 +36,10 @@ onResponse(response) {
 }
 ```
 
-!> The original `response` object or _a new one_ should be returned.
+!> The original `response` object, _a new one_, or a promise should be returned.
 
 ## `onResponseError(error)`
 
 Not authenticated? Server problems? You might end up here. Do what you need with the error.
+
+?> You can return a promise, which is useful when you want to retry failed requests.

docs/api/HttpMiddlewareService.md

@@ -1,6 +1,6 @@
 # HttpMiddlewareService
 
-This is the heart of this plugin module. It works by leveraging axios interceptors to call its middleware queue.
+This is the heart of this plugin module. It works by leveraging axios' adapter to call its middleware stack at each relevant steps of a request.
 
 ## `constructor(axios)`
 
@@ -16,22 +16,29 @@ Sets or replaces the axios instance on which to intercept the requests and respo
 
 Removes the registered interceptors on the axios instance, if any were set.
 
+!> Be aware that changing the default adapter after the middleware service was initialized, then calling `unsetHttp` or `setHttp` will set the default adapter back in the axios instance. Any adapter used after could be lost.
+
 ## `has(middleware)`
 
-Returns `true` is the passed `middleware` instance is within the queue.
+Returns `true` if the passed `middleware` instance is within the stack.
 
 ## `register(middlewares)`
 
-Adds a middleware instance or an array of middlewares to the queue.
+Adds a middleware instance or an array of middlewares to the stack.
 
 You can pass an `HttpMiddleware` instance or a simple object implementing only the functions you need (see the [simplified syntax](simplified-syntax.md)).
 
-!> Throws an error if a middleware instance is already within the queue.
+!> Throws an error if a middleware instance is already within the stack.
 
 ## `unregister(middleware)`
 
-Removes a middleware instance from the queue.
+Removes a middleware instance from the stack.
 
 ## `reset()`
 
-Empty the middleware queue.
+Empty the middleware stack.
+
+## `adapter(config)`
+
+The adapter function that replaces the default axios adapter. It calls the default implementation and passes the resulting promise to the middleware stack's `onSync` method.
+

docs/examples/promise.md

@@ -0,0 +1,33 @@
+# Returning promises
+
+In a case where we'd like to retry a request if not authenticated, we could return a promise in the `onResponseError` method.
+
+```javascript
+import { HttpMiddleware } from 'axios-middleware';
+
+export default class AuthMiddleware extends HttpMiddleware {
+    constructor(auth, http) {
+        super();
+        this.auth = auth;
+        this.http = http;
+    }
+    
+    onResponseError(err) {
+        if (err.response.status === 401 && err.config && !err.config.hasRetriedRequest) {
+            return this.auth()
+            .then(function (token) {
+                err.config.hasRetriedRequest = true;
+                err.config.headers.Authorization = `Bearer ${token}`;
+                
+                // Retrying the request now that we're authenticated.
+                return this.http(err.config);
+            })
+            .catch(function (error) {
+                console.log('Refresh login error: ', error);
+                throw error;
+            });
+        }
+        throw err;
+    }
+}
+```

docs/simplified-syntax.md

@@ -1,6 +1,6 @@
 # Simplified syntax for middlewares
 
-Instead of creating a base class from the [`HttpMiddleware`](api/HttpMiddleware.md) base class, you can use a simple object literal only implementing the functions you need.
+Instead of creating a class from the [`HttpMiddleware`](api/HttpMiddleware.md) base class, you can use a simple object literal only implementing the functions you need.
 
 ```javascript
 service.register({