@netlify/build 29.0.1-rc → 29.0.2

package/src/plugins/resolve.js

@@ -1,152 +0,0 @@
-import { addErrorInfo } from '../error/info.js'
-import { installMissingPlugins } from '../install/missing.js'
-import { resolvePath, tryResolvePath } from '../utils/resolve.js'
-
-import { addExpectedVersions } from './expected_version.js'
-import { addPluginsNodeVersion } from './node_version.js'
-import { addPinnedVersions } from './pinned_version.js'
-
-// Try to find plugins in four places, by priority order:
-//  - already loaded (core plugins)
-//  - local plugin
-//  - external plugin already installed in `node_modules`, most likely through `package.json`
-//  - automatically installed by us, to `.netlify/plugins/`
-export const resolvePluginsPath = async function ({
-  pluginsOptions,
-  siteInfo,
-  buildDir,
-  nodePath,
-  packageJson,
-  userNodeVersion,
-  mode,
-  api,
-  logs,
-  debug,
-  sendStatus,
-  testOpts,
-  featureFlags,
-}) {
-  const autoPluginsDir = getAutoPluginsDir(buildDir)
-  const pluginsOptionsA = await Promise.all(
-    pluginsOptions.map((pluginOptions) => resolvePluginPath({ pluginOptions, buildDir, autoPluginsDir })),
-  )
-  const pluginsOptionsB = addPluginsNodeVersion({
-    pluginsOptions: pluginsOptionsA,
-    nodePath,
-    userNodeVersion,
-    logs,
-  })
-  const pluginsOptionsC = await addPinnedVersions({ pluginsOptions: pluginsOptionsB, api, siteInfo, sendStatus })
-  const pluginsOptionsD = await addExpectedVersions({
-    pluginsOptions: pluginsOptionsC,
-    autoPluginsDir,
-    packageJson,
-    debug,
-    logs,
-    buildDir,
-    testOpts,
-    featureFlags,
-  })
-  const pluginsOptionsE = await handleMissingPlugins({
-    pluginsOptions: pluginsOptionsD,
-    autoPluginsDir,
-    mode,
-    logs,
-  })
-  return pluginsOptionsE
-}
-
-// Find the path to the directory used to install plugins automatically.
-// It is a subdirectory of `buildDir`, so that the plugin can require the
-// project's dependencies (peer dependencies).
-const getAutoPluginsDir = function (buildDir) {
-  return `${buildDir}/${AUTO_PLUGINS_DIR}`
-}
-
-const AUTO_PLUGINS_DIR = '.netlify/plugins/'
-
-const resolvePluginPath = async function ({
-  pluginOptions,
-  pluginOptions: { packageName, loadedFrom },
-  buildDir,
-  autoPluginsDir,
-}) {
-  // Core plugins
-  if (loadedFrom !== undefined) {
-    return pluginOptions
-  }
-
-  const localPackageName = normalizeLocalPackageName(packageName)
-
-  // Local plugins
-  if (localPackageName.startsWith('.')) {
-    const { path: localPath, error } = await tryResolvePath(localPackageName, buildDir)
-    validateLocalPluginPath(error, localPackageName)
-    return { ...pluginOptions, pluginPath: localPath, loadedFrom: 'local' }
-  }
-
-  // Plugin added to `package.json`
-  const { path: manualPath } = await tryResolvePath(packageName, buildDir)
-  if (manualPath !== undefined) {
-    return { ...pluginOptions, pluginPath: manualPath, loadedFrom: 'package.json' }
-  }
-
-  // Previously automatically installed
-  const { path: automaticPath } = await tryResolvePath(packageName, autoPluginsDir)
-  if (automaticPath !== undefined) {
-    return { ...pluginOptions, pluginPath: automaticPath, loadedFrom: 'auto_install' }
-  }
-
-  // Happens if the plugin:
-  //  - name is mispelled
-  //  - is not in our official list
-  //  - is in our official list but has not been installed by this site yet
-  return { ...pluginOptions, loadedFrom: 'auto_install' }
-}
-
-// `packageName` starting with `/` are relative to the build directory
-const normalizeLocalPackageName = function (packageName) {
-  if (packageName.startsWith('/')) {
-    return `.${packageName}`
-  }
-
-  return packageName
-}
-
-// When requiring a local plugin with an invalid file path
-const validateLocalPluginPath = function (error, localPackageName) {
-  if (error !== undefined) {
-    error.message = `Plugin could not be found using local path: ${localPackageName}\n${error.message}`
-    addErrorInfo(error, { type: 'resolveConfig' })
-    throw error
-  }
-}
-
-// Install plugins from the official list that have not been previously installed.
-// Print a warning if they have not been installed through the UI.
-const handleMissingPlugins = async function ({ pluginsOptions, autoPluginsDir, mode, logs }) {
-  const missingPlugins = pluginsOptions.filter(isMissingPlugin)
-
-  if (missingPlugins.length === 0) {
-    return pluginsOptions
-  }
-
-  await installMissingPlugins({ missingPlugins, autoPluginsDir, mode, logs })
-  return await Promise.all(
-    pluginsOptions.map((pluginOptions) => resolveMissingPluginPath({ pluginOptions, autoPluginsDir })),
-  )
-}
-
-// Resolve the plugins that just got automatically installed
-const resolveMissingPluginPath = async function ({ pluginOptions, pluginOptions: { packageName }, autoPluginsDir }) {
-  if (!isMissingPlugin(pluginOptions)) {
-    return pluginOptions
-  }
-
-  const pluginPath = await resolvePath(packageName, autoPluginsDir)
-  return { ...pluginOptions, pluginPath }
-}
-
-const isMissingPlugin = function ({ isMissing }) {
-  return isMissing
-}

package/src/plugins/spawn.js

@@ -1,66 +0,0 @@
-import { fileURLToPath } from 'url'
-
-import { execaNode } from 'execa'
-
-import { addErrorInfo } from '../error/info.js'
-import { logLoadingPlugins, logOutdatedPlugins, logIncompatiblePlugins } from '../log/messages/compatibility.js'
-import { measureDuration } from '../time/main.js'
-
-import { getEventFromChild } from './ipc.js'
-import { getSpawnInfo } from './options.js'
-
-const CHILD_MAIN_FILE = fileURLToPath(new URL('child/main.js', import.meta.url))
-
-// Start child processes used by all plugins
-// We fire plugins through child processes so that:
-//  - each plugin is sandboxed, e.g. cannot access/modify its parent `process`
-//    (for both security and safety reasons)
-//  - logs can be buffered which allows manipulating them for log shipping,
-//    transforming and parallel plugins
-const tStartPlugins = async function ({ pluginsOptions, buildDir, childEnv, logs, debug }) {
-  logLoadingPlugins(logs, pluginsOptions, debug)
-  logOutdatedPlugins(logs, pluginsOptions)
-  logIncompatiblePlugins(logs, pluginsOptions)
-
-  const childProcesses = await Promise.all(
-    pluginsOptions.map(({ pluginDir, nodePath }) => startPlugin({ pluginDir, nodePath, buildDir, childEnv })),
-  )
-  return { childProcesses }
-}
-
-export const startPlugins = measureDuration(tStartPlugins, 'start_plugins')
-
-const startPlugin = async function ({ pluginDir, nodePath, buildDir, childEnv }) {
-  const childProcess = execaNode(CHILD_MAIN_FILE, {
-    cwd: buildDir,
-    preferLocal: true,
-    localDir: pluginDir,
-    nodePath,
-    execPath: nodePath,
-    env: childEnv,
-    extendEnv: false,
-    serialization: 'advanced',
-  })
-
-  try {
-    await getEventFromChild(childProcess, 'ready')
-    return { childProcess }
-  } catch (error) {
-    const spawnInfo = getSpawnInfo()
-    addErrorInfo(error, spawnInfo)
-    throw error
-  }
-}
-
-// Stop all plugins child processes
-export const stopPlugins = function (childProcesses) {
-  childProcesses.forEach(stopPlugin)
-}
-
-const stopPlugin = function ({ childProcess }) {
-  if (childProcess.connected) {
-    childProcess.disconnect()
-  }
-
-  childProcess.kill()
-}

package/src/plugins_core/add.js

@@ -1,49 +0,0 @@
-import { listCorePlugins, isCorePlugin } from './list.js'
-
-// Add core plugins and user plugins together.
-// Do not allow user override of core plugins.
-export const addCorePlugins = function ({ netlifyConfig: { plugins }, constants }) {
-  const corePlugins = listCorePlugins(constants)
-  const allCorePlugins = corePlugins
-    .map((corePlugin) => addCoreProperties(corePlugin, plugins))
-    .filter((corePlugin) => !isOptionalCore(corePlugin, plugins))
-  const userPlugins = plugins.filter(isUserPlugin)
-  const allPlugins = [...userPlugins, ...allCorePlugins]
-  const pluginsOptions = allPlugins.map(normalizePluginOptions)
-  return pluginsOptions
-}
-
-const addCoreProperties = function (corePlugin, plugins) {
-  const inputs = getCorePluginInputs(corePlugin, plugins)
-  return { ...corePlugin, inputs, loadedFrom: 'core', origin: 'core' }
-}
-
-// Core plugins can get inputs too
-const getCorePluginInputs = function (corePlugin, plugins) {
-  const configuredCorePlugin = plugins.find((plugin) => plugin.package === corePlugin.package)
-  if (configuredCorePlugin === undefined) {
-    return {}
-  }
-
-  return configuredCorePlugin.inputs
-}
-
-// Optional core plugins requires user opt-in
-const isOptionalCore = function (pluginA, plugins) {
-  return pluginA.optional && plugins.every((pluginB) => pluginB.package !== pluginA.package)
-}
-
-const isUserPlugin = function (plugin) {
-  return !isCorePlugin(plugin.package)
-}
-
-const normalizePluginOptions = function ({
-  package: packageName,
-  pluginPath,
-  pinned_version: pinnedVersion,
-  loadedFrom,
-  origin,
-  inputs,
-}) {
-  return { packageName, pluginPath, pinnedVersion, loadedFrom, origin, inputs }
-}

package/src/plugins_core/build_command.js

@@ -1,75 +0,0 @@
-import { platform } from 'process'
-
-import { execa } from 'execa'
-
-import { addErrorInfo } from '../error/info.js'
-import { getBuildCommandDescription } from '../log/description.js'
-import { logBuildCommandStart } from '../log/messages/steps.js'
-import { getBuildCommandStdio, handleBuildCommandOutput } from '../log/stream.js'
-
-// Fire `build.command`
-const coreStep = async function ({
-  configPath,
-  buildDir,
-  nodePath,
-  childEnv,
-  logs,
-  netlifyConfig: {
-    build: { command: buildCommand, commandOrigin: buildCommandOrigin },
-  },
-}) {
-  logBuildCommandStart(logs, buildCommand)
-
-  const stdio = getBuildCommandStdio(logs)
-  const childProcess = execa(buildCommand, {
-    shell: SHELL,
-    cwd: buildDir,
-    preferLocal: true,
-    execPath: nodePath,
-    env: childEnv,
-    extendEnv: false,
-    stdio,
-  })
-
-  try {
-    const buildCommandOutput = await childProcess
-    handleBuildCommandOutput(buildCommandOutput, logs)
-    return {}
-  } catch (error) {
-    // In our test environment we use `stdio: 'pipe'` on the build command, meaning our `stdout/stderr` output are
-    // buffered and consequently added to `error.message`. To avoid this and end up with duplicated output in our
-    // logs/snapshots we need to rely on `error.shortMessage`.
-    error.message = error.shortMessage
-    handleBuildCommandOutput(error, logs)
-    addErrorInfo(error, { type: 'buildCommand', location: { buildCommand, buildCommandOrigin, configPath } })
-    throw error
-  }
-}
-
-// We use Bash on Unix and `cmd.exe` on Windows
-const SHELL = platform === 'win32' ? true : 'bash'
-
-const coreStepDescription = function ({
-  netlifyConfig: {
-    build: { commandOrigin: buildCommandOrigin },
-  },
-}) {
-  return getBuildCommandDescription(buildCommandOrigin)
-}
-
-const hasBuildCommand = function ({
-  netlifyConfig: {
-    build: { command: buildCommand },
-  },
-}) {
-  return buildCommand !== undefined && buildCommand !== ''
-}
-
-export const buildCommandCore = {
-  event: 'onBuild',
-  coreStep,
-  coreStepId: 'build_command',
-  coreStepName: 'build.command',
-  coreStepDescription,
-  condition: hasBuildCommand,
-}

package/src/plugins_core/deploy/buildbot_client.js

@@ -1,102 +0,0 @@
-import net from 'net'
-import { normalize, resolve, relative } from 'path'
-import { promisify } from 'util'
-
-import { pEvent } from 'p-event'
-
-import { addErrorInfo } from '../../error/info.js'
-import { runsAfterDeploy } from '../../plugins/events.js'
-import { addAsyncErrorMessage } from '../../utils/errors.js'
-
-export const createBuildbotClient = function (buildbotServerSocket) {
-  const connectionOpts = getConnectionOpts(buildbotServerSocket)
-  const client = net.createConnection(connectionOpts)
-  return client
-}
-
-// Windows does not support Unix sockets well, so we also support `host:port`
-const getConnectionOpts = function (buildbotServerSocket) {
-  if (!buildbotServerSocket.includes(':')) {
-    return { path: buildbotServerSocket }
-  }
-
-  const [host, port] = buildbotServerSocket.split(':')
-  return { host, port }
-}
-
-const eConnectBuildbotClient = async function (client) {
-  await pEvent(client, 'connect')
-}
-
-export const connectBuildbotClient = addAsyncErrorMessage(eConnectBuildbotClient, 'Could not connect to buildbot')
-
-export const closeBuildbotClient = async function (client) {
-  if (client.destroyed) {
-    return
-  }
-
-  await promisify(client.end.bind(client))()
-}
-
-const cWritePayload = async function (buildbotClient, payload) {
-  await promisify(buildbotClient.write.bind(buildbotClient))(JSON.stringify(payload))
-}
-
-const writePayload = addAsyncErrorMessage(cWritePayload, 'Could not send payload to buildbot')
-
-const cGetNextParsedResponsePromise = async function (buildbotClient) {
-  const data = await pEvent(buildbotClient, 'data')
-  return JSON.parse(data)
-}
-
-const getNextParsedResponsePromise = addAsyncErrorMessage(
-  cGetNextParsedResponsePromise,
-  'Invalid response from buildbot',
-)
-
-export const deploySiteWithBuildbotClient = async function ({ client, events, buildDir, repositoryRoot, constants }) {
-  const action = shouldWaitForPostProcessing(events) ? 'deploySiteAndAwaitLive' : 'deploySite'
-  const deployDir = getDeployDir({ buildDir, repositoryRoot, constants })
-  const payload = { action, deployDir }
-
-  const [{ succeeded, values: { error, error_type: errorType } = {} }] = await Promise.all([
-    getNextParsedResponsePromise(client),
-    writePayload(client, payload),
-  ])
-
-  if (!succeeded) {
-    return handleDeployError(error, errorType)
-  }
-}
-
-// The file paths in the buildbot are relative to the repository root.
-// However, the file paths in Build plugins, including `constants.PUBLISH_DIR`
-// are relative to the build directory, which is different when there is a
-// base directory. This converts it.
-// We need to call `normalize()` in case the publish directory is the
-// repository root, so `deployDir` is "." not ""
-const getDeployDir = function ({ buildDir, repositoryRoot, constants: { PUBLISH_DIR } }) {
-  const absolutePublishDir = resolve(buildDir, PUBLISH_DIR)
-  const relativePublishDir = relative(repositoryRoot, absolutePublishDir)
-  const deployDir = normalize(relativePublishDir)
-  return deployDir
-}
-
-// We distinguish between user errors and system errors during deploys
-const handleDeployError = function (error, errorType) {
-  const errorA = new Error(`Deploy did not succeed: ${error}`)
-  const errorInfo =
-    errorType === 'user' ? { type: 'resolveConfig' } : { type: 'coreStep', location: { coreStepName: 'Deploy site' } }
-  addErrorInfo(errorA, errorInfo)
-  throw errorA
-}
-
-// We only wait for post-processing (last stage before site deploy) if the build
-// has some plugins that do post-deploy logic
-const shouldWaitForPostProcessing = function (events) {
-  return events.some(hasPostDeployLogic)
-}
-
-const hasPostDeployLogic = function (event) {
-  return runsAfterDeploy(event)
-}

package/src/plugins_core/deploy/index.js

@@ -1,73 +0,0 @@
-import { saveUpdatedConfig, restoreUpdatedConfig } from '../../core/config.js'
-import { logDeploySuccess } from '../../log/messages/plugins.js'
-
-import {
-  createBuildbotClient,
-  connectBuildbotClient,
-  closeBuildbotClient,
-  deploySiteWithBuildbotClient,
-} from './buildbot_client.js'
-
-const coreStep = async function ({
-  buildDir,
-  configPath,
-  repositoryRoot,
-  constants,
-  buildbotServerSocket,
-  events,
-  logs,
-  featureFlags,
-  context,
-  branch,
-  configMutations,
-  headersPath,
-  redirectsPath,
-  debug,
-  saveConfig,
-}) {
-  const client = createBuildbotClient(buildbotServerSocket)
-  try {
-    await connectBuildbotClient(client)
-    await saveUpdatedConfig({
-      configMutations,
-      buildDir,
-      repositoryRoot,
-      configPath,
-      headersPath,
-      redirectsPath,
-      logs,
-      featureFlags,
-      context,
-      branch,
-      debug,
-      saveConfig,
-    })
-    await deploySiteWithBuildbotClient({ client, events, buildDir, repositoryRoot, constants })
-    await restoreUpdatedConfig({
-      configMutations,
-      buildDir,
-      repositoryRoot,
-      configPath,
-      headersPath,
-      redirectsPath,
-      saveConfig,
-    })
-    logDeploySuccess(logs)
-    return {}
-  } finally {
-    await closeBuildbotClient(client)
-  }
-}
-
-const shouldDeploy = function ({ buildbotServerSocket }) {
-  return buildbotServerSocket !== undefined
-}
-
-export const deploySite = {
-  event: 'onPostBuild',
-  coreStep,
-  coreStepId: 'deploy_site',
-  coreStepName: 'Deploy site',
-  coreStepDescription: () => 'Deploy site',
-  condition: shouldDeploy,
-}

package/src/plugins_core/edge_functions/index.js

@@ -1,123 +0,0 @@
-import { promises as fs } from 'fs'
-import { dirname, join, resolve } from 'path'
-
-import { bundle, find } from '@netlify/edge-bundler'
-import { pathExists } from 'path-exists'
-
-import { logFunctionsToBundle } from '../../log/messages/core_steps.js'
-
-import { tagBundlingError } from './lib/error.js'
-import { parseManifest } from './lib/internal_manifest.js'
-import { validateEdgeFunctionsManifest } from './validate_manifest/validate_edge_functions_manifest.js'
-
-// TODO: Replace this with a custom cache directory.
-const DENO_CLI_CACHE_DIRECTORY = '.netlify/plugins/deno-cli'
-const IMPORT_MAP_FILENAME = 'edge-functions-import-map.json'
-
-// eslint-disable-next-line complexity, max-statements
-const coreStep = async function ({
-  buildDir,
-  constants: {
-    EDGE_FUNCTIONS_DIST: distDirectory,
-    EDGE_FUNCTIONS_SRC: srcDirectory,
-    INTERNAL_EDGE_FUNCTIONS_SRC: internalSrcDirectory,
-    IS_LOCAL: isRunningLocally,
-  },
-  debug,
-  systemLog,
-  featureFlags,
-  logs,
-  netlifyConfig,
-}) {
-  const { edge_functions: configDeclarations = [] } = netlifyConfig
-  const distPath = resolve(buildDir, distDirectory)
-  const internalSrcPath = resolve(buildDir, internalSrcDirectory)
-  const distImportMapPath = join(dirname(internalSrcPath), IMPORT_MAP_FILENAME)
-  const srcPath = srcDirectory ? resolve(buildDir, srcDirectory) : undefined
-  const sourcePaths = [internalSrcPath, srcPath].filter(Boolean)
-
-  logFunctions({ internalSrcDirectory, internalSrcPath, logs, srcDirectory, srcPath })
-
-  const { declarations: internalDeclarations, importMap } = await parseManifest(internalSrcPath)
-  const declarations = [...configDeclarations, ...internalDeclarations]
-
-  // If we're running in buildbot and the feature flag is enabled, we set the
-  // Deno cache dir to a directory that is persisted between builds.
-  const cacheDirectory =
-    !isRunningLocally && featureFlags.edge_functions_cache_cli ? resolve(buildDir, DENO_CLI_CACHE_DIRECTORY) : undefined
-
-  // Edge Bundler expects the dist directory to exist.
-  await fs.mkdir(distPath, { recursive: true })
-
-  try {
-    const { manifest } = await bundle(sourcePaths, distPath, declarations, {
-      basePath: buildDir,
-      cacheDirectory,
-      debug,
-      distImportMapPath,
-      featureFlags,
-      importMaps: [importMap].filter(Boolean),
-      systemLogger: featureFlags.edge_functions_system_logger ? systemLog : undefined,
-    })
-
-    systemLog('Edge Functions manifest:', manifest)
-  } catch (error) {
-    tagBundlingError(error)
-
-    throw error
-  }
-
-  await validateEdgeFunctionsManifest({ buildDir, constants: { EDGE_FUNCTIONS_DIST: distDirectory } })
-
-  return {}
-}
-
-// 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 hasEdgeFunctionsDirectories = async function ({
-  buildDir,
-  constants: { INTERNAL_EDGE_FUNCTIONS_SRC, EDGE_FUNCTIONS_SRC },
-}) {
-  const hasFunctionsSrc = EDGE_FUNCTIONS_SRC !== undefined && EDGE_FUNCTIONS_SRC !== ''
-
-  if (hasFunctionsSrc) {
-    return true
-  }
-
-  const internalFunctionsSrc = resolve(buildDir, INTERNAL_EDGE_FUNCTIONS_SRC)
-
-  return await pathExists(internalFunctionsSrc)
-}
-
-const logFunctions = async ({
-  internalSrcDirectory,
-  internalSrcPath,
-  logs,
-  srcDirectory: userFunctionsSrc,
-  srcPath,
-}) => {
-  const [userFunctions, internalFunctions] = await Promise.all([find([srcPath]), find([internalSrcPath])])
-  const userFunctionsSrcExists = await pathExists(srcPath)
-  const internalFunctionsSrc = internalSrcDirectory
-
-  logFunctionsToBundle({
-    logs,
-    userFunctions: userFunctions.map(({ name }) => name),
-    userFunctionsSrc,
-    userFunctionsSrcExists,
-    internalFunctions: internalFunctions.map(({ name }) => name),
-    internalFunctionsSrc,
-    type: 'Edge Functions',
-  })
-}
-
-export const bundleEdgeFunctions = {
-  event: 'onBuild',
-  coreStep,
-  coreStepId: 'edge_functions_bundling',
-  coreStepName: 'Edge Functions bundling',
-  coreStepDescription: () => 'Edge Functions bundling',
-  condition: hasEdgeFunctionsDirectories,
-}

package/src/plugins_core/edge_functions/lib/internal_manifest.js

@@ -1,54 +0,0 @@
-import { promises as fs } from 'fs'
-import { dirname, join, resolve } from 'path'
-
-const parseManifest = async (internalSourceDirectory) => {
-  const manifestPath = join(internalSourceDirectory, 'manifest.json')
-
-  try {
-    const data = await fs.readFile(manifestPath)
-    const manifest = JSON.parse(data)
-
-    if (manifest.version !== 1) {
-      throw new Error('Unsupported manifest version')
-    }
-
-    const result = {
-      declarations: manifest.functions,
-    }
-
-    if (manifest.import_map) {
-      const importMapPath = resolve(dirname(manifestPath), manifest.import_map)
-      const importMap = await readImportMap(importMapPath)
-
-      return {
-        ...result,
-        importMap,
-      }
-    }
-
-    return result
-  } catch {
-    // no-op
-  }
-
-  return {
-    declarations: [],
-  }
-}
-
-const readImportMap = async (path) => {
-  try {
-    const data = await fs.readFile(path)
-    const importMap = JSON.parse(data)
-
-    return importMap
-  } catch {
-    // no-op
-  }
-
-  return {
-    imports: {},
-  }
-}
-
-export { parseManifest }