netlify-cli 16.1.0 → 16.2.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "netlify-cli",
   "description": "Netlify command line tool",
-  "version": "16.1.0",
+  "version": "16.2.0",
   "author": "Netlify Inc.",
   "type": "module",
   "engines": {
@@ -44,13 +44,13 @@
   "dependencies": {
     "@bugsnag/js": "7.20.2",
     "@fastify/static": "6.10.2",
-    "@netlify/build": "29.20.4",
-    "@netlify/build-info": "7.7.3",
+    "@netlify/build": "29.20.8",
+    "@netlify/build-info": "7.7.4",
     "@netlify/config": "20.8.0",
-    "@netlify/edge-bundler": "8.17.1",
+    "@netlify/edge-bundler": "8.19.0",
     "@netlify/local-functions-proxy": "1.1.1",
-    "@netlify/serverless-functions-api": "1.5.2",
-    "@netlify/zip-it-and-ship-it": "9.15.1",
+    "@netlify/serverless-functions-api": "1.7.3",
+    "@netlify/zip-it-and-ship-it": "9.17.0",
     "@octokit/rest": "19.0.13",
     "ansi-escapes": "6.2.0",
     "ansi-styles": "6.2.1",
@@ -106,7 +106,7 @@
     "isexe": "2.0.0",
     "jsonwebtoken": "9.0.1",
     "jwt-decode": "3.1.2",
-    "lambda-local": "2.1.1",
+    "lambda-local": "2.1.2",
     "listr": "0.14.3",
     "locate-path": "7.2.0",
     "lodash": "4.17.21",
@@ -116,7 +116,7 @@
     "multiparty": "4.2.3",
     "netlify": "13.1.10",
     "netlify-headers-parser": "7.1.2",
-    "netlify-redirect-parser": "14.1.3",
+    "netlify-redirect-parser": "14.2.0",
     "netlify-redirector": "0.4.0",
     "node-fetch": "2.6.12",
     "node-version-alias": "3.4.1",

package/src/commands/dev/dev.mjs

@@ -161,7 +161,7 @@ const dev = async (options, command) => {
     },
   })
 
-  await startFunctionsServer({
+  const functionsRegistry = await startFunctionsServer({
     api,
     command,
     config,
@@ -217,6 +217,7 @@ const dev = async (options, command) => {
     geolocationMode: options.geo,
     geoCountry: options.country,
     accountId,
+    functionsRegistry,
   })
 
   if (devConfig.autoLaunch !== false) {

package/src/commands/serve/serve.mjs

@@ -93,7 +93,7 @@ const serve = async (options, command) => {
     options,
   })
 
-  await startFunctionsServer({
+  const functionsRegistry = await startFunctionsServer({
     api,
     command,
     config,
@@ -132,7 +132,9 @@ const serve = async (options, command) => {
     addonsUrls,
     config,
     configPath: configPathOverride,
+    debug: options.debug,
     env,
+    functionsRegistry,
     geolocationMode: options.geo,
     geoCountry: options.country,
     getUpdatedConfig,

package/src/lib/edge-functions/bootstrap.mjs

@@ -1,5 +1,5 @@
 import { env } from 'process'
 
-const latestBootstrapURL = 'https://64c264287e9cbb0008621df3--edge.netlify.com/bootstrap/index-combined.ts'
+const latestBootstrapURL = 'https://64e7783fce8cfe0008496c72--edge.netlify.com/bootstrap/index-combined.ts'
 
 export const getBootstrapURL = () => env.NETLIFY_EDGE_BOOTSTRAP || latestBootstrapURL

package/src/lib/edge-functions/registry.mjs

@@ -318,23 +318,38 @@ export class EdgeFunctionsRegistry {
       functions: this.#functions,
       featureFlags,
     })
-    const invocationMetadata = {
-      function_config: manifest.function_config,
-      routes: manifest.routes.map((route) => ({ function: route.function, pattern: route.pattern })),
-    }
     const routes = [...manifest.routes, ...manifest.post_cache_routes].map((route) => ({
       ...route,
       pattern: new RegExp(route.pattern),
     }))
-    const functionNames = routes
-      .filter(({ pattern }) => pattern.test(urlPath))
-      .filter(({ function: name }) => {
-        const isExcluded = manifest.function_config[name]?.excluded_patterns?.some((pattern) =>
-          new RegExp(pattern).test(urlPath),
-        )
-        return !isExcluded
-      })
-      .map((route) => route.function)
+
+    /** @type string[] */
+    const functionNames = []
+
+    /** @type number[] */
+    const routeIndexes = []
+
+    routes.forEach((route, index) => {
+      if (!route.pattern.test(urlPath)) {
+        return
+      }
+
+      const isExcluded = manifest.function_config[route.function]?.excluded_patterns?.some((pattern) =>
+        new RegExp(pattern).test(urlPath),
+      )
+
+      if (isExcluded) {
+        return
+      }
+
+      functionNames.push(route.function)
+      routeIndexes.push(index)
+    })
+    const invocationMetadata = {
+      function_config: manifest.function_config,
+      req_routes: routeIndexes,
+      routes: manifest.routes.map((route) => ({ function: route.function, path: route.path, pattern: route.pattern })),
+    }
     const orphanedDeclarations = this.#matchURLPathAgainstOrphanedDeclarations(urlPath)
 
     return { functionNames, invocationMetadata, orphanedDeclarations }

package/src/lib/functions/netlify-function.mjs

@@ -158,6 +158,28 @@ export default class NetlifyFunction {
     }
   }
 
+  async matchURLPath(rawPath) {
+    await this.buildQueue
+
+    const path = (rawPath.endsWith('/') ? rawPath.slice(0, -1) : rawPath).toLowerCase()
+    const { routes = [] } = this.buildData
+    const isMatch = routes.some(({ expression, literal }) => {
+      if (literal !== undefined) {
+        return path === literal
+      }
+
+      if (expression !== undefined) {
+        const regex = new RegExp(expression)
+
+        return regex.test(path)
+      }
+
+      return false
+    })
+
+    return isMatch
+  }
+
   get url() {
     // This line fixes the issue here https://github.com/netlify/cli/issues/4116
     // Not sure why `settings.port` was used here nor does a valid reference exist.

package/src/lib/functions/registry.mjs

@@ -122,6 +122,16 @@ export class FunctionsRegistry {
     return this.functions.get(name)
   }
 
+  async getFunctionForURLPath(urlPath) {
+    for (const func of this.functions.values()) {
+      const isMatch = await func.matchURLPath(urlPath)
+
+      if (isMatch) {
+        return func
+      }
+    }
+  }
+
   async registerFunction(name, funcBeforeHook) {
     const { runtime } = funcBeforeHook
 

package/src/lib/functions/runtimes/js/builders/zisi.mjs

@@ -58,6 +58,7 @@ const buildFunction = async ({
     includedFiles,
     inputs,
     path: functionPath,
+    routes,
     runtimeAPIVersion,
     schedule,
   } = await memoizedBuild({
@@ -81,7 +82,7 @@ const buildFunction = async ({
 
   clearFunctionsCache(targetDirectory)
 
-  return { buildPath, includedFiles, runtimeAPIVersion, srcFiles, schedule }
+  return { buildPath, includedFiles, routes, runtimeAPIVersion, srcFiles, schedule }
 }
 
 /**

package/src/lib/functions/server.mjs

@@ -7,6 +7,7 @@ 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 { NFFunctionName } from '../../utils/headers.mjs'
 import { headers as efHeaders } from '../edge-functions/headers.mjs'
 import { getGeoLocation } from '../geo-location.mjs'
 
@@ -55,9 +56,20 @@ export const createHandler = function (options) {
   const { functionsRegistry } = options
 
   return async function handler(request, response) {
-    // handle proxies without path re-writes (http-servr)
-    const cleanPath = request.path.replace(/^\/.netlify\/(functions|builders)/, '')
-    const functionName = cleanPath.split('/').find(Boolean)
+    // If this header is set, it means we've already matched a function and we
+    // can just grab its name directly. We delete the header from the request
+    // because we don't want to expose it to user code.
+    let functionName = request.header(NFFunctionName)
+    delete request.headers[NFFunctionName]
+
+    // If we didn't match a function with a custom route, let's try to match
+    // using the fixed URL format.
+    if (!functionName) {
+      const cleanPath = request.path.replace(/^\/.netlify\/(functions|builders)/, '')
+
+      functionName = cleanPath.split('/').find(Boolean)
+    }
+
     const func = functionsRegistry.get(functionName)
 
     if (func === undefined) {
@@ -231,7 +243,7 @@ const getFunctionsServer = (options) => {
  * @param {*} options.site
  * @param {string} options.siteUrl
  * @param {*} options.timeouts
- * @returns
+ * @returns {Promise<import('./registry.mjs').FunctionsRegistry | undefined>}
  */
 export const startFunctionsServer = async (options) => {
   const { capabilities, command, config, debug, loadDistFunctions, settings, site, siteUrl, timeouts } = options
@@ -272,9 +284,11 @@ export const startFunctionsServer = async (options) => {
 
   await functionsRegistry.scan(functionsDirectories)
 
-  const server = await getFunctionsServer(Object.assign(options, { functionsRegistry }))
+  const server = getFunctionsServer(Object.assign(options, { functionsRegistry }))
 
   await startWebServer({ server, settings, debug })
+
+  return functionsRegistry
 }
 
 /**

package/src/utils/headers.mjs

@@ -46,4 +46,5 @@ const getErrorMessage = function ({ message }) {
   return message
 }
 
+export const NFFunctionName = 'x-nf-function-name'
 export const NFRequestID = 'x-nf-request-id'

package/src/utils/proxy-server.mjs

@@ -52,6 +52,7 @@ export const generateInspectSettings = (edgeInspect, edgeInspectBrk) => {
  * @param {*} params.siteInfo
  * @param {string} params.projectDir
  * @param {import('./state-config.mjs').default} params.state
+ * @param {import('../lib/functions/registry.mjs').FunctionsRegistry=} params.functionsRegistry
  * @returns
  */
 export const startProxyServer = async ({
@@ -61,6 +62,7 @@ export const startProxyServer = async ({
   configPath,
   debug,
   env,
+  functionsRegistry,
   geoCountry,
   geolocationMode,
   getUpdatedConfig,
@@ -78,6 +80,7 @@ export const startProxyServer = async ({
     configPath: configPath || site.configPath,
     debug,
     env,
+    functionsRegistry,
     geolocationMode,
     geoCountry,
     getUpdatedConfig,

package/src/utils/proxy.mjs

@@ -31,7 +31,7 @@ import renderErrorTemplate from '../lib/render-error-template.mjs'
 
 import { NETLIFYDEVLOG, NETLIFYDEVWARN, log, chalk } from './command-helpers.mjs'
 import createStreamPromise from './create-stream-promise.mjs'
-import { headersForPath, parseHeaders, NFRequestID } from './headers.mjs'
+import { headersForPath, parseHeaders, NFFunctionName, NFRequestID } from './headers.mjs'
 import { generateRequestID } from './request-id.mjs'
 import { createRewriter, onChanges } from './rules-proxy.mjs'
 import { signRedirect } from './sign-redirect.mjs'
@@ -181,7 +181,7 @@ const alternativePathsFor = function (url) {
   return paths
 }
 
-const serveRedirect = async function ({ env, match, options, proxy, req, res, siteInfo }) {
+const serveRedirect = async function ({ env, functionsRegistry, match, options, proxy, req, res, siteInfo }) {
   if (!match) return proxy.web(req, res, options)
 
   options = options || req.proxyOptions || {}
@@ -214,6 +214,7 @@ const serveRedirect = async function ({ env, match, options, proxy, req, res, si
   if (isFunction(options.functionsPort, req.url)) {
     return proxy.web(req, res, { target: options.functionsServer })
   }
+
   const urlForAddons = getAddonUrl(options.addonsUrls, req)
   if (urlForAddons) {
     return handleAddonUrl({ req, res, addonUrl: urlForAddons })
@@ -327,22 +328,28 @@ const serveRedirect = async function ({ env, match, options, proxy, req, res, si
       return proxy.web(req, res, { target: options.functionsServer })
     }
 
+    const functionWithCustomRoute = functionsRegistry && (await functionsRegistry.getFunctionForURLPath(destURL))
     const destStaticFile = await getStatic(dest.pathname, options.publicFolder)
     let statusValue
-    if (match.force || (!staticFile && ((!options.framework && destStaticFile) || isInternal(destURL)))) {
+    if (
+      match.force ||
+      (!staticFile && ((!options.framework && destStaticFile) || isInternal(destURL) || functionWithCustomRoute))
+    ) {
       req.url = destStaticFile ? destStaticFile + dest.search : destURL
       const { status } = match
       statusValue = status
       console.log(`${NETLIFYDEVLOG} Rewrote URL to`, req.url)
     }
 
-    if (isFunction(options.functionsPort, req.url)) {
+    if (isFunction(options.functionsPort, req.url) || functionWithCustomRoute) {
+      const functionHeaders = functionWithCustomRoute ? { [NFFunctionName]: functionWithCustomRoute.name } : {}
       const url = reqToURL(req, originalURL)
       req.headers['x-netlify-original-pathname'] = url.pathname
       req.headers['x-netlify-original-search'] = url.search
 
-      return proxy.web(req, res, { target: options.functionsServer })
+      return proxy.web(req, res, { headers: functionHeaders, target: options.functionsServer })
     }
+
     const addonUrl = getAddonUrl(options.addonsUrls, req)
     if (addonUrl) {
       return handleAddonUrl({ req, res, addonUrl })
@@ -434,12 +441,22 @@ const initializeProxy = async function ({ configPath, distDir, env, host, port,
     }
 
     if (proxyRes.statusCode === 404 || proxyRes.statusCode === 403) {
+      // If a request for `/path` has failed, we'll a few variations like
+      // `/path/index.html` to mimic the CDN behavior.
       if (req.alternativePaths && req.alternativePaths.length !== 0) {
         req.url = req.alternativePaths.shift()
         return proxy.web(req, res, req.proxyOptions)
       }
+
+      // The request has failed but we might still have a matching redirect
+      // rule (without `force`) that should kick in. This is how we mimic the
+      // file shadowing behavior from the CDN.
       if (req.proxyOptions && req.proxyOptions.match) {
         return serveRedirect({
+          // We don't want to match functions at this point because any redirects
+          // to functions will have already been processed, so we don't supply a
+          // functions registry to `serveRedirect`.
+          functionsRegistry: null,
           req,
           res,
           proxy: handlers,
@@ -453,7 +470,19 @@ const initializeProxy = async function ({ configPath, distDir, env, host, port,
 
     if (req.proxyOptions.staticFile && isRedirect({ status: proxyRes.statusCode }) && proxyRes.headers.location) {
       req.url = proxyRes.headers.location
-      return serveRedirect({ req, res, proxy: handlers, match: null, options: req.proxyOptions, siteInfo, env })
+      return serveRedirect({
+        // We don't want to match functions at this point because any redirects
+        // to functions will have already been processed, so we don't supply a
+        // functions registry to `serveRedirect`.
+        functionsRegistry: null,
+        req,
+        res,
+        proxy: handlers,
+        match: null,
+        options: req.proxyOptions,
+        siteInfo,
+        env,
+      })
     }
 
     const responseData = []
@@ -551,7 +580,7 @@ const initializeProxy = async function ({ configPath, distDir, env, host, port,
 }
 
 const onRequest = async (
-  { addonsUrls, edgeFunctionsProxy, env, functionsServer, proxy, rewriter, settings, siteInfo },
+  { addonsUrls, edgeFunctionsProxy, env, functionsRegistry, functionsServer, proxy, rewriter, settings, siteInfo },
   req,
   res,
 ) => {
@@ -565,9 +594,22 @@ 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) : null
+
+  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.name }
+
+    return proxy.web(req, res, { headers, target: functionsServer })
+  }
+
   const addonUrl = getAddonUrl(addonsUrls, req)
   if (addonUrl) {
     return handleAddonUrl({ req, res, addonUrl })
@@ -591,7 +633,7 @@ const onRequest = async (
     // We don't want to generate an ETag for 3xx redirects.
     req[shouldGenerateETag] = ({ statusCode }) => statusCode < 300 || statusCode >= 400
 
-    return serveRedirect({ req, res, proxy, match, options, siteInfo, env })
+    return serveRedirect({ req, res, proxy, match, options, siteInfo, env, functionsRegistry })
   }
 
   // The request will be served by the framework server, which means we want to
@@ -628,6 +670,7 @@ export const startProxy = async function ({
   configPath,
   debug,
   env,
+  functionsRegistry,
   geoCountry,
   geolocationMode,
   getUpdatedConfig,
@@ -681,6 +724,7 @@ export const startProxy = async function ({
     rewriter,
     settings,
     addonsUrls,
+    functionsRegistry,
     functionsServer,
     edgeFunctionsProxy,
     siteInfo,