mirror of
https://github.com/nuxt/nuxt.git
synced 2024-11-11 16:43:55 +00:00
354 lines
11 KiB
JavaScript
354 lines
11 KiB
JavaScript
import ansiHTML from 'ansi-html'
|
|
import serialize from 'serialize-javascript'
|
|
import generateETag from 'etag'
|
|
import fresh from 'fresh'
|
|
import Tapable from 'tappable'
|
|
import pify from 'pify'
|
|
import serveStatic from 'serve-static'
|
|
import compression from 'compression'
|
|
import _ from 'lodash'
|
|
import { resolve, join } from 'path'
|
|
import fs from 'fs-extra'
|
|
import { createBundleRenderer } from 'vue-server-renderer'
|
|
import { getContext, setAnsiColors, encodeHtml } from 'utils'
|
|
import Debug from 'debug'
|
|
|
|
const debug = Debug('nuxt:render')
|
|
debug.color = 4 // Force blue color
|
|
|
|
setAnsiColors(ansiHTML)
|
|
|
|
let jsdom = null
|
|
|
|
const parseTemplate = templateStr => _.template(templateStr, {
|
|
interpolate: /{{([\s\S]+?)}}/g
|
|
})
|
|
|
|
export default class Renderer extends Tapable {
|
|
constructor (nuxt) {
|
|
super()
|
|
this.nuxt = nuxt
|
|
this.options = nuxt.options
|
|
|
|
// Will be set by createRenderer
|
|
this.bundleRenderer = null
|
|
|
|
// Renderer runtime resources
|
|
this.resources = {
|
|
clientManifest: null,
|
|
serverBundle: null,
|
|
appTemplate: null,
|
|
errorTemplate: '<pre>{{ stack }}</pre>' // Will be loaded on ready
|
|
}
|
|
|
|
// Initialize
|
|
if (nuxt.initialized) {
|
|
// If nuxt already initialized
|
|
this._ready = this.ready().catch(this.nuxt.errorHandler)
|
|
} else {
|
|
// Wait for hook
|
|
this.nuxt.plugin('afterInit', () => {
|
|
this._ready = this.ready()
|
|
return this._ready
|
|
})
|
|
}
|
|
}
|
|
|
|
async ready () {
|
|
if (this._ready) {
|
|
return this._ready
|
|
}
|
|
|
|
// For serving static/ files to /
|
|
this.serveStatic = pify(serveStatic(resolve(this.options.srcDir, 'static'), this.options.render.static))
|
|
|
|
// For serving .nuxt/dist/ files (only when build.publicPath is not an URL)
|
|
this.serveStaticNuxt = pify(serveStatic(resolve(this.options.buildDir, 'dist'), {
|
|
maxAge: (this.options.dev ? 0 : '1y') // 1 year in production
|
|
}))
|
|
|
|
// gzip middleware for production
|
|
if (!this.options.dev && this.options.render.gzip) {
|
|
this.gzipMiddleware = pify(compression(this.options.render.gzip))
|
|
}
|
|
|
|
const errorTemplatePath = resolve(this.options.buildDir, 'views/error.html')
|
|
if (fs.existsSync(errorTemplatePath)) {
|
|
this.resources.errorTemplate = parseTemplate(fs.readFileSync(errorTemplatePath, 'utf8'))
|
|
}
|
|
|
|
// Load resources from fs
|
|
if (!this.options.dev) {
|
|
await this.loadResources()
|
|
}
|
|
|
|
return this
|
|
}
|
|
|
|
async loadResources (_fs = fs, isServer) {
|
|
let distPath = resolve(this.options.buildDir, 'dist')
|
|
|
|
const resourceMap = {
|
|
clientManifest: {
|
|
path: join(distPath, 'vue-ssr-client-manifest.json'),
|
|
transform: JSON.parse
|
|
},
|
|
serverBundle: {
|
|
path: join(distPath, 'server-bundle.json'),
|
|
transform: JSON.parse
|
|
},
|
|
appTemplate: {
|
|
path: join(distPath, 'index.html'),
|
|
transform: parseTemplate
|
|
}
|
|
}
|
|
|
|
let updated = []
|
|
|
|
Object.keys(resourceMap).forEach(resourceKey => {
|
|
let { path, transform } = resourceMap[resourceKey]
|
|
let rawKey = '$$' + resourceKey
|
|
let rawData, data
|
|
if (!_fs.existsSync(path)) {
|
|
return // Resource not exists
|
|
}
|
|
rawData = _fs.readFileSync(path, 'utf8')
|
|
if (!rawData || rawData === this.resources[rawKey]) {
|
|
return // No changes
|
|
}
|
|
this.resources[rawKey] = rawData
|
|
data = transform(rawData)
|
|
if (!data) {
|
|
return // Invalid data ?
|
|
}
|
|
this.resources[resourceKey] = data
|
|
updated.push(resourceKey)
|
|
})
|
|
|
|
if (updated.length > 0) {
|
|
// debug('Updated', updated.join(', '), isServer)
|
|
this.createRenderer()
|
|
}
|
|
}
|
|
|
|
createRenderer () {
|
|
// If resources are not yet provided
|
|
if (!this.resources.serverBundle || !this.resources.clientManifest) {
|
|
return
|
|
}
|
|
|
|
// Create bundle renderer for SSR
|
|
this.bundleRenderer = createBundleRenderer(this.resources.serverBundle, Object.assign({
|
|
clientManifest: this.resources.clientManifest,
|
|
runInNewContext: false,
|
|
basedir: this.options.rootDir
|
|
}, this.options.render.ssr))
|
|
|
|
// Promisify renderToString
|
|
this.bundleRenderer.renderToString = pify(this.bundleRenderer.renderToString)
|
|
|
|
if (!this.options.runBuild) {
|
|
this.nuxt.serverReady()
|
|
}
|
|
}
|
|
|
|
async render (req, res) {
|
|
// Get context
|
|
const context = getContext(req, res)
|
|
res.statusCode = 200
|
|
|
|
try {
|
|
// Gzip middleware for production
|
|
if (this.gzipMiddleware) {
|
|
await this.gzipMiddleware(req, res)
|
|
}
|
|
|
|
// If base in req.url, remove it for the middleware and vue-router
|
|
if (this.options.router.base !== '/' && req.url.indexOf(this.options.router.base) === 0) {
|
|
// Compatibility with base url for dev server
|
|
req.url = req.url.replace(this.options.router.base, '/')
|
|
}
|
|
|
|
// Call webpack middleware only in development
|
|
if (this.options.dev && this.nuxt.builder && this.nuxt.builder.webpackDevMiddleware) {
|
|
await this.nuxt.builder.webpackDevMiddleware(req, res)
|
|
await this.nuxt.builder.webpackHotMiddleware(req, res)
|
|
}
|
|
|
|
// Serve static/ files
|
|
await this.serveStatic(req, res)
|
|
|
|
// Serve .nuxt/dist/ files (only for production)
|
|
if (!this.options.dev && req.url.indexOf(this.options.build.publicPath) === 0) {
|
|
const url = req.url
|
|
req.url = req.url.replace(this.options.build.publicPath, '/')
|
|
// Forbid access to sensitive data (#916)
|
|
if (req.url.includes('server-bundle.json')) {
|
|
res.statusCode = 404
|
|
return res.end()
|
|
}
|
|
await this.serveStaticNuxt(req, res)
|
|
/* istanbul ignore next */
|
|
req.url = url
|
|
}
|
|
|
|
if (this.options.dev && req.url.indexOf(this.options.build.publicPath) === 0 && req.url.includes('.hot-update.json')) {
|
|
res.statusCode = 404
|
|
return res.end()
|
|
}
|
|
|
|
const { html, error, redirected, resourceHints } = await this.renderRoute(req.url, context)
|
|
|
|
if (redirected) {
|
|
return html
|
|
}
|
|
|
|
if (error) {
|
|
res.statusCode = context.nuxt.error.statusCode || 500
|
|
}
|
|
|
|
// ETag header
|
|
if (!error && this.options.render.etag) {
|
|
const etag = generateETag(html, this.options.render.etag)
|
|
if (fresh(req.headers, { etag })) {
|
|
res.statusCode = 304
|
|
res.end()
|
|
return
|
|
}
|
|
res.setHeader('ETag', etag)
|
|
}
|
|
|
|
// HTTP2 push headers
|
|
if (!error && this.options.render.http2.push) {
|
|
// Parse resourceHints to extract HTTP.2 prefetch/push headers
|
|
// https://w3c.github.io/preload/#server-push-http-2
|
|
const regex = /link rel="([^"]*)" href="([^"]*)" as="([^"]*)"/g
|
|
const pushAssets = []
|
|
let m
|
|
while (m = regex.exec(resourceHints)) { // eslint-disable-line no-cond-assign
|
|
const [_, rel, href, as] = m // eslint-disable-line no-unused-vars
|
|
if (rel === 'preload') {
|
|
pushAssets.push(`<${href}>; rel=${rel}; as=${as}`)
|
|
}
|
|
}
|
|
// Pass with single Link header
|
|
// https://blog.cloudflare.com/http-2-server-push-with-multiple-assets-per-link-header
|
|
res.setHeader('Link', pushAssets.join(','))
|
|
}
|
|
|
|
// Send response
|
|
res.setHeader('Content-Type', 'text/html; charset=utf-8')
|
|
res.setHeader('Content-Length', Buffer.byteLength(html))
|
|
res.end(html, 'utf8')
|
|
return html
|
|
} catch (err) {
|
|
/* istanbul ignore if */
|
|
if (context.redirected) {
|
|
console.error(err) // eslint-disable-line no-console
|
|
return err
|
|
}
|
|
// Render error template
|
|
const html = this.resources.errorTemplate({
|
|
/* istanbul ignore if */
|
|
error: err,
|
|
stack: ansiHTML(encodeHtml(err.stack))
|
|
})
|
|
// Send response
|
|
res.statusCode = 500
|
|
res.setHeader('Content-Type', 'text/html; charset=utf-8')
|
|
res.setHeader('Content-Length', Buffer.byteLength(html))
|
|
res.end(html, 'utf8')
|
|
return err
|
|
}
|
|
}
|
|
|
|
async renderRoute (url, context = {}) {
|
|
/* istanbul ignore if */
|
|
if (!this.bundleRenderer || !this.resources.appTemplate) {
|
|
return new Promise(resolve => {
|
|
setTimeout(() => resolve(this.renderRoute(url, context)), 1000)
|
|
})
|
|
}
|
|
|
|
// Log rendered url
|
|
debug(`Rendering url ${url}`)
|
|
|
|
// Add url and isSever to the context
|
|
context.url = url
|
|
context.isServer = true
|
|
|
|
// Call renderToString from the bundleRenderer and generate the HTML (will update the context as well)
|
|
let APP = await this.bundleRenderer.renderToString(context)
|
|
|
|
if (!context.nuxt.serverRendered) {
|
|
APP = '<div id="__nuxt"></div>'
|
|
}
|
|
const m = context.meta.inject()
|
|
let HEAD = m.meta.text() + m.title.text() + m.link.text() + m.style.text() + m.script.text() + m.noscript.text()
|
|
if (this.options._routerBaseSpecified) {
|
|
HEAD += `<base href="${this.options.router.base}">`
|
|
}
|
|
const resourceHints = context.renderResourceHints()
|
|
HEAD += resourceHints + context.renderStyles()
|
|
APP += `<script type="text/javascript">window.__NUXT__=${serialize(context.nuxt, { isJSON: true })}</script>`
|
|
APP += context.renderScripts()
|
|
|
|
const html = this.resources.appTemplate({
|
|
HTML_ATTRS: 'data-n-head-ssr ' + m.htmlAttrs.text(),
|
|
BODY_ATTRS: m.bodyAttrs.text(),
|
|
HEAD,
|
|
APP
|
|
})
|
|
|
|
return {
|
|
html,
|
|
resourceHints,
|
|
error: context.nuxt.error,
|
|
redirected: context.redirected
|
|
}
|
|
}
|
|
|
|
async renderAndGetWindow (url, opts = {}) {
|
|
/* istanbul ignore if */
|
|
if (!jsdom) {
|
|
try {
|
|
jsdom = require('jsdom')
|
|
} catch (e) /* istanbul ignore next */ {
|
|
console.error('Fail when calling nuxt.renderAndGetWindow(url)') // eslint-disable-line no-console
|
|
console.error('jsdom module is not installed') // eslint-disable-line no-console
|
|
console.error('Please install jsdom with: npm install --save-dev jsdom') // eslint-disable-line no-console
|
|
throw e
|
|
}
|
|
}
|
|
let options = {
|
|
resources: 'usable', // load subresources (https://github.com/tmpvar/jsdom#loading-subresources)
|
|
runScripts: 'dangerously',
|
|
beforeParse (window) {
|
|
// Mock window.scrollTo
|
|
window.scrollTo = () => {
|
|
}
|
|
}
|
|
}
|
|
if (opts.virtualConsole !== false) {
|
|
options.virtualConsole = new jsdom.VirtualConsole().sendTo(console)
|
|
}
|
|
url = url || 'http://localhost:3000'
|
|
const { window } = await jsdom.JSDOM.fromURL(url, options)
|
|
// If Nuxt could not be loaded (error from the server-side)
|
|
const nuxtExists = window.document.body.innerHTML.includes('window.__NUXT__')
|
|
if (!nuxtExists) {
|
|
/* istanbul ignore next */
|
|
let error = new Error('Could not load the nuxt app')
|
|
/* istanbul ignore next */
|
|
error.body = window.document.body.innerHTML
|
|
throw error
|
|
}
|
|
// Used by nuxt.js to say when the components are loaded and the app ready
|
|
await new Promise((resolve) => {
|
|
window._onNuxtLoaded = () => resolve(window)
|
|
})
|
|
// Send back window object
|
|
return window
|
|
}
|
|
}
|