@netlify/config 18.2.3 → 18.2.5-rc

package/src/env/envelope.js

@@ -1,24 +0,0 @@
-export const getEnvelope = async function ({ api, accountId, siteId }) {
-  if (accountId === undefined) {
-    return {}
-  }
-  try {
-    const environmentVariables = await api.getEnvVars({ accountId, siteId })
-    // eslint-disable-next-line fp/no-mutating-methods
-    const sortedEnvVarsFromDevContext = environmentVariables
-      .sort((left, right) => (left.key.toLowerCase() < right.key.toLowerCase() ? -1 : 1))
-      .reduce((acc, cur) => {
-        const envVar = cur.values.find((val) => ['dev', 'all'].includes(val.context))
-        if (envVar && envVar.value) {
-          return {
-            ...acc,
-            [cur.key]: envVar.value,
-          }
-        }
-        return acc
-      }, {})
-    return sortedEnvVarsFromDevContext
-  } catch {
-    return {}
-  }
-}

package/src/env/git.js

@@ -1,23 +0,0 @@
-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/src/env/main.js

@@ -1,202 +0,0 @@
-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/src/error.js

@@ -1,36 +0,0 @@
-// 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/src/events.js

@@ -1,22 +0,0 @@
-// 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/src/files.js

@@ -1,107 +0,0 @@
-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/src/functions_config.js

@@ -1,83 +0,0 @@
-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/src/headers.js

@@ -1,30 +0,0 @@
-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/src/inline_config.js

@@ -1,9 +0,0 @@
-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/src/log/cleanup.js

@@ -1,92 +0,0 @@
-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/src/log/logger.js

@@ -1,47 +0,0 @@
-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 })
-}