@netlify/config 18.2.2 → 18.2.4-rc

package/src/simplify.js

@@ -1,103 +0,0 @@
-import isPlainObj from 'is-plain-obj'
-import mapObj from 'map-obj'
-
-import { removeFalsy } from './utils/remove_falsy.js'
-
-// Removes default values (empty objects and arrays) from the configuration.
-export const simplifyConfig = function ({
-  build: { environment, processing: { css, html, images, js, ...processing } = {}, services, ...build } = {},
-  functions,
-  plugins,
-  headers,
-  redirects,
-  context = {},
-  ...config
-}) {
-  const buildA = {
-    ...build,
-    ...simplifyEnvironment(environment),
-    ...removeEmptyObject(
-      {
-        ...processing,
-        ...removeEmptyObject(css, 'css'),
-        ...removeEmptyObject(html, 'html'),
-        ...removeEmptyObject(images, 'images'),
-        ...removeEmptyObject(js, 'js'),
-      },
-      'processing',
-    ),
-    ...removeEmptyObject(services, 'services'),
-  }
-  return removeFalsy({
-    ...config,
-    ...removeEmptyObject(simplifyFunctions(functions), 'functions'),
-    ...removeEmptyObject(buildA, 'build'),
-    ...removeEmptyArray(plugins, 'plugins'),
-    ...removeEmptyArray(headers, 'headers'),
-    ...removeEmptyArray(simplifyRedirects(redirects), 'redirects'),
-    ...removeEmptyObject(simplifyContexts(context), 'context'),
-  })
-}
-
-const simplifyEnvironment = function (environment) {
-  return Array.isArray(environment)
-    ? removeEmptyArray(environment, 'environment')
-    : removeEmptyObject(environment, 'environment')
-}
-
-const simplifyContexts = function (contextProps) {
-  return mapObj(contextProps, simplifyContextProps)
-}
-
-const simplifyContextProps = function (context, contextConfig) {
-  return [context, simplifyConfig(contextConfig)]
-}
-
-const simplifyFunctions = function (functions) {
-  return isPlainObj(functions) ? Object.entries(functions).reduce(simplifyFunction, {}) : functions
-}
-
-const simplifyFunction = function (functions, [key, value]) {
-  return { ...functions, ...removeEmptyObject(value, key) }
-}
-
-const simplifyRedirects = function (redirects) {
-  return Array.isArray(redirects) ? redirects.map(simplifyRedirect) : redirects
-}
-
-const simplifyRedirect = function (redirect) {
-  if (!isPlainObj(redirect)) {
-    return redirect
-  }
-
-  const { force, proxy, query, conditions, headers, ...redirectA } = redirect
-  return {
-    ...redirectA,
-    ...removeDefaultValue(force, 'force', false),
-    ...removeDefaultValue(proxy, 'proxy', false),
-    ...removeEmptyObject(query, 'query'),
-    ...removeEmptyObject(conditions, 'conditions'),
-    ...removeEmptyObject(headers, 'headers'),
-  }
-}
-
-const removeDefaultValue = function (value, propName, defaultValue) {
-  return value === defaultValue ? {} : { [propName]: value }
-}
-
-export const removeEmptyObject = function (object, propName) {
-  if (!isPlainObj(object)) {
-    return {}
-  }
-
-  const objectA = removeFalsy(object)
-  return Object.keys(objectA).length === 0 ? {} : { [propName]: objectA }
-}
-
-export const removeEmptyArray = function (array, propName) {
-  if (!Array.isArray(array)) {
-    return {}
-  }
-
-  return array.length === 0 ? {} : { [propName]: array }
-}

package/src/utils/group.js

@@ -1,10 +0,0 @@
-// Group objects according to a key attribute.
-// The key must exist in each object and be a string.
-export const groupBy = function (objects, keyName) {
-  const keys = [...new Set(objects.map((object) => object[keyName]))]
-  return keys.map((key) => groupObjects(objects, keyName, key))
-}
-
-const groupObjects = function (objects, keyName, key) {
-  return objects.filter((object) => object[keyName] === key)
-}

package/src/utils/remove_falsy.js

@@ -1,18 +0,0 @@
-import filterObj from 'filter-obj'
-
-// Remove falsy values from object
-export const removeFalsy = function (obj) {
-  return filterObj(obj, (key, value) => isTruthy(value))
-}
-
-export const removeUndefined = function (obj) {
-  return filterObj(obj, (key, value) => isDefined(value))
-}
-
-export const isTruthy = function (value) {
-  return isDefined(value) && (typeof value !== 'string' || value.trim() !== '')
-}
-
-export const isDefined = function (value) {
-  return value !== undefined && value !== null
-}

package/src/utils/set.js

@@ -1,33 +0,0 @@
-import isPlainObj from 'is-plain-obj'
-
-// Set a property deeply using an array of `keys` which can be either strings
-// (object properties) or integers (array indices).
-// Adds default values when intermediary properties are undefined or have the
-// wrong type. Also extends arrays when they are too small for a given index.
-// Does not mutate.
-export const setProp = function (parent, keys, value) {
-  if (keys.length === 0) {
-    return value
-  }
-
-  if (Number.isInteger(keys[0])) {
-    return setArrayProp(parent, keys, value)
-  }
-
-  return setObjectProp(parent, keys, value)
-}
-
-const setArrayProp = function (parent, [index, ...keys], value) {
-  const arrayParent = Array.isArray(parent) ? parent : []
-  const missingItems = index - arrayParent.length + 1
-  // eslint-disable-next-line unicorn/no-new-array
-  const normalizedParent = missingItems > 0 ? [...arrayParent, ...new Array(missingItems)] : arrayParent
-  const newValue = setProp(normalizedParent[index], keys, value)
-  return [...normalizedParent.slice(0, index), newValue, ...normalizedParent.slice(index + 1)]
-}
-
-const setObjectProp = function (parent, [key, ...keys], value) {
-  const objectParent = isPlainObj(parent) ? parent : {}
-  const newValue = setProp(objectParent[key], keys, value)
-  return { ...objectParent, [key]: newValue }
-}

package/src/utils/toml.js

@@ -1,23 +0,0 @@
-import { parse as loadToml } from 'toml'
-import tomlify from 'tomlify-j0.4'
-
-// Parse from TOML to JavaScript
-export const parseToml = function (configString) {
-  const config = loadToml(configString)
-  // `toml.parse()` returns a object with `null` prototype deeply, which can
-  // sometimes create problems with some utilities. We convert it.
-  // TOML can return Date instances, but JSON will stringify those, and we
-  // don't use Date in netlify.toml, so this should be ok.
-  return JSON.parse(JSON.stringify(config))
-}
-
-// Serialize JavaScript object to TOML
-export const serializeToml = function (object) {
-  return tomlify.toToml(object, { space: 2, replace: replaceTomlValue })
-}
-
-// `tomlify-j0.4` serializes integers as floats, e.g. `200.0`.
-// This is a problem with `redirects[*].status`.
-const replaceTomlValue = function (key, value) {
-  return Number.isInteger(value) ? String(value) : false
-}

package/src/validate/context.js

@@ -1,57 +0,0 @@
-import { warnContextPluginConfig, throwContextPluginsConfig } from '../log/messages.js'
-import { UI_ORIGIN } from '../origin.js'
-
-// The only reason to specify both `[[plugins]]` and
-// `[[contexts.{context}.plugins]]` is to configure context-specific plugin
-// inputs.
-// The second cannot be used to enable a plugin for a specific context, because
-// it would be overridden by `[[plugins]]`.
-// We prevent against that mistake by printing a warning message when both are
-// used. We only do this when `[[plugins]]` is due to plugin being UI-installed.
-// We also fail the build when the following additional conditions apply:
-//  - `package` is the only property in `[[contexts.{context}.plugins]]`, i.e.
-//    there are no context-specific `inputs`
-//  - The current build is not in `context`
-export const validateContextsPluginsConfig = function ({ contextProps, plugins, contexts, logs }) {
-  Object.entries(contextProps).forEach(([givenContext, givenContextProps]) => {
-    validateContextPluginsConfig({ givenContextProps, plugins, givenContext, contexts, logs })
-  })
-}
-
-const validateContextPluginsConfig = function ({
-  givenContextProps: { plugins: contextPlugins = [] },
-  plugins,
-  givenContext,
-  contexts,
-  logs,
-}) {
-  contextPlugins.forEach((pluginConfig) => {
-    validateContextPluginConfig({ pluginConfig, plugins, givenContext, contexts, logs })
-  })
-}
-
-const validateContextPluginConfig = function ({
-  pluginConfig: { package: packageName, inputs = {} },
-  plugins = [],
-  givenContext,
-  contexts,
-  logs,
-}) {
-  if (!isContextFreePlugin(plugins, packageName)) {
-    return
-  }
-
-  if (isPluginConfigError(contexts, givenContext, inputs)) {
-    throwContextPluginsConfig(packageName, givenContext)
-  }
-
-  warnContextPluginConfig(logs, packageName, givenContext)
-}
-
-const isContextFreePlugin = function (plugins, packageName) {
-  return plugins.some((plugin) => plugin.package === packageName && plugin.origin === UI_ORIGIN)
-}
-
-const isPluginConfigError = function (contexts, givenContext, inputs) {
-  return contexts.every((context) => context !== givenContext) && Object.keys(inputs).length === 0
-}

package/src/validate/example.js

@@ -1,37 +0,0 @@
-import indentString from 'indent-string'
-
-import { THEME } from '../log/theme.js'
-import { serializeToml } from '../utils/toml.js'
-
-// Print invalid value and example netlify.toml
-export const getExample = function ({ value, key, prevPath, example, formatInvalid }) {
-  const exampleA = typeof example === 'function' ? example(value, key, prevPath) : example
-  return `
-${THEME.errorSubHeader('Invalid syntax')}
-
-${indentString(getInvalidValue(value, prevPath, formatInvalid), 2)}
-
-${THEME.subHeader('Valid syntax')}
-
-${indentString(serializeToml(exampleA), 2)}`
-}
-
-const getInvalidValue = function (value, prevPath, formatInvalid) {
-  // slice() is temporary, so it does not mutate
-  // eslint-disable-next-line fp/no-mutating-methods
-  const invalidValue = [...prevPath].reverse().reduce(setInvalidValuePart, value)
-
-  // If `formatInvalid` is supplied, we use it to format the invalid value
-  // before serializing it to TOML and printing it.
-  const formattedInvalidValue = typeof formatInvalid === 'function' ? formatInvalid(invalidValue) : invalidValue
-  const invalidValueA = serializeToml(formattedInvalidValue)
-  return invalidValueA
-}
-
-const setInvalidValuePart = function (value, part) {
-  if (Number.isInteger(part)) {
-    return [value]
-  }
-
-  return value === undefined ? {} : { [part]: value }
-}

package/src/validate/helpers.js

@@ -1,31 +0,0 @@
-import isPlainObj from 'is-plain-obj'
-
-export const isArrayOfObjects = function (value) {
-  return Array.isArray(value) && value.every(isPlainObj)
-}
-
-export const isArrayOfStrings = function (value) {
-  return Array.isArray(value) && value.every(isString)
-}
-
-export const isString = function (value) {
-  return typeof value === 'string'
-}
-
-// Check an object valid properties, including legacy ones
-export const validProperties = function (propNames, legacyPropNames) {
-  return {
-    check: (value) => checkValidProperty(value, [...propNames, ...legacyPropNames]),
-    message: `has unknown properties. Valid properties are:
-${propNames.map((propName) => `  - ${propName}`).join('\n')}`,
-  }
-}
-
-const checkValidProperty = function (value, propNames) {
-  return Object.keys(value).every((propName) => propNames.includes(propName))
-}
-
-export const functionsDirectoryCheck = {
-  formatInvalid: ({ functionsDirectory } = {}) => ({ functions: { directory: functionsDirectory } }),
-  propertyName: 'functions.directory',
-}

package/src/validate/identical.js

@@ -1,20 +0,0 @@
-import { throwUserError } from '../error.js'
-
-// Validate that plugin are configured only once per origin
-// (`netlify.toml` or UI).
-// Exception: context-specific configuration since we allow context-specific
-// overrides. This does not validate them since contexts have not been merged
-// yet.
-export const validateIdenticalPlugins = function ({ plugins = [] }) {
-  plugins.filter(hasIdenticalPlugin).forEach(throwIndenticalPlugin)
-}
-
-const hasIdenticalPlugin = function ({ package: packageName, origin }, index, plugins) {
-  return plugins.slice(index + 1).some((pluginA) => packageName === pluginA.package && origin === pluginA.origin)
-}
-
-const throwIndenticalPlugin = function ({ package: packageName, origin }) {
-  throwUserError(`Plugin "${packageName}" must not be specified twice in ${ORIGINS[origin]}`)
-}
-
-const ORIGINS = { config: 'netlify.toml', ui: 'the app' }

package/src/validate/main.js

@@ -1,143 +0,0 @@
-import { throwUserError } from '../error.js'
-import { THEME } from '../log/theme.js'
-
-import { getExample } from './example.js'
-import {
-  PRE_CASE_NORMALIZE_VALIDATIONS,
-  PRE_MERGE_VALIDATIONS,
-  PRE_CONTEXT_VALIDATIONS,
-  PRE_NORMALIZE_VALIDATIONS,
-  POST_NORMALIZE_VALIDATIONS,
-} from './validations.js'
-
-// Validate the configuration file, before case normalization.
-export const validatePreCaseNormalize = function (config) {
-  validateConfig(config, PRE_CASE_NORMALIZE_VALIDATIONS)
-}
-
-// Validate the configuration file, before `defaultConfig` merge.
-export const validatePreMergeConfig = function (config) {
-  validateConfig(config, PRE_MERGE_VALIDATIONS)
-}
-
-// Validate the configuration file, before context merge.
-export const validatePreContextConfig = function (config) {
-  validateConfig(config, PRE_CONTEXT_VALIDATIONS)
-}
-
-// Validate the configuration file, before normalization.
-export const validatePreNormalizeConfig = function (config) {
-  validateConfig(config, PRE_NORMALIZE_VALIDATIONS)
-}
-
-// Validate the configuration file, after normalization.
-export const validatePostNormalizeConfig = function (config) {
-  validateConfig(config, POST_NORMALIZE_VALIDATIONS)
-}
-
-const validateConfig = function (config, validations) {
-  try {
-    validations.forEach(({ property, ...validation }) => {
-      validateProperty(config, { ...validation, nextPath: property.split('.') })
-    })
-  } catch (error) {
-    throwUserError(error)
-  }
-}
-
-// Validate a single property in the configuration file.
-const validateProperty = function (
-  parent,
-  {
-    nextPath: [propName, nextPropName, ...nextPath],
-    prevPath = [propName],
-    propPath = propName,
-    key = propName,
-    check,
-    message,
-    example,
-    formatInvalid,
-    propertyName,
-  },
-) {
-  const value = parent[propName]
-
-  if (nextPropName !== undefined) {
-    return validateChild({
-      value,
-      nextPropName,
-      prevPath,
-      nextPath,
-      propPath,
-      key,
-      check,
-      message,
-      example,
-      formatInvalid,
-      propertyName,
-    })
-  }
-
-  if (value === undefined || (check !== undefined && check(value, key, prevPath))) {
-    return
-  }
-
-  reportError({ prevPath, propPath, message, example, value, key, formatInvalid, propertyName })
-}
-
-const reportError = function ({
-  prevPath,
-  propPath,
-  message,
-  example,
-  value,
-  key,
-  formatInvalid,
-  propertyName = propPath,
-}) {
-  throwUserError(`${THEME.highlightWords('Configuration property')} ${propertyName} ${message}
-${getExample({ value, key, prevPath, example, formatInvalid })}`)
-}
-
-// Recurse over children (each part of the `property` array).
-const validateChild = function ({ value, nextPropName, prevPath, nextPath, propPath, ...rest }) {
-  if (value === undefined) {
-    return
-  }
-
-  if (nextPropName !== '*') {
-    return validateProperty(value, {
-      ...rest,
-      prevPath: [...prevPath, nextPropName],
-      nextPath: [nextPropName, ...nextPath],
-      propPath: `${propPath}.${nextPropName}`,
-      key: nextPropName,
-    })
-  }
-
-  return Object.keys(value).forEach((childProp) => {
-    validateChildProp({ childProp, value, nextPath, propPath, prevPath, ...rest })
-  })
-}
-
-// Can use * to recurse over array|object elements.
-const validateChildProp = function ({ childProp, value, nextPath, propPath, prevPath, ...rest }) {
-  if (Array.isArray(value)) {
-    const key = Number(childProp)
-    return validateProperty(value, {
-      ...rest,
-      prevPath: [...prevPath, key],
-      nextPath: [key, ...nextPath],
-      propPath: `${propPath}[${childProp}]`,
-      key,
-    })
-  }
-
-  validateProperty(value, {
-    ...rest,
-    prevPath: [...prevPath, childProp],
-    nextPath: [childProp, ...nextPath],
-    propPath: `${propPath}.${childProp}`,
-    key: childProp,
-  })
-}