@netlify/build 27.20.4 → 27.20.6

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

@@ -1,60 +1,50 @@
-import { promises as fs } from 'fs'
-import { dirname, join, resolve } from 'path'
-import { pathToFileURL } from 'url'
-
+import { promises as fs } from 'fs';
+import { dirname, join, resolve } from 'path';
+import { pathToFileURL } from 'url';
 const parseManifest = async (internalSourceDirectory, systemLog) => {
-  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 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: {
+                    baseURL: pathToFileURL(importMapPath),
+                    ...importMap,
+                },
+            };
+        }
+        return result;
     }
-
-    const result = {
-      declarations: manifest.functions,
+    catch (error) {
+        if (error.code !== 'ENOENT') {
+            systemLog('Error while parsing internal edge functions manifest:', error);
+        }
     }
-
-    if (manifest.import_map) {
-      const importMapPath = resolve(dirname(manifestPath), manifest.import_map)
-      const importMap = await readImportMap(importMapPath)
-
-      return {
-        ...result,
-        importMap: {
-          baseURL: pathToFileURL(importMapPath),
-          ...importMap,
-        },
-      }
+    return {
+        declarations: [],
+    };
+};
+const readImportMap = async (path) => {
+    try {
+        const data = await fs.readFile(path);
+        const importMap = JSON.parse(data);
+        return importMap;
     }
-
-    return result
-  } catch (error) {
-    if (error.code !== 'ENOENT') {
-      systemLog('Error while parsing internal edge functions manifest:', error)
+    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 }
+    return {
+        imports: {},
+    };
+};
+export { parseManifest };

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

@@ -1,90 +1,75 @@
-import { promises as fs } from 'fs'
-import { join, resolve } from 'path'
-
-import Ajv from 'ajv'
-import ajvErrors from 'ajv-errors'
-
-import { addErrorInfo } from '../../../error/info.js'
-
-const ajv = new Ajv({ allErrors: true })
-ajvErrors(ajv)
-
+import { promises as fs } from 'fs';
+import { join, resolve } from 'path';
+import Ajv from 'ajv';
+import ajvErrors from 'ajv-errors';
+import { addErrorInfo } from '../../../error/info.js';
+const ajv = new Ajv({ allErrors: true });
+ajvErrors(ajv);
 // regex pattern for manifest route pattern
 // checks if the pattern string starts with ^ and ends with $
 // we define this format in edge-bundler:
 // https://github.com/netlify/edge-bundler/blob/main/src/manifest.ts#L66
-const normalizedPatternRegex = /^\^.*\$$/
+const normalizedPatternRegex = /^\^.*\$$/;
 ajv.addFormat('regexPattern', {
-  async: true,
-  validate: (data) => normalizedPatternRegex.test(data),
-})
-
+    async: true,
+    validate: (data) => normalizedPatternRegex.test(data),
+});
 const bundlesSchema = {
-  $async: true,
-  type: 'object',
-  required: ['asset', 'format'],
-  properties: {
-    asset: { type: 'string' },
-    format: { type: 'string' },
-  },
-  additionalProperties: false,
-}
-
+    $async: true,
+    type: 'object',
+    required: ['asset', 'format'],
+    properties: {
+        asset: { type: 'string' },
+        format: { type: 'string' },
+    },
+    additionalProperties: false,
+};
 const routesSchema = {
-  $async: true,
-  type: 'object',
-  required: ['function', 'pattern'],
-  properties: {
-    name: { type: 'string' },
-    function: { type: 'string' },
-    pattern: { type: 'string', format: 'regexPattern', errorMessage: `must match format ${normalizedPatternRegex}` },
-  },
-  additionalProperties: false,
-}
-
-const edgeManifestSchema = {
-  $async: true,
-  type: 'object',
-  required: ['bundles', 'routes', 'bundler_version'],
-  properties: {
-    bundles: {
-      type: 'array',
-      items: bundlesSchema,
+    $async: true,
+    type: 'object',
+    required: ['function', 'pattern'],
+    properties: {
+        name: { type: 'string' },
+        function: { type: 'string' },
+        pattern: { type: 'string', format: 'regexPattern', errorMessage: `must match format ${normalizedPatternRegex}` },
     },
-    routes: {
-      type: 'array',
-      items: routesSchema,
+    additionalProperties: false,
+};
+const edgeManifestSchema = {
+    $async: true,
+    type: 'object',
+    required: ['bundles', 'routes', 'bundler_version'],
+    properties: {
+        bundles: {
+            type: 'array',
+            items: bundlesSchema,
+        },
+        routes: {
+            type: 'array',
+            items: routesSchema,
+        },
+        bundler_version: { type: 'string' },
     },
-    bundler_version: { type: 'string' },
-  },
-  additionalProperties: false,
-  errorMessage: "Couldn't validate Edge Functions manifest.json",
-}
-
+    additionalProperties: false,
+    errorMessage: "Couldn't validate Edge Functions manifest.json",
+};
 const validateManifest = async (manifestData) => {
-  const validate = ajv.compile(edgeManifestSchema)
-
-  await validate(manifestData)
-}
-
-export const validateEdgeFunctionsManifest = async function ({
-  buildDir,
-  constants: { EDGE_FUNCTIONS_DIST: distDirectory },
-}) {
-  try {
-    const edgeFunctionsDistPath = resolve(buildDir, distDirectory)
-    const manifestPath = join(edgeFunctionsDistPath, 'manifest.json')
-    const data = await fs.readFile(manifestPath)
-    const manifestData = JSON.parse(data)
-
-    await validateManifest(manifestData)
-  } catch (error) {
-    const isValidationErr = error instanceof Ajv.ValidationError
-    const parsedErr = isValidationErr ? error.errors : error
-
-    addErrorInfo(parsedErr, { type: 'coreStep' })
-    throw new Error(isValidationErr ? JSON.stringify(parsedErr, null, 2) : parsedErr)
-  }
-
-  return {}
-}
+    const validate = ajv.compile(edgeManifestSchema);
+    await validate(manifestData);
+};
+export const validateEdgeFunctionsManifest = async function ({ buildDir, constants: { EDGE_FUNCTIONS_DIST: distDirectory }, }) {
+    try {
+        const edgeFunctionsDistPath = resolve(buildDir, distDirectory);
+        const manifestPath = join(edgeFunctionsDistPath, 'manifest.json');
+        const data = await fs.readFile(manifestPath);
+        const manifestData = JSON.parse(data);
+        await validateManifest(manifestData);
+    }
+    catch (error) {
+        const isValidationErr = error instanceof Ajv.ValidationError;
+        const parsedErr = isValidationErr ? error.errors : error;
+        addErrorInfo(parsedErr, { type: 'coreStep' });
+        throw new Error(isValidationErr ? JSON.stringify(parsedErr, null, 2) : parsedErr);
+    }
+    return {};
+};

package/lib/plugins_core/functions/error.js

@@ -1,133 +1,99 @@
-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 ['"]([^'"]+)/
-
+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 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 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 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)
-}
-
+    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('/')
-}
-
+    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
+    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 [...modules, match[1]]
-  }, [])
-
-  if (modulesNotFound.length === 0) {
-    return
-  }
-
-  return getModuleNotFoundErrorObject({ error, functionsSrc, moduleNames: modulesNotFound })
-}
-
+    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] : [] })
-}
-
+    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]
-}
-
+    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))
-  )
-}
-
+    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 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".`
+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.`
-
+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 = `
+    const genericMessage = `
 
 By default, dependencies inside a Netlify Function's "package.json" are not automatically installed.
 There are several ways to fix this problem:
@@ -137,27 +103,21 @@ There are several ways to fix this problem:
 
 [[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}`
-}
-
+  `;
+    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']
-
+    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
-}
+    addErrorInfo(error, { type: 'resolveConfig' });
+    return error;
+};

package/lib/plugins_core/functions/feature_flags.js

@@ -1,6 +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,
-})
+    ...featureFlags,
+    defaultEsModulesToEsbuild: featureFlags.buildbot_es_modules_esbuild,
+    parseWithEsbuild: featureFlags.buildbot_zisi_esbuild_parser,
+    traceWithNft: featureFlags.buildbot_zisi_trace_nft,
+});