From aaaff46a1324eecd7bb2d6a65ec2916e38a1576a Mon Sep 17 00:00:00 2001
From: Vlad Sirenko <sirenkovladd@gmail.com>
Date: Tue, 19 Sep 2023 15:13:15 +0200
Subject: [PATCH] add parse raw template in view (#391)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* add parse raw template in view

* Update index.js

Co-authored-by: Gürgün Dayıoğlu <gurgun.dayioglu@icloud.com>

* add doc

---------

Co-authored-by: Gürgün Dayıoğlu <gurgun.dayioglu@icloud.com>
---
 .taprc                    |   1 -
 README.md                 | 328 ++++++++++++++++++++++++++++++++-
 index.js                  | 375 +++++++++++++++++++++++++-------------
 test/helper.js            |  36 ++++
 test/test-art-template.js | 106 +++++++++++
 test/test-dot.js          |  70 ++++++-
 test/test-ejs-async.js    | 122 +++++++++++++
 test/test-ejs.js          |  66 +++++++
 test/test-eta.js          | 129 +++++++++++++
 test/test-handlebars.js   | 202 +++++++++++++++++++-
 test/test-liquid.js       | 111 +++++++++++
 test/test-mustache.js     |  67 +++++++
 test/test-nunjucks.js     | 100 ++++++++++
 test/test-pug.js          |  66 +++++++
 test/test-twig.js         | 103 +++++++++++
 15 files changed, 1746 insertions(+), 136 deletions(-)

diff --git a/.taprc b/.taprc
index e205b5e8..27ed2557 100644
--- a/.taprc
+++ b/.taprc
@@ -3,7 +3,6 @@ jsx: false
 flow: false
 coverage: true
 nyc-arg: [--exclude=out]
-check-coverage: false
 
 files:
   - test/**/*.js
diff --git a/README.md b/README.md
index dc712b56..f9862a16 100644
--- a/README.md
+++ b/README.md
@@ -284,6 +284,37 @@ To use partials in mustache you will need to pass the names and paths in the opt
   }
 ```
 
+```js
+fastify.get('/', (req, reply) => {
+  reply.view('./templates/index.mustache', data)
+})
+```
+
+```js
+fastify.get('/', (req, reply) => {
+  fs.readFile('./templates/index.mustache', 'utf8', (err, file) => {
+    if (err) {
+      reply.send(err)
+    } else {
+      const render = mustache.render.bind(mustache, file)
+      reply.view(render, data)
+    }
+  })
+})
+```
+
+```js
+fastify.get('/', (req, reply) => {
+  fs.readFile('./templates/index.mustache', 'utf8', (err, file) => {
+    if (err) {
+      reply.send(err)
+    } else {
+      reply.view({ raw: file }, data)
+    }
+  })
+})
+```
+
 ### Handlebars
 
 To use partials in handlebars you will need to pass the names and paths in the options parameter:
@@ -330,6 +361,31 @@ fastify.get("/", (req, reply) => {
 });
 ```
 
+```js
+fastify.get('/', (req, reply) => {
+  fs.readFile('./templates/index.hbs', 'utf8', (err, file) => {
+    if (err) {
+      reply.send(err)
+    } else {
+      const render = handlebars.compile(file)
+      reply.view(render, data)
+    }
+  })
+})
+```
+
+```js
+fastify.get('/', (req, reply) => {
+  fs.readFile('./templates/index.hbs', 'utf8', (err, file) => {
+    if (err) {
+      reply.send(err)
+    } else {
+      reply.view({ raw: file }, data)
+    }
+  })
+})
+```
+
 ### Nunjucks
 
 You can load templates from multiple paths when using the nunjucks engine:
@@ -356,6 +412,37 @@ options: {
 }
 ```
 
+```js
+fastify.get('/', (req, reply) => {
+  reply.view('./templates/index.njk', data)
+})
+```
+
+```js
+fastify.get('/', (req, reply) => {
+  fs.readFile('./templates/index.njk', 'utf8', (err, file) => {
+    if (err) {
+      reply.send(err)
+    } else {
+      const render = nunjucks.compile(file)
+      reply.view(render, data)
+    }
+  })
+})
+```
+
+```js
+fastify.get('/', (req, reply) => {
+  fs.readFile('./templates/index.njk', 'utf8', (err, file) => {
+    if (err) {
+      reply.send(err)
+    } else {
+      reply.view({ raw: file }, data)
+    }
+  })
+})
+```
+
 ### Liquid
 
 To configure liquid you need to pass the engine instance as engine option:
@@ -380,6 +467,31 @@ fastify.get("/", (req, reply) => {
 });
 ```
 
+```js
+fastify.get('/', (req, reply) => {
+  fs.readFile('./templates/index.liquid', 'utf8', (err, file) => {
+    if (err) {
+      reply.send(err)
+    } else {
+      const render = engine.renderFile.bind(engine, './templates/index.liquid')
+      reply.view(render, data)
+    }
+  })
+})
+```
+
+```js
+fastify.get('/', (req, reply) => {
+  fs.readFile('./templates/index.liquid', 'utf8', (err, file) => {
+    if (err) {
+      reply.send(err)
+    } else {
+      reply.view({ raw: file }, data)
+    }
+  })
+})
+```
+
 ### doT
 
 When using [doT](https://github.com/olado/doT) the plugin compiles all templates when the application starts, this way all `.def` files are loaded and
@@ -388,8 +500,6 @@ This behavior is recommended by the doT team [here](https://github.com/olado/doT
 To make it possible it is necessary to provide a `root` or `templates` option with the path to the template directory.
 
 ```js
-const path = require('node:path');
-
 fastify.register(require("@fastify/view"), {
   engine: {
     dot: require("dot"),
@@ -406,6 +516,220 @@ fastify.get("/", (req, reply) => {
 });
 ```
 
+```js
+const d = dot.process({ path: 'templates', destination: 'out' })
+fastify.get('/', (req, reply) => {
+  reply.view(d.index, data)
+})
+```
+
+```js
+fastify.get('/', (req, reply) => {
+  reply.view({ raw: readFileSync('./templates/index.dot'), imports: { def: readFileSync('./templates/index.def') } }, data)
+})
+```
+
+### eta
+
+```js
+const { Eta } = require('eta')
+let eta = new Eta()
+fastify.register(pointOfView, {
+  engine: {
+    eta
+  },
+  templates: 'templates'
+})
+
+fastify.get("/", (req, reply) => {
+  reply.view("index.eta", { text: "text" });
+});
+```
+
+```js
+fastify.get('/', (req, reply) => {
+  fs.readFile('./templates/index.eta', 'utf8', (err, file) => {
+    if (err) {
+      reply.send(err)
+    } else {
+      reply.view(eta.compile(file), data)
+    }
+  })
+})
+```
+
+```js
+fastify.get('/', (req, reply) => {
+  fs.readFile('./templates/index.eta', 'utf8', (err, file) => {
+    if (err) {
+      reply.send(err)
+    } else {
+      reply.view({ raw: file }, data)
+    }
+  })
+})
+```
+
+### ejs
+
+```js
+const ejs = require('ejs')
+fastify.register(pointOfView, {
+  engine: {
+    ejs
+  },
+  templates: 'templates'
+})
+
+fastify.get("/", (req, reply) => {
+  reply.view("index.ejs", { text: "text" });
+});
+```
+
+```js
+fastify.get('/', (req, reply) => {
+  fs.readFile('./templates/index.ejs', 'utf8', (err, file) => {
+    if (err) {
+      reply.send(err)
+    } else {
+      reply.view(ejs.compile(file), data)
+    }
+  })
+})
+```
+
+```js
+fastify.get('/', (req, reply) => {
+  fs.readFile('./templates/index.ejs', 'utf8', (err, file) => {
+    if (err) {
+      reply.send(err)
+    } else {
+      reply.view({ raw: file }, data)
+    }
+  })
+})
+```
+
+### pug
+
+```js
+const pug = require('pug')
+fastify.register(pointOfView, {
+  engine: {
+    pug
+  }
+})
+
+
+fastify.get("/", (req, reply) => {
+  reply.view("index.pug", { text: "text" });
+});
+```
+
+```js
+fastify.get('/', (req, reply) => {
+  fs.readFile('./templates/index.pug', 'utf8', (err, file) => {
+    if (err) {
+      reply.send(err)
+    } else {
+      reply.view(pug.compile(file), data)
+    }
+  })
+})
+```
+
+```js
+fastify.get('/', (req, reply) => {
+  fs.readFile('./templates/index.pug', 'utf8', (err, file) => {
+    if (err) {
+      reply.send(err)
+    } else {
+      reply.view({ raw: file }, data)
+    }
+  })
+})
+```
+
+### twig
+
+```js
+const twig = require('twig')
+fastify.register(pointOfView, {
+  engine: {
+    twig
+  }
+})
+
+
+fastify.get("/", (req, reply) => {
+  reply.view("index.twig", { text: "text" });
+});
+```
+
+```js
+fastify.get('/', (req, reply) => {
+  fs.readFile('./templates/index.twig', 'utf8', (err, file) => {
+    if (err) {
+      reply.send(err)
+    } else {
+      reply.view(twig.twig({ data: file }), data)
+    }
+  })
+})
+```
+
+```js
+fastify.get('/', (req, reply) => {
+  fs.readFile('./templates/index.twig', 'utf8', (err, file) => {
+    if (err) {
+      reply.send(err)
+    } else {
+      reply.view({ raw: file }, data)
+    }
+  })
+})
+```
+
+### art
+
+```js
+const art = require('art-template')
+fastify.register(pointOfView, {
+  engine: {
+    'art-template': art
+  }
+})
+
+
+fastify.get("/", (req, reply) => {
+  reply.view("./index.art", { text: "text" });
+});
+```
+
+```js
+fastify.get('/', (req, reply) => {
+  fs.readFile('./templates/index.art', 'utf8', (err, file) => {
+    if (err) {
+      reply.send(err)
+    } else {
+      reply.view(art.compile({ filename: path.join(__dirname, '..', 'templates', 'index.art') }), data)
+    }
+  })
+})
+```
+
+```js
+fastify.get('/', (req, reply) => {
+  fs.readFile('./templates/index.art', 'utf8', (err, file) => {
+    if (err) {
+      reply.send(err)
+    } else {
+      reply.view({ raw: file }, data)
+    }
+  })
+})
+```
+
 <!---
 // This seems a bit random given that there was no mention of typescript before.
 ### Typing
diff --git a/index.js b/index.js
index 667259d8..42824a89 100644
--- a/index.js
+++ b/index.js
@@ -183,29 +183,44 @@ function fastifyView (fastify, opts, next) {
   function getRequestedPath (fastify) {
     return (fastify && fastify.request) ? fastify.request.routeOptions.url : null
   }
+  function onTemplatesLoaded (file, data, callback, requestedPath) {
+    if (useHtmlMinification(globalOptions, requestedPath)) {
+      data = globalOptions.useHtmlMinifier.minify(data, globalOptions.htmlMinifierOptions || {})
+    }
+    if (type === 'handlebars') {
+      data = engine.compile(data, globalOptions.compileOptions)
+    }
+    lru.set(file, data)
+    callback(null, data)
+  }
   // Gets template as string (or precompiled for Handlebars)
   // from LRU cache or filesystem.
   const getTemplate = function (file, callback, requestedPath) {
+    if (typeof file === 'function') {
+      callback(null, file)
+      return
+    }
+    let isRaw = false
+    if (typeof file === 'object' && file.raw) {
+      isRaw = true
+      file = file.raw
+    }
     const data = lru.get(file)
     if (data && prod) {
       callback(null, data)
-    } else {
-      readFile(join(templatesDir, file), 'utf-8', (err, data) => {
-        if (err) {
-          callback(err, null)
-          return
-        }
-
-        if (useHtmlMinification(globalOptions, requestedPath)) {
-          data = globalOptions.useHtmlMinifier.minify(data, globalOptions.htmlMinifierOptions || {})
-        }
-        if (type === 'handlebars') {
-          data = engine.compile(data, globalOptions.compileOptions)
-        }
-        lru.set(file, data)
-        callback(null, data)
-      })
+      return
+    }
+    if (isRaw) {
+      onTemplatesLoaded(file, file, callback, requestedPath)
+      return
     }
+    readFile(join(templatesDir, file), 'utf-8', (err, data) => {
+      if (err) {
+        callback(err, null)
+        return
+      }
+      onTemplatesLoaded(file, data, callback, requestedPath)
+    })
   }
 
   // Gets partials as collection of strings from LRU cache or filesystem.
@@ -253,59 +268,69 @@ function fastifyView (fastify, opts, next) {
     return cacheKey
   }
 
-  function readCallback (that, page, data, localOptions) {
-    return function _readCallback (err, html) {
-      const requestedPath = getRequestedPath(that)
-
-      if (err) {
-        that.send(err)
-        return
-      }
+  function readCallbackEnd (that, compile, data, localOptions) {
+    let cachedPage
+    try {
+      cachedPage = compile(data)
+    } catch (error) {
+      cachedPage = error
+    }
+    if (!that.getHeader('content-type')) {
+      that.header('Content-Type', 'text/html; charset=' + charset)
+    }
+    const requestedPath = getRequestedPath(that)
+    if (!localOptions) {
+      localOptions = globalOptions
+    }
+    if (type === 'ejs' && ((localOptions.async ?? globalOptions.async) || cachedPage instanceof Promise)) {
+      cachedPage.then(html => {
+        if (useHtmlMinification(globalOptions, requestedPath)) {
+          html = globalOptions.useHtmlMinifier.minify(html, globalOptions.htmlMinifierOptions || {})
+        }
+        that.send(html)
+      }).catch(err => that.send(err))
+      return
+    }
+    if (useHtmlMinification(globalOptions, requestedPath)) {
+      cachedPage = globalOptions.useHtmlMinifier.minify(cachedPage, globalOptions.htmlMinifierOptions || {})
+    }
+    that.send(cachedPage)
+  }
 
-      let compiledPage
-      try {
-        if ((type === 'ejs') && viewExt && !globalOptions.includer) {
-          globalOptions.includer = (originalPath, parsedPath) => {
-            return {
-              filename: parsedPath || join(templatesDir, originalPath + '.' + viewExt)
-            }
+  function readCallbackParser (that, page, html, localOptions) {
+    let compiledPage
+    try {
+      if ((type === 'ejs') && viewExt && !globalOptions.includer) {
+        globalOptions.includer = (originalPath, parsedPath) => {
+          return {
+            filename: parsedPath || join(templatesDir, originalPath + '.' + viewExt)
           }
         }
-        globalOptions.filename = join(templatesDir, page)
-        if (localOptions) {
-          for (const key in globalOptions) {
-            if (!Object.prototype.hasOwnProperty.call(localOptions, key)) localOptions[key] = globalOptions[key]
-          }
-        } else localOptions = globalOptions
-        compiledPage = engine.compile(html, localOptions)
-      } catch (error) {
-        that.send(error)
-        return
       }
-      lru.set(page, compiledPage)
+      if (localOptions) {
+        for (const key in globalOptions) {
+          if (!Object.prototype.hasOwnProperty.call(localOptions, key)) localOptions[key] = globalOptions[key]
+        }
+      } else localOptions = globalOptions
+      compiledPage = engine.compile(html, localOptions)
+    } catch (error) {
+      that.send(error)
+      return
+    }
+    lru.set(page, compiledPage)
+    return compiledPage
+  }
 
-      if (!that.getHeader('content-type')) {
-        that.header('Content-Type', 'text/html; charset=' + charset)
-      }
-      let cachedPage
-      try {
-        cachedPage = lru.get(page)(data)
-      } catch (error) {
-        cachedPage = error
-      }
-      if (type === 'ejs' && (localOptions.async ?? globalOptions.async)) {
-        cachedPage.then(html => {
-          if (useHtmlMinification(globalOptions, requestedPath)) {
-            html = globalOptions.useHtmlMinifier.minify(html, globalOptions.htmlMinifierOptions || {})
-          }
-          that.send(html)
-        }).catch(err => that.send(err))
+  function readCallback (that, page, data, localOptions) {
+    return function _readCallback (err, html) {
+      if (err) {
+        that.send(err)
         return
       }
-      if (useHtmlMinification(globalOptions, requestedPath)) {
-        cachedPage = globalOptions.useHtmlMinifier.minify(cachedPage, globalOptions.htmlMinifierOptions || {})
-      }
-      that.send(cachedPage)
+
+      globalOptions.filename = join(templatesDir, page)
+      const compiledPage = readCallbackParser(that, page, html, localOptions)
+      readCallbackEnd(that, compiledPage, data, localOptions)
     }
   }
 
@@ -344,19 +369,30 @@ function fastifyView (fastify, opts, next) {
     }
 
     data = Object.assign({}, defaultCtx, this.locals, data)
-    // append view extension
-    page = getPage(page, type)
+    if (typeof page === 'function') {
+      readCallbackEnd(this, page, data, opts)
+      return
+    }
+    let isRaw = false
+    if (typeof page === 'object' && page.raw) {
+      isRaw = true
+      page = page.raw.toString()
+    } else {
+      // append view extension
+      page = getPage(page, type)
+    }
 
     const toHtml = lru.get(page)
 
     if (toHtml && prod) {
-      if (!this.getHeader('content-type')) {
-        this.header('Content-Type', 'text/html; charset=' + charset)
-      }
-      this.send(toHtml(data))
+      readCallbackEnd(this, toHtml, data, opts)
+      return
+    }
+    if (isRaw) {
+      const compiledPage = readCallbackParser(this, page, page, opts)
+      readCallbackEnd(this, compiledPage, data, opts)
       return
     }
-
     readFile(join(templatesDir, page), 'utf8', readCallback(this, page, data, opts))
   }
 
@@ -377,38 +413,30 @@ function fastifyView (fastify, opts, next) {
       return
     }
     data = Object.assign({}, defaultCtx, this.locals, data)
-    // append view extension
-    page = getPage(page, type)
-    const requestedPath = getRequestedPath(this)
-    getTemplate(page, (err, template) => {
-      if (err) {
-        this.send(err)
-        return
-      }
-      const toHtml = lru.get(page)
-      if (toHtml && prod && (typeof (toHtml) === 'function')) {
-        if (!this.getHeader('content-type')) {
-          this.header('Content-Type', 'text/html; charset=' + charset)
-        }
-        if (opts?.async ?? globalOptions.async) {
-          toHtml(data).then(html => {
-            if (useHtmlMinification(globalOptions, requestedPath)) {
-              this.send(globalOptions.useHtmlMinifier.minify(html, globalOptions.htmlMinifierOptions || {}))
-              return
-            }
-            this.send(html)
-          }).catch(err => this.send(err))
-          return
-        }
-        if (useHtmlMinification(globalOptions, requestedPath)) {
-          this.send(globalOptions.useHtmlMinifier.minify(toHtml(data), globalOptions.htmlMinifierOptions || {}))
-          return
-        }
-        this.send(toHtml(data))
-        return
-      }
-      readFile(join(templatesDir, page), 'utf8', readCallback(this, page, data, opts))
-    }, requestedPath)
+    if (typeof page === 'function') {
+      readCallbackEnd(this, page, data, opts)
+      return
+    }
+    let isRaw = false
+    if (typeof page === 'object' && page.raw) {
+      isRaw = true
+      page = page.raw.toString()
+    } else {
+      // append view extension
+      page = getPage(page, type)
+    }
+    const toHtml = lru.get(page)
+
+    if (toHtml && prod) {
+      readCallbackEnd(this, toHtml, data, opts)
+      return
+    }
+    if (isRaw) {
+      const compiledPage = readCallbackParser(this, page, page, opts)
+      readCallbackEnd(this, compiledPage, data, opts)
+      return
+    }
+    readFile(join(templatesDir, page), 'utf8', readCallback(this, page, data, opts))
   }
 
   function viewArtTemplate (page, data) {
@@ -417,8 +445,11 @@ function fastifyView (fastify, opts, next) {
       return
     }
     data = Object.assign({}, defaultCtx, this.locals, data)
-    // Append view extension.
-    page = getPage(page, 'art')
+
+    if (typeof page === 'string') {
+      // Append view extension.
+      page = getPage(page, 'art')
+    }
 
     const defaultSetting = {
       debug: process.env.NODE_ENV !== 'production',
@@ -429,8 +460,18 @@ function fastifyView (fastify, opts, next) {
     const confs = Object.assign({}, defaultSetting, globalOptions)
 
     function render (filename, data) {
-      confs.filename = join(templatesDir, filename)
-      const render = engine.compile(confs)
+      let render
+      if (typeof filename === 'string') {
+        confs.filename = join(templatesDir, filename)
+        render = engine.compile(confs)
+      } else if (typeof filename === 'function') {
+        render = filename
+      } else if (typeof filename === 'object' && filename.raw) {
+        confs.source = filename.raw.toString()
+        render = engine.compile(confs)
+      } else {
+        throw new Error('Unknown template type')
+      }
       return render(data)
     }
 
@@ -451,9 +492,20 @@ function fastifyView (fastify, opts, next) {
       return
     }
     data = Object.assign({}, defaultCtx, this.locals, data)
-    // Append view extension.
-    page = getPage(page, 'njk')
-    nunjucksEnv.render(page, data, (err, html) => {
+    let render
+    if (typeof page === 'string') {
+      // Append view extension.
+      page = getPage(page, 'njk')
+      // template = nunjucksEnv.getTemplate(page)
+      render = nunjucksEnv.render.bind(nunjucksEnv, page)
+    } else if (typeof page === 'object' && typeof page.render === 'function') {
+      render = page.render.bind(page)
+    } else if (typeof page === 'object' && page.raw) {
+      render = nunjucksEnv.renderString.bind(nunjucksEnv, page.raw.toString())
+    } else {
+      throw new Error('Unknown template type')
+    }
+    render(data, (err, html) => {
       const requestedPath = getRequestedPath(this)
       if (err) return this.send(err)
       if (useHtmlMinification(globalOptions, requestedPath)) {
@@ -493,8 +545,10 @@ function fastifyView (fastify, opts, next) {
       data = Object.assign({}, defaultCtx, this.locals, data)
     }
 
-    // append view extension
-    page = getPage(page, 'hbs')
+    if (typeof page === 'string') {
+      // append view extension
+      page = getPage(page, 'hbs')
+    }
     const requestedPath = getRequestedPath(this)
     getTemplate(page, (err, template) => {
       if (err) {
@@ -546,8 +600,10 @@ function fastifyView (fastify, opts, next) {
 
     const options = Object.assign({}, opts)
     data = Object.assign({}, defaultCtx, this.locals, data)
-    // append view extension
-    page = getPage(page, 'mustache')
+    if (typeof page === 'string') {
+      // append view extension
+      page = getPage(page, 'mustache')
+    }
     const requestedPath = getRequestedPath(this)
     getTemplate(page, (err, templateString) => {
       if (err) {
@@ -559,7 +615,12 @@ function fastifyView (fastify, opts, next) {
           this.send(err)
           return
         }
-        const html = engine.render(templateString, data, partialsObject)
+        let html
+        if (typeof templateString === 'function') {
+          html = templateString(data, partialsObject)
+        } else {
+          html = engine.render(templateString, data, partialsObject)
+        }
 
         if (!this.getHeader('content-type')) {
           this.header('Content-Type', 'text/html; charset=' + charset)
@@ -576,9 +637,19 @@ function fastifyView (fastify, opts, next) {
     }
 
     data = Object.assign({}, defaultCtx, globalOptions, this.locals, data)
-    // Append view extension.
-    page = getPage(page, 'twig')
-    engine.renderFile(join(templatesDir, page), data, (err, html) => {
+    let render
+    if (typeof page === 'string') {
+      // Append view extension.
+      page = getPage(page, 'twig')
+      render = engine.renderFile.bind(engine, join(templatesDir, page))
+    } else if (typeof page === 'object' && typeof page.render === 'function') {
+      render = (data, cb) => cb(null, page.render(data))
+    } else if (typeof page === 'object' && page.raw) {
+      render = (data, cb) => cb(null, engine.twig({ data: page.raw.toString() }).render(data))
+    } else {
+      throw new Error('Unknown template type')
+    }
+    render(data, (err, html) => {
       const requestedPath = getRequestedPath(this)
       if (err) {
         return this.send(err)
@@ -600,10 +671,19 @@ function fastifyView (fastify, opts, next) {
     }
 
     data = Object.assign({}, defaultCtx, this.locals, data)
-    // Append view extension.
-    page = getPage(page, 'liquid')
-
-    engine.renderFile(join(templatesDir, page), data, opts)
+    let render
+    if (typeof page === 'string') {
+      // Append view extension.
+      page = getPage(page, 'liquid')
+      render = engine.renderFile.bind(engine, join(templatesDir, page))
+    } else if (typeof page === 'function') {
+      render = page
+    } else if (typeof page === 'object' && page.raw) {
+      const templates = engine.parse(page.raw)
+      render = engine.render.bind(engine, templates)
+    }
+
+    render(data, opts)
       .then((html) => {
         const requestedPath = getRequestedPath(this)
         if (useHtmlMinification(globalOptions, requestedPath)) {
@@ -636,7 +716,15 @@ function fastifyView (fastify, opts, next) {
         return
       }
       data = Object.assign({}, defaultCtx, this.locals, data)
-      let html = renderModule[page](data)
+      let render
+      if (typeof page === 'function') {
+        render = page
+      } else if (typeof page === 'object' && page.raw) {
+        render = engine.template(page.raw.toString(), { ...engine.templateSettings, ...globalOptions, ...page.settings }, page.imports)
+      } else {
+        render = renderModule[page]
+      }
+      let html = render(data)
       const requestedPath = getRequestedPath(this)
       if (useHtmlMinification(globalOptions, requestedPath)) {
         html = globalOptions.useHtmlMinifier.minify(html, globalOptions.htmlMinifierOptions || {})
@@ -672,13 +760,13 @@ function fastifyView (fastify, opts, next) {
     lru.define = lru.set
 
     engine.configure({
-      views: templatesDir || lru,
+      views: templatesDir,
       cache: prod || globalOptions.templatesSync
     })
 
     const config = Object.assign({
       cache: prod,
-      views: templatesDir || lru
+      views: templatesDir
     }, globalOptions)
 
     const sendContent = html => {
@@ -697,13 +785,38 @@ function fastifyView (fastify, opts, next) {
     }
 
     data = Object.assign({}, defaultCtx, this.locals, data)
-    // Append view extension (Eta will append '.eta' by default,
-    // but this also allows custom extensions)
-    page = getPage(page, 'eta')
+
+    if (typeof page === 'function') {
+      try {
+        const ret = page.call(engine, data, config)
+        if (ret instanceof Promise) {
+          ret.then(sendContent).catch(err => {
+            this.send(err)
+          })
+        } else {
+          sendContent(ret)
+        }
+      } catch (err) {
+        this.send(err)
+      }
+      return
+    }
+
+    let render, renderAsync
+    if (typeof page === 'object' && page.raw) {
+      page = page.raw.toString()
+      render = engine.renderString.bind(engine)
+      renderAsync = engine.renderStringAsync.bind(engine)
+    } else {
+      // Append view extension (Eta will append '.eta' by default,
+      // but this also allows custom extensions)
+      page = getPage(page, 'eta')
+      render = engine.render.bind(engine)
+      renderAsync = engine.renderAsync.bind(engine)
+    }
 
     if (opts?.async ?? globalOptions.async) {
-      engine
-        .renderAsync(page, data, config)
+      renderAsync(page, data, config)
         .then((res) => {
           sendContent(res)
         })
@@ -712,7 +825,7 @@ function fastifyView (fastify, opts, next) {
         })
     } else {
       try {
-        const html = engine.render(page, data, config)
+        const html = render(page, data, config)
         sendContent(html)
       } catch (err) {
         this.send(err)
@@ -721,7 +834,7 @@ function fastifyView (fastify, opts, next) {
   }
 
   if (prod && type === 'handlebars' && globalOptions.partials) {
-    getPartials(type, { partials: globalOptions.partials || {}, requestedPath: getRequestedPath(this) }, (err, partialsObject) => {
+    getPartials(type, { partials: globalOptions.partials, requestedPath: getRequestedPath(this) }, (err, partialsObject) => {
       if (err) {
         next(err)
         return
@@ -750,7 +863,7 @@ function fastifyView (fastify, opts, next) {
               return
             }
 
-            data = Object.assign((data || {}), { body: result })
+            data = Object.assign(data, { body: result })
             render.call(that, layout, data, opts)
           }
         }, page, data, opts)
diff --git a/test/helper.js b/test/helper.js
index fef53341..3a4edec6 100644
--- a/test/helper.js
+++ b/test/helper.js
@@ -142,6 +142,42 @@ module.exports.etaHtmlMinifierTests = function (t, withMinifierOptions) {
       })
     })
   })
+
+  test('reply.view with eta engine and async and html-minifier', t => {
+    t.plan(6)
+    const fastify = Fastify()
+
+    fastify.register(POV, {
+      engine: {
+        eta
+      },
+      options: {
+        useHtmlMinifier: minifier,
+        async: true,
+        ...(withMinifierOptions && { htmlMinifierOptions: minifierOpts })
+      }
+    })
+
+    fastify.get('/', (req, reply) => {
+      reply.view('templates/index.eta', data)
+    })
+
+    fastify.listen({ port: 0 }, err => {
+      t.error(err)
+
+      sget({
+        method: 'GET',
+        url: 'http://localhost:' + fastify.server.address().port
+      }, (err, response, body) => {
+        t.error(err)
+        t.equal(response.statusCode, 200)
+        t.equal(response.headers['content-length'], String(body.length))
+        t.equal(response.headers['content-type'], 'text/html; charset=utf-8')
+        t.equal(minifier.minify(eta.renderString(fs.readFileSync('./templates/index.eta', 'utf8'), data), options), body.toString())
+        fastify.close()
+      })
+    })
+  })
   test('reply.view with eta engine and paths excluded from html-minifier', t => {
     t.plan(6)
     const fastify = Fastify()
diff --git a/test/test-art-template.js b/test/test-art-template.js
index 8e66048a..385ac207 100644
--- a/test/test-art-template.js
+++ b/test/test-art-template.js
@@ -4,6 +4,7 @@ const t = require('tap')
 const test = t.test
 const sget = require('simple-get').concat
 const Fastify = require('fastify')
+const fs = require('node:fs')
 const path = require('node:path')
 
 test('reply.view with art-template engine and custom templates folder', t => {
@@ -496,3 +497,108 @@ test('reply.view with art-template should return 500 if render fails', t => {
     })
   })
 })
+
+test('reply.view with art-template engine and raw template', t => {
+  t.plan(6)
+  const fastify = Fastify()
+  const art = require('art-template')
+  const data = { text: 'text' }
+
+  fastify.register(require('../index'), {
+    engine: {
+      'art-template': art
+    },
+    templates: 'templates'
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.view({ raw: fs.readFileSync('./templates/index.art') }, data)
+  })
+
+  fastify.listen({ port: 10086 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'GET',
+      url: 'http://127.0.0.1:10086/'
+    }, (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')
+
+      const templatePath = path.join(__dirname, '..', 'templates', 'index.art')
+
+      t.equal(art(templatePath, data), body.toString())
+      fastify.close()
+    })
+  })
+})
+
+test('reply.view with art-template engine and function template', t => {
+  t.plan(6)
+  const fastify = Fastify()
+  const art = require('art-template')
+  const data = { text: 'text' }
+
+  fastify.register(require('../index'), {
+    engine: {
+      'art-template': art
+    },
+    templates: 'templates'
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.header('Content-Type', 'text/html').view(art.compile({ filename: path.join(__dirname, '..', 'templates', 'index.art') }), data)
+  })
+
+  fastify.listen({ port: 10086 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'GET',
+      url: 'http://127.0.0.1:10086/'
+    }, (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')
+
+      const templatePath = path.join(__dirname, '..', 'templates', 'index.art')
+
+      t.equal(art(templatePath, data), body.toString())
+      fastify.close()
+    })
+  })
+})
+
+test('reply.view with art-template engine and unknown template type', t => {
+  t.plan(3)
+  const fastify = Fastify()
+  const art = require('art-template')
+  const data = { text: 'text' }
+
+  fastify.register(require('../index'), {
+    engine: {
+      'art-template': art
+    },
+    templates: 'templates'
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.view({}, data)
+  })
+
+  fastify.listen({ port: 10086 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'GET',
+      url: 'http://127.0.0.1:10086/'
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 500)
+      fastify.close()
+    })
+  })
+})
diff --git a/test/test-dot.js b/test/test-dot.js
index a4f3e538..cb0fc297 100644
--- a/test/test-dot.js
+++ b/test/test-dot.js
@@ -4,7 +4,7 @@ const t = require('tap')
 const test = t.test
 const sget = require('simple-get').concat
 const Fastify = require('fastify')
-const { existsSync, rmdirSync } = require('node:fs')
+const { existsSync, rmdirSync, readFileSync } = require('node:fs')
 const { join } = require('node:path')
 const pino = require('pino')
 const split = require('split2')
@@ -580,3 +580,71 @@ test('reply.view should return 500 if layout is missing on render', t => {
     })
   })
 })
+
+test('reply.view with dot engine and raw template', t => {
+  t.plan(6)
+  const fastify = Fastify()
+  const data = { text: 'text' }
+  const engine = require('dot')
+  engine.log = false
+
+  fastify.register(require('../index'), {
+    engine: {
+      dot: engine
+    }
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.view({ raw: readFileSync('./templates/testdot.dot'), imports: { testdef: readFileSync('./templates/testdef.def') } }, data)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port
+    }, (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(body.toString(), engine.process({ path: 'templates', destination: 'out' }).testdot(data))
+      fastify.close()
+    })
+  })
+})
+
+test('reply.view with dot engine and function template', t => {
+  t.plan(6)
+  const fastify = Fastify()
+  const data = { text: 'text' }
+  const engine = require('dot')
+  engine.log = false
+
+  fastify.register(require('../index'), {
+    engine: {
+      dot: engine
+    }
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.header('Content-Type', 'text/html').view(engine.process({ path: 'templates', destination: 'out' }).testdot, data)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port
+    }, (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')
+      t.equal(body.toString(), engine.process({ path: 'templates', destination: 'out' }).testdot(data))
+      fastify.close()
+    })
+  })
+})
diff --git a/test/test-ejs-async.js b/test/test-ejs-async.js
index 64729953..b7aa82c3 100644
--- a/test/test-ejs-async.js
+++ b/test/test-ejs-async.js
@@ -115,6 +115,41 @@ test('reply.view with ejs engine, async: true (global option), and html-minifier
   })
 })
 
+test('reply.view with ejs engine, async: true (global option), and html-minifier without option', t => {
+  t.plan(6)
+  const fastify = Fastify()
+  const ejs = require('ejs')
+
+  fastify.register(require('../index'), {
+    engine: { ejs },
+    options: {
+      async: true,
+      useHtmlMinifier: minifier
+    },
+    templates: 'templates'
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.view('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(minifier.minify(await ejs.render(fs.readFileSync('./templates/ejs-async.ejs', 'utf8'), {}, { async: true })), body.toString())
+      fastify.close()
+    })
+  })
+})
+
 test('reply.view with ejs engine, async: true (global option), and html-minifier in production mode', t => {
   const numTests = 3
   t.plan(numTests * 5 + 1)
@@ -384,3 +419,90 @@ test('reply.view with ejs engine, async: false (local override), and html-minifi
     }
   })
 })
+
+test('reply.view with ejs engine and async: true and raw template', t => {
+  t.plan(6)
+  const fastify = Fastify()
+  const ejs = require('ejs')
+
+  fastify.register(require('../index'), {
+    engine: { ejs }
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.view({ raw: fs.readFileSync('./templates/ejs-async.ejs', 'utf8') }, {}, { async: true })
+  })
+
+  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.view with ejs engine and async: true and function template', t => {
+  t.plan(6)
+  const fastify = Fastify()
+  const ejs = require('ejs')
+
+  fastify.register(require('../index'), {
+    engine: { ejs }
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.view(ejs.compile(fs.readFileSync('./templates/ejs-async.ejs', 'utf8'), { async: true }), {})
+  })
+
+  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.view with promise error', t => {
+  t.plan(3)
+  const fastify = Fastify()
+  const ejs = require('ejs')
+
+  fastify.register(require('../index'), {
+    engine: { ejs }
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.view(() => Promise.reject(new Error('error')), {})
+  })
+
+  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, 500)
+      fastify.close()
+    })
+  })
+})
diff --git a/test/test-ejs.js b/test/test-ejs.js
index 572f152a..8c41fd6d 100644
--- a/test/test-ejs.js
+++ b/test/test-ejs.js
@@ -1134,3 +1134,69 @@ test('fastify.view with ejs engine and callback in production mode', t => {
     })
   })
 })
+
+test('reply.view with ejs engine and raw template', t => {
+  t.plan(6)
+  const fastify = Fastify()
+  const ejs = require('ejs')
+  const data = { text: 'text' }
+
+  fastify.register(require('../index'), {
+    engine: {
+      ejs
+    }
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.view({ raw: fs.readFileSync('./templates/index.ejs', 'utf8') }, data)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port
+    }, (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(ejs.render(fs.readFileSync('./templates/index.ejs', 'utf8'), data), body.toString())
+      fastify.close()
+    })
+  })
+})
+
+test('reply.view with ejs engine and function template', t => {
+  t.plan(6)
+  const fastify = Fastify()
+  const ejs = require('ejs')
+  const data = { text: 'text' }
+
+  fastify.register(require('../index'), {
+    engine: {
+      ejs
+    }
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.view(ejs.compile(fs.readFileSync('./templates/index.ejs', 'utf8')), data)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port
+    }, (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(ejs.render(fs.readFileSync('./templates/index.ejs', 'utf8'), data), body.toString())
+      fastify.close()
+    })
+  })
+})
diff --git a/test/test-eta.js b/test/test-eta.js
index 0a459152..3a15a043 100644
--- a/test/test-eta.js
+++ b/test/test-eta.js
@@ -991,3 +991,132 @@ test('fastify.view with eta engine and async in production mode', t => {
     })
   })
 })
+
+test('reply.view with eta engine and raw template', t => {
+  t.plan(6)
+  const fastify = Fastify()
+
+  const data = { text: 'text' }
+
+  fastify.register(pointOfView, {
+    engine: {
+      eta
+    }
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.view({ raw: fs.readFileSync('./templates/index.eta', 'utf8') }, data)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port
+    }, (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(eta.renderString(fs.readFileSync('./templates/index.eta', 'utf8'), data), body.toString())
+      fastify.close()
+    })
+  })
+})
+
+test('reply.view with eta engine and function template', t => {
+  t.plan(6)
+  const fastify = Fastify()
+
+  const data = { text: 'text' }
+
+  fastify.register(pointOfView, {
+    engine: {
+      eta
+    },
+    templates: 'templates'
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.view(eta.compile(fs.readFileSync('./templates/index.eta', 'utf8')), data)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port
+    }, (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(eta.renderString(fs.readFileSync('./templates/index.eta', 'utf8'), data), body.toString())
+      fastify.close()
+    })
+  })
+})
+
+test('reply.view should return 500 if function return sync error', t => {
+  t.plan(3)
+  const fastify = Fastify()
+
+  const data = { text: 'text' }
+
+  fastify.register(pointOfView, {
+    engine: {
+      eta
+    },
+    root: path.join(__dirname, '../templates')
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.view(() => { throw new Error('kaboom') }, data)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 500)
+      fastify.close()
+    })
+  })
+})
+
+test('reply.view should return 500 if function return async error', t => {
+  t.plan(3)
+  const fastify = Fastify()
+
+  const data = { text: 'text' }
+
+  fastify.register(pointOfView, {
+    engine: {
+      eta
+    },
+    root: path.join(__dirname, '../templates')
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.view(() => Promise.reject(new Error('kaboom')), data)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 500)
+      fastify.close()
+    })
+  })
+})
diff --git a/test/test-handlebars.js b/test/test-handlebars.js
index b4102005..898a42a1 100644
--- a/test/test-handlebars.js
+++ b/test/test-handlebars.js
@@ -876,6 +876,45 @@ test('reply.view with handlebars engine with useDataVariables', t => {
   })
 })
 
+test('reply.view with handlebars engine with useDataVariables and global Ctx', t => {
+  t.plan(6)
+  const fastify = Fastify()
+  const handlebars = require('handlebars').create()
+  const compileOptions = { strict: true }
+  const data = { text: 'text' }
+
+  fastify.register(require('../index'), {
+    engine: {
+      handlebars
+    },
+    options: {
+      compileOptions,
+      useDataVariables: true,
+      partials: { body: './templates/body-data.hbs' }
+    },
+    defaultContext: data
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.view('./templates/index-with-partials.hbs', null)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port
+    }, (err, response, replyBody) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+      t.equal(response.headers['content-length'], '' + replyBody.length)
+      t.equal(response.headers['content-type'], 'text/html; charset=utf-8')
+      t.equal(handlebars.compile(fs.readFileSync('./templates/index-with-partials.hbs', 'utf8'), compileOptions)(null, { data }), replyBody.toString())
+      fastify.close()
+    })
+  })
+})
+
 test('reply.view with handlebars engine with layout option', t => {
   t.plan(6)
   const fastify = Fastify()
@@ -1035,7 +1074,7 @@ test('reply.view with handlebars engine should return 500 if template fails in p
   })
 
   fastify.get('/', (req, reply) => {
-    reply.view('./templates/index.hbs')
+    reply.view('./templates/index-for-layout.hbs')
   })
 
   fastify.listen({ port: 0 }, err => {
@@ -1054,3 +1093,164 @@ test('reply.view with handlebars engine should return 500 if template fails in p
     })
   })
 })
+
+test('reply.view with handlebars engine and raw template', t => {
+  t.plan(6)
+  const fastify = Fastify()
+  const handlebars = require('handlebars')
+  const data = { text: 'text' }
+
+  fastify.register(require('../index'), {
+    engine: {
+      handlebars
+    }
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.header('Content-Type', 'text/html').view({ raw: fs.readFileSync('./templates/index.html', 'utf8') }, data)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port
+    }, (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')
+      t.equal(handlebars.compile(fs.readFileSync('./templates/index.html', 'utf8'))(data), body.toString())
+      fastify.close()
+    })
+  })
+})
+
+test('reply.view with handlebars engine and function template', t => {
+  t.plan(6)
+  const fastify = Fastify()
+  const handlebars = require('handlebars')
+  const data = { text: 'text' }
+
+  fastify.register(require('../index'), {
+    engine: {
+      handlebars
+    }
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.view(handlebars.compile(fs.readFileSync('./templates/index.html', 'utf8')), data)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port
+    }, (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(handlebars.compile(fs.readFileSync('./templates/index.html', 'utf8'))(data), body.toString())
+      fastify.close()
+    })
+  })
+})
+
+test('reply.view with handlebars engine and empty template', t => {
+  t.plan(3)
+  const fastify = Fastify()
+  const handlebars = require('handlebars')
+  const data = { text: 'text' }
+
+  fastify.register(require('../index'), {
+    engine: {
+      handlebars
+    }
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.view(null, data)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 500)
+      fastify.close()
+    })
+  })
+})
+
+test('fastify.view with handlebars engine and callback in production mode and header', t => {
+  t.plan(6)
+  const fastify = Fastify()
+  const handlebars = require('handlebars')
+
+  fastify.register(require('../index'), {
+    engine: {
+      handlebars
+    },
+    production: true,
+    layout: './templates/layout.hbs'
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.header('Content-Type', 'text/html').view('./templates/index-for-layout.hbs', null)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port
+    }, (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')
+      t.equal(handlebars.compile(fs.readFileSync('./templates/index.hbs', 'utf8'))(), body.toString())
+      fastify.close()
+    })
+  })
+})
+
+test('fastify.view with handlebars engine and both layout', t => {
+  t.plan(3)
+  const fastify = Fastify()
+  const handlebars = require('handlebars')
+  const data = { text: 'text' }
+
+  fastify.register(require('../index'), {
+    engine: {
+      handlebars
+    },
+    layout: './templates/layout.hbs'
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.header('Content-Type', 'text/html').view('./templates/index.hbs', data, { layout: './templates/layout.hbs' })
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 500)
+      fastify.close()
+    })
+  })
+})
diff --git a/test/test-liquid.js b/test/test-liquid.js
index adea4078..3acf42a1 100644
--- a/test/test-liquid.js
+++ b/test/test-liquid.js
@@ -3,6 +3,7 @@
 const t = require('tap')
 const test = t.test
 const sget = require('simple-get').concat
+const fs = require('node:fs')
 const Fastify = require('fastify')
 
 require('./helper').liquidHtmlMinifierTests(t, true)
@@ -481,3 +482,113 @@ test('fastify.view with liquid engine template that does not exist errors correc
     })
   })
 })
+
+test('reply.view with liquid engine and raw template', t => {
+  t.plan(7)
+  const fastify = Fastify()
+  const { Liquid } = require('liquidjs')
+  const data = { text: 'text' }
+
+  const engine = new Liquid()
+
+  fastify.register(require('../index'), {
+    engine: {
+      liquid: engine
+    }
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.view({ raw: fs.readFileSync('./templates/index.liquid', 'utf8') }, data)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port
+    }, (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')
+      engine.renderFile('./templates/index.liquid', data)
+        .then((html) => {
+          t.error(err)
+          t.equal(html, body.toString())
+        })
+      fastify.close()
+    })
+  })
+})
+
+test('reply.view with liquid engine and function template', t => {
+  t.plan(7)
+  const fastify = Fastify()
+  const { Liquid } = require('liquidjs')
+  const data = { text: 'text' }
+
+  const engine = new Liquid()
+
+  fastify.register(require('../index'), {
+    engine: {
+      liquid: engine
+    }
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.header('Content-Type', 'text/html').view(engine.renderFile.bind(engine, './templates/index.liquid'), data)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port
+    }, (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')
+      engine.renderFile('./templates/index.liquid', data)
+        .then((html) => {
+          t.error(err)
+          t.equal(html, body.toString())
+        })
+      fastify.close()
+    })
+  })
+})
+
+test('reply.view with liquid engine and unknown template type', t => {
+  t.plan(3)
+  const fastify = Fastify()
+  const { Liquid } = require('liquidjs')
+  const data = { text: 'text' }
+
+  const engine = new Liquid()
+
+  fastify.register(require('../index'), {
+    engine: {
+      liquid: engine
+    }
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.view({ }, data)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 500)
+      fastify.close()
+    })
+  })
+})
diff --git a/test/test-mustache.js b/test/test-mustache.js
index 47fae3cf..4c9aad34 100644
--- a/test/test-mustache.js
+++ b/test/test-mustache.js
@@ -721,3 +721,70 @@ test('fastify.view with mustache engine, should throw page missing', t => {
     })
   })
 })
+test('reply.view for mustache and raw template', t => {
+  t.plan(6)
+  const fastify = Fastify()
+  const mustache = require('mustache')
+  const data = { text: 'text' }
+
+  fastify.register(require('../index'), {
+    engine: {
+      mustache
+    },
+    defaultContext: data
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.view({ raw: fs.readFileSync('./templates/index.html', 'utf8') })
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port
+    }, (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(mustache.render(fs.readFileSync('./templates/index.html', 'utf8'), data), body.toString())
+      fastify.close()
+    })
+  })
+})
+
+test('reply.view for mustache and function template', t => {
+  t.plan(6)
+  const fastify = Fastify()
+  const mustache = require('mustache')
+  const data = { text: 'text' }
+
+  fastify.register(require('../index'), {
+    engine: {
+      mustache
+    },
+    defaultContext: data
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.header('Content-Type', 'text/html').view((mustache.render.bind(mustache, fs.readFileSync('./templates/index.html', 'utf8'))))
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port
+    }, (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')
+      t.equal(mustache.render(fs.readFileSync('./templates/index.html', 'utf8'), data), body.toString())
+      fastify.close()
+    })
+  })
+})
diff --git a/test/test-nunjucks.js b/test/test-nunjucks.js
index 1c5ef447..be1fde6c 100644
--- a/test/test-nunjucks.js
+++ b/test/test-nunjucks.js
@@ -3,6 +3,7 @@
 const t = require('tap')
 const test = t.test
 const sget = require('simple-get').concat
+const fs = require('node:fs')
 const Fastify = require('fastify')
 const path = require('node:path')
 
@@ -537,3 +538,102 @@ test('fastify.view with nunjucks engine should return 500 if render fails', t =>
     })
   })
 })
+
+test('reply.view with nunjucks engine and raw template', t => {
+  t.plan(6)
+  const fastify = Fastify()
+  const nunjucks = require('nunjucks')
+  const data = { text: 'text' }
+
+  fastify.register(require('../index'), {
+    engine: {
+      nunjucks
+    },
+    templates: 'templates'
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.view({ raw: fs.readFileSync('./templates/index.njk') }, data)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port
+    }, (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(nunjucks.render('index.njk', data), body.toString())
+      fastify.close()
+    })
+  })
+})
+
+test('reply.view with nunjucks engine and function template', t => {
+  t.plan(6)
+  const fastify = Fastify()
+  const nunjucks = require('nunjucks')
+  const data = { text: 'text' }
+
+  fastify.register(require('../index'), {
+    engine: {
+      nunjucks
+    },
+    templates: 'templates'
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.view(nunjucks.compile(fs.readFileSync('./templates/index.njk').toString()), data)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port
+    }, (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(nunjucks.render('index.njk', data), body.toString())
+      fastify.close()
+    })
+  })
+})
+
+test('reply.view with nunjucks engine and unknown template type', t => {
+  t.plan(3)
+  const fastify = Fastify()
+  const nunjucks = require('nunjucks')
+  const data = { text: 'text' }
+
+  fastify.register(require('../index'), {
+    engine: {
+      nunjucks
+    },
+    templates: 'templates'
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.view({ }, data)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 500)
+      fastify.close()
+    })
+  })
+})
diff --git a/test/test-pug.js b/test/test-pug.js
index 9d0279a2..484bc72e 100644
--- a/test/test-pug.js
+++ b/test/test-pug.js
@@ -498,3 +498,69 @@ test('reply.view with pug engine should return 500 if compile fails', t => {
     })
   })
 })
+
+test('reply.view with pug engine and raw template', t => {
+  t.plan(6)
+  const fastify = Fastify()
+  const pug = require('pug')
+  const data = { text: 'text' }
+
+  fastify.register(require('../index'), {
+    engine: {
+      pug
+    }
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.view({ raw: fs.readFileSync('./templates/index.pug', 'utf8') }, data)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port
+    }, (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(pug.render(fs.readFileSync('./templates/index.pug', 'utf8'), data), body.toString())
+      fastify.close()
+    })
+  })
+})
+
+test('reply.view with pug engine and function template', t => {
+  t.plan(6)
+  const fastify = Fastify()
+  const pug = require('pug')
+  const data = { text: 'text' }
+
+  fastify.register(require('../index'), {
+    engine: {
+      pug
+    }
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.view(pug.compile(fs.readFileSync('./templates/index.pug', 'utf8')), data)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port
+    }, (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(pug.render(fs.readFileSync('./templates/index.pug', 'utf8'), data), body.toString())
+      fastify.close()
+    })
+  })
+})
diff --git a/test/test-twig.js b/test/test-twig.js
index faf0db3a..42f1cd95 100644
--- a/test/test-twig.js
+++ b/test/test-twig.js
@@ -3,6 +3,7 @@
 const t = require('tap')
 const test = t.test
 const sget = require('simple-get').concat
+const fs = require('node:fs')
 const Fastify = require('fastify')
 
 require('./helper').twigHtmlMinifierTests(t, true)
@@ -451,3 +452,105 @@ test('reply.view with twig engine should return 500 if renderFile fails', t => {
     })
   })
 })
+
+test('reply.view with twig engine and raw template', t => {
+  t.plan(7)
+  const fastify = Fastify()
+  const Twig = require('twig')
+  const data = { title: 'fastify', text: 'text' }
+
+  fastify.register(require('../index'), {
+    engine: {
+      twig: Twig
+    }
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.view({ raw: fs.readFileSync('./templates/index.twig') }, data)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port
+    }, (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')
+      Twig.renderFile('./templates/index.twig', data, (err, html) => {
+        t.error(err)
+        t.equal(html, body.toString())
+      })
+      fastify.close()
+    })
+  })
+})
+
+test('reply.view with twig engine and function template', t => {
+  t.plan(7)
+  const fastify = Fastify()
+  const Twig = require('twig')
+  const data = { title: 'fastify', text: 'text' }
+
+  fastify.register(require('../index'), {
+    engine: {
+      twig: Twig
+    }
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.view(Twig.twig({ data: fs.readFileSync('./templates/index.twig').toString() }), data)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port
+    }, (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')
+      Twig.renderFile('./templates/index.twig', data, (err, html) => {
+        t.error(err)
+        t.equal(html, body.toString())
+      })
+      fastify.close()
+    })
+  })
+})
+
+test('reply.view with twig engine and unknown template type', t => {
+  t.plan(3)
+  const fastify = Fastify()
+  const Twig = require('twig')
+  const data = { title: 'fastify', text: 'text' }
+
+  fastify.register(require('../index'), {
+    engine: {
+      twig: Twig
+    }
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.view({ }, data)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 500)
+      fastify.close()
+    })
+  })
+})