@netlify/config 19.0.0-rc → 19.0.1

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_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' },
-}

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'