@netlify/build 27.5.0-rc → 27.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/build",
-  "version": "27.5.0-rc",
+  "version": "27.7.0",
   "description": "Netlify build module",
   "type": "module",
   "exports": "./src/core/main.js",
@@ -56,9 +56,9 @@
   "license": "MIT",
   "dependencies": {
     "@bugsnag/js": "^7.0.0",
-    "@netlify/edge-bundler": "^1.6.0",
+    "@netlify/edge-bundler": "^1.8.0",
     "@netlify/cache-utils": "^4.0.0",
-    "@netlify/config": "^18.1.1",
+    "@netlify/config": "^18.1.2",
     "@netlify/functions-utils": "^4.2.2",
     "@netlify/git-utils": "^4.0.0",
     "@netlify/plugins-list": "^6.35.0",
@@ -66,6 +66,8 @@
     "@netlify/zip-it-and-ship-it": "5.13.2",
     "@sindresorhus/slugify": "^2.0.0",
     "@types/node": "^16.0.0",
+    "ajv": "^8.11.0",
+    "ajv-errors": "^3.0.0",
     "ansi-escapes": "^5.0.0",
     "chalk": "^5.0.0",
     "clean-stack": "^4.0.0",

package/src/error/monitor/normalize.js

@@ -32,9 +32,9 @@ const normalizeMessage = function (message, [regExp, replacement]) {
 
 const NORMALIZE_REGEXPS = [
   // Base64 URL
-  [/(data:[^;]+;base64),[\w+/-]+/g, 'dataURI'],
+  [/(data:[^;]+;base64),[\w+/-=]+/g, 'dataURI'],
   // File paths
-  [/(["'`, ]|^)([^"'`, \n]*[/\\][^"'`, \n]*)(["'`, ]|$)/gm, '$1/file/path$3'],
+  [/(["'`, ]|^)([^"'`, \n]*[/\\][^"'`, \n]*)(?=["'`, ]|$)/gm, '$1/file/path'],
   // Semantic versions
   [/\d+\.\d+\.\d+(-\d+)?/g, '1.0.0'],
   [/version "[^"]+"/g, 'version "1.0.0"'],
@@ -45,7 +45,7 @@ const NORMALIZE_REGEXPS = [
   // Numbers, e.g. number of issues/problems
   [/\d+/g, '0'],
   // Hexadecimal strings
-  [/[\da-fA-F]{6,}/g, 'hex'],
+  [/[\da-fA-F-]{6,}/g, 'hex'],
   // On unknown inputs, we print the inputs
   [/(does not accept any inputs but you specified: ).*/, '$1'],
   [/(Unknown inputs for plugin).*/, '$1'],
@@ -74,4 +74,6 @@ const NORMALIZE_REGEXPS = [
   [/(Parse Error):[^]*/, '$1'],
   // Multiple empty lines
   [/^\s*$/gm, ''],
+  // Function bundling errors
+  [/Bundling of function "([^"]+)" failed/gm, 'Bundling of function "functionName" failed'],
 ]

package/src/error/monitor/report.js

@@ -21,7 +21,7 @@ export const reportBuildError = async function ({ error, errorMonitor, childEnv,
   const { errorInfo, type, severity, title, group = title } = parseErrorInfo(error)
   const severityA = getSeverity(severity, errorInfo)
   const groupA = getGroup(group, errorInfo)
-  const groupingHash = getGroupingHash(groupA, error, type)
+  const groupingHash = getGroupingHash(groupA, error, type, errorInfo)
   const metadata = getMetadata(errorInfo, childEnv, groupingHash)
   const app = getApp()
   const eventProps = getEventProps({ severity: severityA, group: groupA, groupingHash, metadata, app })
@@ -52,7 +52,12 @@ const getGroup = function (group, errorInfo) {
   return group(errorInfo)
 }
 
-const getGroupingHash = function (group, error, type) {
+const getGroupingHash = function (group, error, type, errorInfo = {}) {
+  // If the error has a `normalizedMessage`, we use it as the grouping hash.
+  if (errorInfo.normalizedMessage) {
+    return errorInfo.normalizedMessage
+  }
+
   const message = error instanceof Error && typeof error.message === 'string' ? error.message : String(error)
   const messageA = normalizeGroupingMessage(message, type)
   return `${group}\n${messageA}`

package/src/error/parse/location.js

@@ -23,8 +23,12 @@ const getBuildCommandLocation = function ({ buildCommand, buildCommandOrigin })
 ${buildCommand}`
 }
 
-const getFunctionsBundlingLocation = function ({ functionName }) {
-  return `While bundling Function "${functionName}"`
+const getFunctionsBundlingLocation = function ({ functionName, functionType }) {
+  if (functionType === 'edge') {
+    return 'While bundling edge function'
+  }
+
+  return `While bundling function "${functionName}"`
 }
 
 const getCoreStepLocation = function ({ coreStepName }) {

package/src/error/type.js

@@ -81,7 +81,13 @@ const TYPES = {
 
   // User error during Functions bundling
   functionsBundling: {
-    title: ({ location: { functionName } }) => `Bundling of Function "${functionName}" failed`,
+    title: ({ location: { functionName, functionType } }) => {
+      if (functionType === 'edge') {
+        return 'Bundling of edge function failed'
+      }
+
+      return `Bundling of function "${functionName}" failed`
+    },
     stackType: 'none',
     locationType: 'functionsBundling',
     severity: 'info',

package/src/plugins_core/edge_functions/index.js

@@ -7,12 +7,15 @@ import { pathExists } from 'path-exists'
 import { logFunctionsToBundle } from '../../log/messages/core_steps.js'
 import { logEdgeManifest } from '../../log/messages/edge_manifest.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: {
@@ -46,18 +49,27 @@ const coreStep = async function ({
   // Edge Bundler expects the dist directory to exist.
   await fs.mkdir(distPath, { recursive: true })
 
-  const { manifest } = await bundle(sourcePaths, distPath, declarations, {
-    cacheDirectory,
-    debug,
-    distImportMapPath,
-    featureFlags,
-    importMaps: [importMap].filter(Boolean),
-  })
-
-  if (debug) {
-    logEdgeManifest({ manifest, logs, debug })
+  try {
+    const { manifest } = await bundle(sourcePaths, distPath, declarations, {
+      basePath: buildDir,
+      cacheDirectory,
+      debug,
+      distImportMapPath,
+      featureFlags,
+      importMaps: [importMap].filter(Boolean),
+    })
+
+    if (debug) {
+      logEdgeManifest({ manifest, logs, debug })
+    }
+  } catch (error) {
+    tagBundlingError(error)
+
+    throw error
   }
 
+  await validateEdgeFunctionsManifest({ buildDir, constants: { EDGE_FUNCTIONS_DIST: distDirectory } })
+
   return {}
 }
 

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

@@ -0,0 +1,21 @@
+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',
+  }
+}

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

@@ -0,0 +1,89 @@
+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 = /^\^.*\$$/
+ajv.addFormat('regexPattern', {
+  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,
+}
+
+const routesSchema = {
+  $async: true,
+  type: 'object',
+  required: ['function', 'pattern'],
+  properties: {
+    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,
+    },
+    routes: {
+      type: 'array',
+      items: routesSchema,
+    },
+    bundler_version: { type: 'string' },
+  },
+  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 {}
+}