@netlify/build 27.4.2 → 27.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/build",
-  "version": "27.4.2",
+  "version": "27.6.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.7.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/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/child/status.js

@@ -6,18 +6,19 @@ import { addErrorInfo } from '../../error/info.js'
 // Report status information to the UI
 export const show = function (runState, showArgs) {
   validateShowArgs(showArgs)
-  const { title, summary, text } = removeEmptyStrings(showArgs)
-  runState.status = { state: 'success', title, summary, text }
+  const { title, summary, text, extraData } = removeEmptyStrings(showArgs)
+  runState.status = { state: 'success', title, summary, text, extraData }
 }
 
 // Validate arguments of `utils.status.show()`
 const validateShowArgs = function (showArgs) {
   try {
     validateShowArgsObject(showArgs)
-    const { title, summary, text, ...otherArgs } = showArgs
+    const { title, summary, text, extraData, ...otherArgs } = showArgs
     validateShowArgsKeys(otherArgs)
     Object.entries({ title, summary, text }).forEach(validateStringArg)
     validateShowArgsSummary(summary)
+    validateShowArgsExtraData(extraData)
   } catch (error) {
     error.message = `utils.status.show() ${error.message}`
     addErrorInfo(error, { type: 'pluginValidation' })
@@ -54,6 +55,12 @@ const validateShowArgsSummary = function (summary) {
   }
 }
 
+const validateShowArgsExtraData = function (extraData) {
+  if (extraData !== undefined && Array.isArray(extraData) === false) {
+    throw new TypeError('provided extra data must be an array')
+  }
+}
+
 const removeEmptyStrings = function (showArgs) {
   return mapObj(showArgs, removeEmptyString)
 }

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 {}
+}

package/src/status/report.js

@@ -104,7 +104,7 @@ const sendApiStatuses = async function ({
 
 const sendApiStatus = async function ({
   api,
-  status: { packageName, version, state, event, title, summary, text },
+  status: { packageName, version, state, event, title, summary, text, extraData },
   childEnv,
   mode,
   netlifyConfig,
@@ -117,7 +117,16 @@ const sendApiStatus = async function ({
   try {
     await api.createPluginRun({
       deploy_id: deployId,
-      body: { package: packageName, version, state, reporting_event: event, title, summary, text },
+      body: {
+        package: packageName,
+        version,
+        state,
+        reporting_event: event,
+        title,
+        summary,
+        text,
+        extra_data: extraData,
+      },
     })
     // Bitballoon API randomly fails with 502.
     // Builds should be successful when this API call fails, but we still want