netlify-cli 16.5.1 → 16.6.0

package/src/lib/functions/server.mjs

@@ -1,12 +1,19 @@
 // @ts-check
 import { Buffer } from 'buffer'
+import { promises as fs } from 'fs'
 
 import express from 'express'
 import expressLogging from 'express-logging'
 import jwtDecode from 'jwt-decode'
 
 import { NETLIFYDEVERR, NETLIFYDEVLOG, error as errorExit, log } from '../../utils/command-helpers.mjs'
-import { CLOCKWORK_USERAGENT, getFunctionsDistPath, getInternalFunctionsDir } from '../../utils/functions/index.mjs'
+import { isFeatureFlagEnabled } from '../../utils/feature-flags.mjs'
+import {
+  CLOCKWORK_USERAGENT,
+  getFunctionsDistPath,
+  getFunctionsServePath,
+  getInternalFunctionsDir,
+} from '../../utils/functions/index.mjs'
 import { NFFunctionName, NFFunctionRoute } from '../../utils/headers.mjs'
 import { headers as efHeaders } from '../edge-functions/headers.mjs'
 import { getGeoLocation } from '../geo-location.mjs'
@@ -244,12 +251,14 @@ const getFunctionsServer = (options) => {
  * @param {*} options.loadDistFunctions
  * @param {*} options.settings
  * @param {*} options.site
+ * @param {*} options.siteInfo
  * @param {string} options.siteUrl
  * @param {*} options.timeouts
  * @returns {Promise<import('./registry.mjs').FunctionsRegistry | undefined>}
  */
 export const startFunctionsServer = async (options) => {
-  const { capabilities, command, config, debug, loadDistFunctions, settings, site, siteUrl, timeouts } = options
+  const { capabilities, command, config, debug, loadDistFunctions, settings, site, siteInfo, siteUrl, timeouts } =
+    options
   const internalFunctionsDir = await getInternalFunctionsDir({ base: site.root })
   const functionsDirectories = []
 
@@ -270,6 +279,14 @@ export const startFunctionsServer = async (options) => {
     functionsDirectories.push(...sourceDirectories)
   }
 
+  try {
+    const functionsServePath = getFunctionsServePath({ base: site.root })
+
+    await fs.rm(functionsServePath, { force: true, recursive: true })
+  } catch {
+    // no-op
+  }
+
   if (functionsDirectories.length === 0) {
     return
   }
@@ -279,6 +296,7 @@ export const startFunctionsServer = async (options) => {
     config,
     debug,
     isConnected: Boolean(siteUrl),
+    logLambdaCompat: isFeatureFlagEnabled('cli_log_lambda_compat', siteInfo),
     // functions always need to be inside the packagePath if set inside a monorepo
     projectRoot: command.workingDir,
     settings,

package/src/lib/functions/synchronous.mjs

@@ -3,11 +3,18 @@ import { Buffer } from 'buffer'
 
 import { isStream } from 'is-stream'
 
-import { chalk, log, NETLIFYDEVERR } from '../../utils/command-helpers.mjs'
+import { chalk, logPadded, NETLIFYDEVERR } from '../../utils/command-helpers.mjs'
 import renderErrorTemplate from '../render-error-template.mjs'
 
 import { detectAwsSdkError } from './utils.mjs'
 
+/**
+ * @typedef InvocationError
+ * @property {string} errorType
+ * @property {string} errorMessage
+ * @property {Array<string>} stackTrace
+ */
+
 const addHeaders = (headers, response) => {
   if (!headers) {
     return
@@ -26,12 +33,21 @@ export const handleSynchronousFunction = function ({
   result,
 }) {
   if (invocationError) {
+    const error = getNormalizedError(invocationError)
+
+    logPadded(
+      `${NETLIFYDEVERR} Function ${chalk.yellow(functionName)} has returned an error: ${
+        error.errorMessage
+      }\n${chalk.dim(error.stackTrace.join('\n'))}`,
+    )
+
     return handleErr(invocationError, request, response)
   }
 
   const { error } = validateLambdaResponse(result)
   if (error) {
-    log(`${NETLIFYDEVERR} ${error}`)
+    logPadded(`${NETLIFYDEVERR} ${error}`)
+
     return handleErr(error, request, response)
   }
 
@@ -41,9 +57,13 @@ export const handleSynchronousFunction = function ({
     addHeaders(result.headers, response)
     addHeaders(result.multiValueHeaders, response)
   } catch (headersError) {
-    formatError(headersError)
+    const normalizedError = getNormalizedError(headersError)
 
-    log(`${NETLIFYDEVERR} Failed to set header in function ${chalk.yellow(functionName)}: ${headersError.message}`)
+    logPadded(
+      `${NETLIFYDEVERR} Failed to set header in function ${chalk.yellow(functionName)}: ${
+        normalizedError.errorMessage
+      }`,
+    )
 
     return handleErr(headersError, request, response)
   }
@@ -60,20 +80,56 @@ export const handleSynchronousFunction = function ({
   response.end()
 }
 
-const formatError = (err) => {
-  err.errorType = err.code
-  err.errorMessage = err.message
-  err.stackTrace = err.trace
+/**
+ * Accepts an error generated by `lambda-local` or an instance of `Error` and
+ * returns a normalized error that we can treat in the same way.
+ *
+ * @param {InvocationError|Error} error
+ * @returns {InvocationError}
+ */
+const getNormalizedError = (error) => {
+  if (error instanceof Error) {
+    const normalizedError = {
+      errorMessage: error.message,
+      errorType: error.name,
+      stackTrace: error.stack ? error.stack.split('\n') : [],
+    }
+
+    if ('code' in error && error.code === 'ERR_REQUIRE_ESM') {
+      return {
+        ...normalizedError,
+        errorMessage:
+          'a CommonJS file cannot import ES modules. Consider switching your function to ES modules. For more information, refer to https://ntl.fyi/functions-runtime.',
+      }
+    }
+
+    return normalizedError
+  }
+
+  // Formatting stack trace lines in the same way that Node.js formats native
+  // errors.
+  const stackTrace = error.stackTrace.map((line) => `    at ${line}`)
+
+  return {
+    errorType: error.errorType,
+    errorMessage: error.errorMessage,
+    stackTrace,
+  }
 }
 
-const formatLambdaLocalError = (err, acceptsHtml) =>
-  acceptsHtml
-    ? JSON.stringify({
-        errorType: err.errorType,
-        errorMessage: err.errorMessage,
-        trace: err.stackTrace,
-      })
-    : `${err.errorType}: ${err.errorMessage}\n ${err.stackTrace?.join('\n ')}`
+const formatLambdaLocalError = (rawError, acceptsHTML) => {
+  const error = getNormalizedError(rawError)
+
+  if (acceptsHTML) {
+    return JSON.stringify({
+      ...error,
+      stackTrace: undefined,
+      trace: error.stackTrace,
+    })
+  }
+
+  return `${error.errorType}: ${error.errorMessage}\n ${error.stackTrace.join('\n')}`
+}
 
 const handleErr = async (err, request, response) => {
   detectAwsSdkError({ err })

package/src/utils/command-helpers.mjs

@@ -163,6 +163,12 @@ export const log = (message = '', ...args) => {
   process.stdout.write(`${format(message, ...args)}\n`)
 }
 
+export const logPadded = (message = '', ...args) => {
+  log('')
+  log(message, ...args)
+  log('')
+}
+
 /**
  * logs a warning message
  * @param {string} message
@@ -262,4 +268,4 @@ export const watchDebounced = async (
   return watcher
 }
 
-export const getTerminalLink = (text, url) => terminalLink(text, url, { fallback: () => `${text} ${url}` })
+export const getTerminalLink = (text, url) => terminalLink(text, url, { fallback: () => `${text} (${url})` })

package/src/utils/functions/functions.mjs

@@ -33,6 +33,12 @@ export const getFunctionsDistPath = async ({ base, packagePath = '' }) => {
   return isDirectory ? path : null
 }
 
+export const getFunctionsServePath = ({ base, packagePath = '' }) => {
+  const path = resolve(base, packagePath, getPathInProject([SERVE_FUNCTIONS_FOLDER]))
+
+  return path
+}
+
 /**
  * Retrieves the internal functions directory and creates it if ensureExists is provided
  * @param {object} config

package/src/utils/proxy.mjs

@@ -27,6 +27,7 @@ import {
   isEdgeFunctionsRequest,
 } from '../lib/edge-functions/proxy.mjs'
 import { fileExistsAsync, isFileAsync } from '../lib/fs.mjs'
+import { DEFAULT_FUNCTION_URL_EXPRESSION } from '../lib/functions/registry.mjs'
 import renderErrorTemplate from '../lib/render-error-template.mjs'
 
 import { NETLIFYDEVLOG, NETLIFYDEVWARN, log, chalk } from './command-helpers.mjs'
@@ -87,7 +88,7 @@ function isInternal(url) {
  * @param {string} url
  */
 function isFunction(functionsPort, url) {
-  return functionsPort && url.match(/^\/.netlify\/(functions|builders)\/.+/)
+  return functionsPort && url.match(DEFAULT_FUNCTION_URL_EXPRESSION)
 }
 
 /**
@@ -328,13 +329,12 @@ const serveRedirect = async function ({ env, functionsRegistry, match, options,
       return proxy.web(req, res, { target: options.functionsServer })
     }
 
-    const functionWithCustomRoute =
-      functionsRegistry && (await functionsRegistry.getFunctionForURLPath(destURL, req.method))
+    const matchingFunction = functionsRegistry && (await functionsRegistry.getFunctionForURLPath(destURL, req.method))
     const destStaticFile = await getStatic(dest.pathname, options.publicFolder)
     let statusValue
     if (
       match.force ||
-      (!staticFile && ((!options.framework && destStaticFile) || isInternal(destURL) || functionWithCustomRoute))
+      (!staticFile && ((!options.framework && destStaticFile) || isInternal(destURL) || matchingFunction))
     ) {
       req.url = destStaticFile ? destStaticFile + dest.search : destURL
       const { status } = match
@@ -342,10 +342,11 @@ const serveRedirect = async function ({ env, functionsRegistry, match, options,
       console.log(`${NETLIFYDEVLOG} Rewrote URL to`, req.url)
     }
 
-    if (isFunction(options.functionsPort, req.url) || functionWithCustomRoute) {
-      const functionHeaders = functionWithCustomRoute
-        ? { [NFFunctionName]: functionWithCustomRoute.func.name, [NFFunctionRoute]: functionWithCustomRoute.route }
-        : {}
+    if (matchingFunction) {
+      const functionHeaders = {
+        [NFFunctionName]: matchingFunction.func.name,
+        [NFFunctionRoute]: matchingFunction.route,
+      }
       const url = reqToURL(req, originalURL)
       req.headers['x-netlify-original-pathname'] = url.pathname
       req.headers['x-netlify-original-search'] = url.search
@@ -597,18 +598,17 @@ const onRequest = async (
     return proxy.web(req, res, { target: edgeFunctionsProxyURL })
   }
 
-  // Does the request match a function on the fixed URL path?
-  if (isFunction(settings.functionsPort, req.url)) {
-    return proxy.web(req, res, { target: functionsServer })
-  }
-
-  // Does the request match a function on a custom URL path?
-  const functionMatch = functionsRegistry ? await functionsRegistry.getFunctionForURLPath(req.url, req.method) : null
+  const functionMatch = functionsRegistry && (await functionsRegistry.getFunctionForURLPath(req.url, req.method))
 
   if (functionMatch) {
     // Setting an internal header with the function name so that we don't
     // have to match the URL again in the functions server.
-    const headers = { [NFFunctionName]: functionMatch.func.name, [NFFunctionRoute]: functionMatch.route.pattern }
+    /** @type {Record<string, string>} */
+    const headers = { [NFFunctionName]: functionMatch.func.name }
+
+    if (functionMatch.route) {
+      headers[NFFunctionRoute] = functionMatch.route.pattern
+    }
 
     return proxy.web(req, res, { headers, target: functionsServer })
   }