refactored global middleware functionality and invoker functionality

Author: sarapowers

index.js

@@ -1,60 +1,87 @@
-class Connext {
-  constructor() {
-    this.routes = [];
-    this.set = app.set.bind(this);
-    this.get = this.set.bind(this, 'GET');
-    this.post = this.set.bind(this, 'POST');
-    this.put = this.set.bind(this, 'PUT');
-    this.patch = this.set.bind(this, 'PATCH');
-    this.delete = this.set.bind(this, 'DELETE');
-    this.head = this.set.bind(this, 'HEAD');
-    this.connect = this.set.bind(this, 'CONNECT');
-    this.options = this.set.bind(this, 'OPTIONS');
-    this.trace = this.set.bind(this, 'TRACE');
-    this.find = this.set.bind(this, 'FIND');
-    this.compareRoutes = app.compareRoutes.bind(this);
-    this.routeSplitter = app.routeSplitter.bind(this);
-    this.use = app.use.bind(this);
+const Dirext = require('dirext-js');
+const fs = require('fs');
+
+const findGlobal = () => {
+  const globalMiddleware = [];
+  try {
+    if (fs.existsSync('./controllers/global.js')) {
+      globalMiddleware.push(...require('./controllers/global.js'));
+    }
+  } catch (err) {
+    console.log(err);
+  }
+  return globalMiddleware;
+};
+
+const app = new Dirext();
+
+module.exports = () => {
+  function connext(req, res) {
+    connext.invoker(req, res);
   }
+  connext.routes = [];
+  connext.globalMiddleware = findGlobal();
+  connext.get = set.bind(connext, 'GET');
+  connext.post = set.bind(connext, 'POST');
+  connext.put = set.bind(connext, 'PUT');
+  connext.patch = set.bind(connext, 'PATCH');
+  connext.delete = set.bind(connext, 'DELETE');
+  connext.head = set.bind(connext, 'HEAD');
+  connext.connect = set.bind(connext, 'CONNECT');
+  connext.options = set.bind(connext, 'OPTIONS');
+  connext.trace = set.bind(connext, 'TRACE');
+  connext.use = app.use.bind(connext);
+  connext.routeSplitter = app.routeSplitter.bind(connext);
+  connext.compareRoutes = app.compareRoutes.bind(connext);
 
-  
-  invoker(req, res) {
-    console.log('this.routes is:', this.routes);
+  function set(...args) {
+    app.set.apply(connext, args);
+    return connext;
+  }
+
+  connext.invoker = function (req, res) {
+    console.log('connext.routes is:', JSON.stringify(connext.routes));
     console.log('hitting invoker');
     // creating a variable to store user's exported array of global middleware functions
-    const global = require('../../pages/api/global');
     // defining an error handler that can be overwritten if the user creates their own global error handling function
-    let errorHandler;
+    let errorHandler = (err, req, res, next) => {
+      res.status(500).send(`err: ${err}`);
+    };
     // if the global middleware array exists and the last function in the array accepts 4 arguments (catch all error route), set errorHandler to that last function
-    if (global[0] && global[global.length - 1].length === 4) errorHandler = global.pop();
+    if (connext.globalMiddleware[connext.globalMiddleware.length - 1].length === 4) {
+      errorHandler = connext.globalMiddleware.pop();
+    }
     // if the global middleware array is not empty set const middleware to that array, otherwise set const middleware to an empty array
-    const middleware = global[0] ? global : [];
+    let middleware = [];
     // deconstruct method and url out of req
     const { method, url } = req;
-    console.log('req.url is: ', req.url);
-    console.log('req.method is: ', req.method);
     // invoke this.find with method and url passed in as arguments at the key 'middleware' and set that to const targetMiddleware
-    const targetMiddleware = this.find(method, url).middleware;
+    const targetMiddleware = app.find.apply(connext, [method, url]).middleware;
     console.log('targetMiddleware is: ', targetMiddleware);
-    console.log(this.find);
     // push the spread array targetMiddleware into middleware array
-    middleware.push(...targetMiddleware);
+    middleware.push(...connext.globalMiddleware, ...targetMiddleware);
     // counter to keep track of position of current middleware function
     console.log('middleware array is: ', middleware);
     let i = 0;
     // loop through middleware array and invoke each function in order. if an error is passed into next function return that error.
     async function next(err) {
-      if (err) return res.json(err);
+      if (err) return errorHandler(err, req, res);
       // eslint-disable-next-line no-useless-catch
-      try {
-        const currentMiddleware = middleware[i];
-        i += 1;
-        await currentMiddleware(req, res, next);
-        return next();
-      } catch (error) {
-        return error;
+      while (i < middleware.length) {
+        try {
+          const currentMiddleware = middleware[i];
+          if (i === middleware.length - 1) {
+            middleware = [];
+          }
+          i += 1;
+          return currentMiddleware(req, res, next);
+        } catch (error) {
+          return error;
+        }
       }
+      console.log('middleware after splice is:', middleware);
     }
     return next();
-  }
-}
+  };
+  return connext;
+};