netlify-cli 17.2.1 → 17.3.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "netlify-cli",
   "description": "Netlify command line tool",
-  "version": "17.2.1",
+  "version": "17.3.0",
   "author": "Netlify Inc.",
   "type": "module",
   "engines": {
@@ -45,12 +45,12 @@
     "@bugsnag/js": "7.20.2",
     "@fastify/static": "6.10.2",
     "@netlify/blobs": "^4.0.0",
-    "@netlify/build": "29.25.0",
-    "@netlify/build-info": "7.10.2",
+    "@netlify/build": "29.26.3",
+    "@netlify/build-info": "7.11.1",
     "@netlify/config": "20.9.0",
     "@netlify/edge-bundler": "^10.1.0",
     "@netlify/local-functions-proxy": "1.1.1",
-    "@netlify/zip-it-and-ship-it": "9.25.7",
+    "@netlify/zip-it-and-ship-it": "9.26.1",
     "@octokit/rest": "19.0.13",
     "ansi-escapes": "6.2.0",
     "ansi-styles": "6.2.1",
@@ -144,6 +144,7 @@
     "through2-map": "3.0.0",
     "to-readable-stream": "3.0.0",
     "toml": "3.0.0",
+    "tomlify-j0.4": "^3.0.0",
     "ulid": "2.3.0",
     "unixify": "1.0.0",
     "update-notifier": "6.0.2",

package/src/commands/build/build.mjs

@@ -51,6 +51,7 @@ const build = async (options, command) => {
   const buildOptions = await getBuildOptions({
     cachedConfig,
     packagePath: command.workspacePackage,
+    currentDir: command.workingDir,
     token,
     options,
   })

package/src/commands/deploy/deploy.mjs

@@ -4,11 +4,12 @@ import { basename, resolve } from 'path'
 import { env } from 'process'
 
 import { runCoreSteps } from '@netlify/build'
-import { restoreConfig, updateConfig } from '@netlify/config'
 import { Option } from 'commander'
 import inquirer from 'inquirer'
 import isEmpty from 'lodash/isEmpty.js'
 import isObject from 'lodash/isObject.js'
+import { parseAllHeaders } from 'netlify-headers-parser'
+import { parseAllRedirects } from 'netlify-redirect-parser'
 import prettyjson from 'prettyjson'
 
 import { cancelDeploy } from '../../lib/api.mjs'
@@ -220,7 +221,10 @@ const getDeployFilesFilter = ({ deployFolder, site }) => {
       (skipNodeModules && base === 'node_modules') ||
       (base.startsWith('.') && base !== '.well-known') ||
       base.startsWith('__MACOSX') ||
-      base.includes('/.')
+      base.includes('/.') ||
+      // headers and redirects are bundled in the config
+      base === '_redirects' ||
+      base === '_headers'
 
     return !skipFile
   }
@@ -322,7 +326,7 @@ const runDeploy = async ({
   alias,
   api,
   command,
-  configPath,
+  config,
   deployFolder,
   deployTimeout,
   deployToProduction,
@@ -358,9 +362,29 @@ const runDeploy = async ({
     const functionDirectories = [internalFunctionsFolder, functionsFolder].filter(Boolean)
     const manifestPath = skipFunctionsCache ? null : await getFunctionsManifestPath({ base: site.root, packagePath })
 
+    const redirectsPath = `${deployFolder}/_redirects`
+    const headersPath = `${deployFolder}/_headers`
+
+    const { redirects } = await parseAllRedirects({
+      configRedirects: config.redirects,
+      redirectsFiles: [redirectsPath],
+      minimal: true,
+    })
+
+    config.redirects = redirects
+
+    const { headers } = await parseAllHeaders({
+      configHeaders: config.headers,
+      // @ts-ignore
+      headersFiles: [headersPath],
+      minimal: true,
+    })
+
+    config.headers = headers
+
     // @ts-ignore
     results = await deploySite(api, siteId, deployFolder, {
-      configPath,
+      config,
       fnDir: functionDirectories,
       functionsConfig,
       statusCb: silent ? () => {} : deployProgressCb(),
@@ -407,10 +431,12 @@ const runDeploy = async ({
  * @param {object} config
  * @param {*} config.cachedConfig
  * @param {string} [config.packagePath]
+ * @param {*} config.deployHandler
+ * @param {string} config.currentDir
  * @param {import('commander').OptionValues} config.options The options of the command
  * @returns
  */
-const handleBuild = async ({ cachedConfig, options, packagePath }) => {
+const handleBuild = async ({ cachedConfig, currentDir, deployHandler, options, packagePath }) => {
   if (!options.build) {
     return {}
   }
@@ -420,6 +446,8 @@ const handleBuild = async ({ cachedConfig, options, packagePath }) => {
     packagePath,
     token,
     options,
+    currentDir,
+    deployHandler,
   })
   const { configMutations, exitCode, newConfig } = await runBuild(resolvedOptions)
   if (exitCode !== 0) {
@@ -529,67 +557,18 @@ const printResults = ({ deployToProduction, isIntegrationDeploy, json, results,
   }
 }
 
-/**
- * The deploy command
- * @param {import('commander').OptionValues} options
- * @param {import('../base-command.mjs').default} command
- */
-export const deploy = async (options, command) => {
-  const { workingDir } = command
-  const { api, site, siteInfo } = command.netlify
+const prepAndRunDeploy = async ({
+  api,
+  command,
+  config,
+  deployToProduction,
+  options,
+  site,
+  siteData,
+  siteId,
+  workingDir,
+}) => {
   const alias = options.alias || options.branch
-
-  command.setAnalyticsPayload({ open: options.open, prod: options.prod, json: options.json, alias: Boolean(alias) })
-
-  if (options.branch) {
-    warn('--branch flag has been renamed to --alias and will be removed in future versions')
-  }
-
-  if (options.context && !options.build) {
-    return error('--context flag is only available when using the --build flag')
-  }
-
-  await command.authenticate(options.auth)
-
-  let siteId = site.id || options.site
-
-  let siteData = {}
-  if (siteId && !isEmpty(siteInfo)) {
-    siteData = siteInfo
-    siteId = siteData.id
-  } else {
-    log("This folder isn't linked to a site yet")
-    const NEW_SITE = '+  Create & configure a new site'
-    const EXISTING_SITE = 'Link this directory to an existing site'
-
-    const initializeOpts = [EXISTING_SITE, NEW_SITE]
-
-    const { initChoice } = await inquirer.prompt([
-      {
-        type: 'list',
-        name: 'initChoice',
-        message: 'What would you like to do?',
-        choices: initializeOpts,
-      },
-    ])
-    // create site or search for one
-    if (initChoice === NEW_SITE) {
-      siteData = await sitesCreate({}, command)
-      site.id = siteData.id
-      siteId = site.id
-    } else if (initChoice === EXISTING_SITE) {
-      siteData = await link({}, command)
-      site.id = siteData.id
-      siteId = site.id
-    }
-  }
-
-  const deployToProduction = options.prod || (options.prodIfUnlocked && !siteData.published_deploy.locked)
-
-  if (options.trigger) {
-    return triggerDeploy({ api, options, siteData, siteId })
-  }
-
   const isUsingEnvelope = siteData && siteData.use_envelope
   // if a context is passed besides dev, we need to pull env vars from that specific context
   if (isUsingEnvelope && options.context && options.context !== 'dev') {
@@ -601,16 +580,10 @@ export const deploy = async (options, command) => {
     })
   }
 
-  const { configMutations = [], newConfig } = await handleBuild({
-    packagePath: command.workspacePackage,
-    cachedConfig: command.netlify.cachedConfig,
-    options,
-  })
-  const config = newConfig || command.netlify.config
-
   const deployFolder = await getDeployFolder({ command, options, config, site, siteData })
   const functionsFolder = getFunctionsFolder({ workingDir, options, config, site, siteData })
   const { configPath } = site
+
   const edgeFunctionsConfig = command.netlify.config.edge_functions
 
   // build flag wasn't used and edge functions exist
@@ -648,20 +621,11 @@ export const deploy = async (options, command) => {
     siteEnv,
   })
 
-  const redirectsPath = `${deployFolder}/_redirects`
-  // @ts-ignore
-  await updateConfig(configMutations, {
-    buildDir: deployFolder,
-    configPath,
-    redirectsPath,
-    context: command.netlify.cachedConfig.context,
-    branch: command.netlify.cachedConfig.branch,
-  })
   const results = await runDeploy({
     alias,
     api,
     command,
-    configPath,
+    config,
     deployFolder,
     deployTimeout: options.timeout * SEC_TO_MILLISEC || DEFAULT_DEPLOY_TIMEOUT,
     deployToProduction,
@@ -677,9 +641,107 @@ export const deploy = async (options, command) => {
     title: options.message,
   })
 
-  // @ts-ignore
-  await restoreConfig(configMutations, { buildDir: deployFolder, configPath, redirectsPath })
+  return results
+}
+
+/**
+ * The deploy command
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command.mjs').default} command
+ */
+export const deploy = async (options, command) => {
+  const { workingDir } = command
+  const { api, site, siteInfo } = command.netlify
+  const alias = options.alias || options.branch
+
+  command.setAnalyticsPayload({ open: options.open, prod: options.prod, json: options.json, alias: Boolean(alias) })
+
+  if (options.branch) {
+    warn('--branch flag has been renamed to --alias and will be removed in future versions')
+  }
+
+  if (options.context && !options.build) {
+    return error('--context flag is only available when using the --build flag')
+  }
 
+  await command.authenticate(options.auth)
+
+  let siteId = site.id || options.site
+
+  let siteData = {}
+  if (siteId && !isEmpty(siteInfo)) {
+    siteData = siteInfo
+    siteId = siteData.id
+  } else {
+    log("This folder isn't linked to a site yet")
+    const NEW_SITE = '+  Create & configure a new site'
+    const EXISTING_SITE = 'Link this directory to an existing site'
+
+    const initializeOpts = [EXISTING_SITE, NEW_SITE]
+
+    const { initChoice } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'initChoice',
+        message: 'What would you like to do?',
+        choices: initializeOpts,
+      },
+    ])
+    // create site or search for one
+    if (initChoice === NEW_SITE) {
+      siteData = await sitesCreate({}, command)
+      site.id = siteData.id
+      siteId = site.id
+    } else if (initChoice === EXISTING_SITE) {
+      siteData = await link({}, command)
+      site.id = siteData.id
+      siteId = site.id
+    }
+  }
+
+  if (options.trigger) {
+    return triggerDeploy({ api, options, siteData, siteId })
+  }
+
+  const deployToProduction = options.prod || (options.prodIfUnlocked && !siteData.published_deploy.locked)
+
+  let results = {}
+
+  if (options.build) {
+    await handleBuild({
+      packagePath: command.workspacePackage,
+      cachedConfig: command.netlify.cachedConfig,
+      currentDir: command.workingDir,
+      options,
+      deployHandler: async ({ netlifyConfig }) => {
+        results = await prepAndRunDeploy({
+          command,
+          options,
+          workingDir,
+          api,
+          site,
+          config: netlifyConfig,
+          siteData,
+          siteId,
+          deployToProduction,
+        })
+
+        return {}
+      },
+    })
+  } else {
+    results = await prepAndRunDeploy({
+      command,
+      options,
+      workingDir,
+      api,
+      site,
+      config: command.netlify.config,
+      siteData,
+      siteId,
+      deployToProduction,
+    })
+  }
   const isIntegrationDeploy = command.name() === 'integration:deploy'
 
   printResults({

package/src/commands/integration/deploy.mjs

@@ -374,6 +374,7 @@ const deploy = async (options, command) => {
   const buildOptions = await getBuildOptions({
     cachedConfig,
     packagePath: command.workspacePackage,
+    currentDir: command.workingDir,
     token,
     options,
   })

package/src/lib/build.mjs

@@ -1,7 +1,9 @@
 // @ts-check
+import fs from 'fs'
 import process from 'process'
 
 import build from '@netlify/build'
+import tomlify from 'tomlify-j0.4'
 
 import { isFeatureFlagEnabled } from '../utils/feature-flags.mjs'
 
@@ -22,36 +24,66 @@ import { featureFlags as edgeFunctionsFeatureFlags } from './edge-functions/cons
  * @param {object} config
  * @param {*} config.cachedConfig
  * @param {string} [config.packagePath]
+ * @param {string} config.currentDir
  * @param {string} config.token
  * @param {import('commander').OptionValues} config.options
+ * @param {*} config.deployHandler
  * @returns {BuildConfig}
  */
 export const getBuildOptions = ({
   cachedConfig,
+  currentDir,
+  deployHandler,
   options: { context, cwd, debug, dry, json, offline, silent },
   packagePath,
   token,
-}) => ({
-  cachedConfig,
-  siteId: cachedConfig.siteInfo.id,
-  packagePath,
-  token,
-  dry,
-  debug,
-  context,
-  mode: 'cli',
-  telemetry: false,
-  // buffer = true will not stream output
-  buffer: json || silent,
-  offline,
-  cwd,
-  featureFlags: {
-    ...edgeFunctionsFeatureFlags,
-    ...getFeatureFlagsFromSiteInfo(cachedConfig.siteInfo),
-    functionsBundlingManifest: true,
-  },
-  edgeFunctionsBootstrapURL: getBootstrapURL(),
-})
+}) => {
+  const eventHandlers = {
+    onEnd: {
+      handler: ({ netlifyConfig }) => {
+        const string = tomlify.toToml(netlifyConfig)
+
+        if (!fs.existsSync(`${currentDir}/.netlify`)) {
+          fs.mkdirSync(`${currentDir}/.netlify`, { recursive: true })
+        }
+        fs.writeFileSync(`${currentDir}/.netlify/netlify.toml`, string)
+
+        return {}
+      },
+      description: 'Save updated config',
+    },
+  }
+
+  if (deployHandler) {
+    eventHandlers.onPostBuild = {
+      handler: deployHandler,
+      description: 'Deploy Site',
+    }
+  }
+
+  return {
+    cachedConfig,
+    siteId: cachedConfig.siteInfo.id,
+    packagePath,
+    token,
+    dry,
+    debug,
+    context,
+    mode: 'cli',
+    telemetry: false,
+    // buffer = true will not stream output
+    buffer: json || silent,
+    offline,
+    cwd,
+    featureFlags: {
+      ...edgeFunctionsFeatureFlags,
+      ...getFeatureFlagsFromSiteInfo(cachedConfig.siteInfo),
+      functionsBundlingManifest: true,
+    },
+    eventHandlers,
+    edgeFunctionsBootstrapURL: getBootstrapURL(),
+  }
+}
 
 /**
  * @param {*} siteInfo

package/src/lib/functions/netlify-function.mjs

@@ -184,7 +184,7 @@ export default class NetlifyFunction {
   }
 
   // Invokes the function and returns its response object.
-  async invoke(event, context = {}) {
+  async invoke(event = {}, context = {}) {
     await this.buildQueue
 
     if (this.buildError) {
@@ -200,10 +200,7 @@ export default class NetlifyFunction {
         token: this.blobsContext.token,
       })
 
-      context.custom = {
-        ...context?.custom,
-        blobs: Buffer.from(payload).toString('base64'),
-      }
+      event.blobs = Buffer.from(payload).toString('base64')
     }
 
     try {

package/src/lib/functions/server.mjs

@@ -233,10 +233,6 @@ const getFunctionsServer = (options) => {
     }),
   )
 
-  app.get('/favicon.ico', function onRequest(_req, res) {
-    res.status(204).end()
-  })
-
   app.all(`${functionsPrefix}*`, functionHandler)
   app.all(`${buildersPrefix}*`, functionHandler)
 

package/src/utils/deploy/deploy-site.mjs

@@ -13,6 +13,7 @@ import {
   DEFAULT_MAX_RETRY,
   DEFAULT_SYNC_LIMIT,
 } from './constants.mjs'
+import { hashConfig } from './hash-config.mjs'
 import hashFiles from './hash-files.mjs'
 import hashFns from './hash-fns.mjs'
 import uploadFiles from './upload-files.mjs'
@@ -27,7 +28,7 @@ export const deploySite = async (
     branch,
     concurrentHash = DEFAULT_CONCURRENT_HASH,
     concurrentUpload = DEFAULT_CONCURRENT_UPLOAD,
-    configPath = null,
+    config,
     deployId,
     deployTimeout = DEFAULT_DEPLOY_TIMEOUT,
     draft = false,
@@ -55,31 +56,39 @@ export const deploySite = async (
   })
 
   const edgeFunctionsDistPath = await getDistPathIfExists(workingDir)
-  const [{ files, filesShaMap }, { fnConfig, fnShaMap, functionSchedules, functions, functionsWithNativeModules }] =
-    await Promise.all([
-      hashFiles({
-        assetType,
-        concurrentHash,
-        directories: [configPath, dir, edgeFunctionsDistPath].filter(Boolean),
-        filter,
-        hashAlgorithm,
-        normalizer: deployFileNormalizer.bind(null, workingDir),
-        statusCb,
-      }),
-      hashFns(fnDir, {
-        functionsConfig,
-        tmpDir,
-        concurrentHash,
-        hashAlgorithm,
-        statusCb,
-        assetType,
-        workingDir,
-        manifestPath,
-        skipFunctionsCache,
-        siteEnv,
-        rootDir: siteRoot,
-      }),
-    ])
+  const [
+    { files: staticFiles, filesShaMap: staticShaMap },
+    { fnConfig, fnShaMap, functionSchedules, functions, functionsWithNativeModules },
+    configFile,
+  ] = await Promise.all([
+    hashFiles({
+      assetType,
+      concurrentHash,
+      directories: [dir, edgeFunctionsDistPath].filter(Boolean),
+      filter,
+      hashAlgorithm,
+      normalizer: deployFileNormalizer.bind(null, workingDir),
+      statusCb,
+    }),
+    hashFns(fnDir, {
+      functionsConfig,
+      tmpDir,
+      concurrentHash,
+      hashAlgorithm,
+      statusCb,
+      assetType,
+      workingDir,
+      manifestPath,
+      skipFunctionsCache,
+      siteEnv,
+      rootDir: siteRoot,
+    }),
+    hashConfig({ config }),
+  ])
+
+  const files = { ...staticFiles, [configFile.normalizedPath]: configFile.hash }
+  const filesShaMap = { ...staticShaMap, [configFile.hash]: [configFile] }
+
   const edgeFunctionsCount = Object.keys(files).filter(isEdgeFunctionFile).length
   const filesCount = Object.keys(files).length - edgeFunctionsCount
   const functionsCount = Object.keys(functions).length

package/src/utils/deploy/hash-config.mjs

@@ -0,0 +1,26 @@
+import hasha from 'hasha'
+import tomlify from 'tomlify-j0.4'
+
+export const hashConfig = ({ config }) => {
+  if (!config) throw new Error('Missing config option')
+  const configString = serializeToml(config)
+
+  const hash = hasha(configString, { algorithm: 'sha1' })
+
+  return {
+    assetType: 'file',
+    body: configString,
+    hash,
+    normalizedPath: 'netlify.toml',
+  }
+}
+
+export const serializeToml = function (object) {
+  return tomlify.toToml(object, { space: 2, replace: replaceTomlValue })
+}
+
+// `tomlify-j0.4` serializes integers as floats, e.g. `200.0`.
+// This is a problem with `redirects[*].status`.
+const replaceTomlValue = function (key, value) {
+  return Number.isInteger(value) ? String(value) : false
+}

package/src/utils/deploy/upload-files.mjs

@@ -14,8 +14,9 @@ const uploadFiles = async (api, deployId, uploadList, { concurrentUpload, maxRet
   })
 
   const uploadFile = async (fileObj, index) => {
-    const { assetType, filepath, invocationMode, normalizedPath, runtime } = fileObj
-    const readStreamCtor = () => fs.createReadStream(filepath)
+    const { assetType, body, filepath, invocationMode, normalizedPath, runtime } = fileObj
+
+    const readStreamCtor = () => body ?? fs.createReadStream(filepath)
 
     statusCb({
       type: 'upload',