libflitter/middleware/MiddlewareUnit.js

  1. /**
  2.  * @module libflitter/middleware/MiddlewareUnit
  3.  */
  5. const CanonicalUnit = require('../canon/CanonicalUnit')
  6. const Middleware = require('./Middleware')
  7. const SoftError = require('../errors/SoftError')
  8. const path = require('path')
  10. /**
  11.  * Unit to load and manage middleware class definitions.
  12.  * @extends module:libflitter/canon/CanonicalUnit~CanonicalUnit
  13.  */
  14. class MiddlewareUnit extends CanonicalUnit {
  15.     /**
  16.      * Defines the services required by this unit.
  17.      * @returns {Array<string>}
  18.      */
  19.     static get services() {
  20.         return [...super.services, 'output']
  21.     }
  23.     /**
  24.      * Get the name of the service provided by this unit: 'middlewares'
  25.      * @returns {string} - 'middlewares'
  26.      */
  27.     static get name() {
  28.         return 'middlewares'
  29.     }
  31.     /**
  32.      * Instantiate the unit.
  33.      * @param {string} [base_directory = './app/routing/middleware']
  34.      * @param {string} [globals_file = './app/routing/Middleware.js']
  35.      */
  36.     constructor(base_directory = './app/routing/middleware', globals_file = './app/routing/Middleware.js') {
  37.         super(base_directory)
  39.         /**
  40.          * Fully-qualified path to the file with the definitions for globally-applied middleware.
  41.          * @type {Promise<void> | Promise<string>}
  42.          */
  43.         this.globals_file = path.resolve(globals_file)
  45.         /**
  46.          * The canonical name of the item.
  47.          * @type {string} = 'middleware'
  48.          */
  49.         this.canonical_item = 'middleware'
  51.         /**
  52.          * The file extension of the canonical item files.
  53.          * @type {string} - '.middleware.js'
  54.          */
  55.         this.suffix = '.middleware.js'
  56.     }
  58.     /**
  59.      * Initializes the unit. Registers global middleware.
  60.      * @param {module:libflitter/app/FlitterApp~FlitterApp} app - the Flitter app
  61.      * @returns {Promise<void>}
  62.      */
  63.     async go(app) {
  64.         await super.go(app)
  66.         // Register global middlewares
  67.         const globals = require(this.globals_file)
  68.         this.globals = globals
  70.         for ( const name of globals ) {
  71.             if ( !(name in this.canonical_items) ) {
  72.                 throw (new SoftError(`Unknown middleware name in global Middleware.js file: ${name}`)).unit(this.constructor.name)
  73.             }
  75.             app.express.use(async (req, res, next, args = {}) => {
  76.                 return await this.canonical_items[name].test(req, res, next, args)
  77.             })
  78.         }
  79.     }
  81.     /**
  82.      * Prepare a single canonical middleware definition and return the value that should be given by the resolver.
  83.      * @param {object} info
  84.      * @param {module:libflitter/app/FlitterApp} info.app
  85.      * @param {string} info.name - the unqualified canonical name
  86.      * @param {*} info.instance - the static middleware CLASS from the file
  87.      * @returns {Promise<*>}
  88.      */
  89.     async init_canonical_file({app, name, instance}) {
  90.         if ( instance.prototype instanceof Middleware ) {
  91.             this.output.debug('Registering middleware: '+name)
  92.             return new instance(app)
  93.         } else {
  94.             throw (new SoftError(`Invalid middleware class definition for ${name}. Middleware classes must extend libflitter/middleware/Middleware.`)).unit(this.constructor.name)
  95.         }
  96.     }
  98.     /**
  99.      * A helper function to return the Express middleware function for a registered middleware, using its Flitter canonical name.
  100.      * @param {string} name - the Flitter canonical name of the middleware whose handler should be returned
  101.      * @param {*} args - An argument or arguments to be passed to the middleware function as the 4th argument.
  102.      * @returns {function} - the Express middleware
  103.      */
  104.     get(name, args) {
  105.         if ( !this.canonical_items[name] ) {
  106.             throw (new SoftError('Attempted to access middleware that does not exist: '+name)).unit(this.constructor.name)
  107.         }
  109.         return (req, res, next, merge_args) => {
  110.             let pass_args = typeof args === 'undefined' ? (merge_args ? merge_args : {}) : args
  111.             return this.canonical_items[name].test(req, res, next, pass_args)
  112.         }
  113.     }
  115.     /**
  116.      * Get the directories provided by this unit.
  117.      * {@link module:libflitter/middleware/MiddlewareUnit~MiddlewareUnit#directory} as "middleware".
  118.      * @returns {{middleware: string}}
  119.      */
  120.     directories() {
  121.         return {
  122.             ...super.directories(),
  123.             global_middleware: this.globals_file,
  124.         }
  125.     }
  127.     /**
  128.      * Get the templates provided by this unit.
  129.      * Currently, "middleware" template, using the generator {@link module:libflitter/templates/middleware}.
  130.      * @returns {{middleware: {template: (middleware|(function(string): string)|*), extension: string, directory: string}}}
  131.      */
  132.     templates(){
  133.         return {
  134.             middleware: {
  135.                 template: require('../templates/middleware'),
  136.                 directory: this.directory,
  137.                 extension: '.middleware.js'
  138.             }
  139.         }
  140.     }
  142.     /**
  143.      * Get the fully-qualified path to the migrations provided by this unit.
  144.      * @returns {string}
  145.      */
  146.     migrations(){
  147.         return path.resolve(__dirname, 'migrations')
  148.     }
  149. }
  151. module.exports = exports = MiddlewareUnit
JAVASCRIPT
Copied!