Nuxt/lib/builder/builder.js

import _ from 'lodash'
import chokidar from 'chokidar'
import fs, { remove, readFile, writeFile, mkdirp, utimes, existsSync } from 'fs-extra'
import hash from 'hash-sum'
import pify from 'pify'
import webpack from 'webpack'
import serialize from 'serialize-javascript'
import { join, resolve, basename, dirname } from 'path'
import Tapable from 'tappable'
import MFS from 'memory-fs'
import webpackDevMiddleware from 'webpack-dev-middleware'
import webpackHotMiddleware from 'webpack-hot-middleware'
import { r, wp, wChunk, createRoutes, sequence, relativeTo, isPureObject } from 'utils'
import Debug from 'debug'
import Glob from 'glob'
import clientWebpackConfig from './webpack/client.config.js'
import serverWebpackConfig from './webpack/server.config.js'
import dllWebpackConfig from './webpack/dll.config.js'
import vueLoaderConfig from './webpack/vue-loader.config'
import styleLoader from './webpack/style-loader'

const debug = Debug('nuxt:build')
debug.color = 2 // Force green color

const glob = pify(Glob)

export default class Builder extends Tapable {
  constructor (nuxt) {
    super()
    this.nuxt = nuxt
    this.isStatic = false // Flag to know if the build is for a generated app
    this.options = nuxt.options

    // Fields that set on build
    this.compiler = null
    this.webpackDevMiddleware = null
    this.webpackHotMiddleware = null

    // Mute stats on dev
    this.webpackStats = this.options.dev ? false : {
      chunks: false,
      children: false,
      modules: false,
      colors: true,
      excludeAssets: [
        /.map$/,
        /index\..+\.html$/,
        /vue-ssr-client-manifest.json/
      ]
    }

    // Helper to resolve build paths
    this.relativeToBuild = (...args) => relativeTo(this.options.buildDir, ...args)

    // Bind styleLoader and vueLoader
    this.styleLoader = styleLoader.bind(this)
    this.vueLoader = vueLoaderConfig.bind(this)

    this._buildStatus = STATUS.INITIAL
  }

  get plugins () {
    return this.options.plugins.map((p, i) => {
      if (typeof p === 'string') p = { src: p }
      p.src = this.nuxt.resolvePath(p.src)
      return { src: p.src, ssr: (p.ssr !== false), name: `plugin${i}` }
    })
  }

  vendor () {
    return [
      'vue',
      'vue-router',
      'vue-meta',
      this.options.store && 'vuex'
    ].concat(this.options.build.vendor).filter(v => v)
  }

  vendorEntries () {
    // Used for dll
    const vendor = this.vendor()
    const vendorEntries = {}
    vendor.forEach(v => {
      try {
        require.resolve(v)
        vendorEntries[v] = [ v ]
      } catch (e) {
        // Ignore
      }
    })
    return vendorEntries
  }

  forGenerate () {
    this.isStatic = true
  }

  async build () {
    // Avoid calling build() method multiple times when dev:true
    /* istanbul ignore if */
    if (this._buildStatus === STATUS.BUILD_DONE && this.options.dev) {
      return this
    }
    // If building
    /* istanbul ignore if */
    if (this._buildStatus === STATUS.BUILDING) {
      return new Promise((resolve) => {
        setTimeout(() => {
          resolve(this.build())
        }, 1000)
      })
    }
    this._buildStatus = STATUS.BUILDING

    // Wait for nuxt ready
    await this.nuxt.ready()

    // Wait for build plugins
    await this.nuxt.applyPluginsAsync('build', this)

    // Babel options
    this.babelOptions = _.defaults(this.options.build.babel, {
      babelrc: false,
      cacheDirectory: !!this.options.dev
    })
    if (!this.babelOptions.babelrc && !this.babelOptions.presets) {
      this.babelOptions.presets = [
        require.resolve('babel-preset-vue-app')
      ]
    }

    // Map postcss plugins into instances on object mode once
    if (isPureObject(this.options.build.postcss)) {
      if (isPureObject(this.options.build.postcss.plugins)) {
        this.options.build.postcss.plugins = Object.keys(this.options.build.postcss.plugins)
          .map(p => {
            const plugin = require(p)
            const opts = this.options.build.postcss.plugins[p]
            if (opts === false) return // Disabled
            const instance = plugin(opts)
            return instance
          }).filter(e => e)
      }
    }

    // Check if pages dir exists and warn if not
    this._nuxtPages = typeof this.options.build.createRoutes !== 'function'
    if (this._nuxtPages) {
      if (!fs.existsSync(join(this.options.srcDir, 'pages'))) {
        let dir = this.options.srcDir
        if (fs.existsSync(join(this.options.srcDir, '..', 'pages'))) {
          throw new Error(`No \`pages\` directory found in ${dir}. Did you mean to run \`nuxt\` in the parent (\`../\`) directory?`)
        } else {
          throw new Error(`Couldn't find a \`pages\` directory in ${dir}. Please create one under the project root`)
        }
      }
    }

    debug(`App root: ${this.options.srcDir}`)
    debug(`Generating ${this.options.buildDir} files...`)

    // Create .nuxt/, .nuxt/components and .nuxt/dist folders
    await remove(r(this.options.buildDir))
    await mkdirp(r(this.options.buildDir, 'components'))
    if (!this.options.dev) {
      await mkdirp(r(this.options.buildDir, 'dist'))
    }

    // Generate routes and interpret the template files
    await this.generateRoutesAndFiles()

    // Start webpack build
    await this.webpackBuild()

    await this.applyPluginsAsync('built', this)

    // Flag to set that building is done
    this._buildStatus = STATUS.BUILD_DONE

    return this
  }

  async generateRoutesAndFiles () {
    debug('Generating files...')
    // -- Templates --
    let templatesFiles = [
      'App.js',
      'client.js',
      'index.js',
      'middleware.js',
      'router.js',
      'server.js',
      'utils.js',
      'empty.js',
      'components/nuxt-error.vue',
      'components/nuxt-loading.vue',
      'components/nuxt-child.js',
      'components/nuxt-link.js',
      'components/nuxt.js',
      'components/no-ssr.js',
      'views/app.template.html',
      'views/error.html'
    ]
    const templateVars = {
      options: this.options,
      messages: this.options.messages,
      uniqBy: _.uniqBy,
      isDev: this.options.dev,
      debug: this.options.debug,
      mode: this.options.mode,
      router: this.options.router,
      env: this.options.env,
      head: this.options.head,
      middleware: fs.existsSync(join(this.options.srcDir, 'middleware')),
      store: this.options.store,
      css: this.options.css,
      plugins: this.plugins,
      appPath: './App.js',
      layouts: Object.assign({}, this.options.layouts),
      loading: typeof this.options.loading === 'string' ? this.relativeToBuild(this.options.srcDir, this.options.loading) : this.options.loading,
      transition: this.options.transition,
      layoutTransition: this.options.layoutTransition,
      components: {
        ErrorPage: this.options.ErrorPage ? this.relativeToBuild(this.options.ErrorPage) : null
      }
    }

    // -- Layouts --
    if (fs.existsSync(resolve(this.options.srcDir, 'layouts'))) {
      const layoutsFiles = await glob('layouts/**/*.vue', { cwd: this.options.srcDir })
      let hasErrorLayout = false
      layoutsFiles.forEach((file) => {
        let name = file.split('/').slice(1).join('/').replace(/\.vue$/, '')
        if (name === 'error') {
          hasErrorLayout = true
          return
        }
        templateVars.layouts[name] = this.relativeToBuild(this.options.srcDir, file)
      })
      if (!templateVars.components.ErrorPage && hasErrorLayout) {
        templateVars.components.ErrorPage = this.relativeToBuild(this.options.srcDir, 'layouts/error.vue')
      }
    }
    // If no default layout, create its folder and add the default folder
    if (!templateVars.layouts.default) {
      await mkdirp(r(this.options.buildDir, 'layouts'))
      templatesFiles.push('layouts/default.vue')
      templateVars.layouts.default = './layouts/default.vue'
    }

    // -- Routes --
    debug('Generating routes...')
    // If user defined a custom method to create routes
    if (this._nuxtPages) {
      // Use nuxt.js createRoutes bases on pages/
      const files = await glob('pages/**/*.vue', { cwd: this.options.srcDir })
      templateVars.router.routes = createRoutes(files, this.options.srcDir)
    } else {
      templateVars.router.routes = this.options.build.createRoutes(this.options.srcDir)
    }

    await this.applyPluginsAsync('extendRoutes', { routes: templateVars.router.routes, templateVars, r })

    // router.extendRoutes method
    if (typeof this.options.router.extendRoutes === 'function') {
      // let the user extend the routes
      const extendedRoutes = this.options.router.extendRoutes(templateVars.router.routes, r)
      // Only overwrite routes when something is returned for backwards compatibility
      if (extendedRoutes !== undefined) {
        templateVars.router.routes = extendedRoutes
      }
    }

    // Make routes accessible for other modules and webpack configs
    this.routes = templateVars.router.routes

    // -- Store --
    // Add store if needed
    if (this.options.store) {
      templatesFiles.push('store.js')
    }

    // Resolve template files
    const customTemplateFiles = this.options.build.templates.map(t => t.dst || basename(t.src || t))

    templatesFiles = templatesFiles.map(file => {
      // Skip if custom file was already provided in build.templates[]
      if (customTemplateFiles.indexOf(file) !== -1) {
        return
      }
      // Allow override templates using a file with same name in ${srcDir}/app
      const customPath = r(this.options.srcDir, 'app', file)
      const customFileExists = fs.existsSync(customPath)

      return {
        src: customFileExists
          ? customPath
          : r(this.options.nuxtAppDir, file),
        dst: file,
        custom: customFileExists
      }
    }).filter(i => !!i)

    // -- Custom templates --
    // Add custom template files
    templatesFiles = templatesFiles.concat(this.options.build.templates.map(t => {
      return Object.assign({
        src: r(this.options.srcDir, t.src || t),
        dst: t.dst || basename(t.src || t),
        custom: true
      }, t)
    }))

    // -- Loading indicator --
    if (this.options.loadingIndicator.name) {
      const indicatorPath1 = resolve(this.options.nuxtAppDir, 'views/loading', this.options.loadingIndicator.name + '.html')
      const indicatorPath2 = this.nuxt.resolvePath(this.options.loadingIndicator.name)
      const indicatorPath = existsSync(indicatorPath1) ? indicatorPath1 : (existsSync(indicatorPath2) ? indicatorPath2 : null)
      if (indicatorPath) {
        templatesFiles.push({
          src: indicatorPath,
          dst: 'loading.html',
          options: this.options.loadingIndicator
        })
      } else {
        console.error(`Could not fetch loading indicator: ${this.options.loadingIndicator.name}`) // eslint-disable-line no-console
      }
    }

    await this.applyPluginsAsync('generate', { builder: this, templatesFiles, templateVars })

    // Interpret and move template files to .nuxt/
    await Promise.all(templatesFiles.map(async ({ src, dst, options, custom }) => {
      // Add template to watchers
      this.options.build.watch.push(src)
      // Render template to dst
      const fileContent = await readFile(src, 'utf8')
      let content
      try {
        const template = _.template(fileContent, {
          imports: {
            serialize,
            hash,
            r,
            wp,
            wChunk,
            resolvePath: this.nuxt.resolvePath.bind(this.nuxt),
            relativeToBuild: this.relativeToBuild
          }
        })
        content = template(Object.assign({}, templateVars, {
          options: options || {},
          custom,
          src,
          dst
        }))
      } catch (err) {
        throw new Error(`Could not compile template ${src}: ${err.message}`)
      }
      const path = r(this.options.buildDir, dst)
      // Ensure parent dir exits
      await mkdirp(dirname(path))
      // Write file
      await writeFile(path, content, 'utf8')
      // Fix webpack loop (https://github.com/webpack/watchpack/issues/25#issuecomment-287789288)
      const dateFS = Date.now() / 1000 - 1000
      return utimes(path, dateFS, dateFS)
    }))

    await this.applyPluginsAsync('generated', this)
  }

  async webpackBuild () {
    debug('Building files...')
    const compilersOptions = []

    // Client
    const clientConfig = clientWebpackConfig.call(this)
    compilersOptions.push(clientConfig)

    // Server
    let serverConfig = null
    if (this.options.build.ssr) {
      serverConfig = serverWebpackConfig.call(this)
      compilersOptions.push(serverConfig)
    }

    // Alias plugins to their real path
    this.plugins.forEach(p => {
      const src = this.relativeToBuild(p.src)

      // Client config
      if (!clientConfig.resolve.alias[p.name]) {
        clientConfig.resolve.alias[p.name] = src
      }

      // Server config
      if (serverConfig && !serverConfig.resolve.alias[p.name]) {
        // Alias to noop for ssr:false plugins
        serverConfig.resolve.alias[p.name] = p.ssr ? src : './empty.js'
      }
    })

    // Make a dll plugin after compile to make next dev builds faster
    if (this.options.build.dll && this.options.dev) {
      compilersOptions.push(dllWebpackConfig.call(this, clientConfig))
    }

    // Simulate webpack multi compiler interface
    // Separate compilers are simpler, safer and faster
    this.compiler = { compilers: [] }
    this.compiler.plugin = (...args) => {
      this.compiler.compilers.forEach(compiler => {
        compiler.plugin(...args)
      })
    }

    // Initialize shared FS and Cache
    const sharedFS = this.options.dev && new MFS()
    const sharedCache = {}

    // Initialize compilers
    compilersOptions.forEach(compilersOption => {
      const compiler = webpack(compilersOption)
      if (sharedFS && !compiler.name.includes('-dll')) {
        compiler.outputFileSystem = sharedFS
      }
      compiler.cache = sharedCache
      this.compiler.compilers.push(compiler)
    })

    // Access to compilers with name
    this.compiler.compilers.forEach(compiler => {
      if (compiler.name) {
        this.compiler[compiler.name] = compiler
      }
    })

    // Run after each compile
    this.compiler.plugin('done', async stats => {
      // Don't reload failed builds
      /* istanbul ignore if */
      if (stats.hasErrors()) {
        return
      }

      // console.log(stats.toString({ chunks: true }))

      // Reload renderer if available
      if (this.nuxt.renderer) {
        this.nuxt.renderer.loadResources(sharedFS || fs)
      }

      await this.applyPluginsAsync('done', { builder: this, stats })
    })

    // Add dev Stuff
    if (this.options.dev) {
      this.webpackDev()
    }

    await this.applyPluginsAsync('compile', { builder: this, compiler: this.compiler })

    // Start Builds
    await sequence(this.compiler.compilers, compiler => new Promise((resolve, reject) => {
      if (this.options.dev) {
        // --- Dev Build ---
        if (compiler.options.name === 'client') {
          // Client watch is started by dev-middleware
          resolve()
        } else if (compiler.options.name.includes('-dll')) {
          // DLL builds should run once
          compiler.run((err, stats) => {
            if (err) {
              return reject(err)
            }
            debug('[DLL] updated')
            resolve()
          })
        } else {
          // Build and watch for changes
          compiler.watch(this.options.watchers.webpack, (err) => {
            /* istanbul ignore if */
            if (err) {
              return reject(err)
            }
            resolve()
          })
        }
      } else {
        // --- Production Build ---
        compiler.run((err, stats) => {
          /* istanbul ignore if */
          if (err) {
            console.error(err) // eslint-disable-line no-console
            return reject(err)
          }

          // Show build stats for production
          console.log(stats.toString(this.webpackStats)) // eslint-disable-line no-console

          /* istanbul ignore if */
          if (stats.hasErrors()) {
            return reject(new Error('Webpack build exited with errors'))
          }
          resolve()
        })
      }
    }))

    await this.applyPluginsAsync('compiled', this)
  }

  webpackDev () {
    debug('Adding webpack middleware...')

    // Create webpack dev middleware
    this.webpackDevMiddleware = pify(webpackDevMiddleware(this.compiler.client, Object.assign({
      publicPath: this.options.build.publicPath,
      stats: this.webpackStats,
      noInfo: true,
      quiet: true,
      watchOptions: this.options.watchers.webpack
    }, this.options.build.devMiddleware)))

    this.webpackHotMiddleware = pify(webpackHotMiddleware(this.compiler.client, Object.assign({
      log: false,
      heartbeat: 10000
    }, this.options.build.hotMiddleware)))

    // Inject to renderer instance
    if (this.nuxt.renderer) {
      this.nuxt.renderer.webpackDevMiddleware = this.webpackDevMiddleware
      this.nuxt.renderer.webpackHotMiddleware = this.webpackHotMiddleware
    }

    // Stop webpack middleware on nuxt.close()
    this.nuxt.plugin('close', () => new Promise(resolve => {
      this.webpackDevMiddleware.close(() => resolve())
    }))

    // Start watching files
    this.watchFiles()
  }

  watchFiles () {
    const patterns = [
      r(this.options.srcDir, 'layouts'),
      r(this.options.srcDir, 'store'),
      r(this.options.srcDir, 'middleware'),
      r(this.options.srcDir, 'layouts/*.vue'),
      r(this.options.srcDir, 'layouts/**/*.vue')
    ]
    if (this._nuxtPages) {
      patterns.push(r(this.options.srcDir, 'pages'))
      patterns.push(r(this.options.srcDir, 'pages/*.vue'))
      patterns.push(r(this.options.srcDir, 'pages/**/*.vue'))
    }
    const options = Object.assign({}, this.options.watchers.chokidar, {
      ignoreInitial: true
    })
    /* istanbul ignore next */
    const refreshFiles = _.debounce(() => this.generateRoutesAndFiles(), 200)

    // Watch for src Files
    let filesWatcher = chokidar.watch(patterns, options)
      .on('add', refreshFiles)
      .on('unlink', refreshFiles)

    // Watch for custom provided files
    let customFilesWatcher = chokidar.watch(_.uniq(this.options.build.watch), options)
      .on('change', refreshFiles)

    // Stop watching on nuxt.close()
    this.nuxt.plugin('close', () => {
      filesWatcher.close()
      customFilesWatcher.close()
    })
  }
}

const STATUS = {
  INITIAL: 1,
  BUILD_DONE: 2,
  BUILDING: 3
}