@contextualize/lambda-router 0.0.4 → 0.0.19

package/dist/router.js

@@ -66,8 +66,9 @@ class Router {
                 response.json({ message: exception.message });
             }
             else {
-                console.error(`Request experienced a critical error`);
-                throw exception;
+                console.error(`Request experienced a critical error: `, exception);
+                response.statusCode = 500;
+                response.json({ message: "Internal Server Error" });
             }
         }
         return response;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contextualize/lambda-router",
-  "version": "0.0.4",
+  "version": "0.0.19",
   "description": "Allows for the creation of Express-like APIs within AWS Lambda",
   "main": "dist/index.js",
   "bin": {

package/readme.md

@@ -2,8 +2,9 @@
 
 Allows for the creation of Express-like APIs within AWS Lambda.
 
-## Create Router
-
+## Routers
+Routers allow you to construct API paths for your application
+### Basic Usage
 ```js
 import { Router, Handler } from '@contextualize/lambda-router';
 
@@ -19,6 +20,78 @@ export const lambdaHandler = Handler.handler(()=>router);
 
 ```
 
+### Errors
+Lambda router has a number of built-in exceptions for common HTTP error codes. Rather than explicity sending an error response and returning from your endpoint code, you can just throw one of these exceptions.
+
+If your application throws an error that does not extend from `@contextualize/lambda-router/PublicError`, a HTTP 500 status is returned by default with 'Internal Server Error'
+
+```js
+router.post('/', (req, res)=>{
+    if(!("required" in req.body)){
+        // Ends execution
+        // Returns a HTTP 400 error to the user
+        // Error message is supplied to user in the response body as json
+        throw new BadRequestError("'required' must be in request body");
+    }
+
+    return res.status(200).json({
+        status: "ok"
+    });
+})
+
+```
+
+### Path Parameters
+Parameters can be passed in through the path using `{}`. Lambda Router will always prioritize named paths before attempting to use a parameterized path.
+```js
+router.get('/{myParam}', (req, res)=>{
+    return res.status(200).json({
+        status: "ok"
+        myParam: req.params['myParam']
+    });
+});
+
+
+router.get('/list', (req, res)=>{
+    return res.status(200).json({
+        status: "ok"
+        list: ['stuff', 'and', 'things']
+    });
+});
+```
+
+### Middleware
+Middleware allow you to run a block of code before all subsequent paths.
+
+
+```js
+import { Router, Handler } from '@contextualize/lambda-router';
+
+const router = new Router();
+
+router.get('/', (req,res)=>{
+    return res.status(200).json({
+        message: "Welcome!"
+    });
+})
+
+// Check user token
+router.use((req)=>{
+    const token = req.headers['Authorization'];
+
+    // Do some token validation
+})
+
+router.get('/protected', (req, res)=>{
+    return res.status(200).json({
+        message: "You are authenticated"
+    });
+})
+
+export const lambdaHandler = Handler.handler(()=>router);
+
+```
+
 ## Background Handler
 Some lambdas may require tasks to run in the background after a request has been handled. `Handler.backgroundHandler` allows you to defer promises for after the lambda has returned a response to the client.
 
@@ -30,7 +103,8 @@ const router = new Router();
 router.get('/', (req, res)=>{
     req.handler.background(async ()=>{
 
-        // Assume this a request that is going to take a long time
+        // Assume this is a request that is going to take a long time
+        // i.e. uploading a file, running a put query
         await fetch('https://example.com')
     })