Extended middleware

CHANGELOG.md

@@ -4,6 +4,7 @@
 
 - Removed support for Node.js below 12
 - Added support for asynchronous creators (#54)
+- Added optional `direction` parameter to middlewares (#53)
 - Updated dependencies
 
 ## 0.14.3

docs/middleware.md

@@ -68,3 +68,36 @@ module.exports = function (cookieName) {
   };
 };
 ```
+
+The `setup` and the creator function can both be `async`, i.e., return a `Promise`.
+
+```js
+module.exports = async function (cookieName) {  
+  // do something that needs to be awaited, e.g.,
+  const answerToLife = await computeAnswerToEverything();
+  return (req, res, next) => {
+    res.headers['set-cookie'] = `${cookieName}=${answerToLife}`;
+    next();
+  };
+};
+```
+
+Another thing to consider is the **direction** that the middleware is applied. By default, the middleware is applied in the **incoming direction** (`in`), i.e., *before* the request has been processed by any injector. Like any middleware, it will be processed before the response will be send to the client.
+
+Another option is to change the `direction` to **outgoing** (`out`):
+
+```json
+{
+  "middlewares": [
+    {
+      "source": "some-middleware-package",
+      "options": [],
+      "direction": "out"
+    }
+  ]
+}
+```
+
+Now this will be applied *after* an injector has been hit.
+
+**Note**: Outgoing middleware is not really useful for modifying responses as the response has already been prepared. The main purpose of an outgoing middleware is to close resources or write out details about the request / response.

src/server/core/webserver.ts

@@ -101,6 +101,16 @@ export class WebServer extends EventEmitter implements BaseKrasServer {
       storage: multer.memoryStorage(),
       limits: { files: 5, fileSize: sizeInMB * 1024 * 1024 },
     });
+    this.app.use((req, res, next) => {
+      //prepares the req / res system
+      req.addedHeaders = {};
+      req.removedHeaders = [];
+      req.addedQuery = {};
+      req.removedQuery = ['_'];
+      res.middlewares = [];
+      res.prepared = undefined;
+      next();
+    });
     this.app.use(upload.any());
     this.app.use(
       text({

src/server/helpers/middlewares.ts

@@ -31,6 +31,7 @@ async function createMiddleware(
   config: KrasConfiguration,
   baseDir: string,
   source: string,
+  direction: 'in' | 'out',
   options: Array<any>,
 ) {
   const creator =
@@ -51,6 +52,7 @@ async function createMiddleware(
           options,
           source,
           active: true,
+          direction,
           handler,
         };
       }
@@ -65,7 +67,27 @@ function integrateMiddlewares(server: KrasServer) {
     const all = server.at('*');
 
     for (const middleware of server.middlewares) {
-      all.any(middleware.handler);
+      all.any((req, res, next) => {
+        if (middleware.active) {
+          if (middleware.direction === 'in') {
+            return middleware.handler(req, res, next);
+          } else if (middleware.direction === 'out') {
+            res.middlewares.push(
+              () =>
+                new Promise<any>((resolve, reject) => {
+                  try {
+                    middleware.handler(req, res, resolve);
+                  } catch (e) {
+                    reject(e);
+                  }
+                }),
+            );
+            return next();
+          }
+        }
+
+        next();
+      });
     }
   }
 }
@@ -77,7 +99,8 @@ export async function withMiddlewares(server: KrasServer, config: KrasConfigurat
     const source = definition.source;
     const baseDir = definition.baseDir || config.directory;
     const options = definition.options || [];
-    const middleware = await createMiddleware(server, config, baseDir, source, options);
+    const direction = definition.direction || 'in';
+    const middleware = await createMiddleware(server, config, baseDir, source, direction, options);
 
     if (middleware) {
       server.middlewares.push(middleware);

src/server/injectors/index.ts

@@ -69,10 +69,24 @@ function getTarget(targets: Array<string>, url: string) {
 
 function normalizeRequest(targets: Array<string>, req: Request): KrasRequest {
   const target = getTarget(targets, req.originalUrl) || '';
-  const url = req.originalUrl.substr(target.length);
-  const query = Object.assign({}, req.query) as Record<string, string>;
-  const headers = Object.assign({}, req.headers) as Record<string, string>;
+  const url = req.originalUrl.substring(target.length);
+
+  const query = Object.assign(
+    {
+      ...req.addedQuery,
+    },
+    req.query,
+  ) as Record<string, string>;
+
+  const headers = Object.assign(
+    {
+      ...req.addedHeaders,
+    },
+    req.headers,
+  ) as Record<string, string>;
+
   let content: any;
+
   if (req.headers['content-type'] && req.headers['content-type'].search('multipart/form-data') !== -1) {
     const formData = new FormData();
     typeof req.body === 'object' &&
@@ -93,7 +107,14 @@ function normalizeRequest(targets: Array<string>, req: Request): KrasRequest {
   }
 
   const method = typeof req.method === 'string' ? req.method : 'GET';
-  delete query._;
+
+  for (const name of req.removedHeaders) {
+    delete headers[name];
+  }
+
+  for (const name of req.removedQuery) {
+    delete query[name];
+  }
 
   return {
     url,
@@ -126,14 +147,20 @@ function handleRequest(server: KrasServer, req: KrasRequest, res: Response) {
 
   server.emit('request', req);
 
-  tryInjectors(injectors, req).then((ans) => {
+  tryInjectors(injectors, req).then(async (ans) => {
+    res.prepared = ans;
+
     if (!ans) {
       server.emit('missing', req);
       ans = fromMissing(req.url);
     } else {
       server.emit('response', ans);
     }
 
+    for (const middleware of res.middlewares) {
+      await middleware();
+    }
+
     sendResponse(req, ans, res);
   });
 }

src/server/types/kras-express.ts

@@ -1,6 +1,22 @@
 import { Request, Response, NextFunction } from 'express';
 import { EventEmitter } from 'events';
 
+declare global {
+  namespace Express {
+    interface Request {
+      addedHeaders: Record<string, string>;
+      removedHeaders: Array<string>;
+      addedQuery: Record<string, string>;
+      removedQuery: Array<string>;
+    }
+
+    interface Response {
+      middlewares: Array<() => Promise<void>>;
+      prepared: any;
+    }
+  }
+}
+
 export interface KrasServerHook {
   handle(req: Request, res: Response): void;
   rate(req: Request): number;

src/server/types/kras-middleware.ts

@@ -2,13 +2,15 @@ import { KrasServerHandler } from './kras-express';
 
 export interface KrasMiddleware {
   source: string;
+  direction: 'in' | 'out';
   options: Array<any>;
   active: boolean;
   handler: KrasServerHandler;
 }
 
 export interface KrasMiddlewareDefinition {
   source: string;
+  direction?: 'in' | 'out';
   baseDir?: string;
   options?: Array<any>;
 }