Mezzo

Abstract anything into middleware.

The future

What if you could use middleware for things other than an HTTP request?

Things like:

• configuring a web server
• building your client assets
• extending component functionality
• DRYing up shared project functionality

Example

From the paradiso web framework:

# Start the web server
#
routes  = require "./routes"
server  = require "paradiso-server"
express = require "paradiso-server-express"

server routes, express
  port:   9000
  static: "public"

Goals

• Abstract library-specific code into small, reusable, and testable middleware.
• Maintain a similar interface for libraries that do the same thing.
• (Change out libraries without changing app code.)
• Piece together and configure middleware easily.

Configuring middleware

If you only pass options to an adapter, it does not run the middleware chain.

build option: true

However, it does save the options for a later execution:

build option: true
build()  # @options.option is still true

Run the workflow

If you pass an adapter or nothing at all, the middleware chain does run:

build()
build browserify, coffeeify
build browserify, coffeeify, option: true

Write middleware

Skeleton implementation of a mezzo middleware:

mezzo = require "mezzo"

module.exports = mezzo class
  constructor: ({
    @adapters  # array of adapters in order of execution
    @options   # any options passed as a parameter (merged)
    @index     # index of this adapter in `@adapters`
  }) ->

  run: ({ env, next }) -> next env

Put it all together

mezzo = require "mezzo"

# Build adapters
#
a = mezzo class
  constructor: ({ @options }) ->

  run: ({ env, next }) ->
    console.log "a @options", @options
  	env.a_run = true
  	next()

b = mezzo class
  run: ({ env, next }) ->
  	console.log "b"
  	next b_run: true

c = mezzo class
  run: ({ env, next }) ->
  	env.c_run = true
  	console.log "c env", env
  	next()

# Set options
#
a opt: true

# Execute middleware chain
#
a b, c, opt2: true

# Output:
#
#   a @options { opt: true, opt2: true }
#   b
#   c env { a_run: true, b_run: true, c_run: true }