netlify-cli 12.6.0 → 12.7.0

package/src/commands/serve/serve.mjs

@@ -0,0 +1,189 @@
+// @ts-check
+import process from 'process'
+
+import { Option } from 'commander'
+
+import { promptEditorHelper } from '../../lib/edge-functions/editor-helper.mjs'
+import { startFunctionsServer } from '../../lib/functions/server.mjs'
+import { printBanner } from '../../utils/banner.mjs'
+import {
+  chalk,
+  exit,
+  log,
+  NETLIFYDEVERR,
+  NETLIFYDEVLOG,
+  NETLIFYDEVWARN,
+  normalizeConfig,
+} from '../../utils/command-helpers.mjs'
+import detectServerSettings, { getConfigWithPlugins } from '../../utils/detect-server-settings.mjs'
+import { getSiteInformation, injectEnvVariables } from '../../utils/dev.mjs'
+import { getEnvelopeEnv, normalizeContext } from '../../utils/env/index.mjs'
+import { getInternalFunctionsDir } from '../../utils/functions/functions.mjs'
+import { ensureNetlifyIgnore } from '../../utils/gitignore.mjs'
+import openBrowser from '../../utils/open-browser.mjs'
+import { generateInspectSettings, startProxyServer } from '../../utils/proxy-server.mjs'
+import { runBuildTimeline } from '../../utils/run-build.mjs'
+import { getGeoCountryArgParser } from '../../utils/validation.mjs'
+
+/**
+ * The serve command
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command.mjs').default} command
+ */
+const serve = async (options, command) => {
+  const { api, cachedConfig, config, repositoryRoot, site, siteInfo, state } = command.netlify
+  config.dev = { ...config.dev }
+  config.build = { ...config.build }
+  /** @type {import('../dev/types').DevConfig} */
+  const devConfig = {
+    ...(config.functionsDirectory && { functions: config.functionsDirectory }),
+    ...(config.build.publish && { publish: config.build.publish }),
+    ...config.dev,
+    ...options,
+    // Override the `framework` value so that we start a static server and not
+    // the framework's development server.
+    framework: '#static',
+  }
+
+  let { env } = cachedConfig
+
+  if (!options.offline && siteInfo.use_envelope) {
+    env = await getEnvelopeEnv({ api, context: options.context, env, siteInfo })
+    log(`${NETLIFYDEVLOG} Injecting environment variable values for ${chalk.yellow('all scopes')}`)
+  }
+
+  await injectEnvVariables({ devConfig, env, site })
+  await promptEditorHelper({ chalk, config, log, NETLIFYDEVLOG, repositoryRoot, state })
+
+  const { addonsUrls, capabilities, siteUrl, timeouts } = await getSiteInformation({
+    // inherited from base command --offline
+    offline: options.offline,
+    api,
+    site,
+    siteInfo,
+  })
+
+  // Ensure the internal functions directory exists so that the functions
+  // server and registry are initialized, and any functions created by
+  // Netlify Build are loaded.
+  await getInternalFunctionsDir({ base: site.root, ensureExists: true })
+
+  /** @type {Partial<import('../../utils/types').ServerSettings>} */
+  let settings = {}
+  try {
+    settings = await detectServerSettings(devConfig, options, site.root)
+
+    cachedConfig.config = getConfigWithPlugins(cachedConfig.config, settings)
+  } catch (error_) {
+    log(NETLIFYDEVERR, error_.message)
+    exit(1)
+  }
+
+  command.setAnalyticsPayload({ projectType: settings.framework || 'custom', live: options.live, graph: options.graph })
+
+  log(`${NETLIFYDEVLOG} Building site for production`)
+  log(
+    `${NETLIFYDEVWARN} Changes will not be hot-reloaded, so if you need to rebuild your site you must exit and run 'netlify serve' again`,
+  )
+
+  const { configPath: configPathOverride } = await runBuildTimeline({ cachedConfig, options, settings, site })
+
+  await startFunctionsServer({
+    api,
+    command,
+    config,
+    debug: options.debug,
+    loadDistFunctions: true,
+    settings,
+    site,
+    siteInfo,
+    siteUrl,
+    capabilities,
+    timeouts,
+  })
+
+  // Try to add `.netlify` to `.gitignore`.
+  try {
+    await ensureNetlifyIgnore(repositoryRoot)
+  } catch {
+    // no-op
+  }
+
+  // TODO: We should consolidate this with the existing config watcher.
+  const getUpdatedConfig = async () => {
+    const cwd = options.cwd || process.cwd()
+    const { config: newConfig } = await command.getConfig({ cwd, offline: true, state })
+    const normalizedNewConfig = normalizeConfig(newConfig)
+
+    return normalizedNewConfig
+  }
+
+  const inspectSettings = generateInspectSettings(options.edgeInspect, options.edgeInspectBrk)
+  const url = await startProxyServer({
+    addonsUrls,
+    config,
+    configPath: configPathOverride,
+    env,
+    geolocationMode: options.geo,
+    geoCountry: options.country,
+    getUpdatedConfig,
+    inspectSettings,
+    offline: options.offline,
+    settings,
+    site,
+    siteInfo,
+    state,
+  })
+
+  if (devConfig.autoLaunch !== false) {
+    await openBrowser({ url, silentBrowserNoneError: true })
+  }
+
+  process.env.URL = url
+  process.env.DEPLOY_URL = url
+
+  printBanner({ url })
+}
+
+/**
+ * Creates the `netlify serve` command
+ * @param {import('../base-command.mjs').default} program
+ * @returns
+ */
+export const createServeCommand = (program) =>
+  program
+    .command('serve')
+    .description(
+      '(Beta) Build the site for production and serve locally. This does not watch the code for changes, so if you need to rebuild your site then you must exit and run `serve` again.',
+    )
+    .option(
+      '--context <context>',
+      'Specify a deploy context or branch for environment variables (contexts: "production", "deploy-preview", "branch-deploy", "dev")',
+      normalizeContext,
+    )
+    .option('-p ,--port <port>', 'port of netlify dev', (value) => Number.parseInt(value))
+    .option('-d ,--dir <path>', 'dir with static files')
+    .option('-f ,--functions <folder>', 'specify a functions folder to serve')
+    .option('-o ,--offline', 'disables any features that require network access')
+    .option('--functionsPort <port>', 'port of functions server', (value) => Number.parseInt(value))
+    .addOption(
+      new Option(
+        '--geo <mode>',
+        'force geolocation data to be updated, use cached data from the last 24h if found, or use a mock location',
+      )
+        .choices(['cache', 'mock', 'update'])
+        .default('cache'),
+    )
+    .addOption(
+      new Option(
+        '--country <geoCountry>',
+        'Two-letter country code (https://ntl.fyi/country-codes) to use as mock geolocation (enables --geo=mock automatically)',
+      ).argParser(getGeoCountryArgParser('netlify dev --geo=mock --country=FR')),
+    )
+    .addOption(
+      new Option('--staticServerPort <port>', 'port of the static app server used when no framework is detected')
+        .argParser((value) => Number.parseInt(value))
+        .hideHelp(),
+    )
+    .addExamples(['netlify serve', 'BROWSER=none netlify serve # disable browser auto opening'])
+    .action(serve)

package/src/functions-templates/javascript/oauth-passport/package.json

@@ -16,7 +16,7 @@
   "dependencies": {
     "cookie-parser": "^1.4.5",
     "express": "^4.17.1",
-    "jsonwebtoken": "^8.5.1",
+    "jsonwebtoken": "^9.0.0",
     "passport": "^0.6.0",
     "passport-github2": "^0.1.12",
     "passport-jwt": "^4.0.0",

package/src/lib/edge-functions/registry.mjs

@@ -213,17 +213,14 @@ export class EdgeFunctionsRegistry {
       if (
         variable.sources.includes('ui') ||
         variable.sources.includes('account') ||
-        variable.sources.includes('addons')
+        variable.sources.includes('addons') ||
+        variable.sources.includes('internal')
       ) {
         env[key] = variable.value
       }
     })
 
     env.DENO_REGION = 'local'
-    env.NETLIFY_DEV = 'true'
-    // We use it in the bootstrap layer to detect whether we're running in production or not
-    // (see https://github.com/netlify/edge-functions-bootstrap/blob/main/src/bootstrap/environment.ts#L2)
-    // env.DENO_DEPLOYMENT_ID = 'xxx='
 
     return env
   }

package/src/lib/functions/registry.mjs

@@ -1,19 +1,22 @@
 // @ts-check
 import { mkdir } from 'fs/promises'
-import { extname, isAbsolute, join } from 'path'
+import { extname, isAbsolute, join, resolve } from 'path'
 import { env } from 'process'
 
+import extractZip from 'extract-zip'
+
 import {
   chalk,
   getTerminalLink,
   log,
   NETLIFYDEVERR,
   NETLIFYDEVLOG,
-  NETLIFYDEVWARN,
   warn,
   watchDebounced,
 } from '../../utils/command-helpers.mjs'
+import { SERVE_FUNCTIONS_FOLDER } from '../../utils/functions/functions.mjs'
 import { getLogMessage } from '../log.mjs'
+import { getPathInProject } from '../settings.mjs'
 
 import NetlifyFunction from './netlify-function.mjs'
 import runtimes from './runtimes/index.mjs'
@@ -21,9 +24,10 @@ import runtimes from './runtimes/index.mjs'
 const ZIP_EXTENSION = '.zip'
 
 export class FunctionsRegistry {
-  constructor({ capabilities, config, isConnected = false, projectRoot, settings, timeouts }) {
+  constructor({ capabilities, config, debug = false, isConnected = false, projectRoot, settings, timeouts }) {
     this.capabilities = capabilities
     this.config = config
+    this.debug = debug
     this.isConnected = isConnected
     this.projectRoot = projectRoot
     this.timeouts = timeouts
@@ -123,7 +127,7 @@ export class FunctionsRegistry {
     return this.functions.get(name)
   }
 
-  registerFunction(name, funcBeforeHook) {
+  async registerFunction(name, funcBeforeHook) {
     const { runtime } = funcBeforeHook
 
     // The `onRegister` hook allows runtimes to modify the function before it's
@@ -145,11 +149,16 @@ export class FunctionsRegistry {
       )
     }
 
-    // This fixes the bug described here https://github.com/netlify/zip-it-and-ship-it/issues/637
-    // If the current function's file is a zip bundle, we ignore it and log a helpful message.
+    // If the function file is a ZIP, we extract it and rewire its main file to
+    // the new location.
     if (extname(func.mainFile) === ZIP_EXTENSION) {
-      log(`${NETLIFYDEVWARN} Skipped bundled function ${chalk.yellow(name)}. Unzip the archive to load it from source.`)
-      return
+      const unzippedDirectory = await this.unzipFunction(func)
+
+      if (this.debug) {
+        log(`${NETLIFYDEVLOG} ${chalk.green('Extracted')} function ${chalk.yellow(name)} from ${func.mainFile}.`)
+      }
+
+      func.mainFile = join(unzippedDirectory, `${func.name}.js`)
     }
 
     this.functions.set(name, func)
@@ -197,34 +206,36 @@ export class FunctionsRegistry {
 
     await Promise.all(deletedFunctions.map((func) => this.unregisterFunction(func.name)))
 
-    functions.forEach(({ mainFile, name, runtime: runtimeName }) => {
-      const runtime = runtimes[runtimeName]
-
-      // If there is no matching runtime, it means this function is not yet
-      // supported in Netlify Dev.
-      if (runtime === undefined) {
-        return
-      }
+    await Promise.all(
+      functions.map(async ({ mainFile, name, runtime: runtimeName }) => {
+        const runtime = runtimes[runtimeName]
 
-      // If this function has already been registered, we skip it.
-      if (this.functions.has(name)) {
-        return
-      }
+        // If there is no matching runtime, it means this function is not yet
+        // supported in Netlify Dev.
+        if (runtime === undefined) {
+          return
+        }
 
-      const func = new NetlifyFunction({
-        config: this.config,
-        directory: directories.find((directory) => mainFile.startsWith(directory)),
-        mainFile,
-        name,
-        projectRoot: this.projectRoot,
-        runtime,
-        timeoutBackground: this.timeouts.backgroundFunctions,
-        timeoutSynchronous: this.timeouts.syncFunctions,
-        settings: this.settings,
-      })
+        // If this function has already been registered, we skip it.
+        if (this.functions.has(name)) {
+          return
+        }
 
-      this.registerFunction(name, func)
-    })
+        const func = new NetlifyFunction({
+          config: this.config,
+          directory: directories.find((directory) => mainFile.startsWith(directory)),
+          mainFile,
+          name,
+          projectRoot: this.projectRoot,
+          runtime,
+          timeoutBackground: this.timeouts.backgroundFunctions,
+          timeoutSynchronous: this.timeouts.syncFunctions,
+          settings: this.settings,
+        })
+
+        await this.registerFunction(name, func)
+      }),
+    )
 
     await Promise.all(directories.map((path) => this.setupDirectoryWatcher(path)))
   }
@@ -261,4 +272,15 @@ export class FunctionsRegistry {
       await watcher.close()
     }
   }
+
+  async unzipFunction(func) {
+    const targetDirectory = resolve(
+      this.projectRoot,
+      getPathInProject([SERVE_FUNCTIONS_FOLDER, '.unzipped', func.name]),
+    )
+
+    await extractZip(func.mainFile, { dir: targetDirectory })
+
+    return targetDirectory
+  }
 }

package/src/lib/functions/runtimes/js/builders/zisi.mjs

@@ -7,6 +7,7 @@ import readPkgUp from 'read-pkg-up'
 import sourceMapSupport from 'source-map-support'
 
 import { NETLIFYDEVERR } from '../../../../../utils/command-helpers.mjs'
+import { SERVE_FUNCTIONS_FOLDER } from '../../../../../utils/functions/functions.mjs'
 import { getPathInProject } from '../../../../settings.mjs'
 import { normalizeFunctionsConfig } from '../../../config.mjs'
 import { memoizedBuild } from '../../../memoized-build.mjs'
@@ -94,7 +95,7 @@ const clearFunctionsCache = (functionsPath) => {
 }
 
 const getTargetDirectory = async ({ errorExit }) => {
-  const targetDirectory = path.resolve(getPathInProject(['functions-serve']))
+  const targetDirectory = path.resolve(getPathInProject([SERVE_FUNCTIONS_FOLDER]))
 
   try {
     await mkdir(targetDirectory, { recursive: true })

package/src/lib/functions/runtimes/rust/index.mjs

@@ -7,6 +7,7 @@ import findUp from 'find-up'
 import toml from 'toml'
 
 import execa from '../../../../utils/execa.mjs'
+import { SERVE_FUNCTIONS_FOLDER } from '../../../../utils/functions/functions.mjs'
 import { getPathInProject } from '../../../settings.mjs'
 import { runFunctionsProxy } from '../../local-proxy.mjs'
 
@@ -16,7 +17,7 @@ export const name = 'rs'
 
 const build = async ({ func }) => {
   const functionDirectory = dirname(func.mainFile)
-  const cacheDirectory = resolve(getPathInProject(['functions-serve']))
+  const cacheDirectory = resolve(getPathInProject([SERVE_FUNCTIONS_FOLDER]))
   const targetDirectory = join(cacheDirectory, func.name)
   const crateName = await getCrateName(functionDirectory)
   const binaryName = `${crateName}${isWindows ? '.exe' : ''}`

package/src/lib/functions/server.mjs

@@ -4,7 +4,7 @@ import jwtDecode from 'jwt-decode'
 
 import { NETLIFYDEVERR, NETLIFYDEVLOG, error as errorExit, log } from '../../utils/command-helpers.mjs'
 import { generateNetlifyGraphJWT } from '../../utils/dev.mjs'
-import { CLOCKWORK_USERAGENT, getInternalFunctionsDir } from '../../utils/functions/index.mjs'
+import { CLOCKWORK_USERAGENT, getFunctionsDistPath, getInternalFunctionsDir } from '../../utils/functions/index.mjs'
 
 import { handleBackgroundFunction, handleBackgroundFunctionResult } from './background.mjs'
 import { createFormSubmissionHandler } from './form-submissions-handler.mjs'
@@ -208,29 +208,46 @@ const getFunctionsServer = async function (options) {
 }
 
 export const startFunctionsServer = async (options) => {
-  const { capabilities, config, settings, site, siteUrl, timeouts } = options
+  const { capabilities, config, debug, loadDistFunctions, settings, site, siteUrl, timeouts } = options
   const internalFunctionsDir = await getInternalFunctionsDir({ base: site.root })
+  const functionsDirectories = []
 
-  // The order of the function directories matters. Leftmost directories take
-  // precedence.
-  const functionsDirectories = [settings.functions, internalFunctionsDir].filter(Boolean)
-
-  if (functionsDirectories.length !== 0) {
-    const functionsRegistry = new FunctionsRegistry({
-      capabilities,
-      config,
-      isConnected: Boolean(siteUrl),
-      projectRoot: site.root,
-      settings,
-      timeouts,
-    })
+  // If the `loadDistFunctions` parameter is sent, the functions server will
+  // use the built functions created by zip-it-and-ship-it rather than building
+  // them from source.
+  if (loadDistFunctions) {
+    const distPath = await getFunctionsDistPath({ base: site.root })
 
-    await functionsRegistry.scan(functionsDirectories)
+    if (distPath) {
+      functionsDirectories.push(distPath)
+    }
+  } else {
+    // The order of the function directories matters. Leftmost directories take
+    // precedence.
+    const sourceDirectories = [settings.functions, internalFunctionsDir].filter(Boolean)
 
-    const server = await getFunctionsServer(Object.assign(options, { functionsRegistry }))
+    functionsDirectories.push(...sourceDirectories)
+  }
 
-    await startWebServer({ server, settings })
+  if (functionsDirectories.length === 0) {
+    return
   }
+
+  const functionsRegistry = new FunctionsRegistry({
+    capabilities,
+    config,
+    debug,
+    isConnected: Boolean(siteUrl),
+    projectRoot: site.root,
+    settings,
+    timeouts,
+  })
+
+  await functionsRegistry.scan(functionsDirectories)
+
+  const server = await getFunctionsServer(Object.assign(options, { functionsRegistry }))
+
+  await startWebServer({ server, settings })
 }
 
 const startWebServer = async ({ server, settings }) => {

package/src/utils/banner.mjs

@@ -0,0 +1,17 @@
+// @ts-check
+import boxen from 'boxen'
+
+import { chalk, log, NETLIFYDEVLOG } from './command-helpers.mjs'
+
+export const printBanner = ({ url }) => {
+  const banner = chalk.bold(`${NETLIFYDEVLOG} Server now ready on ${url}`)
+
+  log(
+    boxen(banner, {
+      padding: 1,
+      margin: 1,
+      align: 'center',
+      borderColor: '#00c7b7',
+    }),
+  )
+}

package/src/utils/detect-server-settings.mjs

@@ -11,7 +11,7 @@ import isPlainObject from 'is-plain-obj'
 
 import { NETLIFYDEVWARN, chalk, log } from './command-helpers.mjs'
 import { acquirePort } from './dev.mjs'
-import { getInternalFunctionsDir } from './functions/index.mjs'
+import { getInternalFunctionsDir } from './functions/functions.mjs'
 
 const formatProperty = (str) => chalk.magenta(`'${str}'`)
 const formatValue = (str) => chalk.green(`'${str}'`)
@@ -364,4 +364,38 @@ const formatSettingsArrForInquirer = function (frameworks) {
   return formattedArr.flat()
 }
 
+/**
+ * Returns a copy of the provided config with any plugins provided by the
+ * server settings
+ * @param {*} config
+ * @param {Partial<import('./types').ServerSettings>} settings
+ * @returns {*} Modified config
+ */
+export const getConfigWithPlugins = (config, settings) => {
+  if (!settings.plugins) {
+    return config
+  }
+
+  // If there are plugins that we should be running for this site, add them
+  // to the config as if they were declared in netlify.toml. We must check
+  // whether the plugin has already been added by another source (like the
+  // TOML file or the UI), as we don't want to run the same plugin twice.
+  const { plugins: existingPlugins = [] } = config
+  const existingPluginNames = new Set(existingPlugins.map((plugin) => plugin.package))
+  const newPlugins = settings.plugins
+    .map((pluginName) => {
+      if (existingPluginNames.has(pluginName)) {
+        return
+      }
+
+      return { package: pluginName, origin: 'config', inputs: {} }
+    })
+    .filter(Boolean)
+
+  return {
+    ...config,
+    plugins: [...newPlugins, ...config.plugins],
+  }
+}
+
 export default detectServerSettings

package/src/utils/dev.mjs

@@ -148,6 +148,10 @@ export const injectEnvVariables = async ({ devConfig, env, site }) => {
       const newSourceName = `${file} file`
       const sources = environment.has(key) ? [newSourceName, ...environment.get(key).sources] : [newSourceName]
 
+      if (sources.includes('internal')) {
+        return
+      }
+
       environment.set(key, {
         sources,
         value: fileEnv[key],
@@ -160,6 +164,7 @@ export const injectEnvVariables = async ({ devConfig, env, site }) => {
     const existsInProcess = process.env[key] !== undefined
     const [usedSource, ...overriddenSources] = existsInProcess ? ['process', ...variable.sources] : variable.sources
     const usedSourceName = getEnvSourceName(usedSource)
+    const isInternal = variable.sources.includes('internal')
 
     overriddenSources.forEach((source) => {
       const sourceName = getEnvSourceName(source)
@@ -173,17 +178,15 @@ export const injectEnvVariables = async ({ devConfig, env, site }) => {
       )
     })
 
-    if (!existsInProcess) {
-      // Omitting `general` env vars to reduce noise in the logs.
-      if (usedSource !== 'general') {
+    if (!existsInProcess || isInternal) {
+      // Omitting `general` and `internal` env vars to reduce noise in the logs.
+      if (usedSource !== 'general' && !isInternal) {
         log(`${NETLIFYDEVLOG} Injected ${usedSourceName} env var: ${chalk.yellow(key)}`)
       }
 
       process.env[key] = variable.value
     }
   }
-
-  process.env.NETLIFY_DEV = 'true'
 }
 
 export const acquirePort = async ({ configuredPort, defaultPort, errorMessage }) => {

package/src/utils/framework-server.mjs

@@ -0,0 +1,66 @@
+// @ts-check
+import waitPort from 'wait-port'
+
+import { startSpinner, stopSpinner } from '../lib/spinner.mjs'
+
+import { error, exit, log, NETLIFYDEVERR, NETLIFYDEVLOG } from './command-helpers.mjs'
+import { runCommand } from './shell.mjs'
+import { startStaticServer } from './static-server.mjs'
+
+// 10 minutes
+const FRAMEWORK_PORT_TIMEOUT = 6e5
+
+/**
+ * @typedef StartReturnObject
+ * @property {4 | 6 | undefined=} ipVersion The version the open port was found on
+ */
+
+/**
+ * Start a static server if the `useStaticServer` is provided or a framework specific server
+ * @param {object} config
+ * @param {Partial<import('./types').ServerSettings>} config.settings
+ * @returns {Promise<StartReturnObject>}
+ */
+export const startFrameworkServer = async function ({ settings }) {
+  if (settings.useStaticServer) {
+    if (settings.command) {
+      runCommand(settings.command, settings.env)
+    }
+    await startStaticServer({ settings })
+
+    return {}
+  }
+
+  log(`${NETLIFYDEVLOG} Starting Netlify Dev with ${settings.framework || 'custom config'}`)
+
+  const spinner = startSpinner({
+    text: `Waiting for framework port ${settings.frameworkPort}. This can be configured using the 'targetPort' property in the netlify.toml`,
+  })
+
+  runCommand(settings.command, settings.env, spinner)
+
+  let port
+  try {
+    port = await waitPort({
+      port: settings.frameworkPort,
+      host: 'localhost',
+      output: 'silent',
+      timeout: FRAMEWORK_PORT_TIMEOUT,
+      ...(settings.pollingStrategies.includes('HTTP') && { protocol: 'http' }),
+    })
+
+    if (!port.open) {
+      throw new Error(`Timed out waiting for port '${settings.frameworkPort}' to be open`)
+    }
+
+    stopSpinner({ error: false, spinner })
+  } catch (error_) {
+    stopSpinner({ error: true, spinner })
+    log(NETLIFYDEVERR, `Netlify Dev could not start or connect to localhost:${settings.frameworkPort}.`)
+    log(NETLIFYDEVERR, `Please make sure your framework server is running on port ${settings.frameworkPort}`)
+    error(error_)
+    exit(1)
+  }
+
+  return { ipVersion: port?.ipVersion }
+}