@netlify/build 27.5.0 → 27.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/build",
-  "version": "27.5.0",
+  "version": "27.6.0",
   "description": "Netlify build module",
   "type": "module",
   "exports": "./src/core/main.js",
@@ -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_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 {}
+}