@netlify/config 19.0.0-rc → 19.0.0

package/src/env/main.js

@@ -1,198 +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 (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/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 })
-}

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/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,
-}