galvez/fastify-apply

Shorthand object syntax for Fastify plugins.

fastify-apply

Experimental shorthand syntax for Fastify.

Define hooks as functions or arrays of functions

export default {
  async onRequest (req, reply) {
    reply.send(`Hello from onRequest`)
  },
  preHandler: [
    async (req, reply) => {
      reply.send('Hello from the first preHandler')
    },
    async (req, reply) => {
      reply.send('Hello from the second preHandler')
    },
  ],
}

Supported hooks:

• onRequest
• preParsing
• preValidation
• preHandler
• preSerialization
• onError
• onSend
• onResponse
• onTimeout
• onReady
• onClose
• onRoute
• onRegister

Define method(key, value) calls

export default {
  decorate: {
    helper () {
      console.log('Helper function')
    }
  },
}

Supported methods:

• addHook
• decorate
• decorateRequest
• decorateReply

Run a function before() or after() everything else in the plugin

export default {
  after({ get }) {
    get('/*', (req, reply) => {})
  },
  before({ get }) {
    get('/route', (req, reply) => {})
  },
}

The first argument to before() and after() is a Proxy instance that will return Fastify methods implictly bound to the current plugin context (the contextual fastify instance, that is).

Full list of methods that come with this implicit binding:

• addSchema
• addHook
• decorateRequest
• decorateReply
• register
• get
• head
• post
• put
• delete
• options
• patch
• all

Encapsulation

Unless you set encapsulate to true, the plugin will be wrapped with fastify-plugin so it stays in the global context. To ensure the applied plugin object is encapsulated:

export default {
  encapsulate: true,
}

Hat off to Matteo Collina for suggesting this option's name.

Full example

async function main () {
  const fastify = require('fastify')()
  await fastify.register(require('./index'))

  fastify.apply({
    after ({ get }) {
      get('/*', (req, reply) => {
        reply.send('/* route properly registered')
      })
    },
    decorate: {
      someHelper () {
        return 'something'
      }
    },
    decorateRequest: {
      foobar: 'something else',
      dynamic: null
    },
    async onRequest (req, reply) {
      req.dynamic = this.someHelper()
      reply.header('x-hello-1', `Hello from hooks: ${req.foobar} - ${req.dynamic}`)
    },
    preHandler: [
      async (req, reply) => {
        reply.header('x-hello-2', 'Hello from the first preHandler')
      },
      async (req, reply) => {
        reply.header('x-hello-3', 'Hello from the second preHandler')
      }
    ],
    before ({ get }) {
      get('/before', (req, reply) => {
        reply.send('/before route properly registered')
      })
    }
  })

  return fastify
}

fastify-apply's Issues

remove or improve proxy

I think The Proxy in

fastify-apply/index.js

Lines 65 to 73 in bbb4834

	const proxy = new Proxy(fastify, {
	get (_, prop) {
	if (bind.includes(prop)) {
	return fastify[prop].bind(fastify)
	} else {
	return fastify[prop]
	}
	}
	})

is not strictly needed as a user can do app.get().

If you would really like to keep it, you should support all HTTP methods as well as route().