@netlify/plugin-nextjs 3.9.1 → 4.0.0-beta.11

package/helpers/copyUnstableIncludedDirs.js

@@ -1,27 +0,0 @@
-const path = require('path')
-const fs = require('fs')
-const AdmZip = require('adm-zip')
-const getNetlifyFunctionName = require('../src/lib/helpers/getNetlifyFunctionName')
-
-// This is UNSTABLE support for special use cases needing files served with their Next.js
-// pages that become Netlify functions. Eventually this will be supported internally.
-const copyUnstableIncludedDirs = ({ nextConfig, functionsDist }) => {
-  for (const name in nextConfig.unstableNetlifyFunctionsSupport || {}) {
-    const includeDirs = nextConfig.unstableNetlifyFunctionsSupport[name].includeDirs || []
-    console.log('Processing included dirs for ', name)
-
-    const zipName = path.join(functionsDist, getNetlifyFunctionName(name) + '.zip')
-    const zip = new AdmZip(zipName)
-    includeDirs.forEach((includes) => {
-      if (fs.lstatSync(includes).isDirectory()) {
-        // We add the files at the root of the ZIP because process.cwd()
-        // points to `/` in serverless functions
-        zip.addLocalFolder(includes, includes)
-        console.log(`Added ${includes} to ${zipName}`)
-      }
-    })
-    zip.writeZip(zipName)
-  }
-}
-
-module.exports = copyUnstableIncludedDirs

package/helpers/doesNotNeedPlugin.js

@@ -1,49 +0,0 @@
-// Checks all the cases for which the plugin should do nothing
-const { redBright, yellowBright } = require('chalk')
-
-const doesSiteUseNextOnNetlify = require('./doesSiteUseNextOnNetlify')
-const isStaticExportProject = require('./isStaticExportProject')
-const usesBuildCommand = require('./usesBuildCommand')
-
-const doesNotNeedPlugin = ({ netlifyConfig, packageJson }) => {
-  // The env var skips the auto-detection
-  const envVar = process.env.NEXT_PLUGIN_FORCE_RUN
-  if (envVar === 'false' || envVar === '0' || envVar === false) {
-    console.log(
-      yellowBright`The env var NEXT_PLUGIN_FORCE_RUN was set to ${JSON.stringify(
-        envVar,
-      )}, so auto-detection is disabled and the plugin will not run`,
-    )
-    return true
-  }
-  if (envVar === 'true' || envVar === '1' || envVar === true) {
-    console.log(
-      yellowBright`The env var NEXT_PLUGIN_FORCE_RUN was set to ${JSON.stringify(
-        envVar,
-      )}, so auto-detection is disabled and the plugin will run regardless`,
-    )
-    return false
-  }
-  // Otherwise use auto-detection
-
-  const { build } = netlifyConfig
-  const { scripts = {} } = packageJson
-
-  if (!build.command) {
-    console.log(
-      redBright`⚠️  Warning: No build command specified in the site's Netlify config, so plugin will not run. This deploy will fail unless you have already exported the site.  ⚠️`,
-    )
-    return true
-  }
-
-  if (usesBuildCommand({ build, scripts, command: 'build-storybook' })) {
-    console.log(
-      yellowBright`Site seems to be building a Storybook rather than the Next.js site, so the Essential Next.js plugin will not run. If this is incorrect, set NEXT_PLUGIN_FORCE_RUN to true`,
-    )
-    return true
-  }
-
-  return isStaticExportProject({ build, scripts }) || doesSiteUseNextOnNetlify({ packageJson })
-}
-
-module.exports = doesNotNeedPlugin

package/helpers/doesSiteUseNextOnNetlify.js

@@ -1,20 +0,0 @@
-// Checks if site is already using next-on-netlify
-const { name: pluginName } = require('../package.json')
-
-const doesSiteUseNextOnNetlify = ({ packageJson }) => {
-  const { name, scripts = {}, dependencies = {} } = packageJson
-
-  const hasNextOnNetlifyInstalled = dependencies['next-on-netlify'] !== undefined
-  const hasNextOnNetlifyPostbuildScript =
-    typeof scripts.postbuild === 'string' && scripts.postbuild.includes('next-on-netlify')
-  const isUsingNextOnNetlify = (hasNextOnNetlifyInstalled || hasNextOnNetlifyPostbuildScript) && pluginName !== name
-  if (isUsingNextOnNetlify) {
-    console.log(
-      `This plugin does not support sites that manually use next-on-netlify. Uninstall next-on-netlify as a dependency and/or remove it from your postbuild script to allow this plugin to run.`,
-    )
-  }
-
-  return isUsingNextOnNetlify
-}
-
-module.exports = doesSiteUseNextOnNetlify

package/helpers/getNextConfig.js

@@ -1,46 +0,0 @@
-'use strict'
-
-const { cwd: getCwd } = require('process')
-
-const moize = require('moize')
-
-const resolveNextModule = require('./resolveNextModule')
-
-// We used to cache nextConfig for any cwd. Now we pass process.cwd() to cache
-// (or memoize) nextConfig per cwd.
-const getNextConfig = async function (failBuild = defaultFailBuild, cwd = getCwd()) {
-  // We cannot load `next` at the top-level because we validate whether the
-  // site is using `next` inside `onPreBuild`.
-  /* eslint-disable import/no-dynamic-require */
-  const { PHASE_PRODUCTION_BUILD } = require(resolveNextModule('next/constants', cwd))
-  const loadConfig = require(resolveNextModule(
-    [
-      // next <= 11.0.1
-      'next/dist/next-server/server/config',
-      // next > 11.0.1
-      'next/dist/server/config',
-    ],
-    cwd,
-  )).default
-  /* eslint-enable import/no-dynamic-require */
-
-  try {
-    return await loadConfig(PHASE_PRODUCTION_BUILD, cwd)
-  } catch (error) {
-    return failBuild('Error loading your next.config.js.', { error })
-  }
-}
-
-const moizedGetNextConfig = moize(getNextConfig, {
-  maxSize: 1e3,
-  isPromise: true,
-  // Memoization cache key. We need to use `transformArgs` so `process.cwd()`
-  // default value is assigned
-  transformArgs: ([, cwd = getCwd()]) => [cwd],
-})
-
-const defaultFailBuild = function (message, { error }) {
-  throw new Error(`${message}\n${error.stack}`)
-}
-
-module.exports = moizedGetNextConfig

package/helpers/getNextRoot.js

@@ -1,20 +0,0 @@
-const { existsSync } = require('fs')
-const path = require('path')
-
-/**
- * If we're in a monorepo then the Next root may not be the same as the base directory
- * If there's no next.config.js in the root, we instead look for it as a sibling of the publish dir
- */
-const getNextRoot = ({ netlifyConfig }) => {
-  let nextRoot = process.cwd()
-  if (
-    !existsSync(path.join(nextRoot, 'next.config.js')) &&
-    netlifyConfig.build.publish &&
-    netlifyConfig.build.publish !== nextRoot
-  ) {
-    nextRoot = path.dirname(netlifyConfig.build.publish)
-  }
-  return nextRoot
-}
-
-module.exports = getNextRoot

package/helpers/isStaticExportProject.js

@@ -1,20 +0,0 @@
-const usesBuildCommand = require('./usesBuildCommand')
-
-// Takes 1. Netlify config's build details and
-// 2. the project's package.json scripts to determine if
-// the Next.js app uses static HTML export
-const isStaticExportProject = ({ build, scripts }) => {
-  const NEXT_EXPORT_COMMAND = 'next export'
-
-  const isStaticExport = usesBuildCommand({ build, scripts, command: NEXT_EXPORT_COMMAND })
-
-  if (isStaticExport) {
-    console.log(
-      'NOTE: Static HTML export Next.js projects (projects that use `next export`) do not require most of this plugin. For these sites, this plugin *only* caches builds.',
-    )
-  }
-
-  return isStaticExport
-}
-
-module.exports = isStaticExportProject

package/helpers/resolveNextModule.js

@@ -1,30 +0,0 @@
-/**
- * Try one or more Next.js imports until one is found.
- * We can't require() these normally, because the "next" package might not be resolvable from the root of a monorepo
- */
-const resolveNextModule = (modules, nextRoot) => {
-  if (!Array.isArray(modules)) {
-    // eslint-disable-next-line no-param-reassign
-    modules = [modules]
-  }
-  for (const key in modules) {
-    const module = modules[key]
-    // Get the default list of require paths...
-    const paths = require.resolve.paths(module)
-    // ...add the root of the Next site to the beginning of that list so we try it first...
-    paths.unshift(nextRoot)
-    // ...then resolve the module using that list of paths.
-    try {
-      const resolved = require.resolve(module, { paths })
-      if (resolved) {
-        return resolved
-      }
-    } catch (error) {
-      // Failed. Trying next.
-    }
-  }
-
-  throw new Error(`Could not resolve Next module. Tried "${modules.join(', ')}"`)
-}
-
-module.exports = resolveNextModule

package/helpers/usesBuildCommand.js

@@ -1,37 +0,0 @@
-const parseNpmScript = require('@netlify/parse-npm-script')
-
-const COMMAND_PLACEHOLDER = '___netlifybuildcommand'
-
-// Does the build command include this value, either directly or via an npm script?
-const usesBuildCommand = ({ build, scripts, command }) => {
-  if (!build.command) return false
-
-  if (build.command.includes(command)) {
-    return true
-  }
-
-  if (!build.command.includes('npm run') && !build.command.includes('yarn')) {
-    return false
-  }
-
-  // Insert a fake script to represent the build command
-
-  const commands = { ...scripts, [COMMAND_PLACEHOLDER]: build.command }
-
-  // This resolves the npm script that is actually being run
-  try {
-    const { raw } = parseNpmScript({ scripts: commands }, COMMAND_PLACEHOLDER)
-    return raw.some((script) => script.includes(command))
-  } catch (error) {
-    console.error(
-      `Static export detection disabled because we could not parse your build command: ${error.message}
-The build command is "${build.command}" and the available npm scripts are: ${Object.keys(scripts)
-        .map((script) => `"${script}"`)
-        .join(', ')}
-
-If the site does use static export then you can set the env var NEXT_PLUGIN_FORCE_RUN to "false" or uninstall the plugin. See https://ntl.fyi/remove-plugin for instructions.`,
-    )
-  }
-}
-
-module.exports = usesBuildCommand

package/helpers/validateNextUsage.js

@@ -1,53 +0,0 @@
-const { yellowBright } = require('chalk')
-const { lt: ltVersion, gte: gteVersion } = require('semver')
-
-const getNextRoot = require('./getNextRoot')
-const resolveNextModule = require('./resolveNextModule')
-
-// Ensure Next.js is available.
-// We use `peerDependencies` instead of `dependencies` so that users can choose
-// the Next.js version. However, this requires them to install "next" in their
-// site.
-const validateNextUsage = function ({ failBuild, netlifyConfig }) {
-  const nextRoot = getNextRoot({ netlifyConfig })
-  //  Because we don't know the monorepo structure, we try to resolve next both locally and in the next root
-  if (!hasPackage('next', nextRoot)) {
-    return failBuild(
-      `This site does not seem to be using Next.js. Please run "npm install next" in the repository.
-If you are using a monorepo, please see the docs on configuring your site: https://ntl.fyi/next-monorepos`,
-    )
-  }
-
-  // We cannot load `next` at the top-level because we validate whether the
-  // site is using `next` inside `onPreBuild`.
-  // Old Next.js versions are not supported
-  // eslint-disable-next-line import/no-dynamic-require
-  const { version } = require(resolveNextModule(`next/package.json`, nextRoot))
-
-  console.log(`Using Next.js ${yellowBright(version)}`)
-
-  if (ltVersion(version, MIN_VERSION)) {
-    return failBuild(`Please upgrade to Next.js ${MIN_VERSION} or later.`)
-  }
-
-  // Recent Next.js versions are sometimes unstable and we might not officially
-  // support them yet. However, they might still work for some users, so we
-  // only print a warning
-  if (gteVersion(version, MIN_EXPERIMENTAL_VERSION)) {
-    console.log(yellowBright(`Warning: support for Next.js >=${MIN_EXPERIMENTAL_VERSION} is experimental`))
-  }
-}
-
-const MIN_VERSION = '10.0.6'
-const MIN_EXPERIMENTAL_VERSION = '11.1.0'
-
-const hasPackage = function (packageName, nextRoot) {
-  try {
-    resolveNextModule(`${packageName}/package.json`, nextRoot)
-    return true
-  } catch (error) {
-    return false
-  }
-}
-
-module.exports = validateNextUsage

package/helpers/verifyBuildTarget.js

@@ -1,69 +0,0 @@
-const path = require('path')
-
-const { writeFile } = require('fs-extra')
-
-const getNextConfig = require('./getNextConfig')
-const getNextRoot = require('./getNextRoot')
-const resolveNextModule = require('./resolveNextModule')
-
-// Checks if site has the correct next.config.js
-const verifyBuildTarget = async ({ failBuild, netlifyConfig }) => {
-  const nextRoot = getNextRoot({ netlifyConfig })
-
-  const { target, configFile } = await getNextConfig(failBuild, nextRoot)
-
-  if (!configFile) {
-    await writeFile(
-      path.resolve(nextRoot, 'next.config.js'),
-      `module.exports = {
-  // Supported targets are "serverless" and "experimental-serverless-trace"
-  target: "serverless",
-  generateBuildId: () => "build"
-}`,
-    )
-  }
-
-  // If the next config exists, log warning if target isn't in acceptableTargets
-  const acceptableTargets = ['serverless', 'experimental-serverless-trace']
-  const isValidTarget = acceptableTargets.includes(target)
-  if (isValidTarget) {
-    return
-  }
-  console.log(
-    `The "target" config property must be one of "${acceptableTargets.join(
-      '", "',
-    )}". Building with "serverless" target.`,
-  )
-
-  // We emulate Vercel so that we can set target to serverless if needed
-  process.env.NOW_BUILDER = true
-  // If no valid target is set, we use an internal Next env var to force it
-  process.env.NEXT_PRIVATE_TARGET = 'serverless'
-
-  // 🐉 We need Next to recalculate "isZeitNow" var so we can set the target, but it's
-  // set as an import side effect so we need to clear the require cache first. 🐲
-  // https://github.com/vercel/next.js/blob/canary/packages/next/telemetry/ci-info.ts
-
-  delete require.cache[resolveNextModule('next/dist/telemetry/ci-info', nextRoot)]
-  delete require.cache[
-    resolveNextModule(
-      [
-        // next <= 11.0.1
-        'next/dist/next-server/server/config',
-        // next > 11.0.1
-        'next/dist/server/config',
-      ],
-      nextRoot,
-    )
-  ]
-
-  // Clear memoized cache
-  getNextConfig.clear()
-
-  // Force the new config to be generated
-  await getNextConfig(failBuild, nextRoot)
-  // Reset the value in case something else is looking for it
-  process.env.NOW_BUILDER = false
-}
-
-module.exports = verifyBuildTarget

package/index.js

@@ -1,175 +0,0 @@
-const { readdirSync, existsSync } = require('fs')
-const path = require('path')
-
-const { yellowBright, greenBright, green } = require('chalk')
-const makeDir = require('make-dir')
-const { satisfies } = require('semver')
-const glob = require('tiny-glob')
-
-const { restoreCache, saveCache } = require('./helpers/cacheBuild')
-const checkNxConfig = require('./helpers/checkNxConfig')
-const copyUnstableIncludedDirs = require('./helpers/copyUnstableIncludedDirs')
-const doesNotNeedPlugin = require('./helpers/doesNotNeedPlugin')
-const getNextConfig = require('./helpers/getNextConfig')
-const getNextRoot = require('./helpers/getNextRoot')
-const validateNextUsage = require('./helpers/validateNextUsage')
-const verifyBuildTarget = require('./helpers/verifyBuildTarget')
-const nextOnNetlify = require('./src')
-
-// This is when the esbuild dynamic import support was added
-const REQUIRED_BUILD_VERSION = '>=15.11.5'
-
-// * Helpful Plugin Context *
-// - Between the prebuild and build steps, the project's build command is run
-// - Between the build and postbuild steps, any functions are bundled
-
-module.exports = {
-  async onPreBuild({ netlifyConfig, packageJson, utils, constants = {} }) {
-    const { FUNCTIONS_SRC = DEFAULT_FUNCTIONS_SRC, INTERNAL_FUNCTIONS_SRC, IS_LOCAL, NETLIFY_BUILD_VERSION } = constants
-
-    const { failBuild } = utils.build
-
-    validateNextUsage({ failBuild, netlifyConfig })
-
-    const hasNoPackageJson = Object.keys(packageJson).length === 0
-    if (hasNoPackageJson) {
-      return failBuild('Could not find a package.json for this project')
-    }
-
-    if (doesNotNeedPlugin({ netlifyConfig, packageJson, failBuild })) {
-      return
-    }
-    // We check for build version because that's what's available to us, but prompt about the cli because that's what they can upgrade
-    if (IS_LOCAL && !satisfies(NETLIFY_BUILD_VERSION, REQUIRED_BUILD_VERSION, { includePrerelease: true })) {
-      return failBuild(
-        `This version of the Essential Next.js plugin requires netlify-cli@4.4.2 or higher. Please upgrade and try again.
-You can do this by running: "npm install -g netlify-cli@latest" or "yarn global add netlify-cli@latest"`,
-      )
-    }
-
-    // Populates the correct config if needed
-    await verifyBuildTarget({ netlifyConfig, packageJson, failBuild })
-    const nextRoot = getNextRoot({ netlifyConfig })
-
-    // Because we memoize nextConfig, we need to do this after the write file
-    const nextConfig = await getNextConfig(utils.failBuild, nextRoot)
-
-    // Nx needs special config handling, so check for it specifically
-    const isNx = Boolean(
-      (packageJson.devDependencies && packageJson.devDependencies['@nrwl/next']) ||
-        (packageJson.dependencies && packageJson.dependencies['@nrwl/next']),
-    )
-
-    if (isNx) {
-      console.log('Detected Nx site. Checking configuration...')
-      checkNxConfig({ netlifyConfig, packageJson, nextConfig, failBuild, constants })
-    }
-
-    if (process.env.NEXT_IMAGE_ALLOWED_DOMAINS) {
-      console.log(
-        `The Essential Next.js plugin now supports reading image domains from your Next config, so using NEXT_IMAGE_ALLOWED_DOMAINS is now deprecated. Please set images.domains in next.config.js instead, and remove the NEXT_IMAGE_ALLOWED_DOMAINS variable.`,
-      )
-    }
-
-    if (INTERNAL_FUNCTIONS_SRC && existsSync(FUNCTIONS_SRC)) {
-      const oldFunctions = await glob('next_*', { cwd: FUNCTIONS_SRC })
-
-      if (oldFunctions.length !== 0) {
-        console.log(yellowBright`
-Detected the following functions that seem to have been generated by an old version of the Essential Next.js plugin. 
-The plugin no longer uses these and they should be deleted to avoid conflicts.\n`)
-        console.log(greenBright`• ${oldFunctions.join('\n• ')}
-`)
-      }
-    }
-
-    await restoreCache({ cache: utils.cache, distDir: nextConfig.distDir, nextRoot })
-
-    // Exit the build process on unhandled promise rejection. This is the default in Node 15+, but earlier versions just warn.
-    // This causes problems as it doesn't then know the build has failed until we try to copy the assets.
-    process.env.NODE_OPTIONS = [process.env.NODE_OPTIONS, '--unhandled-rejections=strict'].filter(Boolean).join(' ')
-  },
-  async onBuild({
-    netlifyConfig,
-    packageJson,
-    constants: { PUBLISH_DIR = DEFAULT_PUBLISH_DIR, INTERNAL_FUNCTIONS_SRC, FUNCTIONS_SRC = DEFAULT_FUNCTIONS_SRC },
-    utils,
-  }) {
-    const { failBuild } = utils.build
-
-    const nextRoot = getNextRoot({ netlifyConfig })
-
-    if (doesNotNeedPlugin({ netlifyConfig, packageJson, failBuild })) {
-      return
-    }
-    console.log('Detected Next.js site. Copying files...')
-
-    const { distDir, configFile } = await getNextConfig(failBuild, nextRoot)
-    const dist = path.resolve(nextRoot, distDir)
-
-    if (!existsSync(dist)) {
-      failBuild(`
-Could not find "${distDir}" after building the site, which indicates that "next build" was not run or that we're looking in the wrong place. 
-We're using the config file ${configFile}, and looking for the dist directory at ${dist}. If this is incorrect, try deleting the config file, or
-moving it to the correct place. Check that your build command includes "next build". If the site is a monorepo, see https://ntl.fyi/next-monorepo 
-for information on configuring the site. If this is not a Next.js site or if it uses static export, you should remove the Essential Next.js plugin. 
-See https://ntl.fyi/remove-plugin for instructions.
-      `)
-    }
-
-    console.log(`** Running Next on Netlify package **`)
-
-    await makeDir(PUBLISH_DIR)
-    await nextOnNetlify({
-      functionsDir: path.resolve(INTERNAL_FUNCTIONS_SRC || FUNCTIONS_SRC),
-      publishDir: netlifyConfig.build.publish || PUBLISH_DIR,
-      nextRoot,
-    })
-
-    if (!netlifyConfig.functions['*'].included_files) {
-      // eslint-disable-next-line no-param-reassign
-      netlifyConfig.functions['*'].included_files = []
-    }
-    netlifyConfig.functions['*'].included_files.push(
-      '!node_modules/@next/swc-*/**/*',
-      '!node_modules/next/dist/compiled/@ampproject/toolbox-optimizer/**/*',
-    )
-  },
-
-  async onPostBuild({ netlifyConfig, packageJson, constants: { FUNCTIONS_DIST = DEFAULT_FUNCTIONS_DIST }, utils }) {
-    if (doesNotNeedPlugin({ netlifyConfig, packageJson, utils })) {
-      utils.status.show({
-        title: 'Essential Next.js Build Plugin did not run',
-        summary: netlifyConfig.build.command
-          ? 'The site either uses static export, manually runs next-on-netlify, or is not a Next.js site'
-          : 'The site config does not specify a build command',
-      })
-      return
-    }
-    const nextRoot = getNextRoot({ netlifyConfig })
-
-    const nextConfig = await getNextConfig(utils.failBuild, nextRoot)
-    const { distDir, generateBuildId } = nextConfig
-    await saveCache({ cache: utils.cache, distDir, nextRoot })
-    copyUnstableIncludedDirs({ nextConfig, functionsDist: path.resolve(FUNCTIONS_DIST) })
-    utils.status.show({
-      title: 'Essential Next.js Build Plugin ran successfully',
-      summary: 'Generated serverless functions and stored the Next.js cache',
-    })
-
-    // The default generateBuildId function returns null, which causes it to use a random value from nanoid
-    // eslint-disable-next-line no-self-compare
-    if (generateBuildId() === null || generateBuildId() !== generateBuildId()) {
-      console.warn(
-        yellowBright`
-For faster deploy times, build IDs should be set to a static value.
-To do this, set ${green`generateBuildId: () => 'build'`} in your next.config.js`,
-        // TODO: add shortlink when docs are updated
-      )
-    }
-  },
-}
-
-const DEFAULT_FUNCTIONS_SRC = 'netlify/functions'
-const DEFAULT_FUNCTIONS_DIST = '.netlify/functions/'
-const DEFAULT_PUBLISH_DIR = 'out'

package/src/index.js

@@ -1,94 +0,0 @@
-const { normalize } = require('path')
-
-const chokidar = require('chokidar')
-const debounceFn = require('debounce-fn')
-const execa = require('execa')
-
-const getNextConfig = require('../helpers/getNextConfig')
-
-const { NETLIFY_PUBLISH_PATH, NETLIFY_FUNCTIONS_PATH, SRC_FILES } = require('./lib/config')
-const { logTitle } = require('./lib/helpers/logger')
-const copyNextAssets = require('./lib/steps/copyNextAssets')
-const copyPublicFiles = require('./lib/steps/copyPublicFiles')
-const prepareFolders = require('./lib/steps/prepareFolders')
-const setupHeaders = require('./lib/steps/setupHeaders')
-const setupImageFunction = require('./lib/steps/setupImageFunction')
-const setupPages = require('./lib/steps/setupPages')
-const setupRedirects = require('./lib/steps/setupRedirects')
-
-const build = async (functionsPath, publishPath, nextRoot) => {
-  const trackNextOnNetlifyFiles = prepareFolders({
-    functionsPath,
-    publishPath,
-  })
-
-  // If we're in a monorepo we need to move into the Next site root
-  const oldCwd = process.cwd()
-  if (nextRoot !== oldCwd) {
-    process.chdir(nextRoot)
-  }
-  copyPublicFiles(publishPath)
-
-  await copyNextAssets(publishPath)
-
-  await setupPages({ functionsPath, publishPath })
-
-  const { images } = await getNextConfig()
-
-  await setupImageFunction(functionsPath, images)
-
-  await setupRedirects(publishPath)
-
-  setupHeaders(publishPath)
-
-  // ...and move back after
-  if (nextRoot !== oldCwd) {
-    process.chdir(oldCwd)
-  }
-
-  trackNextOnNetlifyFiles()
-
-  logTitle('✅ Success! All done!')
-}
-
-const watch = (functionsPath, publishPath, nextRoot) => {
-  logTitle(`👀 Watching source code for changes`)
-
-  const runBuild = debounceFn(
-    async () => {
-      try {
-        execa.sync('next', ['build'], { stdio: 'inherit', preferLocal: true, cwd: nextRoot })
-        await build(functionsPath, publishPath, nextRoot)
-      } catch (error) {
-        console.log(error)
-      }
-    },
-    {
-      wait: 3000,
-    },
-  )
-
-  chokidar.watch(SRC_FILES).on('all', runBuild)
-}
-
-// options param:
-// {
-//   functionsDir: string to path
-//   publishDir: string to path
-//   watch: { directory: string to path }
-// }
-//
-
-const nextOnNetlify = async (options = {}) => {
-  const functionsPath = normalize(options.functionsDir || NETLIFY_FUNCTIONS_PATH)
-  const publishPath = normalize(options.publishDir || NETLIFY_PUBLISH_PATH)
-  const nextRoot = normalize(options.nextRoot || process.cwd())
-
-  if (options.watch) {
-    watch(functionsPath, publishPath, nextRoot)
-  } else {
-    await build(functionsPath, publishPath, nextRoot)
-  }
-}
-
-module.exports = nextOnNetlify