@netlify/build 28.0.0-rc → 28.0.0

package/src/plugins_core/functions/error.js

@@ -1,163 +0,0 @@
-import readdirp from 'readdirp'
-
-import { addErrorInfo } from '../../error/info.js'
-
-const MODULE_NOT_FOUND_CODE = 'MODULE_NOT_FOUND'
-const MODULE_NOT_FOUND_ESBUILD_REGEXP = /^Could not resolve ['"]([^'"]+)/
-const MODULE_NOT_FOUND_REGEXP = /Cannot find module ['"]([^'"]+)/
-
-// Handle errors coming from zip-it-and-ship-it
-export const getZipError = async function (error, functionsSrc) {
-  const moduleNotFoundError = await getModuleNotFoundError(error, functionsSrc)
-
-  if (moduleNotFoundError) {
-    return moduleNotFoundError
-  }
-
-  if (isPackageJsonError(error)) {
-    return getPackageJsonError(error)
-  }
-
-  return error
-}
-
-const getModuleNotFoundError = async function (error, functionsSrc) {
-  const errorFromZisi = await getModuleNotFoundErrorFromZISI(error, functionsSrc)
-
-  if (errorFromZisi) {
-    return errorFromZisi
-  }
-
-  const errorFromEsbuild = await getModuleNotFoundErrorFromEsbuild(error, functionsSrc)
-
-  if (errorFromEsbuild) {
-    return errorFromEsbuild
-  }
-}
-
-const getModuleNotFoundErrorObject = async ({ error, functionsSrc, moduleNames }) => {
-  const message = await getModuleNotFoundMessage(functionsSrc, moduleNames)
-
-  error.message = `${message}\n\n${error.message}`
-  addErrorInfo(error, { type: 'dependencies' })
-
-  return error
-}
-
-const getModuleNotFoundMessage = async function (functionsSrc, moduleNames) {
-  if (moduleNames.length === 0 || !(await lacksNodeModules(functionsSrc))) {
-    return MODULE_NOT_FOUND_MESSAGE
-  }
-
-  if (moduleNames.filter(Boolean).some(isLocalPath)) {
-    return PATH_NOT_FOUND_MESSAGE
-  }
-
-  return getLocalInstallMessage(moduleNames)
-}
-
-const isLocalPath = function (moduleName) {
-  return moduleName.startsWith('.') || moduleName.startsWith('/')
-}
-
-const getModuleNotFoundErrorFromEsbuild = function (error, functionsSrc) {
-  const { errors = [] } = error
-  const modulesNotFound = errors.reduce((modules, errorObject) => {
-    const match = errorObject.text.match(MODULE_NOT_FOUND_ESBUILD_REGEXP)
-
-    if (!match) {
-      return modules
-    }
-
-    return [...modules, match[1]]
-  }, [])
-
-  if (modulesNotFound.length === 0) {
-    return
-  }
-
-  return getModuleNotFoundErrorObject({ error, functionsSrc, moduleNames: modulesNotFound })
-}
-
-const getModuleNotFoundErrorFromZISI = function (error, functionsSrc) {
-  if (!(error instanceof Error && error.code === MODULE_NOT_FOUND_CODE)) {
-    return
-  }
-
-  const moduleName = getModuleNameFromZISIError(error)
-
-  return getModuleNotFoundErrorObject({ error, functionsSrc, moduleNames: moduleName ? [moduleName] : [] })
-}
-
-// This error message always include the same words
-const getModuleNameFromZISIError = function (error) {
-  if (typeof error.message !== 'string') {
-    return
-  }
-
-  const result = MODULE_NOT_FOUND_REGEXP.exec(error.message)
-  if (result === null) {
-    return
-  }
-
-  return result[1]
-}
-
-// Netlify Functions has a `package.json` but no `node_modules`
-const lacksNodeModules = async function (functionsSrc) {
-  return (
-    functionsSrc !== undefined &&
-    (await hasFunctionRootFile('package.json', functionsSrc)) &&
-    !(await hasFunctionRootFile('node_modules', functionsSrc))
-  )
-}
-
-// Functions can be either files or directories, so we need to check on two
-// depth levels
-const hasFunctionRootFile = async function (filename, functionsSrc) {
-  const files = await readdirp.promise(functionsSrc, { depth: 1, fileFilter: filename })
-  return files.length !== 0
-}
-
-const MODULE_NOT_FOUND_MESSAGE = `A Netlify Function failed to require one of its dependencies.
-Please make sure it is present in the site's top-level "package.json".`
-const PATH_NOT_FOUND_MESSAGE = `A Netlify Function failed to require a local file.
-Please make sure the file exists and its path is correctly spelled.`
-
-// A common mistake is to assume Netlify Functions dependencies are
-// automatically installed. This checks for this pattern.
-const getLocalInstallMessage = function (modules) {
-  const genericMessage = `
-
-By default, dependencies inside a Netlify Function's "package.json" are not automatically installed.
-There are several ways to fix this problem:
-  - Removing your Function's "package.json" and adding the dependencies to the project's top-level "package.json" instead. This is the fastest and safest solution.
-  - Running "npm install" or "yarn" inside your Netlify Function in your build command.
-  - Adding the following plugin to your "netlify.toml":
-
-[[plugins]]
-package = "@netlify/plugin-functions-install-core"
-  `
-
-  if (modules.length === 1) {
-    return `A Netlify Function is using "${modules[0]}" but that dependency has not been installed yet.${genericMessage}`
-  }
-
-  const moduleNames = modules.map((name) => `"${name}"`).join(', ')
-
-  return `A Netlify Function is using dependencies that have not been installed yet: ${moduleNames}${genericMessage}`
-}
-
-// We need to load the site's `package.json` when bundling Functions. This is
-// because `optionalDependencies` can make `import()` fail, but we don't want
-// to error then. However, if the `package.json` is invalid, we fail the build.
-const isPackageJsonError = function (error) {
-  return PACKAGE_JSON_ORIGINAL_MESSAGES.some((msg) => error.message.includes(msg))
-}
-
-const PACKAGE_JSON_ORIGINAL_MESSAGES = ['is invalid JSON', 'in JSON at position']
-
-const getPackageJsonError = function (error) {
-  addErrorInfo(error, { type: 'resolveConfig' })
-  return error
-}

package/src/plugins_core/functions/feature_flags.js

@@ -1,6 +0,0 @@
-export const getZisiFeatureFlags = (featureFlags) => ({
-  ...featureFlags,
-  defaultEsModulesToEsbuild: featureFlags.buildbot_es_modules_esbuild,
-  parseWithEsbuild: featureFlags.buildbot_zisi_esbuild_parser,
-  traceWithNft: featureFlags.buildbot_zisi_trace_nft,
-})

package/src/plugins_core/functions/index.js

@@ -1,160 +0,0 @@
-import { resolve } from 'path'
-
-import { zipFunctions } from '@netlify/zip-it-and-ship-it'
-import { pathExists } from 'path-exists'
-
-import { log } from '../../log/logger.js'
-import { logBundleResults, logFunctionsNonExistingDir, logFunctionsToBundle } from '../../log/messages/core_steps.js'
-
-import { getZipError } from './error.js'
-import { getUserAndInternalFunctions, validateFunctionsSrc } from './utils.js'
-import { getZisiParameters } from './zisi.js'
-
-// Returns `true` if at least one of the functions has been configured to use
-// esbuild.
-const isUsingEsbuild = (functionsConfig = {}) =>
-  Object.values(functionsConfig).some((configObject) => configObject.node_bundler === 'esbuild')
-
-const zipFunctionsAndLogResults = async ({
-  buildDir,
-  childEnv,
-  featureFlags,
-  functionsConfig,
-  functionsDist,
-  functionsSrc,
-  internalFunctionsSrc,
-  isRunningLocally,
-  logs,
-  repositoryRoot,
-}) => {
-  const zisiParameters = getZisiParameters({
-    buildDir,
-    childEnv,
-    featureFlags,
-    functionsConfig,
-    functionsDist,
-    isRunningLocally,
-    repositoryRoot,
-  })
-  const bundler = isUsingEsbuild(functionsConfig) ? 'esbuild' : 'zisi'
-
-  try {
-    // Printing an empty line before bundling output.
-    log(logs, '')
-
-    const sourceDirectories = [internalFunctionsSrc, functionsSrc].filter(Boolean)
-    const results = await zipItAndShipIt.zipFunctions(sourceDirectories, functionsDist, zisiParameters)
-
-    logBundleResults({ logs, results })
-
-    return { bundler }
-  } catch (error) {
-    throw await getZipError(error, functionsSrc)
-  }
-}
-
-// Plugin to package Netlify functions with @netlify/zip-it-and-ship-it
-// eslint-disable-next-line complexity
-const coreStep = async function ({
-  childEnv,
-  constants: {
-    INTERNAL_FUNCTIONS_SRC: relativeInternalFunctionsSrc,
-    IS_LOCAL: isRunningLocally,
-    FUNCTIONS_SRC: relativeFunctionsSrc,
-    FUNCTIONS_DIST: relativeFunctionsDist,
-  },
-  buildDir,
-  logs,
-  netlifyConfig,
-  featureFlags,
-  repositoryRoot,
-}) {
-  const functionsSrc = relativeFunctionsSrc === undefined ? undefined : resolve(buildDir, relativeFunctionsSrc)
-  const functionsDist = resolve(buildDir, relativeFunctionsDist)
-  const internalFunctionsSrc = resolve(buildDir, relativeInternalFunctionsSrc)
-  const internalFunctionsSrcExists = await pathExists(internalFunctionsSrc)
-  const functionsSrcExists = await validateFunctionsSrc({ functionsSrc, logs, relativeFunctionsSrc })
-  const [userFunctions = [], internalFunctions = []] = await getUserAndInternalFunctions({
-    featureFlags,
-    functionsSrc,
-    functionsSrcExists,
-    internalFunctionsSrc,
-    internalFunctionsSrcExists,
-  })
-
-  if (functionsSrc && !functionsSrcExists) {
-    logFunctionsNonExistingDir(logs, relativeFunctionsSrc)
-
-    if (internalFunctions.length !== 0) {
-      log(logs, '')
-    }
-  }
-
-  logFunctionsToBundle({
-    logs,
-    userFunctions,
-    userFunctionsSrc: relativeFunctionsSrc,
-    userFunctionsSrcExists: functionsSrcExists,
-    internalFunctions,
-    internalFunctionsSrc: relativeInternalFunctionsSrc,
-  })
-
-  if (userFunctions.length === 0 && internalFunctions.length === 0) {
-    return {}
-  }
-
-  const { bundler } = await zipFunctionsAndLogResults({
-    buildDir,
-    childEnv,
-    featureFlags,
-    functionsConfig: netlifyConfig.functions,
-    functionsDist,
-    functionsSrc,
-    internalFunctionsSrc,
-    isRunningLocally,
-    logs,
-    repositoryRoot,
-  })
-
-  return {
-    tags: {
-      bundler,
-    },
-  }
-}
-
-// We run this core step if at least one of the functions directories (the
-// one configured by the user or the internal one) exists. We use a dynamic
-// `condition` because the directories might be created by the build command
-// or plugins.
-const hasFunctionsDirectories = async function ({ buildDir, constants: { INTERNAL_FUNCTIONS_SRC, FUNCTIONS_SRC } }) {
-  const hasFunctionsSrc = FUNCTIONS_SRC !== undefined && FUNCTIONS_SRC !== ''
-
-  if (hasFunctionsSrc) {
-    return true
-  }
-
-  const internalFunctionsSrc = resolve(buildDir, INTERNAL_FUNCTIONS_SRC)
-
-  return await pathExists(internalFunctionsSrc)
-}
-
-export const bundleFunctions = {
-  event: 'onBuild',
-  coreStep,
-  coreStepId: 'functions_bundling',
-  coreStepName: 'Functions bundling',
-  coreStepDescription: () => 'Functions bundling',
-  condition: hasFunctionsDirectories,
-}
-
-// Named imports with ES modules cannot be mocked (unlike CommonJS) because
-// they are bound at load time.
-// However, some of our tests are asserting which arguments are passed to
-// `zip-it-and-ship-it` methods. Therefore, we need to use an intermediary
-// function and export them so tests can use it.
-export const zipItAndShipIt = {
-  async zipFunctions(...args) {
-    return await zipFunctions(...args)
-  },
-}

package/src/plugins_core/functions/utils.js

@@ -1,66 +0,0 @@
-import { promises as fs } from 'fs'
-import { relative } from 'path'
-
-import { listFunctions } from '@netlify/zip-it-and-ship-it'
-
-import { addErrorInfo } from '../../error/info.js'
-
-import { getZisiFeatureFlags } from './feature_flags.js'
-
-// Returns the `mainFile` of each function found in `functionsSrc`, relative to
-// `functionsSrc`.
-const getRelativeFunctionMainFiles = async function ({ featureFlags, functionsSrc }) {
-  if (functionsSrc === undefined) {
-    return []
-  }
-
-  const zisiFeatureFlags = getZisiFeatureFlags(featureFlags)
-  const functions = await listFunctions(functionsSrc, { featureFlags: zisiFeatureFlags })
-  return functions.map(({ mainFile }) => relative(functionsSrc, mainFile))
-}
-
-export const getUserAndInternalFunctions = ({
-  featureFlags,
-  functionsSrc,
-  functionsSrcExists,
-  internalFunctionsSrc,
-  internalFunctionsSrcExists,
-}) => {
-  const paths = [
-    functionsSrcExists ? functionsSrc : undefined,
-    internalFunctionsSrcExists ? internalFunctionsSrc : undefined,
-  ]
-
-  return Promise.all(paths.map((path) => path && getRelativeFunctionMainFiles({ featureFlags, functionsSrc: path })))
-}
-
-// Returns `true` if the functions directory exists and is valid. Returns
-// `false` if it doesn't exist. Throws an error if it's invalid or can't
-// be accessed.
-export const validateFunctionsSrc = async function ({ functionsSrc, relativeFunctionsSrc }) {
-  if (functionsSrc === undefined) {
-    return false
-  }
-
-  try {
-    const stats = await fs.stat(functionsSrc)
-
-    if (stats.isDirectory()) {
-      return true
-    }
-
-    const error = new Error(
-      `The Netlify Functions setting should target a directory, not a regular file: ${relativeFunctionsSrc}`,
-    )
-
-    addErrorInfo(error, { type: 'resolveConfig' })
-
-    throw error
-  } catch (error) {
-    if (error.code === 'ENOENT') {
-      return false
-    }
-
-    throw error
-  }
-}

package/src/plugins_core/functions/zisi.js

@@ -1,53 +0,0 @@
-import { join, resolve } from 'path'
-
-import mapObject from 'map-obj'
-
-import { getZisiFeatureFlags } from './feature_flags.js'
-
-export const getZisiParameters = ({
-  buildDir,
-  childEnv,
-  featureFlags,
-  functionsConfig,
-  functionsDist,
-  isRunningLocally,
-  repositoryRoot,
-}) => {
-  const nodeVersion = childEnv.AWS_LAMBDA_JS_RUNTIME
-  const manifest = join(functionsDist, 'manifest.json')
-  const config = mapObject(functionsConfig, (expression, object) => [
-    expression,
-    normalizeFunctionConfig({ buildDir, featureFlags, functionConfig: object, isRunningLocally, nodeVersion }),
-  ])
-  const zisiFeatureFlags = getZisiFeatureFlags(featureFlags)
-
-  return { basePath: buildDir, config, manifest, featureFlags: zisiFeatureFlags, repositoryRoot }
-}
-
-// The function configuration keys returned by @netlify/config are not an exact
-// match to the properties that @netlify/zip-it-and-ship-it expects. We do that
-// translation here.
-export const normalizeFunctionConfig = ({ buildDir, functionConfig = {}, isRunningLocally, nodeVersion }) => ({
-  externalNodeModules: functionConfig.external_node_modules,
-  includedFiles: functionConfig.included_files,
-  includedFilesBasePath: buildDir,
-  ignoredNodeModules: functionConfig.ignored_node_modules,
-  nodeVersion,
-  schedule: functionConfig.schedule,
-
-  // When the user selects esbuild as the Node bundler, we still want to use
-  // the legacy ZISI bundler as a fallback. Rather than asking the user to
-  // make this decision, we abstract that complexity away by injecting the
-  // fallback behavior ourselves. We do this by transforming the value
-  // `esbuild` into `esbuild_zisi`, which zip-it-and-ship-it understands.
-  nodeBundler: functionConfig.node_bundler === 'esbuild' ? 'esbuild_zisi' : functionConfig.node_bundler,
-
-  // If the build is running in buildbot, we set the Rust target directory to a
-  // path that will get cached in between builds, allowing us to speed up the
-  // build process.
-  rustTargetDirectory: isRunningLocally ? undefined : resolve(buildDir, '.netlify', 'rust-functions-cache', '[name]'),
-
-  // Go functions should be zipped only when building locally. When running in
-  // buildbot, the Go API client will handle the zipping.
-  zipGo: isRunningLocally ? true : undefined,
-})

package/src/plugins_core/list.js

@@ -1,27 +0,0 @@
-import { fileURLToPath } from 'url'
-
-import { LOCAL_INSTALL_PLUGIN_NAME } from '../install/local.js'
-
-const FUNCTIONS_INSTALL_PLUGIN = fileURLToPath(new URL('functions_install/index.js', import.meta.url))
-
-// List of core plugin names
-const FUNCTIONS_INSTALL_PLUGIN_NAME = '@netlify/plugin-functions-install-core'
-const CORE_PLUGINS = new Set([FUNCTIONS_INSTALL_PLUGIN_NAME, LOCAL_INSTALL_PLUGIN_NAME])
-
-// Plugins that are installed and enabled by default
-export const listCorePlugins = function ({ FUNCTIONS_SRC }) {
-  const functionsInstallPlugin = getFunctionsInstallPlugin(FUNCTIONS_SRC)
-  return [functionsInstallPlugin].filter(Boolean)
-}
-
-const getFunctionsInstallPlugin = function (FUNCTIONS_SRC) {
-  if (FUNCTIONS_SRC === undefined) {
-    return
-  }
-
-  return { package: FUNCTIONS_INSTALL_PLUGIN_NAME, pluginPath: FUNCTIONS_INSTALL_PLUGIN, optional: true }
-}
-
-export const isCorePlugin = function (packageName) {
-  return CORE_PLUGINS.has(packageName)
-}

package/src/status/add.js

@@ -1,36 +0,0 @@
-// Merge plugin status to the list of plugin statuses.
-export const addStatus = function ({ newStatus, statuses, event, packageName, pluginPackageJson: { version } = {} }) {
-  // Either:
-  //  - `build.command`
-  //  - no status was set
-  if (newStatus === undefined) {
-    return statuses
-  }
-
-  const formerStatus = statuses.find((status) => status.packageName === packageName)
-  if (!canOverrideStatus(formerStatus, newStatus)) {
-    return statuses
-  }
-
-  // Overrides plugin's previous status and add more information
-  const newStatuses = statuses.filter((status) => status !== formerStatus)
-  return [...newStatuses, { ...newStatus, event, packageName, version }]
-}
-
-const canOverrideStatus = function (formerStatus, newStatus) {
-  // No previous status
-  if (formerStatus === undefined) {
-    return true
-  }
-
-  // Implicit statuses can never override
-  if (newStatus.implicit) {
-    return false
-  }
-
-  // Error statuses can only be overwritten by more severe error statuses
-  return STATES.indexOf(formerStatus.state) <= STATES.indexOf(newStatus.state)
-}
-
-// Possible status states, ordered by severity.
-const STATES = ['success', 'canceled_plugin', 'failed_plugin', 'failed_build']

package/src/status/colors.js

@@ -1,23 +0,0 @@
-import stripAnsi from 'strip-ansi'
-
-// Remove colors from statuses
-export const removeStatusesColors = function (statuses) {
-  return statuses.map(removeStatusColors)
-}
-
-const removeStatusColors = function (status) {
-  const attributes = COLOR_ATTRIBUTES.map((attribute) => removeAttrColor(status, attribute))
-  return Object.assign({}, status, ...attributes)
-}
-
-const COLOR_ATTRIBUTES = ['title', 'summary', 'text']
-
-const removeAttrColor = function (status, attribute) {
-  const value = status[attribute]
-  if (value === undefined) {
-    return {}
-  }
-
-  const valueA = stripAnsi(value)
-  return { [attribute]: valueA }
-}

package/src/status/load_error.js

@@ -1,11 +0,0 @@
-import { addErrorInfo } from '../error/info.js'
-import { getFullErrorInfo } from '../error/parse/parse.js'
-import { serializeErrorStatus } from '../error/parse/serialize_status.js'
-
-// Errors that happen during plugin loads should be reported as error statuses
-export const addPluginLoadErrorStatus = function ({ error, packageName, version, debug }) {
-  const fullErrorInfo = getFullErrorInfo({ error, colors: false, debug })
-  const errorStatus = serializeErrorStatus({ fullErrorInfo, state: 'failed_build' })
-  const statuses = [{ ...errorStatus, event: 'load', packageName, version }]
-  addErrorInfo(error, { statuses })
-}

package/src/status/report.js

@@ -1,137 +0,0 @@
-import { handleBuildError } from '../error/handle.js'
-import { logStatuses } from '../log/messages/status.js'
-
-import { removeStatusesColors } from './colors.js'
-
-// Report plugin statuses to the console and API
-export const reportStatuses = async function ({
-  statuses,
-  childEnv,
-  api,
-  mode,
-  pluginsOptions,
-  netlifyConfig,
-  errorMonitor,
-  deployId,
-  logs,
-  debug,
-  sendStatus,
-  testOpts,
-}) {
-  const finalStatuses = getFinalStatuses({ statuses, pluginsOptions })
-  if (finalStatuses.length === 0) {
-    return
-  }
-
-  const statusesA = removeStatusesColors(finalStatuses)
-  printStatuses({ statuses: statusesA, mode, logs })
-  await sendApiStatuses({
-    statuses: statusesA,
-    childEnv,
-    api,
-    mode,
-    netlifyConfig,
-    errorMonitor,
-    deployId,
-    logs,
-    debug,
-    sendStatus,
-    testOpts,
-  })
-}
-
-// Some plugins might not have completed due to a build error.
-// In that case, we add a dummy plugin run with state "skipped".
-// This allows the API to know both plugins that have completed and only started
-const getFinalStatuses = function ({ statuses = [], pluginsOptions }) {
-  return pluginsOptions.map(({ packageName }) => getPluginStatus(packageName, statuses))
-}
-
-const getPluginStatus = function (packageName, statuses) {
-  const pluginStatus = statuses.find((status) => status.packageName === packageName)
-
-  if (pluginStatus !== undefined) {
-    return pluginStatus
-  }
-
-  return { packageName, state: 'skipped' }
-}
-
-// When not in production, print statuses to console.
-// Only print successful ones, since errors are logged afterwards.
-const printStatuses = function ({ statuses, mode, logs }) {
-  if (mode === 'buildbot') {
-    return
-  }
-
-  const successStatuses = statuses.filter(shouldPrintStatus)
-
-  if (successStatuses.length === 0) {
-    return
-  }
-
-  logStatuses(logs, successStatuses)
-}
-
-const shouldPrintStatus = function ({ state, summary }) {
-  return state === 'success' && summary !== undefined
-}
-
-// In production, send statuses to the API
-const sendApiStatuses = async function ({
-  statuses,
-  childEnv,
-  api,
-  mode,
-  netlifyConfig,
-  errorMonitor,
-  deployId,
-  logs,
-  debug,
-  sendStatus,
-  testOpts,
-}) {
-  if ((mode !== 'buildbot' && !sendStatus) || api === undefined || !deployId) {
-    return
-  }
-
-  await Promise.all(
-    statuses.map((status) =>
-      sendApiStatus({ api, status, childEnv, mode, netlifyConfig, errorMonitor, deployId, logs, debug, testOpts }),
-    ),
-  )
-}
-
-const sendApiStatus = async function ({
-  api,
-  status: { packageName, version, state, event, title, summary, text, extraData },
-  childEnv,
-  mode,
-  netlifyConfig,
-  errorMonitor,
-  deployId,
-  logs,
-  debug,
-  testOpts,
-}) {
-  try {
-    await api.createPluginRun({
-      deploy_id: deployId,
-      body: {
-        package: packageName,
-        version,
-        state,
-        reporting_event: event,
-        title,
-        summary,
-        text,
-        extra_data: extraData,
-      },
-    })
-    // Bitballoon API randomly fails with 502.
-    // Builds should be successful when this API call fails, but we still want
-    // to report the error both in logs and in error monitoring.
-  } catch (error) {
-    await handleBuildError(error, { errorMonitor, netlifyConfig, childEnv, mode, logs, debug, testOpts })
-  }
-}