Release v2.0.0 (#3)

* - use Object.assign instead of lodash/merge
- refactor test config

[Fixes]

* 1.0.1

* 1.0.2

* feature(release-v2): release v2.0.0

Author: adesege

.babelrc

@@ -1,5 +1,4 @@
 {
-    "presets": [
-        "env"
-    ]
+    "presets": ["env"],
+    "plugins": ["transform-es2015-destructuring", "transform-object-rest-spread"]
 }

Readme.md

@@ -10,6 +10,9 @@ Express API versioning is an express middleware that dynamically loads different
 
 It is written in Javascript ES6 syntax and it is further transpiled down to Javascript ES5 using babel.
 
+# What's new in v2
+- Version 2 introduces a new way to resolve errors using callback instead of the `try` and `catch` block.
+
 # Installation
 
 - `npm install express-api-versioning --save`
@@ -23,46 +26,49 @@ It is written in Javascript ES6 syntax and it is further transpiled down to Java
 ### Using ES5
 
 ` const expressApiVersioning = require('express-api-versioning');`
-### Basic Usage
 
    ```js
 app.use(expressApiVersioning({
-  	instance: app, // passes an instance of express to the entry point
-  	apiPath: path.join(__dirname, './api'), // absolute path to the api directory
-	test: /\/api\/(v[0-9]+).*/, // regular expression to get the version number from the url
-	entryPoint: 'app.js' // entry point exports a function which takes an instance of express as parameter.
-}));
-```
-### Advanced Usage
-
-```js
-app.use(expressApiVersioning({
-	instance: app, // passes an instance of express to the entry point
-	apiPath: path.join(__dirname, './api'), // absolute path to the api directory
-	test: /\/endpoint\/(v[0-9]+).*/, // regular expression to get the version number from the url,
-	entryPoint: 'index.js' // entry point exports a function which takes an instance of express as parameter.
-}));
+		apiPath: path.join(__dirname, './api'),// absolute path to the api directory
+		test: /\/api\/(v[0-9]+).*/, // regular expression to get the version number from the url
+		entryPoint: 'index.js', // entry point exports a function which takes an instance of express as parameter.
+		instance: app // passes an instance of express to the entry point
+}, (error, req, res, next) => {
+    // Do something here with the error
+    next(); // calls the next middleware
+  }));
 ```
-- Check the [src/example](/src/sample) directory to understand the folder structure.
 
 # Error Handling
 
-The middleware will throw an exception when;
+As of v2, the middleware returns an error object as the first parameter of the callback and has properties `code` and `message`.
+
+The middleware will throw an error when;
 1. the `apiPath` is not specified
 1. an express `instance` is not specified and not a function
 1. the api version cannot be found in the `api directory`.
 
+# Error Code
+
+| S/N | Code | Message |
+| --- | -------- | -------- |
+| 1. | 101 | You must explicitly specify a path to where the APIs reside |
+| 2. | 102 | You must explicitly set an instance of express |
+| 3. | 103 | Entry point not Found |
+| 4. | 104 | No version number found |
+| 5. | 105 | An instance of express must be a function but got type `${typeof instance}` |
+
 # Issue Reporting
 
-Please use the [issues](/issues) page to report an issue.
+Please use the [issues](https://github.com/adesege/express-api-versioning/issues) page to report an issue.
 
 # API References
 
 `Express API Versioning` is highly customizable and does not introduce complexities to your application folder structure. It takes a configuration object as parameter.
 
 | Configuration item | Default | Description |
 | ------ | ------ | ------- |
-| test | `/\/api\/(v[0-9]+)[a-z0-9/_+-]*/`| Regular expression to get the version number from the request url. It gets the version number from the first group of the regex match.
+| test | `/\/api\/(v[0-9]+).*/`| Regular expression to get the version number from the request url. It gets the version number from the first group of the regex match.
 | entryPoint | app.js | Entry point for each api version. It exports a function which takes an instance of express as parameter.
 | apiPath | empty string | Absolute path to each api version container/directory. This is usually `path.join(__dirname, './api')`.
 | instance | null | An instance of express app which will be passed down to the entry point for usage.

package-lock.json

@@ -12,15 +12,19 @@
     "url": "https://github.com/adesege/express-api-versioning.git"
   },
   "scripts": {
-    "test": "mocha --compilers js:babel-register src/test/**/**.js",
+    "test": "mocha --compilers js:babel-register src/test/**.spec.js --timeout 100000",
     "build": "rm -rf ./build && babel --watch src/ --out-dir build/",
     "prepublish": "rm -rf ./build && babel src/ --out-dir build/",
     "coveralls": "NODE_ENV=test nyc npm test && nyc report --reporter=lcov --reporter=text --reporter=lcovonly || coveralls"
   },
   "keywords": [
     "express",
     "api",
-    "versioning"
+    "versioning",
+    "express api versioning",
+    "express-api-versioning",
+    "version",
+    "expressjs"
   ],
   "author": {
     "name": "Fadojutimi Temitayo Olusegun",
@@ -39,6 +43,8 @@
   "dependencies": {
     "babel-cli": "^6.26.0",
     "babel-core": "^6.26.0",
+    "babel-plugin-transform-es2015-destructuring": "^6.23.0",
+    "babel-plugin-transform-object-rest-spread": "^6.26.0",
     "babel-preset-env": "^1.6.0",
     "chai": "^4.1.2",
     "express": "^4.15.5",

package.json

@@ -1,8 +1,7 @@
 import path from 'path';
 import fs from 'fs';
-import { Exception } from './utils/exception';
 
-export default (config) => {
+export default (config, callback) => {
   // define default configuration options
   const defaultConfig = {
     test: /\/api\/(v[0-9]+).*/,
@@ -11,30 +10,43 @@ export default (config) => {
     instance: null
   };
 
-  // merge default configuration options with user defined config options
-  const mergedConfig = Object.assign({}, defaultConfig, config);
+    // merge default configuration options with user defined config options
+  const mergedConfig = {
+    ...defaultConfig,
+    ...config
+  };
 
-  // get config options from merged configs
+    // get config options from merged configs
   const {
     test,
     entryPoint,
     apiPath,
     instance
   } = mergedConfig;
 
-  if (!apiPath) { // throw exception if the apiPath is not specified
-    throw new Exception('You must explicitly specify a path to where the APIs reside');
-  }
+  return (httpRequest, httpResponse, next) => {
+    if (!apiPath) { // throw an error if the apiPath is not specified
+      return callback({
+        code: 101,
+        message: 'You must explicitly specify a path to where the APIs reside'
+      }, httpRequest, httpResponse, next);
+    }
 
-  if (!instance) { // throw an exception if the express instance is undefined
-    throw new Exception('You must explicitly set an instance of express');
-  }
+    if (!instance) { // throw an error if the express instance is undefined
+      return callback({
+        code: 102,
+        message: 'You must explicitly set an instance of express'
+      }, httpRequest, httpResponse, next);
+    }
 
-  if (typeof instance !== 'function') { // throw an exception if the instance is not a function
-    throw new Exception(`An instance of express must be a function but got type ${typeof instance}`);
-  }
+    if (typeof instance !== 'function') { // throw an error if the instance is not a function
+      /* istanbul ignore next */
+      return callback({
+        code: 105,
+        message: `An instance of express must be a function but got type ${typeof instance}`
+      }, httpRequest, httpResponse, next);
+    }
 
-  return (httpRequest, httpResponse, next) => {
     // test if the version number/type exist in the url
     const testUrl = httpRequest.url.match(test);
     const version = testUrl ? testUrl[1] : '';
@@ -43,14 +55,23 @@ export default (config) => {
       // normalize path to the entry point
       const fullPath = path.normalize(`${apiPath}/${version}/${entryPoint}`);
       if (fs.existsSync(fullPath)) { // check if the entry point exist
+        /* istanbul ignore else */
         if (typeof require(fullPath).default === 'function') {
           require(fullPath).default(instance); // import the entry point
         } else {
           require(fullPath)(instance);
         }
-        next();
+        return callback(null, httpRequest, httpResponse, next);
       }
+      return callback({
+        code: 103,
+        message: 'Entry point not Found'
+      }, httpRequest, httpResponse, next); // we can't find the entry point, throw an error
     }
-    throw new Exception('Not Found');
+    // we can't find the version number from the url, throw an error
+    return callback({
+      code: 104,
+      message: 'No version number found'
+    }, httpRequest, httpResponse, next);
   };
 };