@lutzklai/pavo 0.0.10

package/index.js

@@ -0,0 +1,54 @@
+/* eslint-disable global-require */
+
+const statusCodes = require('http-status-codes');
+
+const app = require('./src/app');
+const appEvents = require('./src/appEvents');
+const appTest = require('./src/appTest');
+const bootstrap = require('./src/bootstrap');
+const moduleFinder = require('./src/moduleFinder');
+const authStrategyHelper = require('./src/helperUtils/authStrategyHelper');
+const diHelper = require('./src/helperUtils/diHelper');
+const loggerHelper = require('./src/helperUtils/loggerHelper');
+const moduleBootstrap = require('./src/module/moduleBootstrap');
+const moduleBootstrapTest = require('./src/module/moduleBootstrapTest');
+const modulePlugins = require('./src/module/modulePlugins');
+const moduleTesting = require('./src/module/moduleTesting');
+
+/**
+ * Injects items into the given dependency injector.
+ *
+ * @param {{register: function}} diContainer
+ */
+function inject(diContainer) {
+  const previousSource = diContainer.setRegisterSource(__filename);
+
+  const pavoStatusCodes = Object.assign({}, statusCodes);
+  pavoStatusCodes.$filename = __filename;
+
+  diContainer.register('usingPavo', true, true, {filename: __filename});
+  diContainer.register('pavoAuthStrategyHelper', authStrategyHelper);
+  diContainer.register('statusCodes', pavoStatusCodes);
+
+  diContainer.setRegisterSource(previousSource);
+}
+
+module.exports = {
+  app,
+  appEvents,
+  appTest,
+  bootstrap,
+  inject,
+  module: {
+    bootstrap: moduleBootstrap,
+    testing: moduleTesting,
+    testingSetup: moduleBootstrapTest
+  },
+  moduleFinder,
+  plugins: modulePlugins,
+  utils: {
+    authStrategyHelper,
+    diHelper,
+    loggerHelper
+  }
+};

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@lutzklai/pavo",
+  "version": "0.0.10",
+  "description": "The Clevyr Pavo API framework.",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "Project Content <admin@projectcontent.com>",
+  "license": "ISC",
+  "dependencies": {
+    "@lutzklai/functional-di": "^0.3.3",
+    "async-eventemitter": "^0.2.4",
+    "colors": "^1.1.2",
+    "dataloader": "^1.4.0",
+    "http-status-codes": "^1.3.0",
+    "lodash": "^4.17.4",
+    "winston": "^2.4.0",
+    "winston-rollbar2": "^2.1.4"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  }
+}

package/src/app.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const bootstrap = require('./bootstrap');
+
+/**
+ * The Pavo app.
+ *
+ * @param {string} projectBaseDir
+ * @param {{inject: function}} appDiContainer
+ * @param {boolean} isTesting
+ * @returns {Promise}
+ */
+function pavoApp(projectBaseDir, appDiContainer, isTesting) {
+  let pavoAppServer = null;
+
+  /**
+   * Allows the application to retrieve the server object after initialization.
+   * This must be registered in the application diContainer before the app is bootstrapped!
+   *
+   * @returns {{}}
+   */
+  function pavoAppServerFactory() {
+    return pavoAppServer;
+  }
+
+  pavoAppServerFactory.$singleton = true;
+  pavoAppServerFactory.$filename = __filename;
+  appDiContainer.register('pavoAppServer', pavoAppServerFactory);
+
+  // Bootstrap the application.
+  return bootstrap(projectBaseDir, appDiContainer, isTesting).then(function startServer() {
+    // By sending true, we tell the server to start up.
+    const resolvedServer = appDiContainer.resolve('server', {shouldStart: true});
+
+    if (resolvedServer && resolvedServer.then) {
+      resolvedServer.then((setup) => {
+        pavoAppServer = setup;
+      });
+    } else {
+      pavoAppServer = resolvedServer;
+    }
+  });
+}
+
+module.exports = pavoApp;

package/src/appEvents.js

@@ -0,0 +1,131 @@
+'use strict';
+
+const AsyncEventEmitter = require('async-eventemitter');
+
+/**
+ * The PavoEvents object.
+ * Triggers and processes events during the setup process of the app server.
+ */
+class PavoEvents extends AsyncEventEmitter {
+  /**
+   * Defines the class properties.
+   */
+  constructor() {
+    super();
+
+    /* The Pavo Events. */
+    this.EVENT_BEFORE_MIDDLEWARE = 'EVENT_BEFORE_MIDDLEWARE';
+    this.EVENT_PROCESS_MIDDLEWARE = 'EVENT_PROCESS_MIDDLEWARE';
+    this.EVENT_PROCESS_AUTH_STRATEGIES = 'EVENT_PROCESS_AUTH_STRATEGIES';
+    this.EVENT_AFTER_MIDDLEWARE = 'EVENT_AFTER_MIDDLEWARE';
+    this.EVENT_PROCESS_MODULES = 'EVENT_PROCESS_MODULES';
+    this.EVENT_BEFORE_START = 'EVENT_BEFORE_START';
+    this.EVENT_AFTER_START = 'EVENT_AFTER_START';
+  }
+
+  /**
+   * Emits an event and returns a promise after all listeners have finished.
+   *
+   * @param {string} event
+   * @param {*} data
+   * @returns {Promise}
+   */
+  emitPromise(event, data) {
+    if (!this[event] || String(this[event]) !== event) {
+      return Promise.reject(new Error(
+        `Invalid event '${event}' given to app event system. Check pavo.appEvents for valid events.`
+      ));
+    }
+
+    return new Promise((resolve, reject) => {
+      this.emit(event, data, (error, response) => {
+        if (error) {
+          reject(error);
+        } else {
+          resolve(response);
+        }
+      });
+    });
+  }
+
+  /**
+   * Processes the given handler before the app middleware is processed.
+   *
+   * @param {function} handler
+   * @returns {Promise}
+   */
+  onBeforeMiddleware(handler) {
+    return this.on(this.EVENT_BEFORE_MIDDLEWARE, handler);
+  }
+
+  /**
+   * Processes the given handler when the middlewares are ready to be processed.
+   *
+   * @param {function} handler
+   * @returns {Promise}
+   */
+  onProcessMiddleware(handler) {
+    return this.on(this.EVENT_PROCESS_MIDDLEWARE, handler);
+  }
+
+  /**
+   * Processes the given handler when the authentication strategies are ready to be processed.
+   *
+   * @param {function} handler
+   * @returns {Promise}
+   */
+  onProcessAuthStrategies(handler) {
+    return this.on(this.EVENT_PROCESS_AUTH_STRATEGIES, handler);
+  }
+
+  /**
+   * Processes the given handler after the app middleware is processed.
+   *
+   * @param {function} handler
+   * @returns {Promise}
+   */
+  onAfterMiddleware(handler) {
+    return this.on(this.EVENT_AFTER_MIDDLEWARE, handler);
+  }
+
+  /**
+   * Processes the given handler when the modules are ready to be processed.
+   *
+   * @param {function} handler
+   * @returns {Promise}
+   */
+  onProcessModules(handler) {
+    return this.on(this.EVENT_PROCESS_MODULES, handler);
+  }
+
+  /**
+   * Processes the given handler before the app server is started.
+   *
+   * @param {function} handler
+   * @returns {Promise}
+   */
+  onBeforeStart(handler) {
+    return this.on(this.EVENT_BEFORE_START, handler);
+  }
+
+  /**
+   * Processes the given handler after the app server has been started.
+   *
+   * @param {function} handler
+   * @returns {Promise}
+   */
+  onAfterStart(handler) {
+    return this.on(this.EVENT_AFTER_START, handler);
+  }
+}
+
+/**
+ * Initializes a new PavoEvents object.
+ *
+ * @returns {PavoEvents}
+ */
+function pavoEventsFactory() {
+  return new PavoEvents();
+}
+
+module.exports = pavoEventsFactory;

package/src/appTest.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const bootstrap = require('./bootstrap');
+
+/**
+ * Initializes the app for testing purposes.
+ *
+ * @param {string} baseDir
+ * @param {function} appDiFactory
+ * @returns {function}
+ */
+function initAppForTesting(baseDir, appDiFactory) {
+  /**
+   * Initializes the application for testing purposes.
+   *
+   * @param {string=} modName
+   * @param {Object=} testingConfig
+   * @returns {Promise<Object.<string, Object>>} Promise that returns the Hapi server.
+   */
+  return function testApplication(modName, testingConfig) {
+    // First setup the application dependency injector.
+    const appDiContainer = appDiFactory();
+
+    // Define any testing setup information
+    appDiContainer.register('testingConfig', testingConfig || {});
+
+    // Bootstrap the application.
+    return bootstrap(baseDir, appDiContainer, true).then(function getTestingServer(diContainers) {
+      if (!diContainers[modName]) {
+        throw new Error(`Bootstrap did not return DI container for module '${modName}'.`);
+      }
+
+      return {
+        [modName]: diContainers[modName],
+        app: diContainers.app,
+        mod: diContainers[modName]
+      }
+    });
+  }
+}
+
+module.exports = initAppForTesting;

package/src/bootstrap.js

@@ -0,0 +1,101 @@
+'use strict';
+
+const lodash = require('lodash');
+
+const moduleFinder = require('./moduleFinder.js');
+
+/**
+ * Bootstraps the application by initializing the dependency injector, loading each module,
+ * and registering the module plugins with the DI.
+ *
+ * @param {string} baseDir
+ * @param {Object} appDiContainer
+ * @param {boolean} isTesting
+ * @returns {Promise<Object.<string, Object>>} A promise that returns the application DI container.
+ */
+function bootstrapApp(baseDir, appDiContainer, isTesting) {
+  let allModDiContainers = {};
+  let allModServices = {};
+  let moduleLoaders = [];
+  let modulePlugins = {};
+
+  // Module finder will auto detect each module and return each of their loaders.
+  return moduleFinder(baseDir).then(function afterModulesFound(foundModuleFactories) {
+    // Up the event maxListeners cap to 2 per modules found.
+    // This prevents sequelize from throwing a warning.
+    process.setMaxListeners(foundModuleFactories.length * 2);
+
+    moduleLoaders = foundModuleFactories.map(function startEachModule(moduleFactory) {
+      return {
+        directory: moduleFactory.directory,
+        module: moduleFactory.module()
+      };
+    });
+
+    /**
+     * Order of module setup operation:
+     *   1. initModule (Sync)
+     *   2. loadModuleServices (Sync)
+     *   3. registerAppServices (Sync)
+     *   4. configureModuleTesting (Async)
+     *   5. resolveModulePlugins (Sync)
+     */
+
+    moduleLoaders = moduleLoaders.map((moduleLoader) => {
+      const modDiContainers = moduleLoader.module.initModule(appDiContainer, moduleLoader.directory);
+
+      if (modDiContainers) {
+        allModDiContainers = Object.assign({}, allModDiContainers, modDiContainers);
+      }
+
+      return moduleLoader.module;
+    });
+
+    moduleLoaders.forEach((moduleLoader) => {
+      const modServices = moduleLoader.loadModuleServices();
+
+      // Store each service into a collection of all module services.
+      if (modServices) {
+        allModServices = Object.assign({}, allModServices, modServices);
+      }
+    });
+
+    // Register the mod services with the app di container.
+    lodash.forEach(allModServices, function registerNewServices(service, serviceName) {
+      appDiContainer.register(serviceName, service);
+    });
+
+    moduleLoaders.forEach((moduleLoader) => {
+      moduleLoader.registerAppServices(allModServices);
+    });
+
+    if (isTesting) {
+      return Promise.all(moduleLoaders.map((moduleLoader) => {
+        return moduleLoader.configureModuleTesting();
+      }));
+    }
+
+    return true;
+  }).then(function afterModulesAreConfigured() {
+    moduleLoaders.forEach((moduleLoader) => {
+      const newPlugins = moduleLoader.resolveModulePlugins();
+
+      if (newPlugins) {
+        modulePlugins = Object.assign({}, modulePlugins, newPlugins);
+      }
+    });
+
+    const modulePluginsFactory = function modulePluginsFactory() {
+      return lodash.values(modulePlugins);
+    };
+    modulePluginsFactory.$filename = __filename;
+
+    appDiContainer.register('modulePlugins', modulePluginsFactory);
+
+    return Object.assign({}, allModDiContainers, {
+      app: appDiContainer
+    });
+  });
+}
+
+module.exports = bootstrapApp;

package/src/helperUtils/authStrategyHelper.js

@@ -0,0 +1,44 @@
+'use strict';
+
+/**
+ * Builds the authStrategyHelper.
+ *
+ * @returns {{}}
+ */
+function authStrategyHelperFactory() {
+  /**
+   * Translates a promise strategy into a passport callback strategy.
+   *
+   * @param {function} strategy The promise based
+   * @returns {function}
+   */
+  function strategyWrapper(strategy) {
+    return function promiseStrategy() {
+      const args = Array.from(arguments);
+
+      let done = null;
+      while (args.length && (!done || typeof done !== 'function')) {
+        done = args.pop();
+      }
+
+      strategy.apply(null, args).then(
+        (strategyResponse) => {
+          if (strategyResponse.invalid) {
+            return done(null, false, strategyResponse.invalid);
+          }
+          return done(null, strategyResponse);
+        },
+        done
+      );
+    };
+  }
+
+  return {
+    strategyWrapper
+  };
+}
+
+authStrategyHelperFactory.$inject = true;
+authStrategyHelperFactory.$filename = __filename;
+
+module.exports = authStrategyHelperFactory;

package/src/helperUtils/diHelper.js

@@ -0,0 +1,252 @@
+'use strict';
+
+const diContainerFactory = require('@lutzklai/functional-di');
+const lodash = require('lodash');
+const fs = require('fs');
+const path = require('path');
+
+// Requiring colors alters the string prototype to allow color mutations.
+require('colors');
+
+/**
+ * Sub folder glob pattern.
+ */
+const SUB_FOLDER_GLOB = '/**/*';
+
+/**
+ * The default file matching regexps for different file types.
+ * @type {Object.<string, RegExp>}
+ */
+const FILE_REGEXPS = {
+  authStrategies: /Strategy\.js$/i,
+  config: /Config\.js$/i,
+  constants: /Constants\.js$/i,
+  helperUtils: /\.js$/i,
+  models: /Model\.js$/i,
+  policies: /Polic(y|ies)\.js$/i,
+  routes: /Route\.js$/i,
+  schemas: /Schema\.js$/i,
+  services: /Service\.js$/i
+};
+
+/**
+ * The default list of module folders.
+ * @type {Object.<string, string>}
+ */
+const MODULE_FOLDERS = {
+  authStrategies: 'authStrategies',
+  config: 'config',
+  constants: 'constants',
+  helperUtils: 'helperUtils',
+  models: 'models',
+  policies: 'policies',
+  routes: 'routes' + SUB_FOLDER_GLOB,
+  schemas: 'schemas',
+  services: 'services'
+};
+
+/**
+ * The regexp used to match when a file is a test file.
+ * @const {RegExp}
+ */
+const TEST_MATCH_REGEXP = /\.test\.js$/i;
+
+/**
+ * File/directory not found error.
+ * @const {string}
+ */
+const ENOENT = 'ENOENT';
+
+/**
+ * Builds the diHelper.
+ *
+ * @param {Object.<string, RegExp>=} overrideFileRegexps
+ * @param {Object.<string, string>=} overrideModuleFolders
+ * @param {RegExp=} overrideTestRegexp
+ * @param {boolean=} logNotFound
+ * @returns {{}}
+ */
+function diHelperFactory(overrideFileRegexps, overrideModuleFolders, overrideTestRegexp, logNotFound) {
+  const fileRegexps = Object.assign({}, FILE_REGEXPS, overrideFileRegexps || {});
+  const moduleFolders = Object.assign({}, MODULE_FOLDERS, overrideModuleFolders || {});
+  const testRegexp = overrideTestRegexp || TEST_MATCH_REGEXP;
+  const logNotFoundErrors = logNotFound || false;
+
+  /**
+   * Loads either a new Di Container or a clone of the given parent Di Container.
+   *
+   * @param {{}=} parentDiContainer
+   * @returns {{}}
+   */
+  function getDiContainer(parentDiContainer) {
+    let diContainer;
+    if (parentDiContainer) {
+      diContainer = parentDiContainer.clone();
+    } else {
+      diContainer = diContainerFactory();
+    }
+
+    return diContainer;
+  }
+
+  /**
+   * Injects all the files (or regexp matching files) from a folder into the dependency injector.
+   * Note: Files with no '.' or extension in the name will be skipped.
+   *
+   * @param {{register: function}} diContainer
+   * @param {string|string[]} folderPath
+   * @param {RegExp=} fileRegexp
+   * @param {Object.<string, string>=} injectionNameMap
+   * @param {{followSubFolders: boolean}=} folderOptions
+   * @returns {{}}
+   */
+  function injectFilesFromFolder(diContainer, folderPath, fileRegexp, injectionNameMap, folderOptions) {
+    const safeInjectionMap = injectionNameMap || {};
+    const safeFolderOptions = folderOptions || {};
+    const followSubFolders = Boolean(safeFolderOptions.followSubFolders);
+
+    let safeFolderPath = folderPath;
+    if (Array.isArray(folderPath)) {
+      safeFolderPath = path.join.apply(null, folderPath);
+    }
+
+    let files = [];
+    try {
+      files = fs.readdirSync(safeFolderPath); // eslint-disable-line no-sync
+    } catch (readDirError) {
+      if (readDirError.code && readDirError.code === ENOENT) {
+        if (logNotFoundErrors) {
+          console.log( // eslint-disable-line no-console
+            `Skipping injections from folder ${safeFolderPath}`.yellow
+          );
+        }
+      } else {
+        throw readDirError;
+      }
+    }
+
+    files.forEach((fileName) => {
+      if (fileName.indexOf('.') === -1) {
+        if (followSubFolders) {
+          const newFolderPath = [safeFolderPath, fileName];
+          injectFilesFromFolder(diContainer, newFolderPath, fileRegexp, injectionNameMap, safeFolderOptions);
+        }
+        return;
+      } else if (fileRegexp && !fileName.match(fileRegexp)) {
+        return;
+      } else if (fileName.match(testRegexp)) {
+        return;
+      }
+
+      let injectionName = null;
+      if (safeInjectionMap[fileName] === false) {
+        return;
+      } else if (safeInjectionMap[fileName]) {
+        injectionName = safeInjectionMap[fileName];
+      } else {
+        const fileNameParts = String(fileName).split('.');
+        injectionName = fileNameParts[0];
+      }
+
+      const fullFilePath = path.join(safeFolderPath, '/', fileName);
+      diContainer.register(injectionName, require(fullFilePath)); // eslint-disable-line global-require
+    });
+
+    return diContainer;
+  }
+
+  /**
+   * Automagically injects all the files for the module.
+   *
+   * @param {{register: function}} diContainer
+   * @param {string|string[]} moduleFolderPath
+   * @param {Object.<string, string>=} injectionNameMap
+   * @returns {{}}
+   */
+  function injectFilesForModule(diContainer, moduleFolderPath, injectionNameMap) {
+    let safeFolderPath = moduleFolderPath;
+    if (Array.isArray(moduleFolderPath)) {
+      safeFolderPath = path.join.apply(null, moduleFolderPath);
+    }
+
+    let files = [];
+    try {
+      files = fs.readdirSync(safeFolderPath); // eslint-disable-line no-sync
+    } catch (readDirError) {
+      if (readDirError.code && readDirError.code === ENOENT) {
+        if (logNotFoundErrors) {
+          console.log( // eslint-disable-line no-console
+            `Skipping injections from folder ${safeFolderPath}`.yellow
+          );
+        }
+      } else {
+        throw readDirError;
+      }
+    }
+
+    const injectFolderOptions = {followSubFolders: false};
+
+    files.forEach((fileName) => {
+      // Skip non-folder files.
+      if (fileName.indexOf('.') !== -1) {
+        return;
+      }
+
+      let matchedFolderName = null;
+      let followSubFolders = false;
+      lodash.values(moduleFolders).forEach((moduleFolderName) => {
+        // If the module folder name ends in '/**/*' then it will cause sub folders to be searched as well.
+        if (moduleFolderName.substr(0 - SUB_FOLDER_GLOB.length) === SUB_FOLDER_GLOB) {
+          const onlyFolderName = moduleFolderName.substring(0, moduleFolderName.length - SUB_FOLDER_GLOB.length);
+          if (fileName === onlyFolderName) {
+            matchedFolderName = fileName;
+            followSubFolders = true;
+          }
+          return;
+        }
+
+        if (fileName === moduleFolderName) {
+          matchedFolderName = fileName;
+        }
+      });
+
+      if (!matchedFolderName) {
+        return;
+      }
+
+      injectFilesFromFolder(
+        diContainer,
+        [moduleFolderPath, matchedFolderName],
+        fileRegexps[matchedFolderName],
+        injectionNameMap,
+        {...injectFolderOptions, followSubFolders}
+      );
+    });
+
+    return diContainer;
+  }
+
+  /**
+   * Automagically injects the top level files for the project.
+   * NOTE: This does not inject any module files.
+   *
+   * @param {{register: function}} diContainer
+   * @param {string|string[]} projectSrcFolderPath
+   * @param {Object.<string, string>=} injectionNameMap
+   * @returns {{}}
+   */
+  function injectFilesForProject(diContainer, projectSrcFolderPath, injectionNameMap) {
+    return injectFilesForModule(diContainer, projectSrcFolderPath, injectionNameMap);
+  }
+
+  return {
+    getDiContainer,
+    injectFilesFromFolder,
+    injectFilesForModule,
+    injectFilesForProject,
+    fileRegexp: Object.assign({}, fileRegexps),
+    moduleFolders: Object.assign({}, moduleFolders)
+  };
+}
+
+module.exports = diHelperFactory;

package/src/helperUtils/loggerHelper.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const winston = require('winston');
+
+/**
+ * Exposes 'winston.transports.Rollbar'.
+ */
+require('winston-rollbar2');
+
+/**
+ * Gets a new logger instance.
+ *
+ * @param {{}} options
+ * @returns {{}}
+ */
+function getNewLogger(options) {
+  const loggerOptions = options || {};
+
+  const defaultConsoleOptions = loggerOptions.console || {};
+
+  const transports = loggerOptions.transports || [
+    getTransportByName('console', defaultConsoleOptions)
+  ];
+
+  const newLogger = new (winston.Logger)({
+    transports: transports
+  });
+  newLogger.$filename = __filename;
+
+  return newLogger;
+}
+
+/**
+ * Gets a logging transport by the given name and options.
+ *
+ * @param {string} name
+ * @param {{}} options
+ * @returns {{}}
+ * @throws {Error} If the transport could not be found.
+ */
+function getTransportByName(name, options) {
+  const transportOptions = options || {};
+
+  switch (name) {
+    case 'console':
+      return new (winston.transports.Console)(transportOptions);
+    case 'http':
+      return new (winston.transports.Http)(transportOptions);
+    case 'file':
+      return new (winston.transports.File)(transportOptions);
+    case 'rollbar':
+      return new (winston.transports.Rollbar)(transportOptions);
+    default:
+      throw new Error(`Could not find transport named '${name}'`);
+  }
+}
+
+module.exports = {
+  getNewLogger,
+  getTransportByName
+};

package/src/module/moduleBootstrap.js

@@ -0,0 +1,126 @@
+'use strict';
+
+const lodash = require('lodash');
+
+const MOD_KEY_MAX = Number.MAX_SAFE_INTEGER;
+
+/**
+ * Provides the list of functions for bootstrapping a module.
+ *
+ * @param {{name: string}} modConfig
+ * @param {function} moduleDiFactory
+ * @param {function} testingSetup
+ * @param {string[]} serviceNames
+ * @returns {{
+ *   initModule: function,
+ *   loadModuleServices: function,
+ *   registerAppServices: function,
+ *   configureModuleTesting: function,
+ *   resolveModulePlugins: function
+ * }}
+ */
+function modBootstrapFactory(modConfig, moduleDiFactory, testingSetup, serviceNames) {
+  let modName = modConfig.name;
+  let modKey = (modName || '') + Math.floor((Math.random() * MOD_KEY_MAX));
+
+  const safeServiceNames = serviceNames || [];
+
+  let modDiContainer = null;
+  let dependencyArgs = {};
+  let modServices = {};
+
+  /**
+   * Initializes the module by loading its dependency injector.
+   *
+   * @param {Object} parentDiContainer
+   * @param {string} directoryName
+   * @returns {Promise.<{Object}>}
+   */
+  function initModule(parentDiContainer, directoryName) {
+    if (directoryName && !modName) {
+      modName = `${directoryName}Module`;
+      modKey = modName + modKey;
+    }
+
+    modDiContainer = moduleDiFactory(parentDiContainer);
+
+    return {
+      [modKey]: modDiContainer
+    };
+  }
+
+  /**
+   * Loads the services for this module.
+   *
+   * @returns {Object.<string, function>}
+   */
+  function loadModuleServices() {
+    modServices = {};
+    safeServiceNames.forEach(function mapServices(serviceName) {
+      modServices[serviceName] = modDiContainer.resolveCurry(serviceName);
+    });
+
+    return modServices;
+  }
+
+  /**
+   * Registers other application services with this module's DI container.
+   *
+   * @param {Object.<string, function>} appServices
+   */
+  function registerAppServices(appServices) {
+    if (!appServices) {
+      return;
+    }
+
+    lodash.forEach(appServices, function registerNewServices(service, serviceName) {
+      if (modServices[serviceName]) {
+        // Do not register our own module services.
+        return;
+      }
+
+      modDiContainer.register(serviceName, service);
+    });
+  }
+
+  /**
+   * Runs testing configuration for this module.
+   *
+   * @returns {Promise}
+   */
+  function configureModuleTesting() {
+    return testingSetup(
+      modDiContainer,
+      modDiContainer.resolve('testingConfig')
+    ).then((testingDependencyArgs) => {
+      dependencyArgs = Object.assign({}, dependencyArgs, testingDependencyArgs);
+    });
+  }
+
+  /**
+   * Resolves and returns the module plugins.
+   *
+   * @returns {Object.<string, Object>}
+   */
+  function resolveModulePlugins() {
+    const moduleAsPlugin = modDiContainer.resolve('moduleAsPlugin', dependencyArgs || null)();
+
+    if (modName && !moduleAsPlugin.name) {
+      moduleAsPlugin.name = modName;
+    }
+
+    return {
+      [modKey]: moduleAsPlugin
+    };
+  }
+
+  return {
+    initModule,
+    loadModuleServices,
+    registerAppServices,
+    configureModuleTesting,
+    resolveModulePlugins
+  };
+}
+
+module.exports = modBootstrapFactory;

package/src/module/moduleBootstrapTest.js

@@ -0,0 +1,40 @@
+'use strict';
+
+/**
+ * Initializes the module testing bootstrap.
+ *
+ * @param {{createSeededDatabase: function}} dbSeed
+ * @returns {function}
+ */
+function initModuleTestingBootstrap(dbSeed) {
+  /**
+   * Initializes the application for testing purposes.
+   *
+   * @param {Object} modDiContainer
+   * @param {{routeName: string, onDbSeeded: function}} config
+   * @returns {Promise<{moduleRoutes: string[]}>}
+   */
+  return function setupModuleTesting(modDiContainer, config) {
+    const safeConfig = config || {};
+    const routeName = safeConfig.routeName || '';
+    const onDbSeeded = safeConfig.onDbSeeded || null;
+
+    const returnArgs = {
+      moduleRoutes: [routeName]
+    };
+
+    if (!dbSeed) {
+      return Promise.resolve(returnArgs);
+    }
+
+    return dbSeed.createSeededDatabase(routeName + 'Test', modDiContainer).then(() => {
+      if (onDbSeeded && typeof onDbSeeded === 'function') {
+        onDbSeeded(modDiContainer);
+      }
+
+      return returnArgs;
+    });
+  }
+}
+
+module.exports = initModuleTestingBootstrap;

package/src/module/modulePlugins.js

@@ -0,0 +1,37 @@
+'use strict';
+
+// Requiring colors alters the string prototype to allow color mutations.
+require('colors');
+
+/**
+ * Initializes the module plugins parser.
+ *
+ * @param {{}} app
+ * @param {boolean=} skipLogging
+ * @returns {{registerWithApp: function}}
+ */
+function initModulePlugins(app, skipLogging) {
+  /**
+   * Registers each plugin with the server/app.
+   *
+   * @param {Array.<{register: function}>} modulePlugins
+   * @returns {Array.<{}>}
+   */
+  function registerWithApp(modulePlugins) {
+    const registerPromises = modulePlugins.map((modulePlugin) => {
+      if (modulePlugin.name && !skipLogging) {
+        console.log('Loading module', String(modulePlugin.name).cyan.bold); // eslint-disable-line no-console
+      }
+
+      return Promise.resolve(modulePlugin.register(app));
+    });
+
+    return Promise.all(registerPromises);
+  }
+
+  return {
+    registerWithApp
+  };
+}
+
+module.exports = initModulePlugins;

package/src/module/moduleTesting.js

@@ -0,0 +1,86 @@
+'use strict';
+
+/**
+ * Converts the given arguments to a testing config object.
+ *
+ * @param {string=} routeName
+ * @param {function=} onDbSeeded
+ * @returns {Object}
+ */
+function convertArgumentsToConfig(routeName, onDbSeeded) {
+  return {
+    routeName: routeName ? String(routeName) : '',
+    onDbSeeded: onDbSeeded || null
+  };
+}
+
+/**
+ * Provides the list of functions for testing a module.
+ *
+ * @param {function} appTesting
+ * @param {{name: string}} modConfig
+ * @returns {{
+ *   bootstrap: function,
+ *   bootstrapServer: function,
+ *   setup: function
+ * }}
+ */
+function modTestingFactory(appTesting, modConfig) {
+  const modName = modConfig.name;
+
+  /**
+   * Initializes the application for testing purposes and returns the module's DI container.
+   *
+   * @param {string=} routeName
+   * @param {function=} onDbSeeded
+   * @returns {Promise<Object.<string, Object>>} Promise that returns the module's DI container.
+   */
+  function bootstrapTestApplication(routeName, onDbSeeded) {
+    return appTesting(
+      modName,
+      convertArgumentsToConfig(routeName, onDbSeeded)
+    );
+  }
+
+  /**
+   * Initializes the application server for testing purposes.
+   *
+   * @param {string=} routeName
+   * @param {function=} onDbSeeded
+   * @returns {Promise<Object>} Promise that returns the Hapi server.
+   */
+  function bootstrapTestAppServer(routeName, onDbSeeded) {
+    const mockAdminUser = {
+      id: 1001,
+      isAdmin: true
+    };
+
+    return appTesting(
+      modName,
+      convertArgumentsToConfig(routeName, onDbSeeded)
+    ).then(function getServerFromModDiContainer(diContainers) {
+      // By sending false, we are preventing the server from starting.
+      return diContainers.app.resolve('server', {shouldStart: false});
+    }).then(function getMockServer(server) {
+      return {
+        inject: (call) => {
+          if (!call.credentials) {
+            call.credentials = {};
+          }
+          if (!call.credentials.user) {
+            call.credentials.user = mockAdminUser;
+          }
+
+          return server.inject(call);
+        }
+      };
+    });
+  }
+
+  return {
+    bootstrap: bootstrapTestApplication,
+    bootstrapServer: bootstrapTestAppServer
+  };
+}
+
+module.exports = modTestingFactory;

package/src/moduleFinder.js

@@ -0,0 +1,51 @@
+'use strict';
+
+/* eslint-disable global-require */
+
+const path = require('path');
+const fs = require('fs');
+
+// Requiring colors alters the string prototype to allow color mutations.
+require('colors');
+
+/**
+ * Loads the main module loader factories for all modules in the modules directory.
+ *
+ * @param {string} baseDirectory
+ * @returns {Promise.<Array.<Object>>}
+ */
+function moduleFinder(baseDirectory) {
+  const modulesPath = path.join(baseDirectory, 'modules');
+
+  return new Promise(function moduleFinderPromise(resolve, reject) {
+    fs.readdir(modulesPath, function afterReadModulesDir(err, files) {
+      if (err) {
+        if (err.code === 'ENOENT') {
+          console.log( // eslint-disable-line no-console
+            `Could not find required module folder at ${modulesPath}`.red.bold
+          );
+        }
+
+        reject(err);
+        return;
+      }
+
+      resolve(files);
+    });
+  }).then(function parseOutFiles(files) {
+    return files.filter(function filterOutFilesWithDots(fileName) {
+      return (fileName.indexOf('.') < 0);
+    });
+  }).then(function requireFoundModules(directoryNames) {
+    return directoryNames.map(function requireModule(directoryName) {
+      return {
+        directory: directoryName,
+        module: require(
+          path.join(modulesPath, directoryName, 'index.js')
+        )
+      };
+    });
+  });
+}
+
+module.exports = moduleFinder;