expeditaea 1.0.0

package/packages/generator/test/generator.init.test.js

@@ -0,0 +1,234 @@
+import consola from 'consola'
+import fsExtra from 'fs-extra'
+import { flatRoutes, isString, isUrl, promisifyRoute } from '@nuxt/utils'
+
+import Generator from '../src/generator'
+import { createNuxt, hookCalls } from './__utils__'
+
+jest.mock('fs-extra')
+jest.mock('@nuxt/utils')
+
+describe('generator: initialize', () => {
+  beforeAll(() => {
+    isString.mockImplementation(str => typeof str === 'string')
+  })
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  test('should construct Generator', () => {
+    isUrl.mockReturnValueOnce(true)
+    const nuxt = createNuxt()
+    nuxt.options = {
+      ...nuxt.options,
+      build: { publicPath: 'http://localhost:3000' }
+    }
+    const builder = jest.fn()
+    const generator = new Generator(nuxt, builder)
+
+    expect(generator.nuxt).toBe(nuxt)
+    expect(generator.options).toBe(nuxt.options)
+    expect(generator.builder).toBe(builder)
+    expect(generator.staticRoutes).toBePath(
+      '/var/nuxt/static',
+      'C:\\nuxt\\static'
+    )
+    expect(generator.srcBuiltPath).toBePath(
+      '/var/nuxt/build/dist/client',
+      'C:\\nuxt\\build\\dist\\client'
+    )
+    expect(generator.distPath).toBePath(
+      '/var/nuxt/generate',
+      'C:\\nuxt\\generate'
+    )
+    expect(generator.distNuxtPath).toBePath(
+      '/var/nuxt/generate',
+      'C:\\nuxt\\generate'
+    )
+  })
+
+  test('should append publicPath to distPath if publicPath is not url', () => {
+    isUrl.mockReturnValueOnce(false)
+    const nuxt = createNuxt()
+    nuxt.options = {
+      ...nuxt.options,
+      build: { publicPath: '__public' }
+    }
+    const builder = jest.fn()
+    const generator = new Generator(nuxt, builder)
+
+    expect(generator.distNuxtPath).toBePath(
+      '/var/nuxt/generate/__public',
+      'C:\\nuxt\\generate\\__public'
+    )
+  })
+
+  test('should initiate with build and init by default', async () => {
+    const nuxt = createNuxt()
+    const builder = { forGenerate: jest.fn(), build: jest.fn() }
+    const generator = new Generator(nuxt, builder)
+
+    generator.initDist = jest.fn()
+
+    await generator.initiate()
+
+    expect(nuxt.ready).toBeCalledTimes(1)
+    expect(hookCalls(nuxt, 'generate:before')[0]).toMatchObject([generator, { dir: generator.distPath }])
+    expect(builder.forGenerate).toBeCalledTimes(1)
+    expect(builder.build).toBeCalledTimes(1)
+    expect(generator.initDist).toBeCalledTimes(1)
+  })
+
+  test('should initiate without build and init if disabled', async () => {
+    const nuxt = createNuxt()
+    const builder = { forGenerate: jest.fn(), build: jest.fn() }
+    const generator = new Generator(nuxt, builder)
+
+    generator.initDist = jest.fn()
+    fsExtra.exists.mockReturnValueOnce(true)
+    generator.getBuildConfig = jest.fn(() => ({ ssr: true, target: 'static' }))
+
+    await generator.initiate({ build: false, init: false })
+
+    expect(nuxt.ready).toBeCalledTimes(1)
+    expect(hookCalls(nuxt, 'generate:before')[0]).toMatchObject([generator, { dir: generator.distPath }])
+    expect(builder.forGenerate).not.toBeCalled()
+    expect(builder.build).not.toBeCalled()
+    expect(generator.initDist).not.toBeCalled()
+  })
+
+  test('should init routes with generate.routes and routes.json', async () => {
+    const nuxt = createNuxt()
+    nuxt.options = {
+      ...nuxt.options,
+      generate: {
+        ...nuxt.options.generate,
+        exclude: [/test/],
+        routes: ['/foo', '/foo/bar']
+      },
+      router: {
+        mode: 'history'
+      }
+    }
+    const generator = new Generator(nuxt)
+
+    flatRoutes.mockImplementationOnce(routes => routes)
+    promisifyRoute.mockImplementationOnce(routes => routes)
+    generator.getAppRoutes = jest.fn(() => ['/index', '/about', '/test'])
+    generator.decorateWithPayloads = jest.fn(() => 'decoratedRoutes')
+
+    const routes = await generator.initRoutes()
+
+    expect(promisifyRoute).toBeCalledTimes(1)
+    expect(promisifyRoute).toBeCalledWith(['/foo', '/foo/bar'])
+    expect(flatRoutes).toBeCalledTimes(1)
+    expect(flatRoutes).toBeCalledWith(['/index', '/about', '/test'])
+    expect(generator.decorateWithPayloads).toBeCalledTimes(1)
+    expect(generator.decorateWithPayloads).toBeCalledWith(['/index', '/about'], ['/foo', '/foo/bar'])
+    expect(hookCalls(nuxt, 'generate:extendRoutes')[0][0]).toBe('decoratedRoutes')
+    expect(routes).toEqual('decoratedRoutes')
+  })
+
+  test('should init routes with hash mode', async () => {
+    const nuxt = createNuxt()
+    nuxt.options = {
+      ...nuxt.options,
+      generate: {
+        ...nuxt.options.generate,
+        exclude: [/test/],
+        routes: ['/foo', '/foo/bar']
+      },
+      router: {
+        mode: 'hash'
+      }
+    }
+    const generator = new Generator(nuxt)
+
+    flatRoutes.mockImplementationOnce(routes => routes)
+    promisifyRoute.mockImplementationOnce(routes => routes)
+    generator.decorateWithPayloads = jest.fn(() => 'decoratedRoutes')
+
+    const routes = await generator.initRoutes()
+
+    expect(promisifyRoute).not.toBeCalled()
+    expect(flatRoutes).not.toBeCalled()
+    expect(generator.decorateWithPayloads).toBeCalledTimes(1)
+    expect(generator.decorateWithPayloads).toBeCalledWith(['/'], [])
+    expect(hookCalls(nuxt, 'generate:extendRoutes')[0][0]).toBe('decoratedRoutes')
+    expect(routes).toEqual('decoratedRoutes')
+
+    promisifyRoute.mockReset()
+    flatRoutes.mockReset()
+  })
+
+  test('should throw error when route can not be resolved', async () => {
+    const nuxt = createNuxt()
+    nuxt.options.router = { mode: 'history' }
+    const generator = new Generator(nuxt)
+
+    promisifyRoute.mockImplementationOnce(() => {
+      throw new Error('promisifyRoute failed')
+    })
+
+    await expect(generator.initRoutes()).rejects.toThrow('promisifyRoute failed')
+
+    expect(promisifyRoute).toBeCalledTimes(1)
+    expect(promisifyRoute).toBeCalledWith([])
+    expect(consola.error).toBeCalledTimes(1)
+    expect(consola.error).toBeCalledWith('Could not resolve routes')
+  })
+
+  test('should initialize destination folder', async () => {
+    const nuxt = createNuxt()
+    nuxt.options.generate.fallback = 'fallback.html'
+    const generator = new Generator(nuxt)
+    fsExtra.exists.mockReturnValueOnce(false)
+
+    await generator.initDist()
+
+    expect(fsExtra.emptyDir).toBeCalledTimes(1)
+    expect(fsExtra.emptyDir).toBeCalledWith(generator.distPath)
+    expect(hookCalls(nuxt, 'generate:distRemoved')[0][0]).toMatchObject(generator)
+    expect(fsExtra.exists).toBeCalledTimes(1)
+    expect(fsExtra.exists).toBeCalledWith(generator.staticRoutes)
+    expect(fsExtra.copy).toBeCalledTimes(1)
+    expect(fsExtra.copy).toBeCalledWith(generator.srcBuiltPath, generator.distNuxtPath)
+    expect(fsExtra.writeFile).toBeCalledTimes(1)
+    expect(fsExtra.writeFile.mock.calls[0][0]).toBePath(
+      '/var/nuxt/generate/.nojekyll',
+      'C:\\nuxt\\generate\\.nojekyll'
+    )
+    expect(hookCalls(nuxt, 'generate:distCopied')[0][0]).toMatchObject(generator)
+  })
+
+  test('should copy static routes if path exists', async () => {
+    const nuxt = createNuxt()
+    nuxt.options.generate.fallback = 'fallback.html'
+    const generator = new Generator(nuxt)
+    fsExtra.exists.mockReturnValueOnce(true)
+
+    await generator.initDist()
+
+    expect(fsExtra.copy).toBeCalledTimes(2)
+    expect(fsExtra.copy).nthCalledWith(1, generator.staticRoutes, generator.distPath)
+    expect(fsExtra.copy).nthCalledWith(2, generator.srcBuiltPath, generator.distNuxtPath)
+  })
+
+  test('should decorate routes with payloads', () => {
+    const nuxt = createNuxt()
+    const generator = new Generator(nuxt)
+
+    const routes = ['/index', '/about', '/test']
+    const generateRoutes = ['/foo', { route: '/foo/bar', payload: { param: 'foo bar' } }]
+    const routeMap = generator.decorateWithPayloads(routes, generateRoutes)
+
+    expect(routeMap).toEqual([
+      { payload: null, route: '/index' },
+      { payload: null, route: '/about' },
+      { payload: null, route: '/test' },
+      { payload: null, route: '/foo' },
+      { payload: { param: 'foo bar' }, route: '/foo/bar' }
+    ])
+  })
+})

package/packages/generator/test/generator.route.test.js

@@ -0,0 +1,245 @@
+import consola from 'consola'
+import fsExtra from 'fs-extra'
+import htmlMinifier from 'html-minifier'
+
+import Generator from '../src/generator'
+import { createNuxt, hookCalls } from './__utils__'
+
+jest.mock('fs-extra')
+jest.mock('html-minifier')
+jest.mock('@nuxt/utils')
+
+describe('generator: generate route', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  test('should generate route', async () => {
+    const nuxt = createNuxt()
+    nuxt.options.build.html = { minify: false }
+    nuxt.options.generate.minify = undefined
+    nuxt.options.generate.subFolders = false
+    const generator = new Generator(nuxt)
+
+    const route = '/foo/'
+    const payload = {}
+    const errors = []
+
+    const returned = await generator.generateRoute({ route, payload, errors })
+
+    expect(nuxt.server.renderRoute).toBeCalledTimes(1)
+    expect(nuxt.server.renderRoute).toBeCalledWith('/foo', { payload })
+
+    const genernatePageHookCall = hookCalls(nuxt, 'generate:page')[0][0]
+    expect(genernatePageHookCall).toMatchObject({
+      route: '/foo',
+      html: 'rendered html'
+    })
+    expect(genernatePageHookCall.path).toBePath(
+      '/var/nuxt/generate/foo.html',
+      'C:\\nuxt\\generate\\foo.html'
+    )
+
+    const genernateRouteCreatedHookCall = hookCalls(nuxt, 'generate:routeCreated')[0][0]
+    expect(genernateRouteCreatedHookCall).toMatchObject({
+      route: '/foo',
+      errors: []
+    })
+    expect(genernateRouteCreatedHookCall.path).toBePath(
+      '/var/nuxt/generate/foo.html',
+      'C:\\nuxt\\generate\\foo.html'
+    )
+
+    expect(fsExtra.mkdirp).toBeCalledTimes(1)
+    expect(fsExtra.mkdirp.mock.calls[0][0]).toBePath(
+      '/var/nuxt/generate',
+      'C:\\nuxt\\generate'
+    )
+    expect(fsExtra.writeFile).toBeCalledTimes(1)
+    expect(fsExtra.writeFile).toBeCalledWith(expect.any(String), 'rendered html', 'utf8')
+    expect(fsExtra.writeFile.mock.calls[0][0]).toBePath(
+      '/var/nuxt/generate/foo.html',
+      'C:\\nuxt\\generate\\foo.html'
+    )
+    expect(returned).toEqual(true)
+  })
+
+  test('should create unhandled error if render route has any exception', async () => {
+    const nuxt = createNuxt()
+    const error = new Error('render route failed')
+    nuxt.server.renderRoute.mockImplementationOnce(() => {
+      throw error
+    })
+    const generator = new Generator(nuxt)
+    generator._formatErrors = jest.fn(() => 'formatted errors')
+
+    const route = '/foo'
+    const payload = {}
+    const errors = []
+
+    const returned = await generator.generateRoute({ route, payload, errors })
+
+    expect(nuxt.server.renderRoute).toBeCalledTimes(1)
+    expect(nuxt.server.renderRoute).toBeCalledWith('/foo', { payload })
+    expect(nuxt.callHook).toBeCalledWith('generate:routeFailed', {
+      route,
+      errors: [{ type: 'unhandled', route, error }]
+    })
+    expect(generator._formatErrors).toBeCalledTimes(1)
+    expect(generator._formatErrors).toBeCalledWith([{ type: 'unhandled', route, error }])
+    expect(consola.error).toBeCalledTimes(1)
+    expect(consola.error).toBeCalledWith('formatted errors')
+    expect(errors).toEqual([{
+      error,
+      route,
+      type: 'unhandled'
+    }])
+    expect(returned).toEqual(false)
+  })
+
+  test('should create handled error if render route failed', async () => {
+    const nuxt = createNuxt()
+    nuxt.options.build.html = { minify: false }
+    nuxt.options.generate.minify = undefined
+    const error = new Error('render route failed')
+    nuxt.server.renderRoute.mockReturnValueOnce({
+      html: 'renderer html',
+      error
+    })
+    const generator = new Generator(nuxt)
+
+    const route = '/foo'
+    const payload = {}
+    const errors = []
+
+    const returned = await generator.generateRoute({ route, payload, errors })
+
+    expect(consola.error).toBeCalledTimes(1)
+    expect(consola.error).toBeCalledWith('Error generating route "/foo": render route failed')
+    expect(errors).toEqual([{
+      error,
+      route,
+      type: 'handled'
+    }])
+    expect(returned).toEqual(true)
+  })
+
+  test('should warn generate.minify deprecation message', async () => {
+    const nuxt = createNuxt()
+    nuxt.options.build.html = { minify: false }
+    nuxt.options.generate.minify = false
+    const generator = new Generator(nuxt)
+
+    const route = '/foo'
+
+    const returned = await generator.generateRoute({ route })
+
+    expect(consola.warn).toBeCalledTimes(1)
+    expect(consola.warn).toBeCalledWith(
+      'generate.minify has been deprecated and will be removed in the next major version. Use build.html.minify instead!'
+    )
+    expect(returned).toEqual(true)
+  })
+
+  test('should minify generated html', async () => {
+    const nuxt = createNuxt()
+    nuxt.options.build.html = { minify: { value: 'test-minify' } }
+    nuxt.options.generate.minify = undefined
+    const generator = new Generator(nuxt)
+    htmlMinifier.minify.mockReturnValueOnce('minified rendered html')
+
+    const route = '/foo'
+
+    const returned = await generator.generateRoute({ route })
+
+    expect(htmlMinifier.minify).toBeCalledTimes(1)
+    expect(htmlMinifier.minify).toBeCalledWith('rendered html', { value: 'test-minify' })
+    expect(fsExtra.writeFile).toBeCalledTimes(1)
+    expect(fsExtra.writeFile).toBeCalledWith(expect.any(String), 'minified rendered html', 'utf8')
+    expect(fsExtra.writeFile.mock.calls[0][0]).toBePath(
+      '/var/nuxt/generate/foo.html',
+      'C:\\nuxt\\generate\\foo.html'
+    )
+    expect(returned).toEqual(true)
+  })
+
+  test('should create unhandled error if minify failed', async () => {
+    const nuxt = createNuxt()
+    nuxt.options.build.html = { minify: { value: 'test-minify' } }
+    nuxt.options.generate.minify = undefined
+    const generator = new Generator(nuxt)
+    htmlMinifier.minify.mockImplementationOnce(() => {
+      throw new Error('minify html failed')
+    })
+
+    const route = '/foo'
+    const errors = []
+
+    const returned = await generator.generateRoute({ route, errors })
+
+    expect(htmlMinifier.minify).toBeCalledTimes(1)
+    expect(htmlMinifier.minify).toBeCalledWith('rendered html', { value: 'test-minify' })
+    expect(errors).toEqual([{
+      route,
+      type: 'unhandled',
+      error: new Error('HTML minification failed. Make sure the route generates valid HTML. Failed HTML:\n rendered html')
+    }])
+    expect(returned).toEqual(true)
+  })
+
+  test('should generate file in sub folder', async () => {
+    const nuxt = createNuxt()
+    nuxt.options.build.html = { minify: false }
+    nuxt.options.generate.subFolders = true
+    const generator = new Generator(nuxt)
+
+    const route = '/foo'
+
+    const returned = await generator.generateRoute({ route })
+
+    expect(fsExtra.writeFile).toBeCalledTimes(1)
+    expect(fsExtra.writeFile).toBeCalledWith(expect.any(String), 'rendered html', 'utf8')
+    expect(fsExtra.writeFile.mock.calls[0][0]).toBePath(
+      '/var/nuxt/generate/foo/index.html',
+      'C:\\nuxt\\generate\\foo\\index.html'
+    )
+    expect(returned).toEqual(true)
+  })
+
+  test('should generate 404 file in flat folder', async () => {
+    const nuxt = createNuxt()
+    nuxt.options.build.html = { minify: false }
+    nuxt.options.generate.subFolders = true
+    const generator = new Generator(nuxt)
+
+    const route = '/404'
+
+    const returned = await generator.generateRoute({ route })
+
+    expect(fsExtra.writeFile).toBeCalledTimes(1)
+    expect(fsExtra.writeFile).toBeCalledWith(expect.any(String), 'rendered html', 'utf8')
+    expect(fsExtra.writeFile.mock.calls[0][0]).toBePath(
+      '/var/nuxt/generate/404.html',
+      'C:\\nuxt\\generate\\404.html'
+    )
+    expect(returned).toEqual(true)
+  })
+
+  test('should generate file in flat folder if route is empty', async () => {
+    const nuxt = createNuxt()
+    nuxt.options.build.html = { minify: false }
+    const generator = new Generator(nuxt)
+
+    const route = ''
+
+    const returned = await generator.generateRoute({ route })
+
+    expect(fsExtra.writeFile).toBeCalledTimes(1)
+    expect(fsExtra.writeFile).toBeCalledWith(expect.any(String), 'rendered html', 'utf8')
+    expect(fsExtra.writeFile.mock.calls[0][0]).toBePath(
+      '/var/nuxt/generate/index.html',
+      'C:\\nuxt\\generate\\index.html'
+    )
+    expect(returned).toEqual(true)
+  })
+})

package/packages/generator/test/index.test.js

@@ -0,0 +1,11 @@
+import { Generator } from '../src'
+
+jest.mock('../src/generator', () => ({
+  generator: true
+}))
+
+describe('generator: entry', () => {
+  test('should export Generator', () => {
+    expect(Generator.generator).toEqual(true)
+  })
+})

package/packages/server/package.js

@@ -0,0 +1,4 @@
+export default {
+  build: true,
+  externals: ['jsdom']
+}

package/packages/server/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@nuxt/server",
+  "version": "2.15.6",
+  "repository": "nuxt/nuxt.js",
+  "license": "MIT",
+  "main": "dist/server.js",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@nuxt/utils": "2.15.6",
+    "@nuxt/vue-renderer": "2.15.6",
+    "@nuxtjs/youch": "^4.2.3",
+    "compression": "^1.7.4",
+    "connect": "^3.7.0",
+    "consola": "^2.15.3",
+    "etag": "^1.8.1",
+    "fresh": "^0.5.2",
+    "fs-extra": "^9.1.0",
+    "ip": "^1.1.5",
+    "launch-editor-middleware": "^2.2.1",
+    "on-headers": "^1.0.2",
+    "pify": "^5.0.0",
+    "serve-placeholder": "^1.2.3",
+    "serve-static": "^1.14.1",
+    "server-destroy": "^1.0.1",
+    "ufo": "^0.7.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/packages/server/src/context.js

@@ -0,0 +1,8 @@
+export default class ServerContext {
+  constructor (server) {
+    this.nuxt = server.nuxt
+    this.globals = server.globals
+    this.options = server.options
+    this.resources = server.resources
+  }
+}

package/packages/server/src/index.js

@@ -0,0 +1,2 @@
+export { default as Server } from './server'
+export { default as Listener } from './listener'

package/packages/server/src/jsdom.js

@@ -0,0 +1,75 @@
+import consola from 'consola'
+import { timeout } from '@nuxt/utils'
+
+export default async function renderAndGetWindow (
+  url = 'http://localhost:3000',
+  jsdomOpts = {},
+  {
+    loadedCallback,
+    loadingTimeout = 2000,
+    globals
+  } = {}
+) {
+  const jsdom = await import('jsdom')
+    .then(m => m.default || m)
+    .catch((e) => {
+      consola.error(`
+         jsdom is not installed. Please install jsdom with:
+          $ yarn add --dev jsdom
+          OR
+          $ npm install --dev jsdom
+        `)
+      throw e
+    })
+
+  const options = Object.assign({
+    // Load subresources (https://github.com/tmpvar/jsdom#loading-subresources)
+    resources: 'usable',
+    runScripts: 'dangerously',
+    virtualConsole: true,
+    beforeParse (window) {
+      // Mock window.scrollTo
+      window.scrollTo = () => {}
+    }
+  }, jsdomOpts)
+
+  const jsdomErrHandler = (err) => {
+    throw err
+  }
+
+  if (options.virtualConsole) {
+    if (options.virtualConsole === true) {
+      options.virtualConsole = new jsdom.VirtualConsole().sendTo(consola)
+    }
+    // Throw error when window creation failed
+    options.virtualConsole.on('jsdomError', jsdomErrHandler)
+  } else {
+    // If we get the virtualConsole option as `false` we should delete for don't pass it to `jsdom.JSDOM.fromURL`
+    delete options.virtualConsole
+  }
+
+  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(`id="${globals.id}"`)
+
+  if (!nuxtExists) {
+    const error = new Error('Could not load the nuxt app')
+    error.body = window.document.body.innerHTML
+    window.close()
+    throw error
+  }
+
+  // Used by Nuxt to say when the components are loaded and the app ready
+  await timeout(new Promise((resolve) => {
+    window[loadedCallback] = () => resolve(window)
+  }), loadingTimeout, `Components loading in renderAndGetWindow was not completed in ${loadingTimeout / 1000}s`)
+
+  if (options.virtualConsole) {
+    // After window initialized successfully
+    options.virtualConsole.removeListener('jsdomError', jsdomErrHandler)
+  }
+
+  // Send back window object
+  return window
+}