@netlify/config 18.2.2 → 18.2.4-rc

package/src/log/main.js

@@ -1,48 +0,0 @@
-import { cleanupConfig, cleanupEnvironment } from './cleanup.js'
-import { logObject, logSubHeader } from './logger.js'
-import { cleanupConfigOpts } from './options.js'
-
-// Log options in debug mode.
-export const logOpts = function (opts, { logs, debug, cachedConfig, cachedConfigPath }) {
-  // In production, print those in the first call to `@netlify/config`, not the
-  // second one done inside `@netlify/build`
-  if (!debug || cachedConfig !== undefined || cachedConfigPath !== undefined) {
-    return
-  }
-
-  logSubHeader(logs, 'Initial build environment')
-  logObject(logs, cleanupConfigOpts(opts))
-}
-
-// Log `defaultConfig` option in debug mode
-export const logDefaultConfig = function (defaultConfig, { logs, debug, baseRelDir }) {
-  if (!debug || defaultConfig === undefined) {
-    return
-  }
-
-  logSubHeader(logs, 'UI build settings')
-  logObject(logs, cleanupConfig({ ...defaultConfig, baseRelDir }))
-}
-
-// Log `inlineConfig` option in debug mode
-export const logInlineConfig = function (initialConfig, { logs, debug }) {
-  if (!debug || Object.keys(initialConfig).length === 0) {
-    return
-  }
-
-  logSubHeader(logs, 'Configuration override')
-  logObject(logs, cleanupConfig(initialConfig))
-}
-
-// Log return value of `@netlify/config` in debug mode
-export const logResult = function ({ configPath, buildDir, config, context, branch, env }, { logs, debug }) {
-  if (!debug) {
-    return
-  }
-
-  logSubHeader(logs, 'Resolved build environment')
-  logObject(logs, { configPath, buildDir, context, branch, env: cleanupEnvironment(env) })
-
-  logSubHeader(logs, 'Resolved config')
-  logObject(logs, cleanupConfig(config))
-}

package/src/log/messages.js

@@ -1,126 +0,0 @@
-import { throwUserError } from '../error.js'
-
-import { logWarning } from './logger.js'
-
-export const ERROR_CALL_TO_ACTION = `Double-check your login status with 'netlify status' or contact support with details of your error.`
-
-export const throwOnInvalidTomlSequence = function (invalidSequence) {
-  throwUserError(
-    `In netlify.toml, the following backslash should be escaped: ${invalidSequence}
-The following should be used instead: \\${invalidSequence}`,
-  )
-}
-
-export const warnLegacyFunctionsDirectory = ({ config = {}, logs }) => {
-  const { functionsDirectory, functionsDirectoryOrigin } = config
-
-  if (functionsDirectoryOrigin !== 'config-v1') {
-    return
-  }
-
-  logWarning(
-    logs,
-    `
-Detected functions directory configuration in netlify.toml under [build] settings.
-We recommend updating netlify.toml to set the functions directory under [functions] settings using the directory property. For example,
-
-[functions]
-  directory = "${functionsDirectory}"`,
-  )
-}
-
-export const warnContextPluginConfig = function (logs, packageName, context) {
-  logWarning(
-    logs,
-    `
-"${packageName}" is installed in the UI, which means that it runs in all deploy contexts, regardless of file-based configuration.
-To run "${packageName}" in the ${context} context only, uninstall the plugin from the site plugins list.`,
-  )
-}
-
-export const throwContextPluginsConfig = function (packageName, context) {
-  throwUserError(
-    `
-"${packageName}" is installed in the UI, which means that it runs in all deploy contexts, regardless of file-based configuration.
-To run "${packageName}" in the ${context} context only, uninstall the plugin from the site plugins list.
-To run "${packageName}" in all contexts, please remove the following section from "netlify.toml".
-
-  [[context.${context}.plugins]]
-  package = "${packageName}"
-`,
-  )
-}
-
-export const warnHeadersParsing = function (logs, errors) {
-  if (errors.length === 0) {
-    return
-  }
-
-  const errorMessage = errors.map(getErrorMessage).join('\n\n')
-  logWarning(
-    logs,
-    `
-Warning: some headers have syntax errors:
-
-${errorMessage}`,
-  )
-}
-
-// Headers with different cases are not currently the way users probably
-// intend them to be, so we print a warning message.
-// See issue at https://github.com/netlify/build/issues/2290
-export const warnHeadersCaseSensitivity = function (logs, headers) {
-  const headersA = headers.flatMap(getHeaderNames).filter(isNotDuplicateHeaderName).map(addHeaderLowerCase)
-  const differentCaseHeader = headersA.find(hasHeaderCaseDuplicate)
-  if (differentCaseHeader === undefined) {
-    return
-  }
-
-  const { forPath, headerName } = headersA.find((header) => isHeaderCaseDuplicate(header, differentCaseHeader))
-  const sameForPath = forPath === differentCaseHeader.forPath ? ` for "${forPath}"` : ''
-  logWarning(
-    logs,
-    `
-Warning: the same header is set twice with different cases${sameForPath}: "${headerName}" and "${differentCaseHeader.headerName}"`,
-  )
-}
-
-const getHeaderNames = function ({ for: forPath, values = {} }) {
-  return Object.keys(values).map((headerName) => ({ forPath, headerName }))
-}
-
-const isNotDuplicateHeaderName = function ({ headerName }, index, headers) {
-  return headers.slice(index + 1).every((header) => header.headerName !== headerName)
-}
-
-const addHeaderLowerCase = function ({ forPath, headerName }) {
-  const lowerHeaderName = headerName.toLowerCase()
-  return { forPath, headerName, lowerHeaderName }
-}
-
-const hasHeaderCaseDuplicate = function ({ lowerHeaderName }, index, headers) {
-  return headers.slice(index + 1).some((header) => header.lowerHeaderName === lowerHeaderName)
-}
-
-const isHeaderCaseDuplicate = function ({ headerName, lowerHeaderName }, differentCaseHeader) {
-  return differentCaseHeader.headerName !== headerName && differentCaseHeader.lowerHeaderName === lowerHeaderName
-}
-
-export const warnRedirectsParsing = function (logs, errors) {
-  if (errors.length === 0) {
-    return
-  }
-
-  const errorMessage = errors.map(getErrorMessage).join('\n\n')
-  logWarning(
-    logs,
-    `
-Warning: some redirects have syntax errors:
-
-${errorMessage}`,
-  )
-}
-
-const getErrorMessage = function ({ message }) {
-  return message
-}

package/src/log/options.js

@@ -1,43 +0,0 @@
-import { DEFAULT_FEATURE_FLAGS } from '../options/feature_flags.js'
-import { removeEmptyArray } from '../simplify.js'
-import { removeFalsy } from '../utils/remove_falsy.js'
-
-// Use an allowlist to prevent printing confidential values.
-export const cleanupConfigOpts = function ({
-  config,
-  cwd,
-  context,
-  branch,
-  mode,
-  repositoryRoot,
-  siteId,
-  baseRelDir,
-  env = {},
-  featureFlags = {},
-}) {
-  const envA = Object.keys(env)
-  return removeFalsy({
-    config,
-    cwd,
-    context,
-    branch,
-    mode,
-    repositoryRoot,
-    siteId,
-    baseRelDir,
-    ...removeEmptyArray(envA, 'env'),
-    featureFlags: cleanFeatureFlags(featureFlags),
-  })
-}
-
-// We only show feature flags related to `@netlify/config`.
-// Also, we only print enabled feature flags.
-const cleanFeatureFlags = function (featureFlags) {
-  return Object.entries(featureFlags)
-    .filter(shouldPrintFeatureFlag)
-    .map(([featureFlagName]) => featureFlagName)
-}
-
-const shouldPrintFeatureFlag = function ([featureFlagName, enabled]) {
-  return enabled && featureFlagName in DEFAULT_FEATURE_FLAGS
-}

package/src/log/serialize.js

@@ -1,5 +0,0 @@
-import { dump } from 'js-yaml'
-
-export const serializeObject = function (object) {
-  return dump(object, { noRefs: true, sortKeys: true, lineWidth: Number.POSITIVE_INFINITY }).trimEnd()
-}

package/src/log/theme.js

@@ -1,14 +0,0 @@
-import chalk from 'chalk'
-
-// Color theme. Please use this instead of requiring chalk directly, to ensure
-// consistent colors.
-export const THEME = {
-  // Single lines used as subheaders
-  subHeader: chalk.cyan.bold,
-  // Single lines used as subheaders indicating an error
-  errorSubHeader: chalk.red.bold,
-  // Same for warnings
-  warningLine: chalk.yellowBright,
-  // One of several words that should be highlighted inside a line
-  highlightWords: chalk.cyan,
-}

package/src/main.js

@@ -1,285 +0,0 @@
-import { getApiClient } from './api/client.js'
-import { getSiteInfo } from './api/site_info.js'
-import { getInitialBase, getBase, addBase } from './base.js'
-import { getBuildDir } from './build_dir.js'
-import { getCachedConfig } from './cached_config.js'
-import { normalizeContextProps, mergeContext } from './context.js'
-import { parseDefaultConfig } from './default.js'
-import { getEnv } from './env/main.js'
-import { resolveConfigPaths } from './files.js'
-import { getHeadersPath, addHeaders } from './headers.js'
-import { getInlineConfig } from './inline_config.js'
-import { logResult } from './log/main.js'
-import { mergeConfigs } from './merge.js'
-import { normalizeBeforeConfigMerge, normalizeAfterConfigMerge } from './merge_normalize.js'
-import { addDefaultOpts, normalizeOpts } from './options/main.js'
-import { UI_ORIGIN, CONFIG_ORIGIN, INLINE_ORIGIN } from './origin.js'
-import { parseConfig } from './parse.js'
-import { getConfigPath } from './path.js'
-import { getRedirectsPath, addRedirects } from './redirects.js'
-
-export { DEV_EVENTS, EVENTS } from './events.js'
-export { cleanupConfig } from './log/cleanup.js'
-// eslint-disable-next-line import/max-dependencies
-export { updateConfig, restoreConfig } from './mutations/update.js'
-
-// Load the configuration file.
-// Takes an optional configuration file path as input and return the resolved
-// `config` together with related properties such as the `configPath`.
-export const resolveConfig = async function (opts) {
-  const { cachedConfig, cachedConfigPath, host, scheme, pathPrefix, testOpts, token, offline, ...optsA } =
-    addDefaultOpts(opts)
-  // `api` is not JSON-serializable, so we cannot cache it inside `cachedConfig`
-  const api = getApiClient({ token, offline, host, scheme, pathPrefix, testOpts })
-
-  const parsedCachedConfig = await getCachedConfig({ cachedConfig, cachedConfigPath, token, api })
-  if (parsedCachedConfig !== undefined) {
-    return parsedCachedConfig
-  }
-
-  const {
-    config: configOpt,
-    defaultConfig,
-    inlineConfig,
-    configMutations,
-    cwd,
-    context,
-    repositoryRoot,
-    base,
-    branch,
-    siteId,
-    deployId,
-    buildId,
-    baseRelDir,
-    mode,
-    debug,
-    logs,
-    featureFlags,
-  } = await normalizeOpts(optsA)
-
-  const { siteInfo, accounts, addons } = await getSiteInfo({ api, siteId, mode, testOpts })
-
-  const { defaultConfig: defaultConfigA, baseRelDir: baseRelDirA } = parseDefaultConfig({
-    defaultConfig,
-    base,
-    baseRelDir,
-    siteInfo,
-    logs,
-    debug,
-  })
-  const inlineConfigA = getInlineConfig({ inlineConfig, configMutations, logs, debug })
-
-  const { configPath, config, buildDir, redirectsPath, headersPath } = await loadConfig({
-    configOpt,
-    cwd,
-    context,
-    repositoryRoot,
-    branch,
-    defaultConfig: defaultConfigA,
-    inlineConfig: inlineConfigA,
-    baseRelDir: baseRelDirA,
-    logs,
-    featureFlags,
-  })
-
-  const env = await getEnv({
-    api,
-    mode,
-    config,
-    siteInfo,
-    accounts,
-    addons,
-    buildDir,
-    branch,
-    deployId,
-    buildId,
-    context,
-  })
-
-  // @todo Remove in the next major version.
-  const configA = addLegacyFunctionsDirectory(config)
-
-  const result = {
-    siteInfo,
-    accounts,
-    addons,
-    env,
-    configPath,
-    redirectsPath,
-    headersPath,
-    buildDir,
-    repositoryRoot,
-    config: configA,
-    context,
-    branch,
-    token,
-    api,
-    logs,
-  }
-  logResult(result, { logs, debug })
-  return result
-}
-
-// Adds a `build.functions` property that mirrors `functionsDirectory`, for
-// backward compatibility.
-const addLegacyFunctionsDirectory = (config) => {
-  if (!config.functionsDirectory) {
-    return config
-  }
-
-  return {
-    ...config,
-    build: {
-      ...config.build,
-      functions: config.functionsDirectory,
-    },
-  }
-}
-
-// Try to load the configuration file in two passes.
-// The first pass uses the `defaultConfig`'s `build.base` (if defined).
-// The second pass uses the `build.base` from the first pass (if defined).
-const loadConfig = async function ({
-  configOpt,
-  cwd,
-  context,
-  repositoryRoot,
-  branch,
-  defaultConfig,
-  inlineConfig,
-  baseRelDir,
-  logs,
-  featureFlags,
-}) {
-  const initialBase = getInitialBase({ repositoryRoot, defaultConfig, inlineConfig })
-  const { configPath, config, buildDir, base, redirectsPath, headersPath } = await getFullConfig({
-    configOpt,
-    cwd,
-    context,
-    repositoryRoot,
-    branch,
-    defaultConfig,
-    inlineConfig,
-    baseRelDir,
-    configBase: initialBase,
-    logs,
-    featureFlags,
-  })
-
-  // No second pass needed if:
-  //  - there is no `build.base` (in which case both `base` and `initialBase`
-  //    are `undefined`)
-  //  - `build.base` is the same as the `Base directory` UI setting (already
-  //    used in the first round)
-  //  - `baseRelDir` feature flag is not used. This feature flag was introduced
-  //    to ensure backward compatibility.
-  if (!baseRelDir || base === initialBase) {
-    return { configPath, config, buildDir, redirectsPath, headersPath }
-  }
-
-  const {
-    configPath: configPathA,
-    config: configA,
-    buildDir: buildDirA,
-    redirectsPath: redirectsPathA,
-    headersPath: headersPathA,
-  } = await getFullConfig({
-    cwd,
-    context,
-    repositoryRoot,
-    branch,
-    defaultConfig,
-    inlineConfig,
-    baseRelDir,
-    configBase: base,
-    base,
-    logs,
-    featureFlags,
-  })
-  return {
-    configPath: configPathA,
-    config: configA,
-    buildDir: buildDirA,
-    redirectsPath: redirectsPathA,
-    headersPath: headersPathA,
-  }
-}
-
-// Load configuration file and normalize it, merge contexts, etc.
-const getFullConfig = async function ({
-  configOpt,
-  cwd,
-  context,
-  repositoryRoot,
-  branch,
-  defaultConfig,
-  inlineConfig,
-  baseRelDir,
-  configBase,
-  base,
-  logs,
-  featureFlags,
-}) {
-  const configPath = await getConfigPath({ configOpt, cwd, repositoryRoot, configBase })
-
-  try {
-    const config = await parseConfig(configPath)
-    const configA = mergeAndNormalizeConfig({
-      config,
-      defaultConfig,
-      inlineConfig,
-      context,
-      branch,
-      logs,
-    })
-    const {
-      config: configB,
-      buildDir,
-      base: baseA,
-    } = await resolveFiles({ config: configA, repositoryRoot, base, baseRelDir })
-    const headersPath = getHeadersPath(configB)
-    const configC = await addHeaders({ config: configB, headersPath, logs, featureFlags })
-    const redirectsPath = getRedirectsPath(configC)
-    const configD = await addRedirects({ config: configC, redirectsPath, logs, featureFlags })
-    return { configPath, config: configD, buildDir, base: baseA, redirectsPath, headersPath }
-  } catch (error) {
-    const configName = configPath === undefined ? '' : ` file ${configPath}`
-    error.message = `When resolving config${configName}:\n${error.message}`
-    throw error
-  }
-}
-
-// Merge:
-//  - `--defaultConfig`: UI build settings and UI-installed plugins
-//  - `inlineConfig`: Netlify CLI flags
-// Then merge context-specific configuration.
-// Before and after those steps, also performs validation and normalization.
-// Those need to be done at different stages depending on whether they should
-// happen before/after the merges mentioned above.
-const mergeAndNormalizeConfig = function ({ config, defaultConfig, inlineConfig, context, branch, logs }) {
-  const configA = normalizeConfigAndContext(config, CONFIG_ORIGIN)
-  const defaultConfigA = normalizeConfigAndContext(defaultConfig, UI_ORIGIN)
-  const inlineConfigA = normalizeConfigAndContext(inlineConfig, INLINE_ORIGIN)
-
-  const configB = mergeConfigs([defaultConfigA, configA])
-  const configC = mergeContext({ config: configB, context, branch, logs })
-  const configD = mergeConfigs([configC, inlineConfigA])
-
-  const configE = normalizeAfterConfigMerge(configD)
-  return configE
-}
-
-const normalizeConfigAndContext = function (config, origin) {
-  const configA = normalizeBeforeConfigMerge(config, origin)
-  const configB = normalizeContextProps({ config: configA, origin })
-  return configB
-}
-
-// Find base directory, build directory and resolve all paths to absolute paths
-const resolveFiles = async function ({ config, repositoryRoot, base, baseRelDir }) {
-  const baseA = getBase(base, repositoryRoot, config)
-  const buildDir = await getBuildDir(repositoryRoot, baseA)
-  const configA = await resolveConfigPaths({ config, repositoryRoot, buildDir, baseRelDir })
-  const configB = addBase(configA, baseA)
-  return { config: configB, buildDir, base: baseA }
-}

package/src/merge.js

@@ -1,53 +0,0 @@
-import deepmerge from 'deepmerge'
-import isPlainObj from 'is-plain-obj'
-
-import { groupBy } from './utils/group.js'
-import { removeUndefined } from './utils/remove_falsy.js'
-
-// Merge an array of configuration objects.
-// Last items have higher priority.
-// Configuration objects are deeply merged.
-//   - Arrays are overridden, not concatenated.
-export const mergeConfigs = function (configs) {
-  const cleanedConfigs = configs.map(removeUndefinedProps)
-  return deepmerge.all(cleanedConfigs, { arrayMerge })
-}
-
-const removeUndefinedProps = function ({ build = {}, ...config }) {
-  return removeUndefined({ ...config, build: removeUndefined(build) })
-}
-
-// By default `deepmerge` concatenates arrays. We use the `arrayMerge` option
-// to remove this behavior. Also, we merge some array properties differently,
-// such as `plugins`.
-const arrayMerge = function (arrayA, arrayB) {
-  if (isPluginsProperty(arrayA) && isPluginsProperty(arrayB)) {
-    return mergePlugins(arrayA, arrayB)
-  }
-
-  return arrayB
-}
-
-// `deepmerge` does not allow retrieving the name of the array property being
-// merged, so we need to do some heuristics.
-const isPluginsProperty = function (array) {
-  return Array.isArray(array) && array.every(isPluginObject)
-}
-
-const isPluginObject = function (object) {
-  return isPlainObj(object) && typeof object.package === 'string'
-}
-
-// Merge two `config.plugins`. Merge plugins with the same `plugin.package`.
-const mergePlugins = function (pluginsA, pluginsB) {
-  const plugins = [...pluginsA, ...pluginsB]
-  return groupBy(plugins, 'package').map(mergePluginConfigs)
-}
-
-const mergePluginConfigs = function (plugins) {
-  return plugins.reduce(mergePluginsPair, {})
-}
-
-const mergePluginsPair = function (pluginA, pluginB) {
-  return deepmerge(pluginA, pluginB, { arrayMerge })
-}

package/src/merge_normalize.js

@@ -1,31 +0,0 @@
-import { normalizeConfigCase } from './case.js'
-import { normalizeConfig } from './normalize.js'
-import { addOrigins } from './origin.js'
-import { validateIdenticalPlugins } from './validate/identical.js'
-import {
-  validatePreCaseNormalize,
-  validatePreMergeConfig,
-  validatePreNormalizeConfig,
-  validatePostNormalizeConfig,
-} from './validate/main.js'
-
-// Perform validation and normalization logic to apply to all of:
-//  - config, defaultConfig, inlineConfig
-//  - context-specific configs
-// Therefore, this is performing before merging those together.
-export const normalizeBeforeConfigMerge = function (config, origin) {
-  validatePreCaseNormalize(config)
-  const configA = normalizeConfigCase(config)
-  validatePreMergeConfig(configA)
-  const configB = addOrigins(configA, origin)
-  validateIdenticalPlugins(configB)
-  return configB
-}
-
-// Validation and normalization logic performed after merging
-export const normalizeAfterConfigMerge = function (config) {
-  validatePreNormalizeConfig(config)
-  const configA = normalizeConfig(config)
-  validatePostNormalizeConfig(configA)
-  return configA
-}

package/src/mutations/apply.js

@@ -1,78 +0,0 @@
-import { throwUserError } from '../error.js'
-import { EVENTS } from '../events.js'
-import { WILDCARD_ALL, FUNCTION_CONFIG_PROPERTIES } from '../functions_config.js'
-import { setProp } from '../utils/set.js'
-
-import { getPropName } from './config_prop_name.js'
-
-// Apply a series of mutations to `inlineConfig`.
-// Meant to be used to apply configuration changes at build time.
-// Those are applied on the `inlineConfig` object after `@netlify/config`
-// normalization. Therefore, this function also denormalizes (reverts that
-// normalization) so that the final `config` object can be serialized back to
-// a `netlify.toml`.
-export const applyMutations = function (inlineConfig, configMutations) {
-  return configMutations.reduce(applyMutation, inlineConfig)
-}
-
-const applyMutation = function (inlineConfig, { keys, value, event }) {
-  const propName = getPropName(keys)
-  if (!(propName in MUTABLE_PROPS)) {
-    throwUserError(`"netlifyConfig.${propName}" is read-only.`)
-  }
-
-  const { lastEvent, denormalize } = MUTABLE_PROPS[propName]
-  validateEvent(lastEvent, event, propName)
-
-  return denormalize === undefined ? setProp(inlineConfig, keys, value) : denormalize(inlineConfig, value, keys)
-}
-
-const validateEvent = function (lastEvent, event, propName) {
-  if (EVENTS.indexOf(lastEvent) < EVENTS.indexOf(event)) {
-    throwUserError(`"netlifyConfig.${propName}" cannot be modified after "${lastEvent}".`)
-  }
-}
-
-// `functions['*'].*` has higher priority than `functions.*` so we convert the
-// latter to the former.
-const denormalizeFunctionsTopProps = function (
-  { functions, functions: { [WILDCARD_ALL]: wildcardProps } = {}, ...inlineConfig },
-  value,
-  [, key],
-) {
-  return FUNCTION_CONFIG_PROPERTIES.has(key)
-    ? {
-        ...inlineConfig,
-        functions: { ...functions, [WILDCARD_ALL]: { ...wildcardProps, [key]: value } },
-      }
-    : { ...inlineConfig, functions: { ...functions, [key]: value } }
-}
-
-// List of properties that are not read-only.
-const MUTABLE_PROPS = {
-  'build.command': { lastEvent: 'onPreBuild' },
-  'build.edge_functions': { lastEvent: 'onPostBuild' },
-  'build.environment': { lastEvent: 'onPostBuild' },
-  'build.environment.*': { lastEvent: 'onPostBuild' },
-  'build.functions': { lastEvent: 'onBuild' },
-  'build.processing': { lastEvent: 'onPostBuild' },
-  'build.processing.css': { lastEvent: 'onPostBuild' },
-  'build.processing.css.bundle': { lastEvent: 'onPostBuild' },
-  'build.processing.css.minify': { lastEvent: 'onPostBuild' },
-  'build.processing.html': { lastEvent: 'onPostBuild' },
-  'build.processing.html.pretty_urls': { lastEvent: 'onPostBuild' },
-  'build.processing.images': { lastEvent: 'onPostBuild' },
-  'build.processing.images.compress': { lastEvent: 'onPostBuild' },
-  'build.processing.js': { lastEvent: 'onPostBuild' },
-  'build.processing.js.bundle': { lastEvent: 'onPostBuild' },
-  'build.processing.js.minify': { lastEvent: 'onPostBuild' },
-  'build.processing.skip_processing': { lastEvent: 'onPostBuild' },
-  'build.publish': { lastEvent: 'onPostBuild' },
-  'build.services': { lastEvent: 'onPostBuild' },
-  'build.services.*': { lastEvent: 'onPostBuild' },
-  edge_functions: { lastEvent: 'onPostBuild' },
-  'functions.*': { lastEvent: 'onBuild', denormalize: denormalizeFunctionsTopProps },
-  'functions.*.*': { lastEvent: 'onBuild' },
-  headers: { lastEvent: 'onPostBuild' },
-  redirects: { lastEvent: 'onPostBuild' },
-}