@netlify/build 29.0.1-rc → 29.0.2

package/lib/plugins/resolve.js

@@ -0,0 +1,110 @@
+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/lib/plugins/spawn.js

@@ -0,0 +1,58 @@
+import { fileURLToPath } from 'url';
+import { execaNode } from 'execa';
+import { addErrorInfo } from '../error/info.js';
+import { logRuntime, 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, featureFlags }) {
+    logRuntime(logs, pluginsOptions);
+    logLoadingPlugins(logs, pluginsOptions, debug);
+    logOutdatedPlugins(logs, pluginsOptions, featureFlags);
+    logIncompatiblePlugins(logs, pluginsOptions);
+    const childProcesses = await Promise.all(pluginsOptions.map(({ pluginDir, nodePath }) => startPlugin({ pluginDir, nodePath, buildDir, childEnv, featureFlags })));
+    return { childProcesses };
+};
+export const startPlugins = measureDuration(tStartPlugins, 'start_plugins');
+const startPlugin = async function ({ pluginDir, nodePath, buildDir, childEnv, featureFlags }) {
+    const childProcess = execaNode(CHILD_MAIN_FILE, [], {
+        cwd: buildDir,
+        preferLocal: true,
+        localDir: pluginDir,
+        nodePath,
+        execPath: nodePath,
+        env: childEnv,
+        extendEnv: false,
+        // Feature flag: https://app.launchdarkly.com/default/production/features/netlify_build_use_json_serialization_for_plugin_ipc/targeting
+        // TODO: remove feature flag once fully rolled out
+        ...(!featureFlags.netlify_build_use_json_serialization_for_plugin_ipc && {
+            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/lib/plugins_core/add.js

@@ -0,0 +1,35 @@
+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/lib/plugins_core/build_command.js

@@ -0,0 +1,50 @@
+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/lib/plugins_core/deploy/buildbot_client.js

@@ -0,0 +1,87 @@
+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 errorIs422 = error !== undefined && error.code === '422';
+    const errMsg = errorIs422
+        ? `
+    File upload failed because of mismatched SHAs.
+    This can happen when files are changed after the deployment process has started but before they are uploaded.
+
+    Error: ${error}
+    `
+        : `Deploy did not succeed: ${error}`;
+    const errorA = new Error(errMsg);
+    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/lib/plugins_core/deploy/index.js

@@ -0,0 +1,49 @@
+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/lib/plugins_core/edge_functions/index.js

@@ -0,0 +1,76 @@
+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 { 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';
+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: declarations = [] } = 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 });
+    // 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,
+            configPath: join(internalSrcPath, 'manifest.json'),
+            debug,
+            distImportMapPath,
+            featureFlags,
+            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 → lib}/plugins_core/edge_functions/lib/error.js

@@ -1,21 +1,17 @@
-import { CUSTOM_ERROR_KEY, getErrorInfo, isBuildError } from '../../../error/info.js'
-
+import { CUSTOM_ERROR_KEY, getErrorInfo, isBuildError } from '../../../error/info.js';
 // If we have a custom error tagged with `functionsBundling` (which happens if
 // there is an issue with user code), we tag it as coming from an edge function
 // so that we can adjust the downstream error messages accordingly.
 export const tagBundlingError = (error) => {
-  if (!isBuildError(error)) {
-    return
-  }
-
-  const [errorInfo = {}] = getErrorInfo(error)
-
-  if (errorInfo.type !== 'functionsBundling') {
-    return
-  }
-
-  error[CUSTOM_ERROR_KEY].location = {
-    ...error[CUSTOM_ERROR_KEY].location,
-    functionType: 'edge',
-  }
-}
+    if (!isBuildError(error)) {
+        return;
+    }
+    const [errorInfo = {}] = getErrorInfo(error);
+    if (errorInfo.type !== 'functionsBundling') {
+        return;
+    }
+    error[CUSTOM_ERROR_KEY].location = {
+        ...error[CUSTOM_ERROR_KEY].location,
+        functionType: 'edge',
+    };
+};

package/lib/plugins_core/edge_functions/validate_manifest/validate_edge_functions_manifest.js

@@ -0,0 +1,21 @@
+import { promises as fs } from 'fs';
+import { join, resolve } from 'path';
+import { ManifestValidationError, validateManifest } from '@netlify/edge-bundler';
+import { addErrorInfo } from '../../../error/info.js';
+export const validateEdgeFunctionsManifest = async function ({ buildDir, constants: { EDGE_FUNCTIONS_DIST: distDirectory }, }) {
+    const edgeFunctionsDistPath = resolve(buildDir, distDirectory);
+    const manifestPath = join(edgeFunctionsDistPath, 'manifest.json');
+    const data = await fs.readFile(manifestPath);
+    // @ts-expect-error TypeScript is not aware that parse can handle Buffer
+    const manifestData = JSON.parse(data);
+    try {
+        validateManifest(manifestData);
+    }
+    catch (error) {
+        if (error instanceof ManifestValidationError) {
+            addErrorInfo(error, { type: 'coreStep' });
+        }
+        throw error;
+    }
+    return {};
+};

package/lib/plugins_core/functions/error.js

@@ -0,0 +1,123 @@
+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/lib/plugins_core/functions/feature_flags.js

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