@netlify/config 18.2.2 → 18.2.4-rc

package/src/mutations/config_prop_name.js

@@ -1,16 +0,0 @@
-// Retrieve normalized property name
-export const getPropName = function (keys) {
-  return keys.reduce(normalizeDynamicProp, '')
-}
-
-// Some properties are user-defined, i.e. we need to replace them with a "*" token
-// Check if a property name is dynamic, such as `functions.{functionName}`, or
-// is an array index.
-// In those cases, we replace it by "*".
-const normalizeDynamicProp = function (propName, key) {
-  const normalizedKey = Number.isInteger(key) || DYNAMIC_OBJECT_PROPS.has(propName) ? '*' : String(key)
-  return propName === '' ? normalizedKey : `${propName}.${normalizedKey}`
-}
-
-// Properties with dynamic children
-const DYNAMIC_OBJECT_PROPS = new Set(['build.services', 'build.environment', 'functions', 'functions.*'])

package/src/mutations/update.js

@@ -1,117 +0,0 @@
-import { promises as fs } from 'fs'
-
-import { pathExists } from 'path-exists'
-
-import { ensureConfigPriority } from '../context.js'
-import { addHeaders } from '../headers.js'
-import { mergeConfigs } from '../merge.js'
-import { parseOptionalConfig } from '../parse.js'
-import { addRedirects } from '../redirects.js'
-import { simplifyConfig } from '../simplify.js'
-import { serializeToml } from '../utils/toml.js'
-
-import { applyMutations } from './apply.js'
-
-// Persist configuration changes to `netlify.toml`.
-// If `netlify.toml` does not exist, creates it. Otherwise, merges the changes.
-export const updateConfig = async function (
-  configMutations,
-  { buildDir, configPath, headersPath, redirectsPath, context, branch, logs, featureFlags },
-) {
-  if (configMutations.length === 0) {
-    return
-  }
-
-  const inlineConfig = applyMutations({}, configMutations)
-  const normalizedInlineConfig = ensureConfigPriority(inlineConfig, context, branch)
-  const updatedConfig = await mergeWithConfig(normalizedInlineConfig, configPath)
-  const configWithHeaders = await addHeaders({ config: updatedConfig, headersPath, logs, featureFlags })
-  const finalConfig = await addRedirects({ config: configWithHeaders, redirectsPath, logs, featureFlags })
-  const simplifiedConfig = simplifyConfig(finalConfig)
-  await backupConfig({ buildDir, configPath, headersPath, redirectsPath })
-  await Promise.all([
-    saveConfig(configPath, simplifiedConfig),
-    deleteSideFile(headersPath),
-    deleteSideFile(redirectsPath),
-  ])
-}
-
-// If `netlify.toml` exists, deeply merges the configuration changes.
-const mergeWithConfig = async function (normalizedInlineConfig, configPath) {
-  const config = await parseOptionalConfig(configPath)
-  const updatedConfig = mergeConfigs([config, normalizedInlineConfig])
-  return updatedConfig
-}
-
-// Serialize the changes to `netlify.toml`
-const saveConfig = async function (configPath, simplifiedConfig) {
-  const serializedConfig = serializeToml(simplifiedConfig)
-  await fs.writeFile(configPath, serializedConfig)
-}
-
-// Deletes `_headers/_redirects` since they are merged to `netlify.toml`,
-// to fix any priority problem.
-const deleteSideFile = async function (filePath) {
-  if (filePath === undefined || !(await pathExists(filePath))) {
-    return
-  }
-
-  await fs.unlink(filePath)
-}
-
-// Modifications to `netlify.toml` and `_headers/_redirects` are only meant for
-// the deploy API call. After it's been performed, we restore their former
-// state.
-// We do this by backing them up inside some sibling directory.
-const backupConfig = async function ({ buildDir, configPath, headersPath, redirectsPath }) {
-  const tempDir = getTempDir(buildDir)
-  await fs.mkdir(tempDir, { recursive: true })
-  await Promise.all([
-    backupFile(configPath, `${tempDir}/netlify.toml`),
-    backupFile(headersPath, `${tempDir}/_headers`),
-    backupFile(redirectsPath, `${tempDir}/_redirects`),
-  ])
-}
-
-export const restoreConfig = async function (configMutations, { buildDir, configPath, headersPath, redirectsPath }) {
-  if (configMutations.length === 0) {
-    return
-  }
-
-  const tempDir = getTempDir(buildDir)
-  await Promise.all([
-    copyOrDelete(`${tempDir}/netlify.toml`, configPath),
-    copyOrDelete(`${tempDir}/_headers`, headersPath),
-    copyOrDelete(`${tempDir}/_redirects`, redirectsPath),
-  ])
-}
-
-const getTempDir = function (buildDir) {
-  return `${buildDir}/.netlify/deploy`
-}
-
-const backupFile = async function (original, backup) {
-  // this makes sure we don't restore stale files
-  await deleteNoError(backup)
-
-  if (!(await pathExists(original))) {
-    return
-  }
-
-  await fs.copyFile(original, backup)
-}
-
-const deleteNoError = async (path) => {
-  try {
-    await fs.unlink(path)
-  } catch {}
-}
-
-const copyOrDelete = async function (src, dest) {
-  if (await pathExists(src)) {
-    await fs.copyFile(src, dest)
-    return
-  }
-
-  await deleteNoError(dest)
-}

package/src/normalize.js

@@ -1,36 +0,0 @@
-import { normalizeFunctionsProps, WILDCARD_ALL } from './functions_config.js'
-import { mergeConfigs } from './merge.js'
-import { DEFAULT_ORIGIN } from './origin.js'
-import { removeFalsy } from './utils/remove_falsy.js'
-
-// Normalize configuration object
-export const normalizeConfig = function (config) {
-  const configA = removeEmpty(config)
-  const { build, functions, plugins, ...configB } = mergeConfigs([DEFAULT_CONFIG, configA])
-  const { build: buildA, functions: functionsA, functionsDirectoryProps } = normalizeFunctionsProps(build, functions)
-  const pluginsA = plugins.map(normalizePlugin)
-  return { ...configB, build: buildA, functions: functionsA, plugins: pluginsA, ...functionsDirectoryProps }
-}
-
-// Remove empty strings.
-// This notably ensures that empty strings in the build command are removed.
-// Otherwise those would be run during builds, making the build fail.
-const removeEmpty = function ({ build, ...config }) {
-  return removeFalsy({ ...config, build: removeFalsy(build) })
-}
-
-const DEFAULT_CONFIG = {
-  build: {
-    environment: {},
-    publish: '.',
-    publishOrigin: DEFAULT_ORIGIN,
-    processing: { css: {}, html: {}, images: {}, js: {} },
-    services: {},
-  },
-  functions: { [WILDCARD_ALL]: {} },
-  plugins: [],
-}
-
-const normalizePlugin = function ({ inputs = {}, ...plugin }) {
-  return removeFalsy({ ...plugin, inputs })
-}

package/src/options/base.js

@@ -1,66 +0,0 @@
-import { promises as fs } from 'fs'
-import { dirname, relative, sep } from 'path'
-
-import { pathExists } from 'path-exists'
-
-// Retrieve `base` override.
-// This uses any directory below `repositoryRoot` and above (or equal to)
-// `cwd` that has a `.netlify` or `netlify.toml`. This allows Netlify CLI users
-// to `cd` into monorepo directories to change their base and build directories.
-// Do all checks in parallel for speed
-export const getBaseOverride = async function ({ repositoryRoot, cwd }) {
-  // Performance optimization
-  if (repositoryRoot === cwd) {
-    return {}
-  }
-
-  const [repositoryRootA, cwdA] = await Promise.all([fs.realpath(repositoryRoot), fs.realpath(cwd)])
-  const basePaths = getBasePaths(repositoryRootA, cwdA)
-  const basePath = await locatePath(basePaths)
-
-  if (basePath === undefined) {
-    return {}
-  }
-
-  // `base` starting with a `/` are relative to `repositoryRoot`, so we cannot
-  // return an absolute path
-  const base = relative(repositoryRoot, dirname(basePath))
-  // When `base` is explicitely overridden, `baseRelDir: true` makes more sense
-  // since we want `publish`, `functions` and `edge_functions` to be relative to it.
-  return { base, baseRelDir: true }
-}
-
-// Returns list of files to check for the existence of a `base`
-const getBasePaths = function (repositoryRoot, cwd) {
-  const subdirs = getSubdirs(repositoryRoot, cwd)
-  const basePaths = subdirs.flatMap((subdir) => BASE_FILENAMES.map((filename) => `${subdir}/${filename}`))
-  return basePaths
-}
-
-// Retrieves list of directories between `repositoryRoot` and `cwd`, including
-// `cwd` but excluding `repositoryRoot`
-const getSubdirs = function (repositoryRoot, dir, subdirs = []) {
-  if (!dir.startsWith(`${repositoryRoot}${sep}`)) {
-    return subdirs
-  }
-
-  return getSubdirs(repositoryRoot, dirname(dir), [...subdirs, dir])
-}
-
-const BASE_FILENAMES = ['.netlify', 'netlify.toml', 'package.json']
-
-// Returns the first path that exists.
-// Like `locate-path` library but works with mixed files/directories
-const locatePath = async function (paths) {
-  const results = await Promise.all(paths.map(returnIfExists))
-  const path = results.find(Boolean)
-  return path
-}
-
-const returnIfExists = async function (path) {
-  if (!(await pathExists(path))) {
-    return
-  }
-
-  return path
-}

package/src/options/branch.js

@@ -1,34 +0,0 @@
-import { execaCommand } from 'execa'
-
-// Find out git branch among (in priority order):
-//   - `branch` option
-//   - `BRANCH` environment variable
-//   - `HEAD` branch (using `git`)
-//   - `main` (using `git`)
-//   - 'master' (fallback)
-export const getBranch = async function ({ branch, repositoryRoot }) {
-  if (branch) {
-    return branch
-  }
-
-  const headBranch = await getGitBranch(repositoryRoot, 'HEAD')
-  if (headBranch !== undefined) {
-    return headBranch
-  }
-
-  const mainBranch = await getGitBranch(repositoryRoot, 'main')
-  if (mainBranch !== undefined) {
-    return mainBranch
-  }
-
-  return FALLBACK_BRANCH
-}
-
-const getGitBranch = async function (repositoryRoot, gitRef) {
-  try {
-    const { stdout } = await execaCommand(`git rev-parse --abbrev-ref ${gitRef}`, { cwd: repositoryRoot })
-    return stdout
-  } catch {}
-}
-
-const FALLBACK_BRANCH = 'master'

package/src/options/feature_flags.js

@@ -1,15 +0,0 @@
-// From CLI `--featureFlags=a,b,c` to programmatic `{ a: true, b: true, c: true }`
-export const normalizeCliFeatureFlags = function (cliFeatureFlags) {
-  return Object.assign({}, ...cliFeatureFlags.split(',').filter(isNotEmpty).map(getFeatureFlag))
-}
-
-const isNotEmpty = function (name) {
-  return name.trim() !== ''
-}
-
-const getFeatureFlag = function (name) {
-  return { [name]: true }
-}
-
-// Default values for feature flags
-export const DEFAULT_FEATURE_FLAGS = {}

package/src/options/main.js

@@ -1,111 +0,0 @@
-import { resolve } from 'path'
-import process from 'process'
-
-import { isDirectory } from 'path-type'
-
-import { throwUserError } from '../error.js'
-import { getBufferLogs } from '../log/logger.js'
-import { logOpts } from '../log/main.js'
-import { removeFalsy } from '../utils/remove_falsy.js'
-
-import { getBaseOverride } from './base.js'
-import { getBranch } from './branch.js'
-import { DEFAULT_FEATURE_FLAGS } from './feature_flags.js'
-import { getRepositoryRoot } from './repository_root.js'
-
-// Assign default options
-export const addDefaultOpts = function (opts = {}) {
-  const rawOpts = removeFalsy(opts)
-
-  const defaultOpts = getDefaultOpts(rawOpts)
-  const mergedOpts = {
-    ...defaultOpts,
-    ...rawOpts,
-    featureFlags: { ...defaultOpts.featureFlags, ...rawOpts.featureFlags },
-  }
-  const normalizedOpts = removeFalsy(mergedOpts)
-
-  const logs = getBufferLogs(normalizedOpts)
-  const normalizedOptsA = { ...normalizedOpts, logs }
-
-  logOpts(rawOpts, normalizedOptsA)
-
-  return normalizedOptsA
-}
-
-const getDefaultOpts = function ({ env: envOpt = {}, cwd: cwdOpt, defaultConfig = {} }) {
-  const combinedEnv = { ...process.env, ...envOpt }
-  return {
-    defaultConfig,
-    ...getDefaultCwd(cwdOpt),
-    env: envOpt,
-    context: combinedEnv.CONTEXT || 'production',
-    branch: combinedEnv.BRANCH,
-    host: combinedEnv.NETLIFY_API_HOST,
-    token: combinedEnv.NETLIFY_AUTH_TOKEN,
-    siteId: combinedEnv.NETLIFY_SITE_ID,
-    deployId: combinedEnv.DEPLOY_ID || DEFAULT_DEPLOY_ID,
-    buildId: combinedEnv.BUILD_ID || DEFAULT_BUILD_ID,
-    mode: 'require',
-    offline: false,
-    debug: getDefaultDebug(combinedEnv, defaultConfig),
-    buffer: false,
-    featureFlags: DEFAULT_FEATURE_FLAGS,
-    inlineConfig: {},
-    configMutations: [],
-  }
-}
-
-// Local builds do not have any deploys, so some dummy ids are used instead
-const DEFAULT_DEPLOY_ID = '0'
-const DEFAULT_BUILD_ID = '0'
-
-// --debug can be set using an environment variable `NETLIFY_BUILD_DEBUG` either
-// locally or in the UI build settings
-const getDefaultDebug = function (combinedEnv, { build: { environment = {} } = {} }) {
-  return Boolean(combinedEnv.NETLIFY_BUILD_DEBUG || environment.NETLIFY_BUILD_DEBUG)
-}
-
-// `process.cwd()` can throw, so only call it when needed
-const getDefaultCwd = function (cwdOpt) {
-  if (cwdOpt !== undefined) {
-    return {}
-  }
-
-  const cwd = process.cwd()
-  return { cwd }
-}
-
-// Normalize options
-export const normalizeOpts = async function (opts) {
-  const repositoryRoot = await getRepositoryRoot(opts)
-  const optsA = { ...opts, repositoryRoot }
-
-  const branch = await getBranch(optsA)
-  const optsB = { ...optsA, branch }
-
-  const optsC = removeFalsy(optsB)
-  const optsD = await normalizeDirs(optsC)
-
-  const baseOverride = await getBaseOverride(optsD)
-  const optsE = { ...baseOverride, ...optsD }
-  return optsE
-}
-
-// Verify that options point to existing directories.
-// Also resolve them to absolute file paths.
-const normalizeDirs = async function (opts) {
-  const dirOpts = await Promise.all(DIR_OPTIONS.map((optName) => normalizeDir(opts, optName)))
-  return Object.assign({}, opts, ...dirOpts)
-}
-
-const DIR_OPTIONS = ['cwd', 'repositoryRoot']
-
-const normalizeDir = async function (opts, optName) {
-  const path = opts[optName]
-  const resolvedPath = resolve(path)
-  if (!(await isDirectory(path))) {
-    throwUserError(`Option '${optName}' points to a non-existing directory: ${resolvedPath}`)
-  }
-  return { [optName]: resolvedPath }
-}

package/src/options/repository_root.js

@@ -1,21 +0,0 @@
-import { dirname } from 'path'
-
-import { findUp } from 'find-up'
-
-// Find out repository root among (in priority order):
-//  - `repositoryRoot` option
-//  - find a `.git` directory up from `cwd`
-//  - `cwd` (fallback)
-export const getRepositoryRoot = async function ({ repositoryRoot, cwd }) {
-  if (repositoryRoot !== undefined) {
-    return repositoryRoot
-  }
-
-  const repositoryRootA = await findUp('.git', { cwd, type: 'directory' })
-
-  if (repositoryRootA === undefined) {
-    return cwd
-  }
-
-  return dirname(repositoryRootA)
-}

package/src/origin.js

@@ -1,38 +0,0 @@
-import { isTruthy } from './utils/remove_falsy.js'
-
-// `build.commandOrigin`, `build.publishOrigin` and `plugins[*].origin` constants
-export const UI_ORIGIN = 'ui'
-export const CONFIG_ORIGIN = 'config'
-export const DEFAULT_ORIGIN = 'default'
-export const INLINE_ORIGIN = 'inline'
-
-// Add `build.commandOrigin`, `build.publishOrigin` and `plugins[*].origin`.
-// This shows whether those properties came from the `ui` or from the `config`.
-export const addOrigins = function (config, origin) {
-  const configA = addBuildCommandOrigin({ config, origin })
-  const configB = addBuildPublishOrigin({ config: configA, origin })
-  const configC = addConfigPluginOrigin({ config: configB, origin })
-  const configD = addHeadersOrigin({ config: configC, origin })
-  const configE = addRedirectsOrigin({ config: configD, origin })
-  return configE
-}
-
-const addBuildCommandOrigin = function ({ config, config: { build = {} }, origin }) {
-  return isTruthy(build.command) ? { ...config, build: { ...build, commandOrigin: origin } } : config
-}
-
-const addBuildPublishOrigin = function ({ config, config: { build = {} }, origin }) {
-  return isTruthy(build.publish) ? { ...config, build: { ...build, publishOrigin: origin } } : config
-}
-
-const addConfigPluginOrigin = function ({ config, config: { plugins }, origin }) {
-  return Array.isArray(plugins) ? { ...config, plugins: plugins.map((plugin) => ({ ...plugin, origin })) } : config
-}
-
-const addHeadersOrigin = function ({ config, config: { headers }, origin }) {
-  return isTruthy(headers) ? { ...config, headersOrigin: origin } : config
-}
-
-const addRedirectsOrigin = function ({ config, config: { redirects }, origin }) {
-  return isTruthy(redirects) ? { ...config, redirectsOrigin: origin } : config
-}

package/src/parse.js

@@ -1,69 +0,0 @@
-import { promises as fs } from 'fs'
-
-import { pathExists } from 'path-exists'
-
-import { throwUserError } from './error.js'
-import { throwOnInvalidTomlSequence } from './log/messages.js'
-import { parseToml } from './utils/toml.js'
-
-// Load the configuration file and parse it (TOML)
-export const parseConfig = async function (configPath) {
-  if (configPath === undefined) {
-    return {}
-  }
-
-  if (!(await pathExists(configPath))) {
-    throwUserError('Configuration file does not exist')
-  }
-
-  return await readConfigPath(configPath)
-}
-
-// Same but `configPath` is required and `configPath` might point to a
-// non-existing file.
-export const parseOptionalConfig = async function (configPath) {
-  if (!(await pathExists(configPath))) {
-    return {}
-  }
-
-  return await readConfigPath(configPath)
-}
-
-const readConfigPath = async function (configPath) {
-  const configString = await readConfig(configPath)
-
-  validateTomlBlackslashes(configString)
-
-  try {
-    return parseToml(configString)
-  } catch (error) {
-    throwUserError('Could not parse configuration file', error)
-  }
-}
-
-// Reach the configuration file's raw content
-const readConfig = async function (configPath) {
-  try {
-    return await fs.readFile(configPath, 'utf8')
-  } catch (error) {
-    throwUserError('Could not read configuration file', error)
-  }
-}
-
-const validateTomlBlackslashes = function (configString) {
-  const result = INVALID_TOML_BLACKSLASH.exec(configString)
-  if (result === null) {
-    return
-  }
-
-  const [, invalidTripleSequence, invalidSequence = invalidTripleSequence] = result
-  throwOnInvalidTomlSequence(invalidSequence)
-}
-
-// The TOML specification forbids unrecognized backslash sequences. However,
-// `toml-node` does not respect the specification and do not fail on those.
-// Therefore, we print a warning message.
-// This only applies to " and """ strings, not ' nor '''
-// Also, """ strings can use trailing backslashes.
-const INVALID_TOML_BLACKSLASH =
-  /\n[a-zA-Z]+ *= *(?:(?:""".*(?<!\\)(\\[^"\\btnfruU\n]).*""")|(?:"(?!")[^\n]*(?<!\\)(\\[^"\\btnfruU])[^\n]*"))/su

package/src/path.js

@@ -1,52 +0,0 @@
-import { resolve } from 'path'
-
-import { findUp } from 'find-up'
-import pLocate from 'p-locate'
-import { pathExists } from 'path-exists'
-
-// Configuration location can be:
-//  - a local path with the --config CLI flag
-//  - a `netlify.*` file in the `repositoryRoot/{base}`
-//  - a `netlify.*` file in the `repositoryRoot`
-//  - a `netlify.*` file in the current directory or any parent
-export const getConfigPath = async function ({ configOpt, cwd, repositoryRoot, configBase }) {
-  const configPath = await pLocate(
-    [
-      searchConfigOpt(cwd, configOpt),
-      searchBaseConfigFile(repositoryRoot, configBase),
-      searchConfigFile(repositoryRoot),
-      findUp(FILENAME, { cwd }),
-    ],
-    Boolean,
-  )
-  return configPath
-}
-
-// --config CLI flag
-const searchConfigOpt = function (cwd, configOpt) {
-  if (configOpt === undefined) {
-    return
-  }
-
-  return resolve(cwd, configOpt)
-}
-
-// Look for `repositoryRoot/{base}/netlify.*`
-const searchBaseConfigFile = function (repositoryRoot, configBase) {
-  if (configBase === undefined) {
-    return
-  }
-
-  return searchConfigFile(configBase)
-}
-
-// Look for several file extensions for `netlify.*`
-const searchConfigFile = async function (cwd) {
-  const path = resolve(cwd, FILENAME)
-  if (!(await pathExists(path))) {
-    return
-  }
-  return path
-}
-
-const FILENAME = 'netlify.toml'

package/src/redirects.js

@@ -1,29 +0,0 @@
-import { resolve } from 'path'
-
-import { parseAllRedirects } from 'netlify-redirect-parser'
-
-import { warnRedirectsParsing } from './log/messages.js'
-
-// Retrieve path to `_redirects` file (even if it does not exist yet)
-export const getRedirectsPath = function ({ build: { publish } }) {
-  return resolve(publish, REDIRECTS_FILENAME)
-}
-
-const REDIRECTS_FILENAME = '_redirects'
-
-// Add `config.redirects`
-export const addRedirects = async function ({
-  config: { redirects: configRedirects, ...config },
-  redirectsPath,
-  logs,
-  featureFlags,
-}) {
-  const { redirects, errors } = await parseAllRedirects({
-    redirectsFiles: [redirectsPath],
-    configRedirects,
-    minimal: true,
-    featureFlags,
-  })
-  warnRedirectsParsing(logs, errors)
-  return { ...config, redirects }
-}