@netlify/build 29.18.0 → 29.19.0-rc.0

package/lib/core/build.js

@@ -33,12 +33,13 @@ export const startBuild = function (flags) {
     const rootTracingContext = startTracing(tracingOpts, getSystemLogger(logs, debug, systemLogFile));
     return { ...flagsA, rootTracingContext, debug, systemLogFile, errorMonitor, logs, timers };
 };
-const tExecBuild = async function ({ config, defaultConfig, cachedConfig, cachedConfigPath, outputConfigPath, cwd, repositoryRoot, apiHost, token, siteId, context, branch, baseRelDir, env: envOpt, debug, systemLogFile, verbose, nodePath, functionsDistDir, edgeFunctionsDistDir, cacheDir, dry, mode, offline, deployId, buildId, testOpts, errorMonitor, errorParams, logs, timers, buildbotServerSocket, sendStatus, saveConfig, featureFlags, timeline, devCommand, quiet, framework, explicitSecretKeys, }) {
+const tExecBuild = async function ({ config, defaultConfig, cachedConfig, cachedConfigPath, outputConfigPath, cwd, packagePath, repositoryRoot, apiHost, token, siteId, context, branch, baseRelDir, env: envOpt, debug, systemLogFile, verbose, nodePath, functionsDistDir, edgeFunctionsDistDir, cacheDir, dry, mode, offline, deployId, buildId, testOpts, errorMonitor, errorParams, logs, timers, buildbotServerSocket, sendStatus, saveConfig, featureFlags, timeline, devCommand, quiet, framework, explicitSecretKeys, }) {
     const configOpts = getConfigOpts({
         config,
         defaultConfig,
         cwd,
         repositoryRoot,
+        packagePath,
         apiHost,
         token,
         siteId,
@@ -81,6 +82,7 @@ const tExecBuild = async function ({ config, defaultConfig, cachedConfig, cached
         functionsDistDir,
         edgeFunctionsDistDir,
         cacheDir,
+        packagePath,
         netlifyConfig,
         siteInfo,
         apiHost,
@@ -103,6 +105,7 @@ const tExecBuild = async function ({ config, defaultConfig, cachedConfig, cached
         redirectsPath,
         buildDir,
         repositoryRoot: repositoryRootA,
+        packagePath,
         nodePath,
         packageJson,
         userNodeVersion,
@@ -145,7 +148,7 @@ const tExecBuild = async function ({ config, defaultConfig, cachedConfig, cached
 };
 export const execBuild = measureDuration(tExecBuild, 'total', { parentTag: 'build_site' });
 // Runs a build then report any plugin statuses
-export const runAndReportBuild = async function ({ pluginsOptions, netlifyConfig, configOpts, siteInfo, configPath, outputConfigPath, headersPath, redirectsPath, buildDir, repositoryRoot, nodePath, packageJson, userNodeVersion, childEnv, context, branch, buildbotServerSocket, constants, dry, mode, api, errorMonitor, deployId, errorParams, logs, debug, systemLog, verbose, timers, sendStatus, saveConfig, testOpts, featureFlags, timeline, devCommand, quiet, integrations, explicitSecretKeys, }) {
+export const runAndReportBuild = async function ({ pluginsOptions, netlifyConfig, configOpts, siteInfo, configPath, outputConfigPath, headersPath, redirectsPath, packagePath, buildDir, repositoryRoot, nodePath, packageJson, userNodeVersion, childEnv, context, branch, buildbotServerSocket, constants, dry, mode, api, errorMonitor, deployId, errorParams, logs, debug, systemLog, verbose, timers, sendStatus, saveConfig, testOpts, featureFlags, timeline, devCommand, quiet, integrations, explicitSecretKeys, }) {
     try {
         const { stepsCount, netlifyConfig: netlifyConfigA, statuses, pluginsOptions: pluginsOptionsA, failedPlugins, timers: timersA, configMutations, metrics, } = await initAndRunBuild({
             pluginsOptions,
@@ -157,6 +160,7 @@ export const runAndReportBuild = async function ({ pluginsOptions, netlifyConfig
             headersPath,
             redirectsPath,
             buildDir,
+            packagePath,
             repositoryRoot,
             nodePath,
             packageJson,
@@ -246,13 +250,14 @@ export const runAndReportBuild = async function ({ pluginsOptions, netlifyConfig
     }
 };
 // Initialize plugin processes then runs a build
-const initAndRunBuild = async function ({ pluginsOptions, netlifyConfig, configOpts, siteInfo, configPath, outputConfigPath, headersPath, redirectsPath, buildDir, repositoryRoot, nodePath, packageJson, userNodeVersion, childEnv, context, branch, dry, mode, api, errorMonitor, deployId, errorParams, logs, debug, systemLog, verbose, sendStatus, saveConfig, timers, testOpts, buildbotServerSocket, constants, featureFlags, timeline, devCommand, quiet, integrations, explicitSecretKeys, }) {
+const initAndRunBuild = async function ({ pluginsOptions, netlifyConfig, configOpts, siteInfo, configPath, outputConfigPath, headersPath, redirectsPath, buildDir, packagePath, repositoryRoot, nodePath, packageJson, userNodeVersion, childEnv, context, branch, dry, mode, api, errorMonitor, deployId, errorParams, logs, debug, systemLog, verbose, sendStatus, saveConfig, timers, testOpts, buildbotServerSocket, constants, featureFlags, timeline, devCommand, quiet, integrations, explicitSecretKeys, }) {
     const { pluginsOptions: pluginsOptionsA, timers: timersA } = await getPluginsOptions({
         pluginsOptions,
         netlifyConfig,
         siteInfo,
         buildDir,
         nodePath,
+        packagePath,
         packageJson,
         userNodeVersion,
         mode,
@@ -289,6 +294,7 @@ const initAndRunBuild = async function ({ pluginsOptions, netlifyConfig, configO
             headersPath,
             redirectsPath,
             buildDir,
+            packagePath,
             repositoryRoot,
             nodePath,
             childEnv,
@@ -341,7 +347,7 @@ const initAndRunBuild = async function ({ pluginsOptions, netlifyConfig, configO
 };
 // Load plugin main files, retrieve their event handlers then runs them,
 // together with the build command
-const runBuild = async function ({ childProcesses, pluginsOptions, netlifyConfig, configOpts, packageJson, configPath, outputConfigPath, userNodeVersion, headersPath, redirectsPath, buildDir, repositoryRoot, nodePath, childEnv, context, branch, dry, buildbotServerSocket, constants, mode, api, errorMonitor, deployId, errorParams, logs, debug, systemLog, verbose, saveConfig, timers, testOpts, featureFlags, timeline, devCommand, quiet, explicitSecretKeys, }) {
+const runBuild = async function ({ childProcesses, pluginsOptions, netlifyConfig, configOpts, packageJson, configPath, outputConfigPath, userNodeVersion, headersPath, redirectsPath, buildDir, repositoryRoot, packagePath, nodePath, childEnv, context, branch, dry, buildbotServerSocket, constants, mode, api, errorMonitor, deployId, errorParams, logs, debug, systemLog, verbose, saveConfig, timers, testOpts, featureFlags, timeline, devCommand, quiet, explicitSecretKeys, }) {
     const { pluginsSteps, timers: timersA } = await loadPlugins({
         pluginsOptions,
         childProcesses,
@@ -366,6 +372,7 @@ const runBuild = async function ({ childProcesses, pluginsOptions, netlifyConfig
         redirectsPath,
         buildDir,
         repositoryRoot,
+        packagePath,
         nodePath,
         childEnv,
         context,

package/lib/core/config.js

@@ -15,11 +15,12 @@ import { getUserNodeVersion } from './user_node_version.js';
 //    the build
 //  - If plugins change the configuration, `configMutations` is used instead
 // In both cases, almost all options should remain the same.
-export const getConfigOpts = function ({ config, defaultConfig, cwd, repositoryRoot, apiHost, token, siteId, context, branch, baseRelDir, envOpt, mode, offline, deployId, buildId, testOpts, featureFlags, }) {
+export const getConfigOpts = function ({ config, defaultConfig, cwd, repositoryRoot, packagePath, apiHost, token, siteId, context, branch, baseRelDir, envOpt, mode, offline, deployId, buildId, testOpts, featureFlags, }) {
     return {
         config,
         defaultConfig,
         cwd,
+        packagePath,
         repositoryRoot,
         context,
         branch,

package/lib/core/constants.js

@@ -4,12 +4,14 @@ import mapObj from 'map-obj';
 import { pathExists } from 'path-exists';
 import { ROOT_PACKAGE_JSON } from '../utils/json.js';
 // Retrieve constants passed to plugins
-export const getConstants = async function ({ configPath, buildDir, functionsDistDir, edgeFunctionsDistDir, cacheDir, netlifyConfig, siteInfo: { id: siteId }, apiHost, token, mode, }) {
+export const getConstants = async function ({ configPath, buildDir, packagePath, functionsDistDir, edgeFunctionsDistDir, cacheDir, netlifyConfig, siteInfo: { id: siteId }, apiHost, token, mode, }) {
     const isLocal = mode !== 'buildbot';
     const normalizedCacheDir = getCacheDir({ cacheDir, cwd: buildDir });
     const constants = {
         // Path to the Netlify configuration file
         CONFIG_PATH: configPath,
+        // In monorepos this is the path that is used to point to a package that should be deployed
+        PACKAGE_PATH: packagePath,
         // The directory where built serverless functions are placed before deployment
         FUNCTIONS_DIST: functionsDistDir,
         // The directory where built Edge Functions are placed before deployment

package/lib/core/flags.js

@@ -43,6 +43,10 @@ Default: current directory`,
         describe: `Git repository root directory. Used to retrieve the configuration file.
 Default: automatically guessed`,
     },
+    packagePath: {
+        string: true,
+        describe: `When using a monorepo, specifies the relative path from the repository root to the package being built`,
+    },
     apiHost: {
         string: true,
         describe: `Netlify API endpoint.

package/lib/plugins/options.js

@@ -8,12 +8,13 @@ import { getPackageJson } from '../utils/package.js';
 import { useManifest } from './manifest/main.js';
 import { resolvePluginsPath } from './resolve.js';
 // Load core plugins and user plugins
-const tGetPluginsOptions = async function ({ pluginsOptions, netlifyConfig: { plugins }, siteInfo, buildDir, nodePath, packageJson, userNodeVersion, mode, api, logs, debug, sendStatus, testOpts, featureFlags, integrations, }) {
+const tGetPluginsOptions = async function ({ pluginsOptions, netlifyConfig: { plugins }, siteInfo, buildDir, packagePath, nodePath, packageJson, userNodeVersion, mode, api, logs, debug, sendStatus, testOpts, featureFlags, integrations, }) {
     const pluginsOptionsA = await resolvePluginsPath({
         pluginsOptions,
         siteInfo,
         buildDir,
         nodePath,
+        packagePath,
         packageJson,
         userNodeVersion,
         mode,

package/lib/plugins/resolve.js

@@ -1,16 +1,18 @@
+import { join } from 'path';
 import { addErrorInfo } from '../error/info.js';
 import { installMissingPlugins, installIntegrationPlugins } 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';
+const AUTO_PLUGINS_DIR = '.netlify/plugins/';
 // 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, integrations, }) {
-    const autoPluginsDir = getAutoPluginsDir(buildDir);
+export const resolvePluginsPath = async function ({ pluginsOptions, siteInfo, buildDir, packagePath, nodePath, packageJson, userNodeVersion, mode, api, logs, debug, sendStatus, testOpts, featureFlags, integrations, }) {
+    const autoPluginsDir = getAutoPluginsDir(buildDir, packagePath);
     const pluginsOptionsA = await Promise.all(pluginsOptions.map((pluginOptions) => resolvePluginPath({ pluginOptions, buildDir, autoPluginsDir })));
     const pluginsOptionsB = addPluginsNodeVersion({
         pluginsOptions: pluginsOptionsA,
@@ -41,13 +43,17 @@ export const resolvePluginsPath = async function ({ pluginsOptions, siteInfo, bu
     }
     return [...pluginsOptionsE, ...integrationPluginOptions];
 };
-// 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}`;
+/**
+ * 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).
+ * @param {string} buildDir
+ * @param {string} [packagePath]
+ * @returns
+ */
+const getAutoPluginsDir = function (buildDir, packagePath) {
+    return join(buildDir, packagePath || '', AUTO_PLUGINS_DIR);
 };
-const AUTO_PLUGINS_DIR = '.netlify/plugins/';
 const resolvePluginPath = async function ({ pluginOptions, pluginOptions: { packageName, loadedFrom }, buildDir, autoPluginsDir, }) {
     // Core plugins
     if (loadedFrom !== undefined) {

package/lib/plugins_core/deploy/index.js

@@ -1,13 +1,14 @@
 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 coreStep = async function ({ buildDir, configPath, repositoryRoot, packagePath, constants, buildbotServerSocket, events, logs, featureFlags, context, branch, configMutations, headersPath, redirectsPath, debug, saveConfig, }) {
     const client = createBuildbotClient(buildbotServerSocket);
     try {
         await connectBuildbotClient(client);
         await saveUpdatedConfig({
             configMutations,
             buildDir,
+            packagePath,
             repositoryRoot,
             configPath,
             headersPath,

package/lib/plugins_core/edge_functions/index.js

@@ -8,11 +8,11 @@ import { validateEdgeFunctionsManifest } from './validate_manifest/validate_edge
 // 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';
-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 coreStep = async function ({ buildDir, packagePath, 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: declarations = [] } = netlifyConfig;
     const { deno_import_map: userDefinedImportMap } = netlifyConfig.functions['*'];
-    const distPath = resolve(buildDir, distDirectory);
-    const internalSrcPath = resolve(buildDir, internalSrcDirectory);
+    const distPath = resolve(buildDir, packagePath || '', distDirectory);
+    const internalSrcPath = resolve(buildDir, packagePath || '', internalSrcDirectory);
     const distImportMapPath = join(dirname(internalSrcPath), IMPORT_MAP_FILENAME);
     const srcPath = srcDirectory ? resolve(buildDir, srcDirectory) : undefined;
     const sourcePaths = [internalSrcPath, srcPath].filter(Boolean);
@@ -72,12 +72,12 @@ const getMetrics = (manifest) => {
 // 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 hasEdgeFunctionsDirectories = async function ({ buildDir, packagePath, 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);
+    const internalFunctionsSrc = resolve(buildDir, packagePath || '', INTERNAL_EDGE_FUNCTIONS_SRC);
     return await pathExists(internalFunctionsSrc);
 };
 const logFunctions = async ({ internalSrcDirectory, internalSrcPath, logs, srcDirectory: userFunctionsSrc, srcPath, }) => {

package/lib/plugins_core/functions/index.js

@@ -39,10 +39,10 @@ const zipFunctionsAndLogResults = async ({ buildDir, childEnv, featureFlags, fun
     }
 };
 // Plugin to package Netlify functions with @netlify/zip-it-and-ship-it
-const coreStep = async function ({ childEnv, constants: { INTERNAL_FUNCTIONS_SRC: relativeInternalFunctionsSrc, IS_LOCAL: isRunningLocally, FUNCTIONS_SRC: relativeFunctionsSrc, FUNCTIONS_DIST: relativeFunctionsDist, }, buildDir, logs, netlifyConfig, featureFlags, repositoryRoot, userNodeVersion, systemLog, }) {
+const coreStep = async function ({ childEnv, constants: { INTERNAL_FUNCTIONS_SRC: relativeInternalFunctionsSrc, IS_LOCAL: isRunningLocally, FUNCTIONS_SRC: relativeFunctionsSrc, FUNCTIONS_DIST: relativeFunctionsDist, }, buildDir, packagePath, logs, netlifyConfig, featureFlags, repositoryRoot, userNodeVersion, systemLog, }) {
     const functionsSrc = relativeFunctionsSrc === undefined ? undefined : resolve(buildDir, relativeFunctionsSrc);
-    const functionsDist = resolve(buildDir, relativeFunctionsDist);
-    const internalFunctionsSrc = resolve(buildDir, relativeInternalFunctionsSrc);
+    const functionsDist = resolve(buildDir, packagePath || '', relativeFunctionsDist);
+    const internalFunctionsSrc = resolve(buildDir, packagePath || '', relativeInternalFunctionsSrc);
     const internalFunctionsSrcExists = await pathExists(internalFunctionsSrc);
     const functionsSrcExists = await validateFunctionsSrc({ functionsSrc, relativeFunctionsSrc });
     const [userFunctions = [], internalFunctions = []] = await getUserAndInternalFunctions({
@@ -95,12 +95,12 @@ const coreStep = async function ({ childEnv, constants: { INTERNAL_FUNCTIONS_SRC
 // 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 hasFunctionsDirectories = async function ({ buildDir, packagePath, constants: { INTERNAL_FUNCTIONS_SRC, FUNCTIONS_SRC }, }) {
     const hasFunctionsSrc = FUNCTIONS_SRC !== undefined && FUNCTIONS_SRC !== '';
     if (hasFunctionsSrc) {
         return true;
     }
-    const internalFunctionsSrc = resolve(buildDir, INTERNAL_FUNCTIONS_SRC);
+    const internalFunctionsSrc = resolve(buildDir, packagePath || '', INTERNAL_FUNCTIONS_SRC);
     return await pathExists(internalFunctionsSrc);
 };
 export const bundleFunctions = {

package/lib/plugins_core/save_artifacts/index.js

@@ -1,11 +1,12 @@
 import { saveUpdatedConfig } from '../../core/config.js';
 import { shouldDeploy } from '../deploy/index.js';
-const coreStep = async function ({ buildDir, configPath, outputConfigPath, repositoryRoot, logs, featureFlags, context, branch, configMutations, headersPath, redirectsPath, debug, saveConfig, }) {
+const coreStep = async function ({ buildDir, configPath, packagePath, outputConfigPath, repositoryRoot, logs, featureFlags, context, branch, configMutations, headersPath, redirectsPath, debug, saveConfig, }) {
     await saveUpdatedConfig({
         configMutations,
         buildDir,
         repositoryRoot,
         configPath,
+        packagePath,
         outputConfigPath,
         headersPath,
         redirectsPath,

package/lib/steps/core_step.js

@@ -2,7 +2,7 @@ import { setEnvChanges } from '../env/changes.js';
 import { addErrorInfo, isBuildError } from '../error/info.js';
 import { updateNetlifyConfig, listConfigSideFiles } from './update_config.js';
 // Fire a core step
-export const fireCoreStep = async function ({ coreStep, coreStepId, coreStepName, configPath, outputConfigPath, buildDir, repositoryRoot, constants, buildbotServerSocket, events, logs, nodePath, childEnv, context, branch, envChanges, errorParams, configOpts, netlifyConfig, configMutations, headersPath, redirectsPath, featureFlags, debug, systemLog, saveConfig, userNodeVersion, explicitSecretKeys, }) {
+export const fireCoreStep = async function ({ coreStep, coreStepId, coreStepName, configPath, outputConfigPath, buildDir, repositoryRoot, packagePath, constants, buildbotServerSocket, events, logs, nodePath, childEnv, context, branch, envChanges, errorParams, configOpts, netlifyConfig, configMutations, headersPath, redirectsPath, featureFlags, debug, systemLog, saveConfig, userNodeVersion, explicitSecretKeys, }) {
     try {
         const configSideFiles = await listConfigSideFiles([headersPath, redirectsPath]);
         const childEnvA = setEnvChanges(envChanges, { ...childEnv });
@@ -12,6 +12,7 @@ export const fireCoreStep = async function ({ coreStep, coreStepId, coreStepName
             buildDir,
             repositoryRoot,
             constants,
+            packagePath,
             buildbotServerSocket,
             events,
             logs,

package/lib/steps/plugin.js

@@ -6,7 +6,7 @@ import { getSuccessStatus } from '../status/success.js';
 import { getPluginErrorType } from './error.js';
 import { updateNetlifyConfig, listConfigSideFiles } from './update_config.js';
 // Fire a plugin step
-export const firePluginStep = async function ({ event, childProcess, packageName, pluginPackageJson, loadedFrom, origin, envChanges, errorParams, configOpts, netlifyConfig, configMutations, headersPath, redirectsPath, constants, steps, error, logs, featureFlags, debug, verbose, }) {
+export const firePluginStep = async function ({ event, childProcess, packageName, packagePath, pluginPackageJson, loadedFrom, origin, envChanges, errorParams, configOpts, netlifyConfig, configMutations, headersPath, redirectsPath, constants, steps, error, logs, featureFlags, debug, verbose, }) {
     const listeners = pipePluginOutput(childProcess, logs);
     const isTrustedPlugin = pluginPackageJson?.name?.startsWith('@netlify/');
     try {
@@ -29,6 +29,7 @@ export const firePluginStep = async function ({ event, childProcess, packageName
             configOpts,
             netlifyConfig,
             headersPath,
+            packagePath,
             redirectsPath,
             configMutations,
             newConfigMutations,

package/lib/steps/run_core_steps.js

@@ -39,13 +39,14 @@ const getBuildSteps = function (buildSteps) {
     const allSteps = getSteps([]).steps.filter(({ coreStepId }) => buildSteps.includes(coreStepId));
     return allSteps;
 };
-const executeBuildStep = async function ({ config, defaultConfig, cachedConfig, debug, nodePath, functionsDistDir, edgeFunctionsDistDir, errorMonitor, mode, logs, errorParams, featureFlags, buildSteps, repositoryRoot, systemLog, }) {
+const executeBuildStep = async function ({ config, packagePath, defaultConfig, cachedConfig, debug, nodePath, functionsDistDir, edgeFunctionsDistDir, errorMonitor, mode, logs, errorParams, featureFlags, buildSteps, repositoryRoot, systemLog, }) {
     const configOpts = getConfigOpts({
         config,
         defaultConfig,
         featureFlags,
         mode,
         repositoryRoot,
+        packagePath,
     });
     const { netlifyConfig, buildDir, siteInfo, childEnv, userNodeVersion, repositoryRoot: repositoryRootA, } = await loadConfig({
         configOpts,
@@ -58,6 +59,7 @@ const executeBuildStep = async function ({ config, defaultConfig, cachedConfig,
     const constants = await getConstants({
         buildDir,
         functionsDistDir,
+        packagePath,
         edgeFunctionsDistDir,
         netlifyConfig,
         siteInfo,

package/lib/steps/run_step.js

@@ -10,11 +10,13 @@ import { firePluginStep } from './plugin.js';
 import { getStepReturn } from './return.js';
 const tracer = trace.getTracer('steps');
 // Run a step (core, build command or plugin)
-export const runStep = async function ({ event, childProcess, packageName, coreStep, coreStepId, coreStepName, coreStepDescription, pluginPackageJson, loadedFrom, origin, condition, configPath, outputConfigPath, buildDir, repositoryRoot, nodePath, index, childEnv, context, branch, envChanges, constants, steps, buildbotServerSocket, events, mode, api, errorMonitor, deployId, errorParams, error, failedPlugins, configOpts, netlifyConfig, configMutations, headersPath, redirectsPath, logs, debug, systemLog, verbose, saveConfig, timers, testOpts, featureFlags, quiet, userNodeVersion, explicitSecretKeys, }) {
+export const runStep = async function ({ event, childProcess, packageName, coreStep, coreStepId, coreStepName, coreStepDescription, pluginPackageJson, loadedFrom, origin, condition, configPath, outputConfigPath, buildDir, packagePath, repositoryRoot, nodePath, index, childEnv, context, branch, envChanges, constants, steps, buildbotServerSocket, events, mode, api, errorMonitor, deployId, errorParams, error, failedPlugins, configOpts, netlifyConfig, configMutations, headersPath, redirectsPath, logs, debug, systemLog, verbose, saveConfig, timers, testOpts, featureFlags, quiet, userNodeVersion, explicitSecretKeys, }) {
     // Add relevant attributes to the upcoming span context
     const attributes = {
         'build.execution.step.name': coreStepName,
         'build.execution.step.package_name': packageName,
+        'build.execution.step.package_path': packagePath,
+        'build.execution.step.build_dir': buildDir,
         'build.execution.step.id': coreStepId,
         'build.execution.step.loaded_from': loadedFrom,
         'build.execution.step.origin': origin,
@@ -32,6 +34,7 @@ export const runStep = async function ({ event, childProcess, packageName, coreS
             failedPlugins,
             netlifyConfig,
             condition,
+            packagePath,
             constants: constantsA,
             buildbotServerSocket,
             buildDir,
@@ -57,6 +60,7 @@ export const runStep = async function ({ event, childProcess, packageName, coreS
             coreStep,
             coreStepId,
             coreStepName,
+            packagePath,
             configPath,
             outputConfigPath,
             buildDir,
@@ -148,10 +152,18 @@ export const runStep = async function ({ event, childProcess, packageName, coreS
 // or available. However, one might be created by a build plugin, in which case,
 // those core plugins should be triggered. We use a dynamic `condition()` to
 // model this behavior.
-const shouldRunStep = async function ({ event, packageName, error, failedPlugins, netlifyConfig, condition, constants, buildbotServerSocket, buildDir, saveConfig, explicitSecretKeys, }) {
+const shouldRunStep = async function ({ event, packageName, error, packagePath, failedPlugins, netlifyConfig, condition, constants, buildbotServerSocket, buildDir, saveConfig, explicitSecretKeys, }) {
     if (failedPlugins.includes(packageName) ||
         (condition !== undefined &&
-            !(await condition({ buildDir, constants, buildbotServerSocket, netlifyConfig, saveConfig, explicitSecretKeys })))) {
+            !(await condition({
+                packagePath,
+                buildDir,
+                constants,
+                buildbotServerSocket,
+                netlifyConfig,
+                saveConfig,
+                explicitSecretKeys,
+            })))) {
         return false;
     }
     if (error !== undefined) {
@@ -167,7 +179,7 @@ const getFireStep = function (packageName, coreStepId, event) {
     const parentTag = normalizeTagName(packageName);
     return measureDuration(tFireStep, event, { parentTag, category: 'pluginEvent' });
 };
-const tFireStep = function ({ event, childProcess, packageName, pluginPackageJson, loadedFrom, origin, coreStep, coreStepId, coreStepName, configPath, outputConfigPath, buildDir, repositoryRoot, nodePath, childEnv, context, branch, envChanges, constants, steps, buildbotServerSocket, events, error, logs, debug, systemLog, verbose, saveConfig, errorParams, configOpts, netlifyConfig, configMutations, headersPath, redirectsPath, featureFlags, userNodeVersion, explicitSecretKeys, }) {
+const tFireStep = function ({ event, childProcess, packageName, pluginPackageJson, loadedFrom, origin, coreStep, coreStepId, coreStepName, configPath, outputConfigPath, buildDir, repositoryRoot, packagePath, nodePath, childEnv, context, branch, envChanges, constants, steps, buildbotServerSocket, events, error, logs, debug, systemLog, verbose, saveConfig, errorParams, configOpts, netlifyConfig, configMutations, headersPath, redirectsPath, featureFlags, userNodeVersion, explicitSecretKeys, }) {
     if (coreStep !== undefined) {
         return fireCoreStep({
             coreStep,
@@ -177,6 +189,7 @@ const tFireStep = function ({ event, childProcess, packageName, pluginPackageJso
             outputConfigPath,
             buildDir,
             repositoryRoot,
+            packagePath,
             constants,
             buildbotServerSocket,
             events,
@@ -204,6 +217,7 @@ const tFireStep = function ({ event, childProcess, packageName, pluginPackageJso
         event,
         childProcess,
         packageName,
+        packagePath,
         pluginPackageJson,
         loadedFrom,
         origin,

package/lib/steps/run_steps.js

@@ -7,7 +7,7 @@ import { runStep } from './run_step.js';
 // list of `failedPlugins` (that ran `utils.build.failPlugin()`).
 // If an error arises, runs `onError` events.
 // Runs `onEnd` events at the end, whether an error was thrown or not.
-export const runSteps = async function ({ steps, buildbotServerSocket, events, configPath, outputConfigPath, headersPath, redirectsPath, buildDir, repositoryRoot, nodePath, childEnv, context, branch, constants, mode, api, errorMonitor, deployId, errorParams, netlifyConfig, configOpts, logs, debug, systemLog, verbose, saveConfig, timers, testOpts, featureFlags, quiet, userNodeVersion, explicitSecretKeys, }) {
+export const runSteps = async function ({ steps, buildbotServerSocket, events, configPath, outputConfigPath, headersPath, redirectsPath, buildDir, packagePath, repositoryRoot, nodePath, childEnv, context, branch, constants, mode, api, errorMonitor, deployId, errorParams, netlifyConfig, configOpts, logs, debug, systemLog, verbose, saveConfig, timers, testOpts, featureFlags, quiet, userNodeVersion, explicitSecretKeys, }) {
     const { index: stepsCount, error: errorA, netlifyConfig: netlifyConfigC, statuses: statusesB, failedPlugins: failedPluginsA, timers: timersC, configMutations: configMutationsB, metrics: metricsC, } = await pReduce(steps, async ({ index, error, failedPlugins, envChanges, netlifyConfig: netlifyConfigA, configMutations, headersPath: headersPathA, redirectsPath: redirectsPathA, statuses, timers: timersA, metrics: metricsA, }, { event, childProcess, packageName, coreStep, coreStepId, coreStepName, coreStepDescription, pluginPackageJson, loadedFrom, origin, condition, }) => {
         const { newIndex = index, newError = error, failedPlugin = [], newEnvChanges = {}, netlifyConfig: netlifyConfigB = netlifyConfigA, configMutations: configMutationsA = configMutations, headersPath: headersPathB = headersPathA, redirectsPath: redirectsPathB = redirectsPathA, newStatus, timers: timersB = timersA, metrics: metricsB = [], } = await runStep({
             event,
@@ -24,6 +24,7 @@ export const runSteps = async function ({ steps, buildbotServerSocket, events, c
             configPath,
             outputConfigPath,
             buildDir,
+            packagePath,
             repositoryRoot,
             nodePath,
             index,

package/lib/time/main.js

@@ -23,6 +23,12 @@ const kMeasureDuration = function (func, stageTag, { parentTag = undefined, cate
         return { ...returnObject, timers: timersB, durationNs };
     };
 };
+// TODO: type properly like this and fix all the upstream type issues
+// export const measureDuration: <T extends (...args: any) => any>(
+//   fn: T,
+//   tag: string,
+//   options?: { parentTag?: any; category?: any },
+// ) => T = keepFuncProps(kMeasureDuration)
 // Ensure the wrapped function `name` is not `anonymous` in stack traces
 export const measureDuration = keepFuncProps(kMeasureDuration);
 // Create a new object representing a completed timer

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/build",
-  "version": "29.18.0",
+  "version": "29.19.0-rc.0",
   "description": "Netlify build module",
   "type": "module",
   "exports": "./lib/core/main.js",
@@ -65,14 +65,14 @@
     "@bugsnag/js": "^7.0.0",
     "@honeycombio/opentelemetry-node": "^0.4.0",
     "@netlify/cache-utils": "^5.1.5",
-    "@netlify/config": "^20.7.0",
+    "@netlify/config": "^20.8.0",
     "@netlify/edge-bundler": "8.17.1",
     "@netlify/framework-info": "^9.8.10",
     "@netlify/functions-utils": "^5.2.20",
     "@netlify/git-utils": "^5.1.1",
-    "@netlify/plugins-list": "^6.68.0",
+    "@netlify/plugins-list": "^6.71.0",
     "@netlify/run-utils": "^5.1.1",
-    "@netlify/zip-it-and-ship-it": "9.14.0",
+    "@netlify/zip-it-and-ship-it": "9.15.0",
     "@opentelemetry/api": "^1.4.1",
     "@sindresorhus/slugify": "^2.0.0",
     "ansi-escapes": "^6.0.0",
@@ -147,6 +147,5 @@
     "compilerOptions": {
       "module": "commonjs"
     }
-  },
-  "gitHead": "f79e1dae2fb91563cfb4ca527d6c832f2c36de8a"
+  }
 }