feat: viewAsync reply decorator

Closes #394
Closes #412

benchmark/fastify-ejs-view.js

@@ -0,0 +1,6 @@
+'use strict'
+
+require('./setup.js')({
+  engine: { ejs: require('ejs') },
+  route: (req, reply) => { reply.view('index.ejs', { text: 'text' }) }
+})

benchmark/fastify.js

@@ -2,5 +2,5 @@
 
 require('./setup.js')({
   engine: { ejs: require('ejs') },
-  route: (req, reply) => { reply.view('index.ejs', { text: 'text' }) }
+  route: (req, reply) => { return reply.viewAsync('index.ejs', { text: 'text' }) }
 })

index.js

@@ -32,6 +32,7 @@ async function fastifyView (fastify, opts) {
   }
   const charset = opts.charset || 'utf-8'
   const propertyName = opts.propertyName || 'view'
+  const asyncPropertyName = opts.asyncPropertyName || `${propertyName}Async`
   const engine = opts.engine[type]
   const globalOptions = opts.options || {}
   const templatesDir = resolveTemplateDir(opts)
@@ -106,6 +107,28 @@ async function fastifyView (fastify, opts) {
 
   const renderer = renders[type] ? renders[type] : renders._default
 
+  async function asyncRender (page) {
+    if (!page) {
+      throw new Error('Missing page')
+    }
+
+    let result = await renderer.apply(this, arguments)
+
+    if (minify && !isPathExcludedMinification(this)) {
+      result = await minify(result, globalOptions.htmlMinifierOptions)
+    }
+
+    if (!this.getHeader('Content-Type')) {
+      this.header('Content-Type', 'text/html; charset=' + charset)
+    }
+
+    return result
+  }
+
+  const fakeRequest = {
+    getHeader: () => true
+  }
+
   function viewDecorator (page) {
     const args = Array.from(arguments)
 
@@ -114,11 +137,7 @@ async function fastifyView (fastify, opts) {
       done = args.pop()
     }
 
-    let promise = !page ? Promise.reject(new Error('Missing page')) : renderer.apply(this, args)
-
-    if (minify) {
-      promise = promise.then((result) => minify(result, globalOptions.htmlMinifierOptions))
-    }
+    const promise = asyncRender.apply(fakeRequest, args)
 
     if (typeof done === 'function') {
       promise.then(done.bind(null, null), done)
@@ -134,27 +153,19 @@ async function fastifyView (fastify, opts) {
 
   fastify.decorate(propertyName, viewDecorator)
 
-  fastify.decorateReply(propertyName, async function (page) {
-    if (!page) {
-      this.send(new Error('Missing page'))
-    }
+  fastify.decorateReply(propertyName, async function (page, data, opts) {
     try {
-      const result = await renderer.apply(this, arguments)
-      if (!this.getHeader('Content-Type')) {
-        this.header('Content-Type', 'text/html; charset=' + charset)
-      }
-
-      if (minify && !isPathExcludedMinification(this)) {
-        this.send(await minify(result, globalOptions.htmlMinifierOptions))
-      } else {
-        this.send(result)
-      }
+      const html = await asyncRender.call(this, page, data, opts)
+      this.send(html)
     } catch (err) {
       this.send(err)
     }
+
     return this
   })
 
+  fastify.decorateReply(asyncPropertyName, asyncRender)
+
   if (!fastify.hasReplyDecorator('locals')) {
     fastify.decorateReply('locals', null)
 

test/test-ejs-async.js

@@ -506,3 +506,71 @@ test('reply.view with promise error', t => {
     })
   })
 })
+
+test('reply.viewAsync with ejs engine and async: true (global option)', t => {
+  t.plan(6)
+  const fastify = Fastify()
+  const ejs = require('ejs')
+
+  fastify.register(require('../index'), {
+    engine: { ejs },
+    options: { async: true },
+    templates: 'templates'
+  })
+
+  fastify.get('/', async (req, reply) => {
+    return reply.viewAsync('ejs-async.ejs')
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port
+    }, async (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+      t.equal(response.headers['content-length'], '' + body.length)
+      t.equal(response.headers['content-type'], 'text/html; charset=utf-8')
+      t.equal(await ejs.render(fs.readFileSync('./templates/ejs-async.ejs', 'utf8'), {}, { async: true }), body.toString())
+      fastify.close()
+    })
+  })
+})
+
+test('reply.viewAsync with ejs engine, async: true (global option), and html-minifier-terser', t => {
+  t.plan(6)
+  const fastify = Fastify()
+  const ejs = require('ejs')
+
+  fastify.register(require('../index'), {
+    engine: { ejs },
+    options: {
+      async: true,
+      useHtmlMinifier: minifier,
+      htmlMinifierOptions: minifierOpts
+    },
+    templates: 'templates'
+  })
+
+  fastify.get('/', (req, reply) => {
+    return reply.viewAsync('ejs-async.ejs')
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port
+    }, async (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+      t.equal(response.headers['content-length'], '' + body.length)
+      t.equal(response.headers['content-type'], 'text/html; charset=utf-8')
+      t.equal(await minifier.minify(await ejs.render(fs.readFileSync('./templates/ejs-async.ejs', 'utf8'), {}, { async: true }), minifierOpts), body.toString())
+      fastify.close()
+    })
+  })
+})