Handle errors properly

Author: sebastienfilion

README.md

@@ -1,6 +1,6 @@
 # Functional HTTP server
 
-Common Functional Programming Algebraic data types for JavaScript that is compatible with most modern browsers and Deno.
+A simple HTTP server inspired by Express and in tune with Functional Programming principles in JavaScript for Deno.  
 
 [![deno land](http://img.shields.io/badge/available%20on-deno.land/x-lightgrey.svg?logo=deno&labelColor=black)](https://github.com/sebastienfilion/[email protected])
 [![deno version](https://img.shields.io/badge/deno-^1.4.6-lightgrey?logo=deno)](https://github.com/denoland/deno)
@@ -75,7 +75,7 @@ startHTTPServer(
   { port: 8080 },
   route(
     handlers.get('/', _ => Task.of(Response.OK({ 'content-type': 'text/plain' }, encodeText("Hello, Hoge!"))))
-  );
+  )
 );
 ```
 
@@ -93,7 +93,7 @@ import { explodeRequest } from "https://deno.land/x/[email protected].
 startHTTPServer(
   { port: 8080 },
   route(
-    handlers.get('/users', explodeRequest(({ filters }) => retrieveUsers(filters))),
+    handlers.get('/users', explodeRequest(({ status }) => retrieveUsers({ filters: { status } }))),
     handlers.post(/\/users\/(?<userID>.+)$/, explodeRequest(({ userID }, { data: user }) => updateUser(userID, user)))
   )
 );
@@ -102,7 +102,7 @@ startHTTPServer(
 For this sample, a `GET` request made with a query string will be parsed as an object.
 
 ```bash
-$ curl localhost:8080/users?filters[status]=active
+$ curl localhost:8080/users?status=active
 ```
 
 And, a `POST` request with a body as JSON will be parsed as well.

library/route.js

@@ -76,7 +76,7 @@ import { assertIsRegex } from "https://deno.land/x/[email protected]/library/uti
  * startHTTPServer(
  *   { port: 8080 },
  *   route(
- *     handlers.get('/users', explodeRequest(({ filters }) => retrieveUsers(filters))),
+ *     handlers.get('/users', explodeRequest(({ status }) => retrieveUsers({ filters: { status } }))),
  *     handlers.post(/\/users\/(?<userID>.+)$/, explodeRequest(({ userID }, { data: user }) => updateUser(userID, user)))
  *   )
  * );
@@ -85,7 +85,7 @@ import { assertIsRegex } from "https://deno.land/x/[email protected]/library/uti
  * For this sample, a `GET` request made with a query string will be parsed as an object.
  *
  * ```bash
- * $ curl localhost:8080/users?filters[status]=active
+ * $ curl localhost:8080/users?status=active
  * ```
  *
  * And, a `POST` request with a body as JSON will be parsed as well.
@@ -108,15 +108,13 @@ import { assertIsRegex } from "https://deno.land/x/[email protected]/library/uti
  * startHTTPServer({ port: 8080 }, route(...userRoutes, ...sensorRoutes));
  * ```
  *
- * ### middleware
+ * ### Middleware
  *
- * This library doesn't come with a special function to create middleware or anything; but that doesn't mean you can't
- * do it with some function composition.
+ * Before talking about middlewares, I think it is important to talk about the power of function composition and couple of
+ * things special about `startHTTPServer` and `route`:
  *
- * Before jumping into an example, you need to keep in mind two concepts:
- *
- *   1. The function `startHTTPServer` takes a unary function that must return a `Task` of `Response`.
- *   2. The function `route`, will always return early if the argument is not a `Request`.
+ * 1. The function `startHTTPServer` takes a unary function that must return a `Task` of `Response`.
+ * 2. The function `route`, will always return early if the argument is not a `Request`.
  *
  * So for example, if you needed to discard any request with a content type that is not `application/json`, you could
  * do the following.

library/server.js

@@ -1,6 +1,9 @@
+import { gray, red } from "https://deno.land/[email protected]/fmt/colors.ts";
 import { serve, serveTLS } from "https://deno.land/[email protected]/http/server.ts";
-import { curry, reduce } from "https://x.nest.land/[email protected]/source/index.js";
+import { cond, curry, reduce } from "https://x.nest.land/[email protected]/source/index.js";
+import { encodeText } from "https://deno.land/x/[email protected]/library/utilities.js";
 import Request from "https://deno.land/x/[email protected]/library/Request.js";
+import Response from "https://deno.land/x/[email protected]/library/Response.js";
 
 /**
  * ## Simple HTTP server
@@ -41,10 +44,27 @@ export const stream = curry(
     for await (const _request of iterator) {
       const { body = new Uint8Array([]), headers, method, url } = _request;
 
-      unaryFunction(Request({ ...destructureHeaders(headers), method, url }, await Deno.readAll(body)))
-        .map(response => _request.respond({ ...response.headers, body: response.raw }))
-        .run()
-        .catch(error => console.error(error));
+      const handleResponse = response => _request.respond({ ...response.headers, body: response.raw });
+      const handleError = error =>
+        console.error(red(`An error occurred in an handler: ${error.message}\n${gray(error.stack)}`))
+        || _request.respond({ status: 500, body: encodeText(error.message) })
+
+      try {
+        unaryFunction(Request({ ...destructureHeaders(headers), method, url }, await Deno.readAll(body)))
+          .run()
+          .then(
+            container =>
+              container.fold({
+                Left: cond([
+                  [ Response.is, handleResponse ],
+                  [ _ => true, handleError ]
+                ]),
+                Right: handleResponse
+              }),
+          );
+      } catch (error) {
+        handleError(error);
+      }
     }
   }
 );
@@ -60,4 +80,4 @@ export const startHTTPServer = (options, unaryFunction) => {
   return server;
 };
 
-export default startHTTPServer;
+export default startHTTPServer;

library/server_test.js

@@ -1,5 +1,7 @@
 import { assert, assertEquals } from "https://deno.land/[email protected]/testing/asserts.ts";
+import { compose, converge, mergeRight } from "https://x.nest.land/[email protected]/source/index.js";
 
+import Either from "https://deno.land/x/[email protected]/library/Either.js";
 import Task from "https://deno.land/x/[email protected]/library/Task.js";
 import { decodeRaw, encodeText, safeExtract } from "https://deno.land/x/[email protected]/library/utilities.js";
 import { fetch } from "https://deno.land/x/[email protected]/library/browser_safe.js";
@@ -8,17 +10,21 @@ import Response from "https://deno.land/x/[email protected]/library/Response.
 
 import { handlers, route } from "./route.js";
 import { startHTTPServer } from "./server.js";
-import { authorizeRequest, explodeRequest } from "./utilities.js";
+import { factorizeMiddleware, explodeRequest } from "./utilities.js";
 
-const authorize = authorizeRequest(_ => Task.of({ authorizationToken: "hoge" }));
+const authorize = factorizeMiddleware(request =>
+  request.headers["accept"] === 'application/json'
+    ? Task.of({ authorizationToken: "hoge" })
+    : Task(_ => Either.Left(Response.BadRequest({}, new Uint8Array([]))))
+);
 
 const routeHandlers = [
   handlers.get('/', _ => Task.of(Response.OK({}, new Uint8Array([])))),
   handlers.post('/hoge', request => Task.of(Response.OK({}, request.raw))),
   handlers.get(
     '/hoge',
     explodeRequest(
-      ({ 'filters[status]': status }) =>
+      ({ status }) =>
         Task.of(Response.OK({}, encodeText(JSON.stringify({ status }))))
     )
   ),
@@ -28,17 +34,13 @@ const routeHandlers = [
   ),
   handlers.put(
     '/hoge',
-    explodeRequest(
-      (meta, body) =>
-        Task.of(Response.OK({}, encodeText(JSON.stringify(body))))
-    )
+    explodeRequest((meta, body) => Task.of(Response.OK({}, encodeText(JSON.stringify(body)))))
   ),
   handlers.post(
     '/fuga/piyo',
     authorize(
-      // explodeRequest(
-        ({ authorizationToken }) => Task.of(Response.OK({}, encodeText(JSON.stringify({ authorizationToken }))))
-      // )
+      ({ authorizationToken }) =>
+        Task.of(Response.OK({}, encodeText(JSON.stringify({ authorizationToken }))))
     )
   )
 ];
@@ -79,11 +81,11 @@ Deno.test(
 );
 
 Deno.test(
-  "startHTTPServer with explodeRequest: GET /hoge",
+  "startHTTPServer with explodeRequest: GET /hoge?status=active",
   async () => {
     const server = startHTTPServer({ port: 8080 }, route(...routeHandlers));
 
-    const container = await fetch(Request.GET('http://localhost:8080/hoge?filters[status]=active')).run()
+    const container = await fetch(Request.GET('http://localhost:8080/hoge?status=active')).run()
 
     const response = safeExtract("Failed to unpack the response", container);
 
@@ -169,3 +171,31 @@ Deno.test(
     server.close();
   }
 );
+
+Deno.test(
+  "startHTTPServer with explodeRequest: POST /fuga/piyo -- unauthorized",
+  async () => {
+    const server = startHTTPServer({ port: 8080 }, route(...routeHandlers));
+
+    const container = await fetch(
+      Request(
+        {
+          headers: {
+            'accept': 'text/plain',
+            'content-type': 'application/json'
+          },
+          method: 'POST',
+          url: 'http://localhost:8080/fuga/piyo'
+        },
+        new Uint8Array([])
+      )
+    ).run()
+
+    const response = safeExtract("Failed to unpack the response", container);
+
+    assert(Response.is(response));
+    assertEquals(response.headers.status, 400);
+
+    server.close();
+  }
+);

library/utilities.js

@@ -95,11 +95,3 @@ export const explodeRequest = parseRequest([ parseMeta, parseBody ]);
 // factorizeMiddleware :: (Request -> Task a) -> (Request -> a -> Task Response) -> Request -> Task Response
 export const factorizeMiddleware = middlewareFunction => handlerFunction =>
     request => middlewareFunction(request).chain(options => handlerFunction(options, request));
-
-// authorize :: (Request -> Task a) -> (a -> Task Response) -> Task Response
-export const authorizeRequest = authorizationFunction => factorizeMiddleware(
-  compose(
-    // Note: Need to implement `alt` for Task :thinking:
-    authorizationFunction
-  )
-);

library/utilities_test.js

@@ -1,32 +1,18 @@
 import { assert, assertEquals } from "https://deno.land/[email protected]/testing/asserts.ts"
 import { curry } from "https://x.nest.land/[email protected]/source/index.js";
 
-import Task from "https://deno.land/x/[email protected]/library/Task.js";
-import { decodeRaw, encodeText, safeExtract } from "https://deno.land/x/[email protected]/library/utilities.js";
 import Request from "https://deno.land/x/[email protected]/library/Request.js";
 import Response from "https://deno.land/x/[email protected]/library/Response.js";
+import Task from "https://deno.land/x/[email protected]/library/Task.js";
+import { decodeRaw, encodeText, safeExtract } from "https://deno.land/x/[email protected]/library/utilities.js";
 
-import { authorizeRequest, explodeRequest, factorizeMiddleware, parseBody, parseQueryString, parseURLParameters } from "./utilities.js";
-
-Deno.test(
-  "authorizeRequest",
-  async () => {
-    const middleware = authorizeRequest(_ => Task.of({ hoge: "hoge" }));
-    const handler = middleware(
-      curry((options, _) => Task.of(Response.OK({}, encodeText(JSON.stringify(options)))))
-    );
-    const request = Request({}, new Uint8Array([]));
-
-    const container = await handler(request).run()
-
-    const response = safeExtract("Failed to authorize the request.", container);
-
-    assertEquals(
-      JSON.parse(decodeRaw(response.raw)),
-      { hoge: "hoge" }
-    );
-  }
-);
+import {
+  explodeRequest,
+  factorizeMiddleware,
+  parseBody,
+  parseQueryString,
+  parseURLParameters
+} from "./utilities.js";
 
 Deno.test(
   "explodeRequest",