pattern-router

Object-pattern-matching-based routing

• Patterns are plain objects
• Messages are plain objects
• Messages are matched structurally against patterns
• Most specific patterns match route
• Router is a runtime-agnostic Writable stream

Install

npm install pattern-router

Include

const router = require('pattern-router')

import router from 'pattern-router'

Usage

const PatternRouter = require('.')

const router = new PatternRouter()

router.register({ type: 'ping' }, (message) => {
  console.log('ping', message)
})

router.register({ type: 'ping', extra: { deep: 'stuff' } }, (message) => {
  console.log('specific ping', message)
})

router.write({ type: 'ping', extra: { deep: 'stuff' }, id: 1 })
//specific ping { type: 'ping', extra: { deep: 'stuff' }, id: 1 }

router.write({ type: 'ping', id: 2 })
//ping { type: 'ping', id: 2 }

router.write({ type: 'pong' })
// nothing

API

new PatternRouter([options])

Creates a streamx.Writable in objectMode.

options are passed to Writable

options.multi - set to true to match and call multiple pattern handlers

register(pattern, handler)

Registers a pattern and its handler function.

• pattern must be an object
• handler(message, pattern) is called for each match
• more specific patterns run first
• registration order breaks ties

Returns router instance.

Throws TypeError if handler is not a function.

lookup(message) → pattern | null

Returns the first matching pattern for message, using the same ordering rules as write().

Does not call handlers.

write(message)

Writes a message to the router.

• invokes all matching handlers
• handlers run synchronously
• errors thrown by handlers error the stream

Return value follows streamx.Writable#write.

Matching

Pattern matching is performed by ptnm.

• pattern keys must exist in the message
• values are compared using ===
• matching is recursive for objects
• extra message keys are ignored

Ordering

Patterns are ordered by structural depth.

• each own enumerable key adds weight
• nested objects add weight recursively
• ties are broken by registration order

Ordering is computed lazily:

• on first lookup() or write()
• after each register()

License

Apache-2.0