netlify-cli 16.1.0 → 16.3.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "netlify-cli",
   "description": "Netlify command line tool",
-  "version": "16.1.0",
+  "version": "16.3.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/config": "20.8.0",
-    "@netlify/edge-bundler": "8.17.1",
+    "@netlify/build": "29.20.12",
+    "@netlify/build-info": "7.8.0",
+    "@netlify/config": "20.8.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.3",
     "@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/lm/lm-info.mjs

@@ -37,4 +37,4 @@ const lmInfo = async () => {
  * @returns
  */
 export const createLmInfoCommand = (program) =>
-  program.command('lm:info').description('Show large media requirements information.').action(lmInfo)
+  program.command('lm:info', { hidden: true }).description('Show large media requirements information.').action(lmInfo)

package/src/commands/lm/lm-install.mjs

@@ -20,7 +20,7 @@ const lmInstall = async ({ force }) => {
  */
 export const createLmInstallCommand = (program) =>
   program
-    .command('lm:install')
+    .command('lm:install', { hidden: true })
     .alias('lm:init')
     .description(
       `Configures your computer to use Netlify Large Media

package/src/commands/lm/lm-setup.mjs

@@ -97,7 +97,7 @@ const lmSetup = async (options, command) => {
  */
 export const createLmSetupCommand = (program) =>
   program
-    .command('lm:setup')
+    .command('lm:setup', { hidden: true })
     .description('Configures your site to use Netlify Large Media')
     .option('-s, --skip-install', 'Skip the credentials helper installation check')
     .option('-f, --force-install', 'Force the credentials helper installation')

package/src/commands/lm/lm.mjs

@@ -25,8 +25,10 @@ export const createLmCommand = (program) => {
   createLmUninstallCommand(program)
 
   program
-    .command('lm')
-    .description('Handle Netlify Large Media operations\nThe lm command will help you manage large media for a site')
+    .command('lm', { hidden: true })
+    .description(
+      '[Deprecated and will be removed from future versions] Handle Netlify Large Media operations\nThe lm command will help you manage large media for a site',
+    )
     .addExamples(['netlify lm:info', 'netlify lm:install', 'netlify lm:setup'])
     .action(lm)
 }

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://64f73321fdd56900083fa618--edge.netlify.com/bootstrap/index-combined.ts'
 
 export const getBootstrapURL = () => env.NETLIFY_EDGE_BOOTSTRAP || latestBootstrapURL

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

@@ -5,10 +5,13 @@ export const headers = {
   DeployID: 'x-nf-deploy-id',
   FeatureFlags: 'x-nf-feature-flags',
   ForwardedHost: 'x-forwarded-host',
+  ForwardedProtocol: 'x-forwarded-proto',
   Functions: 'x-nf-edge-functions',
   InvocationMetadata: 'x-nf-edge-functions-metadata',
   Geo: 'x-nf-geo',
   Passthrough: 'x-nf-passthrough',
+  PassthroughHost: 'x-nf-passthrough-host',
+  PassthroughProtocol: 'x-nf-passthrough-proto',
   IP: 'x-nf-client-connection-ip',
   Site: 'X-NF-Site-Info',
   DebugLogging: 'x-nf-debug-logging',

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

@@ -78,6 +78,7 @@ export const createAccountInfoHeader = (accountInfo = {}) => {
  * @param {boolean=} config.offline
  * @param {*} config.passthroughPort
  * @param {*} config.projectDir
+ * @param {*} config.settings
  * @param {*} config.siteInfo
  * @param {*} config.state
  * @returns
@@ -96,6 +97,7 @@ export const initializeProxy = async ({
   offline,
   passthroughPort,
   projectDir,
+  settings,
   siteInfo,
   state,
 }) => {
@@ -146,7 +148,7 @@ export const initializeProxy = async ({
     await registry.initialize()
 
     const url = new URL(req.url, `http://${LOCAL_HOST}:${mainPort}`)
-    const { functionNames, invocationMetadata, orphanedDeclarations } = registry.matchURLPath(url.pathname)
+    const { functionNames, invocationMetadata, orphanedDeclarations } = registry.matchURLPath(url.pathname, req.method)
 
     // If the request matches a config declaration for an Edge Function without
     // a matching function file, we warn the user.
@@ -167,28 +169,22 @@ export const initializeProxy = async ({
     }
 
     const featureFlags = ['edge_functions_bootstrap_failure_mode']
-    const forwardedHost = `localhost:${passthroughPort}`
 
     req[headersSymbol] = {
       [headers.FeatureFlags]: getFeatureFlagsHeader(featureFlags),
-      [headers.ForwardedHost]: forwardedHost,
+      [headers.ForwardedProtocol]: settings.https ? 'https:' : 'http:',
       [headers.Functions]: functionNames.join(','),
       [headers.InvocationMetadata]: getInvocationMetadataHeader(invocationMetadata),
       [headers.IP]: LOCAL_HOST,
       [headers.Passthrough]: 'passthrough',
+      [headers.PassthroughHost]: `localhost:${passthroughPort}`,
+      [headers.PassthroughProtocol]: 'http:',
     }
 
     if (debug) {
       req[headersSymbol][headers.DebugLogging] = '1'
     }
 
-    // If we're using a different port for passthrough requests, which is the
-    // case when the CLI is running on HTTPS, use it on the Host header so
-    // that the request URL inside the edge function is something accessible.
-    if (mainPort !== passthroughPort) {
-      req[headersSymbol].host = forwardedHost
-    }
-
     return `http://${LOCAL_HOST}:${isolatePort}`
   }
 }

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

@@ -302,8 +302,9 @@ export class EdgeFunctionsRegistry {
 
   /**
    * @param {string} urlPath
+   * @param {string} method
    */
-  matchURLPath(urlPath) {
+  matchURLPath(urlPath, method) {
     const declarations = this.#bundler.mergeDeclarations(
       this.#declarationsFromTOML,
       this.#userFunctionConfigs,
@@ -318,23 +319,42 @@ 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.methods && route.methods.length !== 0 && !route.methods.includes(method)) {
+        return
+      }
+
+      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,36 @@ export default class NetlifyFunction {
     }
   }
 
+  /**
+   * Matches all routes agains the incoming request. If a match is found, then the matched route is returned.
+   * @param {string} rawPath
+   * @param {string} method
+   * @returns matched route
+   */
+  async matchURLPath(rawPath, method) {
+    await this.buildQueue
+
+    const path = (rawPath.endsWith('/') ? rawPath.slice(0, -1) : rawPath).toLowerCase()
+    const { routes = [] } = this.buildData
+    return routes.find(({ expression, literal, methods }) => {
+      if (methods.length !== 0 && !methods.includes(method)) {
+        return false
+      }
+
+      if (literal !== undefined) {
+        return path === literal
+      }
+
+      if (expression !== undefined) {
+        const regex = new RegExp(expression)
+
+        return regex.test(path)
+      }
+
+      return false
+    })
+  }
+
   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, method) {
+    for (const func of this.functions.values()) {
+      const route = await func.matchURLPath(urlPath, method)
+
+      if (route) {
+        return { func, route }
+      }
+    }
+  }
+
   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, NFFunctionRoute } from '../../utils/headers.mjs'
 import { headers as efHeaders } from '../edge-functions/headers.mjs'
 import { getGeoLocation } from '../geo-location.mjs'
 
@@ -55,9 +56,22 @@ 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 these headers are 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]
+    const functionRoute = request.header(NFFunctionRoute)
+    delete request.headers[NFFunctionRoute]
+
+    // 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) {
@@ -136,6 +150,7 @@ export const createHandler = function (options) {
       isBase64Encoded,
       rawUrl,
       rawQuery,
+      route: functionRoute,
     }
 
     const clientContext = buildClientContext(request.headers) || {}
@@ -231,7 +246,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 +287,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,6 @@ const getErrorMessage = function ({ message }) {
   return message
 }
 
+export const NFFunctionName = 'x-nf-function-name'
+export const NFFunctionRoute = 'x-nf-function-route'
 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, NFFunctionRoute } 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,31 @@ 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, req.method))
     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.func.name, [NFFunctionRoute]: functionWithCustomRoute.route }
+        : {}
       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 +444,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 +473,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 +583,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 +597,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, req.method) : 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.func.name, [NFFunctionRoute]: functionMatch.route.pattern }
+
+    return proxy.web(req, res, { headers, target: functionsServer })
+  }
+
   const addonUrl = getAddonUrl(addonsUrls, req)
   if (addonUrl) {
     return handleAddonUrl({ req, res, addonUrl })
@@ -591,7 +636,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 +673,7 @@ export const startProxy = async function ({
   configPath,
   debug,
   env,
+  functionsRegistry,
   geoCountry,
   geolocationMode,
   getUpdatedConfig,
@@ -652,6 +698,7 @@ export const startProxy = async function ({
     mainPort: settings.port,
     offline,
     passthroughPort: secondaryServerPort || settings.port,
+    settings,
     projectDir,
     siteInfo,
     accountId,
@@ -681,6 +728,7 @@ export const startProxy = async function ({
     rewriter,
     settings,
     addonsUrls,
+    functionsRegistry,
     functionsServer,
     edgeFunctionsProxy,
     siteInfo,