feat: HttpException and his inherited exception accept an origin parameters

docs/getting-started.md

@@ -8,39 +8,57 @@ You can get the latest release using npm:
 $ npm install --save ts-httpexceptions
 ```
 
-> **Important!** Ts.ED requires Node >= 6, Express >= 4 and TypeScript >= 2.0. 
+> **Important!** Ts.ED requires Node >= 8 and TypeScript >= 2.0. 
 
 
 ## Example
 
 ```typescript
-   import {BadRequest, Exception} from 'ts-httpexceptions';
-   let express = require('express');
-   let app = express();
-
-   app.get('/my/route', (req, res) => {
+import {BadRequest, Exception, NotFound} from 'ts-httpexceptions';
+const express = require('express'); // Koa works also
+const app = express();
+
+app.get('/my/route/:id', async (req, res, next) => {
+ if (req.params.id === undefined) {
+   const error = new BadRequest("ID is required")
 
-        throw new BadRequest('Custom Message'); //Emit
-        // OR
-        // throw new Exception(510, 'Custom Message');
+   // Additionally
+   error.headers = {
+     'x-header': 'value'
+   }
+   error.errors = [{'message': "ID is required"}]
+   error.body = [{'message': "ID is required"}]
 
-   });
+   next(error);
+ }
+
+ try {
+   const user = await getUser(res.params.id)
+   res.json(user);
+ } catch(origin) {
+   next(new NotFound('User not found',  origin))
+ }
+});
+
+
+//GlobalHandler middleware catch exception and send response to the client
+app.use((err, request, response, next) => {
+ if(err instanceof Exception) {
+   if (err.errors) { // If errors is provided
+     response.set({'x-errors': JSON.stringify(err.errors)})
+   }
 
-   app.get('/my/route/params', (req, res) => {
-
-      if (req.params.id === undefined){
-        throw new BadRequest();
-      }
-
-   });
+   if (err.headers) {
+     response.set(err.headers)
+   }
 
+   if (err.body) { // If a body is provided
+     return response.status(err.status).json(err.body)
+   }
 
-   //GlobalHandler middleware catch exception and send response to the client
-   app.use((err, request, response) => {
-
-        if(err instanceof Exception){
-            response.status(err.status).send(err.message);
-        }
-
-   });
+   return response.status(err.status).send(err.message);
+ }
+
+ next()
+});
 ```

readme.md

@@ -83,35 +83,53 @@ $ npm install ts-httpexceptions
 ## API
 
 ```typescript
-   import {BadRequest, Exception} from 'ts-httpexceptions';
-   let express = require('express');
-   let app = express();
-
-   app.get('/my/route', (req, res) => {
+import {BadRequest, Exception, NotFound} from 'ts-httpexceptions';
+const express = require('express');
+const app = express();
+
+app.get('/my/route/:id', async (req, res, next) => {
+ if (req.params.id === undefined) {
+   const error = new BadRequest("ID is required")
 
-        throw new BadRequest('Custom Message'); //Emit
-        // OR
-        // throw new Exception(510, 'Custom Message');
+   // Additionally
+   error.headers = {
+     'x-header': 'value'
+   }
+   error.errors = [{'message': "ID is required"}]
+   error.body = [{'message': "ID is required"}]
 
-   });
+   next(error);
+ }
+
+ try {
+   const user = await getUser(res.params.id)
+   res.json(user);
+ } catch(origin) {
+   next(new NotFound('User not found',  origin))
+ }
+});
+
+
+//GlobalHandler middleware catch exception and send response to the client
+app.use((err, request, response, next) => {
+ if(err instanceof Exception) {
+   if (err.errors) { // If errors is provided
+     response.set({'x-errors': JSON.stringify(err.errors)})
+   }
 
-   app.get('/my/route/params', (req, res) => {
-
-      if (req.params.id === undefined){
-        throw new BadRequest();
-      }
-
-   });
+   if (err.headers) {
+     response.set(err.headers)
+   }
 
+   if (err.body) { // If a body is provided
+     return response.status(err.status).json(err.body)
+   }
 
-   //GlobalHandler middleware catch exception and send response to the client
-   app.use((err, request, response) => {
-
-        if(err instanceof Exception){
-            response.status(err.status).send(err.message);
-        }
-
-   });
+   return response.status(err.status).send(err.message);
+ }
+
+ next()
+});
 ```
 
 

src/clientErrors/BadMapping.ts

@@ -1,16 +1,10 @@
 import {Exception} from "../core/Exception";
 
-/**
- *
- */
 export class BadMapping extends Exception {
+  static readonly STATUS = 421;
   name: string = "BAD_MAPPING";
 
-  /**
-   *
-   * @param message
-   */
-  constructor(message: string) {
-    super(421, message);
+  constructor(message: string, origin?: Error | string | any) {
+    super(BadMapping.STATUS, message, origin);
   }
 }

src/clientErrors/BadRequest.ts

@@ -1,9 +1,10 @@
 import {Exception} from "../core/Exception";
 
 export class BadRequest extends Exception {
+  static readonly STATUS = 400;
   name: string = "BAD_REQUEST";
 
-  constructor(message: string) {
-    super(400, message);
+  constructor(message: string, origin?: Error | string | any) {
+    super(BadRequest.STATUS, message, origin);
   }
 }

src/clientErrors/Conflict.ts

@@ -1,9 +1,10 @@
 import {Exception} from "../core/Exception";
 
 export class Conflict extends Exception {
+  static readonly STATUS = 409;
   name: string = "CONFLICT";
 
-  constructor(message: string) {
-    super(409, message);
+  constructor(message: string, origin?: Error | string | any) {
+    super(Conflict.STATUS, message, origin);
   }
 }

src/clientErrors/ExpectationFailed.ts

@@ -1,9 +1,10 @@
 import {Exception} from "../core/Exception";
 
 export class ExpectationFailed extends Exception {
+  static readonly STATUS = 417;
   name: string = "EXPECTATION_FAILED";
 
-  constructor(message: string) {
-    super(417, message);
+  constructor(message: string, origin?: Error | string | any) {
+    super(ExpectationFailed.STATUS, message, origin);
   }
 }

src/clientErrors/Forbidden.ts

@@ -1,9 +1,10 @@
 import {Exception} from "../core/Exception";
 
 export class Forbidden extends Exception {
+  static readonly STATUS = 403;
   name: string = "FORBIDDEN";
 
-  constructor(message: string) {
-    super(403, message);
+  constructor(message: string, origin?: Error | string | any) {
+    super(Forbidden.STATUS, message, origin);
   }
 }

src/clientErrors/Gone.ts

@@ -1,9 +1,10 @@
 import {Exception} from "../core/Exception";
 
 export class Gone extends Exception {
+  static readonly STATUS = 410;
   name: string = "GONE";
 
-  constructor(message: string) {
-    super(410, message);
+  constructor(message: string, origin?: Error | string | any) {
+    super(Gone.STATUS, message, origin);
   }
 }

src/clientErrors/ImATeapot.ts

@@ -1,9 +1,10 @@
 import {Exception} from "../core/Exception";
 
 export class ImATeapot extends Exception {
+  static readonly STATUS = 418;
   name: string = "IM_A_TEAPOT";
 
-  constructor(message: string) {
-    super(418, message);
+  constructor(message: string, origin?: Error | string | any) {
+    super(ImATeapot.STATUS, message, origin);
   }
 }

src/clientErrors/LengthRequired.ts

@@ -1,9 +1,10 @@
 import {Exception} from "../core/Exception";
 
 export class LengthRequired extends Exception {
+  static readonly STATUS = 411;
   name: string = "LENGTH_REQUIRED";
 
-  constructor(message: string) {
-    super(411, message);
+  constructor(message: string, origin?: Error | string | any) {
+    super(LengthRequired.STATUS, message, origin);
   }
 }

src/clientErrors/MethodNotAllowed.ts

@@ -1,9 +1,10 @@
 import {Exception} from "../core/Exception";
 
 export class MethodNotAllowed extends Exception {
+  static readonly STATUS = 405;
   name: string = "METHOD_NOT_ALLOWED";
 
-  constructor(message: string) {
-    super(405, message);
+  constructor(message: string, origin?: Error | string | any) {
+    super(MethodNotAllowed.STATUS, message, origin);
   }
 }

src/clientErrors/MisdirectedRequest.ts

@@ -1,9 +1,10 @@
 import {Exception} from "../core/Exception";
 
 export class MisdirectedRequest extends Exception {
+  static readonly STATUS = 421;
   name: string = "MISDIRECTED_REQUEST";
 
-  constructor(message: string) {
-    super(421, message);
+  constructor(message: string, origin?: Error | string | any) {
+    super(MisdirectedRequest.STATUS, message, origin);
   }
 }

src/clientErrors/NotAcceptable.ts

@@ -1,9 +1,10 @@
 import {Exception} from "../core/Exception";
 
 export class NotAcceptable extends Exception {
+  static readonly STATUS = 406;
   name: string = "NOT_ACCEPTABLE";
 
-  constructor(message: string) {
-    super(406, "You must accept content-type " + message);
+  constructor(message: string, origin: Error | string | any = "You must accept content-type " + message) {
+    super(NotAcceptable.STATUS, origin);
   }
 }

src/clientErrors/NotFound.ts

@@ -1,9 +1,10 @@
 import {Exception} from "../core/Exception";
 
 export class NotFound extends Exception {
+  static readonly STATUS = 404;
   name: string = "NOT_FOUND";
 
-  constructor(message: string) {
-    super(404, message);
+  constructor(message: string, origin?: Error | string | any) {
+    super(NotFound.STATUS, message, origin);
   }
 }

src/clientErrors/PaymentRequired.ts

@@ -1,9 +1,10 @@
 import {Exception} from "../core/Exception";
 
 export class PaymentRequired extends Exception {
+  static readonly STATUS = 402;
   name: string = "PAYMENT_REQUIRED";
 
-  constructor(message: string) {
-    super(402, message);
+  constructor(message: string, origin?: Error | string | any) {
+    super(PaymentRequired.STATUS, message, origin);
   }
 }

src/clientErrors/PreconditionFailed.ts

@@ -1,9 +1,10 @@
 import {Exception} from "../core/Exception";
 
 export class PreconditionFailed extends Exception {
+  static readonly STATUS = 412;
   name: string = "PRECONDITION_FAILED";
 
-  constructor(message: string) {
-    super(412, message);
+  constructor(message: string, origin?: Error | string | any) {
+    super(PreconditionFailed.STATUS, message, origin);
   }
 }

src/clientErrors/PreconditionRequired.ts

@@ -1,9 +1,10 @@
 import {Exception} from "../core/Exception";
 
 export class PreconditionRequired extends Exception {
+  static readonly STATUS = 428;
   name: string = "PRECONDITION_REQUIRED";
 
-  constructor(message: string) {
-    super(428, message);
+  constructor(message: string, origin?: Error | string | any) {
+    super(PreconditionRequired.STATUS, message, origin);
   }
 }

src/clientErrors/ProxyAuthentificationRequired.ts

@@ -1,9 +1,10 @@
 import {Exception} from "../core/Exception";
 
 export class ProxyAuthentificationRequired extends Exception {
+  static readonly STATUS = 407;
   name: string = "PROXY_AUTHENTIFICATION_REQUIRED";
 
-  constructor(message: string) {
-    super(407, message);
+  constructor(message: string, origin?: Error | string | any) {
+    super(ProxyAuthentificationRequired.STATUS, message, origin);
   }
 }

src/clientErrors/RequestEntityTooLarge.ts

@@ -1,9 +1,10 @@
 import {Exception} from "../core/Exception";
 
 export class RequestEntityTooLarge extends Exception {
+  static readonly STATUS = 413;
   name: string = "REQUEST_ENTITY_TOO_LARGE";
 
-  constructor(message: string) {
-    super(413, message);
+  constructor(message: string, origin?: Error | string | any) {
+    super(RequestEntityTooLarge.STATUS, message, origin);
   }
 }