@netlify/config 18.2.4-rc → 18.2.4

package/lib/env/git.js

@@ -0,0 +1,23 @@
+import { execa } from 'execa'
+
+import { removeFalsy } from '../utils/remove_falsy.js'
+
+// Retrieve git-related information for use in environment variables.
+// git is optional and there might be not git repository.
+// We purposely keep this decoupled from the git utility.
+export const getGitEnv = async function (buildDir, branch) {
+  const [COMMIT_REF, CACHED_COMMIT_REF] = await Promise.all([
+    git(['rev-parse', 'HEAD'], buildDir),
+    git(['rev-parse', 'HEAD^'], buildDir),
+  ])
+  const gitEnv = { BRANCH: branch, HEAD: branch, COMMIT_REF, CACHED_COMMIT_REF, PULL_REQUEST: 'false' }
+  const gitEnvA = removeFalsy(gitEnv)
+  return gitEnvA
+}
+
+const git = async function (args, cwd) {
+  try {
+    const { stdout } = await execa('git', args, { cwd })
+    return stdout
+  } catch {}
+}

package/lib/env/main.js

@@ -0,0 +1,202 @@
+import omit from 'omit.js'
+
+import { removeFalsy } from '../utils/remove_falsy.js'
+
+import { getEnvelope } from './envelope.js'
+import { getGitEnv } from './git.js'
+
+// Retrieve this site's environment variable. Also take into account team-wide
+// environment variables and addons.
+// The buildbot already has the right environment variables. This is mostly
+// meant so that local builds can mimic production builds
+// TODO: add `netlify.toml` `build.environment`, after normalization
+// TODO: add `CONTEXT` and others
+export const getEnv = async function ({
+  api,
+  mode,
+  config,
+  siteInfo,
+  accounts,
+  addons,
+  buildDir,
+  branch,
+  deployId,
+  buildId,
+  context,
+}) {
+  if (mode === 'buildbot') {
+    return {}
+  }
+
+  const generalEnv = await getGeneralEnv({ siteInfo, buildDir, branch, deployId, buildId, context })
+  const [accountEnv, addonsEnv, uiEnv, configFileEnv] = await getUserEnv({ api, config, siteInfo, accounts, addons })
+
+  // Sources of environment variables, in descending order of precedence.
+  const sources = [
+    { key: 'configFile', values: configFileEnv },
+    { key: 'ui', values: uiEnv },
+    { key: 'addons', values: addonsEnv },
+    { key: 'account', values: accountEnv },
+    { key: 'general', values: generalEnv },
+  ]
+
+  // A hash mapping names of environment variables to objects containing the following properties:
+  // - sources: List of sources where the environment variable was found. The first element is the source that
+  //   actually provided the variable (i.e. the one with the highest precedence).
+  // - value: The value of the environment variable.
+  const env = new Map()
+
+  sources.forEach((source) => {
+    Object.keys(source.values).forEach((key) => {
+      if (env.has(key)) {
+        const { sources: envSources, value } = env.get(key)
+
+        env.set(key, {
+          sources: [...envSources, source.key],
+          value: convertToString(value),
+        })
+      } else {
+        env.set(key, {
+          sources: [source.key],
+          value: convertToString(source.values[key]),
+        })
+      }
+    })
+  })
+
+  return Object.fromEntries(env)
+}
+
+const convertToString = (value) => {
+  if (value === null || value === undefined) {
+    return value
+  }
+
+  if (typeof value === 'string') {
+    return value
+  }
+
+  return value.toString()
+}
+
+// Environment variables not set by users, but meant to mimic the production
+// environment.
+const getGeneralEnv = async function ({
+  siteInfo,
+  siteInfo: { id, name },
+  buildDir,
+  branch,
+  deployId,
+  buildId,
+  context,
+}) {
+  const gitEnv = await getGitEnv(buildDir, branch)
+  const deployUrls = getDeployUrls({ siteInfo, branch, deployId })
+  return removeFalsy({
+    SITE_ID: id,
+    SITE_NAME: name,
+    DEPLOY_ID: deployId,
+    BUILD_ID: buildId,
+    ...deployUrls,
+    CONTEXT: context,
+    NETLIFY_LOCAL: 'true',
+    ...gitEnv,
+    // Localization
+    LANG: 'en_US.UTF-8',
+    LANGUAGE: 'en_US:en',
+    LC_ALL: 'en_US.UTF-8',
+    // Disable telemetry of some tools
+    GATSBY_TELEMETRY_DISABLED: '1',
+    NEXT_TELEMETRY_DISABLED: '1',
+  })
+}
+
+const getDeployUrls = function ({
+  siteInfo: { name = DEFAULT_SITE_NAME, ssl_url: sslUrl, build_settings: { repo_url: REPOSITORY_URL } = {} },
+  branch,
+  deployId,
+}) {
+  return {
+    URL: sslUrl,
+    REPOSITORY_URL,
+    DEPLOY_PRIME_URL: `https://${branch}--${name}${NETLIFY_DEFAULT_DOMAIN}`,
+    DEPLOY_URL: `https://${deployId}--${name}${NETLIFY_DEFAULT_DOMAIN}`,
+  }
+}
+
+const NETLIFY_DEFAULT_DOMAIN = '.netlify.app'
+// `site.name` is `undefined` when there is no token or siteId
+const DEFAULT_SITE_NAME = 'site-name'
+
+// Environment variables specified by the user
+const getUserEnv = async function ({ api, config, siteInfo, accounts, addons }) {
+  const accountEnv = await getAccountEnv({ api, siteInfo, accounts })
+  const addonsEnv = getAddonsEnv(addons)
+  const uiEnv = getUiEnv({ siteInfo })
+  const configFileEnv = getConfigFileEnv({ config })
+  return [accountEnv, addonsEnv, uiEnv, configFileEnv].map(cleanUserEnv)
+}
+
+// Account-wide environment variables
+const getAccountEnv = async function ({ api, siteInfo, accounts }) {
+  if (siteInfo.use_envelope) {
+    const envelope = await getEnvelope({ api, accountId: siteInfo.account_slug })
+    return envelope
+  }
+  const { site_env: siteEnv = {} } = accounts.find(({ slug }) => slug === siteInfo.account_slug) || {}
+  return siteEnv
+}
+
+// Environment variables from addons
+const getAddonsEnv = function (addons) {
+  return Object.assign({}, ...addons.map(getAddonEnv))
+}
+
+const getAddonEnv = function ({ env }) {
+  return env
+}
+
+// Site-specific environment variables set in the UI
+const getUiEnv = function ({ siteInfo: { build_settings: { env = {} } = {} } }) {
+  return env
+}
+
+// Site-specific environment variables set in netlify.toml
+const getConfigFileEnv = function ({
+  config: {
+    build: { environment = {} },
+  },
+}) {
+  return environment
+}
+
+// Some environment variables cannot be overridden by configuration
+const cleanUserEnv = function (userEnv) {
+  return omit.default(userEnv, READONLY_ENV)
+}
+
+const READONLY_ENV = [
+  // Set in local builds
+  'BRANCH',
+  'CACHED_COMMIT_REF',
+  'COMMIT_REF',
+  'CONTEXT',
+  'HEAD',
+  'REPOSITORY_URL',
+  'URL',
+
+  // CI builds set NETLIFY=true while CLI and programmatic builds set
+  // NETLIFY_LOCAL=true
+  'NETLIFY',
+  'NETLIFY_LOCAL',
+
+  // Not set in local builds because there is no CI build/deploy, incoming hooks nor PR
+  'INCOMING_HOOK_BODY',
+  'INCOMING_HOOK_TITLE',
+  'INCOMING_HOOK_URL',
+  'NETLIFY_BUILD_BASE',
+  'NETLIFY_BUILD_LIFECYCLE_TRIAL',
+  'NETLIFY_IMAGES_CDN_DOMAIN',
+  'PULL_REQUEST',
+  'REVIEW_ID',
+]

package/lib/error.js

@@ -0,0 +1,36 @@
+// We distinguish between errors thrown intentionally and uncaught exceptions
+// (such as bugs) with a `customErrorInfo.type` property.
+export const throwUserError = function (messageOrError, error) {
+  const errorA = getError(messageOrError, error)
+  errorA[CUSTOM_ERROR_KEY] = { type: USER_ERROR_TYPE }
+  throw errorA
+}
+
+// Can pass either `message`, `error` or `message, error`
+const getError = function (messageOrError, error) {
+  if (messageOrError instanceof Error) {
+    return messageOrError
+  }
+
+  if (error === undefined) {
+    return new Error(messageOrError)
+  }
+
+  error.message = `${messageOrError}\n${error.message}`
+  return error
+}
+
+export const isUserError = function (error) {
+  return (
+    canHaveErrorInfo(error) && error[CUSTOM_ERROR_KEY] !== undefined && error[CUSTOM_ERROR_KEY].type === USER_ERROR_TYPE
+  )
+}
+
+// Exceptions that are not objects (including `Error` instances) cannot have an
+// `CUSTOM_ERROR_KEY` property
+const canHaveErrorInfo = function (error) {
+  return error != null
+}
+
+const CUSTOM_ERROR_KEY = 'customErrorInfo'
+const USER_ERROR_TYPE = 'resolveConfig'

package/lib/events.js

@@ -0,0 +1,22 @@
+// List of build plugins events
+export const EVENTS = [
+  // Before build command
+  'onPreBuild',
+  // After build command, before Functions bundling
+  'onBuild',
+  // After Functions bundling
+  'onPostBuild',
+  // After build success
+  'onSuccess',
+  // After build error
+  'onError',
+  // After build error or success
+  'onEnd',
+]
+
+export const DEV_EVENTS = [
+  // Before dev command
+  'onPreDev',
+  // The dev command
+  'onDev',
+]

package/lib/files.js

@@ -0,0 +1,107 @@
+import { resolve, relative, parse } from 'path'
+
+import { getProperty, setProperty, deleteProperty } from 'dot-prop'
+import { pathExists } from 'path-exists'
+
+import { throwUserError } from './error.js'
+import { mergeConfigs } from './merge.js'
+import { isTruthy } from './utils/remove_falsy.js'
+
+// Make configuration paths relative to `buildDir` and converts them to
+// absolute paths
+export const resolveConfigPaths = async function ({ config, repositoryRoot, buildDir, baseRelDir }) {
+  const baseRel = baseRelDir ? buildDir : repositoryRoot
+  const configA = resolvePaths(config, FILE_PATH_CONFIG_PROPS, baseRel, repositoryRoot)
+  const configB = await addDefaultPaths(configA, repositoryRoot, baseRel)
+  return configB
+}
+
+// All file paths in the configuration file are are relative to `buildDir`
+// (if `baseRelDir` is `true`).
+const FILE_PATH_CONFIG_PROPS = ['functionsDirectory', 'build.publish', 'build.edge_functions']
+
+const resolvePaths = function (config, propNames, baseRel, repositoryRoot) {
+  return propNames.reduce((configA, propName) => resolvePathProp(configA, propName, baseRel, repositoryRoot), config)
+}
+
+const resolvePathProp = function (config, propName, baseRel, repositoryRoot) {
+  const path = getProperty(config, propName)
+
+  if (!isTruthy(path)) {
+    deleteProperty(config, propName)
+    return config
+  }
+
+  return setProperty(config, propName, resolvePath(repositoryRoot, baseRel, path, propName))
+}
+
+export const resolvePath = function (repositoryRoot, baseRel, originalPath, propName) {
+  if (!isTruthy(originalPath)) {
+    return
+  }
+
+  const path = originalPath.replace(LEADING_SLASH_REGEXP, '')
+  const pathA = resolve(baseRel, path)
+  validateInsideRoot(originalPath, pathA, repositoryRoot, propName)
+  return pathA
+}
+
+// We allow paths in configuration file to start with /
+// In that case, those are actually relative paths not absolute.
+const LEADING_SLASH_REGEXP = /^\/+/
+
+// We ensure all file paths are within the repository root directory.
+// However we allow file paths to be outside of the build directory, since this
+// can be convenient in monorepo setups.
+const validateInsideRoot = function (originalPath, path, repositoryRoot, propName) {
+  if (relative(repositoryRoot, path).startsWith('..') || getWindowsDrive(repositoryRoot) !== getWindowsDrive(path)) {
+    throwUserError(
+      `Configuration property "${propName}" "${originalPath}" must be inside the repository root directory.`,
+    )
+  }
+}
+
+const getWindowsDrive = function (path) {
+  return parse(path).root
+}
+
+// Some configuration properties have default values that are only set if a
+// specific directory/file exists in the build directory
+const addDefaultPaths = async function (config, repositoryRoot, baseRel) {
+  const defaultPathsConfigs = await Promise.all(
+    DEFAULT_PATHS.map(({ defaultPath, getConfig, propName }) =>
+      addDefaultPath({ repositoryRoot, baseRel, defaultPath, getConfig, propName }),
+    ),
+  )
+  const defaultPathsConfigsA = defaultPathsConfigs.filter(Boolean)
+  return mergeConfigs([...defaultPathsConfigsA, config])
+}
+
+const DEFAULT_PATHS = [
+  // @todo Remove once we drop support for the legacy default functions directory.
+  {
+    getConfig: (directory) => ({ functionsDirectory: directory, functionsDirectoryOrigin: 'default-v1' }),
+    defaultPath: 'netlify-automatic-functions',
+    propName: 'functions.directory',
+  },
+  {
+    getConfig: (directory) => ({ functionsDirectory: directory, functionsDirectoryOrigin: 'default' }),
+    defaultPath: 'netlify/functions',
+    propName: 'functions.directory',
+  },
+  {
+    getConfig: (directory) => ({ build: { edge_functions: directory } }),
+    defaultPath: 'netlify/edge-functions',
+    propName: 'build.edge_functions',
+  },
+]
+
+const addDefaultPath = async function ({ repositoryRoot, baseRel, defaultPath, getConfig, propName }) {
+  const absolutePath = resolvePath(repositoryRoot, baseRel, defaultPath, propName)
+
+  if (!(await pathExists(absolutePath))) {
+    return
+  }
+
+  return getConfig(absolutePath)
+}

package/lib/functions_config.js

@@ -0,0 +1,83 @@
+import isPlainObj from 'is-plain-obj'
+
+import { isDefined } from './utils/remove_falsy.js'
+
+export const bundlers = ['esbuild', 'nft', 'zisi']
+export const WILDCARD_ALL = '*'
+
+// Removing the legacy `functions` from the `build` block.
+// Looking for a default directory in the `functions` block, separating it
+// from the rest of the configuration if it exists.
+export const normalizeFunctionsProps = function (
+  { functions: v1FunctionsDirectory, ...build },
+  { [WILDCARD_ALL]: wildcardProps, ...functions },
+) {
+  const functionsA = Object.entries(functions).reduce(normalizeFunctionsProp, { [WILDCARD_ALL]: wildcardProps })
+  const { directory: functionsDirectory, functions: functionsB } = extractFunctionsDirectory(functionsA)
+  const functionsDirectoryProps = getFunctionsDirectoryProps({ functionsDirectory, v1FunctionsDirectory })
+  return { build, functions: functionsB, functionsDirectoryProps }
+}
+
+// Normalizes a functions configuration object, so that the first level of keys
+// represents function expressions mapped to a configuration object.
+//
+// Example input:
+// {
+//   "external_node_modules": ["one"],
+//   "my-function": { "external_node_modules": ["two"] }
+// }
+//
+// Example output:
+// {
+//   "*": { "external_node_modules": ["one"] },
+//   "my-function": { "external_node_modules": ["two"] }
+// }
+// If `prop` is one of `configProperties``, we might be dealing with a
+// top-level property (i.e. one that targets all functions). We consider
+// that to be the case if the value is an object where all keys are also
+// config properties. If not, it's simply a function with the same name
+// as one of the config properties.
+const normalizeFunctionsProp = (functions, [propName, propValue]) =>
+  isConfigProperty(propName) && !isConfigLeaf(propValue)
+    ? { ...functions, [WILDCARD_ALL]: { [propName]: propValue, ...functions[WILDCARD_ALL] } }
+    : { ...functions, [propName]: propValue }
+
+const isConfigLeaf = (functionConfig) =>
+  isPlainObj(functionConfig) && Object.keys(functionConfig).every(isConfigProperty)
+
+const isConfigProperty = (propName) => FUNCTION_CONFIG_PROPERTIES.has(propName)
+
+export const FUNCTION_CONFIG_PROPERTIES = new Set([
+  'directory',
+  'external_node_modules',
+  'ignored_node_modules',
+  'included_files',
+  'node_bundler',
+  'schedule',
+])
+
+// Takes a functions configuration object and looks for the functions directory
+// definition, returning it under the `directory` key. The rest of the config
+// object is returned under the `functions` key.
+const extractFunctionsDirectory = ({ [WILDCARD_ALL]: { directory, ...wildcardFunctionsConfig }, ...functions }) => ({
+  directory,
+  functions: { ...functions, [WILDCARD_ALL]: wildcardFunctionsConfig },
+})
+
+const getFunctionsDirectoryProps = ({ functionsDirectory, v1FunctionsDirectory }) => {
+  if (isDefined(functionsDirectory)) {
+    return {
+      functionsDirectory,
+      functionsDirectoryOrigin: 'config',
+    }
+  }
+
+  if (isDefined(v1FunctionsDirectory)) {
+    return {
+      functionsDirectory: v1FunctionsDirectory,
+      functionsDirectoryOrigin: 'config-v1',
+    }
+  }
+
+  return {}
+}

package/lib/headers.js

@@ -0,0 +1,30 @@
+import { resolve } from 'path'
+
+import { parseAllHeaders } from 'netlify-headers-parser'
+
+import { warnHeadersParsing, warnHeadersCaseSensitivity } from './log/messages.js'
+
+// Retrieve path to `_headers` file (even if it does not exist yet)
+export const getHeadersPath = function ({ build: { publish } }) {
+  return resolve(publish, HEADERS_FILENAME)
+}
+
+const HEADERS_FILENAME = '_headers'
+
+// Add `config.headers`
+export const addHeaders = async function ({
+  config: { headers: configHeaders, ...config },
+  headersPath,
+  logs,
+  featureFlags,
+}) {
+  const { headers, errors } = await parseAllHeaders({
+    headersFiles: [headersPath],
+    configHeaders,
+    minimal: true,
+    featureFlags,
+  })
+  warnHeadersParsing(logs, errors)
+  warnHeadersCaseSensitivity(logs, headers)
+  return { ...config, headers }
+}

package/lib/inline_config.js

@@ -0,0 +1,9 @@
+import { logInlineConfig } from './log/main.js'
+import { applyMutations } from './mutations/apply.js'
+
+// Retrieve the `--inlineConfig` CLI flag
+export const getInlineConfig = function ({ inlineConfig, configMutations, logs, debug }) {
+  const mutatedInlineConfig = applyMutations(inlineConfig, configMutations)
+  logInlineConfig(mutatedInlineConfig, { logs, debug })
+  return mutatedInlineConfig
+}

package/lib/log/cleanup.js

@@ -0,0 +1,92 @@
+import filterObj from 'filter-obj'
+
+import { simplifyConfig } from '../simplify.js'
+
+// Make sure we are not printing secret values. Use an allow list.
+export const cleanupConfig = function ({
+  build: {
+    base,
+    command,
+    commandOrigin,
+    environment = {},
+    edge_functions: edgeFunctions,
+    ignore,
+    processing,
+    publish,
+    publishOrigin,
+  } = {},
+  headers,
+  headersOrigin,
+  plugins = [],
+  redirects,
+  redirectsOrigin,
+  baseRelDir,
+  functions,
+  functionsDirectory,
+}) {
+  const environmentA = cleanupEnvironment(environment)
+  const build = {
+    base,
+    command,
+    commandOrigin,
+    environment: environmentA,
+    edge_functions: edgeFunctions,
+    ignore,
+    processing,
+    publish,
+    publishOrigin,
+  }
+  const pluginsA = plugins.map(cleanupPlugin)
+  const netlifyConfig = simplifyConfig({
+    build,
+    plugins: pluginsA,
+    headers,
+    headersOrigin,
+    redirects,
+    redirectsOrigin,
+    baseRelDir,
+    functions,
+    functionsDirectory,
+  })
+  const netlifyConfigA = truncateArray(netlifyConfig, 'headers')
+  const netlifyConfigB = truncateArray(netlifyConfigA, 'redirects')
+  return netlifyConfigB
+}
+
+export const cleanupEnvironment = function (environment) {
+  return Object.keys(environment).filter((key) => !BUILDBOT_ENVIRONMENT.has(key))
+}
+
+// Added by the buildbot. We only want to print environment variables specified
+// by the user.
+const BUILDBOT_ENVIRONMENT = new Set([
+  'BRANCH',
+  'CONTEXT',
+  'DEPLOY_PRIME_URL',
+  'DEPLOY_URL',
+  'GO_VERSION',
+  'NETLIFY_IMAGES_CDN_DOMAIN',
+  'SITE_ID',
+  'SITE_NAME',
+  'URL',
+])
+
+const cleanupPlugin = function ({ package: packageName, origin, inputs = {} }) {
+  const inputsA = filterObj(inputs, isPublicInput)
+  return { package: packageName, origin, inputs: inputsA }
+}
+
+const isPublicInput = function (key, input) {
+  return typeof input === 'boolean'
+}
+
+// `headers` and `redirects` can be very long, which can take several minutes
+// to print in the build logs. We truncate them before logging.
+const truncateArray = function (netlifyConfig, propName) {
+  const array = netlifyConfig[propName]
+  return Array.isArray(array) && array.length > MAX_ARRAY_LENGTH
+    ? { ...netlifyConfig, [propName]: array.slice(0, MAX_ARRAY_LENGTH) }
+    : netlifyConfig
+}
+
+const MAX_ARRAY_LENGTH = 100

package/lib/log/logger.js

@@ -0,0 +1,47 @@
+import figures from 'figures'
+
+import { serializeObject } from './serialize.js'
+import { THEME } from './theme.js'
+
+// When the `buffer` option is true, we return logs instead of printing them
+// on the console. The logs are accumulated in a `logs` array variable.
+export const getBufferLogs = function ({ buffer }) {
+  if (!buffer) {
+    return
+  }
+
+  return { stdout: [], stderr: [] }
+}
+
+// This should be used instead of `console.log()`
+// Printed on stderr because stdout is reserved for the JSON output
+export const log = function (logs, string, { color } = {}) {
+  const stringA = String(string).replace(EMPTY_LINES_REGEXP, EMPTY_LINE)
+  const stringB = color === undefined ? stringA : color(stringA)
+
+  if (logs !== undefined) {
+    // `logs` is a stateful variable
+    // eslint-disable-next-line fp/no-mutating-methods
+    logs.stderr.push(stringB)
+    return
+  }
+
+  console.warn(stringB)
+}
+
+// We need to add a zero width space character in empty lines. Otherwise the
+// buildbot removes those due to a bug: https://github.com/netlify/buildbot/issues/595
+const EMPTY_LINES_REGEXP = /^\s*$/gm
+const EMPTY_LINE = '\u{200B}'
+
+export const logWarning = function (logs, string, opts) {
+  log(logs, string, { color: THEME.warningLine, ...opts })
+}
+
+export const logObject = function (logs, object, opts) {
+  log(logs, serializeObject(object), opts)
+}
+
+export const logSubHeader = function (logs, string, opts) {
+  log(logs, `\n${figures.pointer} ${string}`, { color: THEME.subHeader, ...opts })
+}