Removes HttpMiddleware base class

Author: emileber

docs/README.md

@@ -1,13 +1,12 @@
 # Axios HTTP middleware service
 
-Simple [axios](https://github.com/axios/axios) HTTP middleware service to simplify hooking to HTTP requests made through Axios.
+Simple [axios](https://github.com/axios/axios) HTTP middleware service to simplify hooking (and testing of hooks) to HTTP requests made through Axios.
 
 ## What's this?
 
-There are two classes exposed in this module:
+A [`HttpMiddlewareService`](api/Service.md) which manages a middleware stack and hooking itself to an axios instance.
 
-- [`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.
+Middlewares are just objects or classes composed of simple methods for different points in a request lifecycle.
 
 It works with either the global axios or a local instance.
 
@@ -17,11 +16,11 @@ Using axios interceptors makes the code tightly coupled to axios and harder to t
 
 This middleware service module:
 
-- offers more functionalities (e.g. see [`onSync`](api/HttpMiddleware?id=onsyncpromise))
+- offers more functionalities (e.g. see [`onSync`](api/methods?id=onsyncpromise))
 - looser coupling to axios
 - really easy to test middleware classes
 
-It improves readability and reusability.
+It improves readability and reusability in a centralized hooking strategy.
 
 ## Examples
 
@@ -37,26 +36,38 @@ The following example is using the [simplified syntax](simplified-syntax.md).
 import axios from 'axios';
 import { HttpMiddlewareService } from 'axios-middleware';
 
-// Create a new service instance
 const service = new HttpMiddlewareService(axios);
 
-// Then register your middleware instances.
 service.register({
     onRequest(config) {
-        // handle the request config
+        console.log('onRequest');
         return config;
     },
     onSync(promise) {
-        // handle the promsie
+		console.log('onSync');
         return promise;
     },
     onResponse(response) {
-        // handle the response
+        console.log('onResponse');
         return response;
     }
 });
 
-// We're good to go!
-export default service;
+console.log('Ready to fetch.');
+
+// Just use axios like you would normally.
+axios('https://jsonplaceholder.typicode.com/posts/1')
+  .then(({ data }) => console.log('Received:', data));
+```
+
+It should output:
+
+```
+Ready to fetch.
+onRequest
+onSync
+onResponse
+Received: {userId: 1, id: 1, title: "sunt aut facere repellat provident occaecati excepturi optio reprehenderit", body: "quia et suscipit↵suscipit recusandae consequuntur …strum rerum est autem sunt rem eveniet architecto"}
 ```
 
+[**Demo snippet**](https://jsfiddle.net/emileber/sfqo0rt1/)

docs/_sidebar.md

@@ -4,8 +4,8 @@
   - [Simplified syntax](simplified-syntax.md)
 
 - API
-  - [`HttpMiddleware`](api/HttpMiddleware.md)
-  - [`HttpMiddlewareService`](api/HttpMiddlewareService.md)
+  - [Middleware methods](api/methods.md)
+  - [`Service` class](api/Service.md)
 
 - Examples
   - [Locale middleware](examples/locale-middleware.md)

docs/api/HttpMiddlewareService.md renamed to docs/api/Service.md

@@ -1,6 +1,6 @@
-# HttpMiddlewareService
+# Middleware `Service` class
 
-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.
+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 lifecycle.
 
 ## `constructor(axios)`
 
@@ -26,7 +26,7 @@ Returns `true` if the passed `middleware` instance is within the stack.
 
 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)).
+You can pass a class 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 stack.
 

docs/api/HttpMiddleware.md renamed to docs/api/methods.md

@@ -1,12 +1,8 @@
-# HttpMiddleware
+# The middleware methods
 
-?> This class is optional if you opt to use the [simplified syntax](simplified-syntax.md).
+These will be called at different step of a request lifecycle. Each method can return a promise which will be resolved or reject before continuing through the middleware stack.
 
-The base implementation to inherit when creating your custom implementation. **Any function is optional** and should be provided within a custom middleware only if needed.
-
-## `constructor`
-
-The constructor isn't used in the default middleware, leaving it totally available to the child classes. Very useful to pass any relevant services your middleware might need, like [the `i18n` service in our example](examples/locale-middleware.md).
+?> **Any function is optional** and should be provided within a custom middleware only if needed.
 
 ## `onRequest(config)`
 
@@ -36,7 +32,7 @@ onResponse(response) {
 }
 ```
 
-!> The original `response` object, _a new one_, or a promise should be returned.
+!> The original `response` object, or _a new/modified one_, or a promise should be returned.
 
 ## `onResponseError(error)`
 

docs/examples/browser.md

@@ -39,20 +39,18 @@ var app = app || {};
 /**
 * Custom Middleware class
 */
-app.MyMiddleware = (function(HttpMiddleware){
+app.MyMiddleware = (function(){
     function MyMiddleware() {
-        // call the parent constructor
-        HttpMiddleware.apply(this, arguments);
     }
 
-    var proto = MyMiddleware.prototype = Object.create(HttpMiddleware.prototype);
+    var proto = MyMiddleware.prototype = Object.create();
 
     proto.constructor = MyMiddleware;
     proto.onRequest = function(config) {
       // handle the request
     };
     return MyMiddleware;
-})(AxiosMiddleware.HttpMiddleware);
+})();
 ```
 
 Then register these middlewares with a newly created `HttpMiddlewareService` instance.
@@ -64,15 +62,15 @@ var app = app || {};
 /**
 * Middleware Service
 */
-app.MiddlewareService = (function(HttpMiddlewareService, MyMiddleware) {
+app.MiddlewareService = (function(MiddlewareService, MyMiddleware) {
     // Create a new service instance
-    var service = new HttpMiddlewareService(axios);
+    var service = new MiddlewareService(axios);
 
     // Then register your middleware instances.
     service.register(new MyMiddleware());
 
     return service;
-})(AxiosMiddleware.HttpMiddlewareService, app.MyMiddleware);
+})(AxiosMiddleware.Service, app.MyMiddleware);
 ```
 
 In this case, the order in which to import the JS files is important.

docs/examples/es5.md

@@ -1,19 +1,19 @@
 # Usage with ES5 in Node
 
-ES5 doesn't have [classes](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes) so you can't use the easy extend syntax sugar. Creating a new middleware from the base `HttpMiddleware` class can still be done with a typical prototype based inheritance pattern.
+ES5 doesn't have [classes](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes) so you can't use the easy extend syntax sugar. Creating a new middleware from a base middleware class can still be done with a typical prototype based inheritance pattern.
 
 Create a custom middleware to register.
 
 ```javascript
-var HttpMiddleware = require('axios-middleware').HttpMiddleware;
+var BaseMiddleware = require('./base-middleware');
 
 function MyMiddleware() {
     // call the parent constructor
-    HttpMiddleware.apply(this, arguments);
+    BaseMiddleware.apply(this, arguments);
 }
 
 // Prototype wiring
-var proto = MyMiddleware.prototype = Object.create(HttpMiddleware.prototype);
+var proto = MyMiddleware.prototype = Object.create(BaseMiddleware.prototype);
 proto.constructor = MyMiddleware;
 
 // Method overriding
@@ -28,11 +28,11 @@ Then export the service.
 
 ```javascript
 var axios = require('axios'),
-    HttpMiddlewareService = require('axios-middleware').HttpMiddlewareService,
+    Service = require('axios-middleware').Service,
     MyMiddleware = require('./MyMiddleware');
 
 // Create a new service instance
-var service = new HttpMiddlewareService(axios);
+var service = new Service(axios);
 
 // Then register your middleware instances.
 service.register(new MyMiddleware());

docs/examples/locale-middleware.md

@@ -3,11 +3,8 @@
 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 {
+export default class LocaleMiddleware {
     constructor(i18n) {
-        super();
         this.i18n = i18n;
     }
 

docs/examples/promise.md

@@ -3,11 +3,8 @@
 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 {
+export default class AuthMiddleware {
     constructor(auth, http) {
-        super();
         this.auth = auth;
         this.http = http;
     }

docs/examples/service.md

@@ -2,12 +2,12 @@
 
 ```javascript
 import axios from 'axios';
-import { HttpMiddlewareService } from 'axios-middleware';
+import { Service } from 'axios-middleware';
 import i18n from './i18n';
 import { LocaleMiddleware, OtherMiddleware } from './middlewares';
 
 // Create a new service instance
-const service = new HttpMiddlewareService(axios);
+const service = new Service(axios);
 
 // Then register your middleware instances.
 service.register([

docs/simplified-syntax.md

@@ -1,6 +1,6 @@
 # Simplified syntax for middlewares
 
-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.
+Instead of creating a class, you can use a simple object literal only implementing the [methods](api/methods.md) you need.
 
 ```javascript
 service.register({