fix: functions:serve should serve V2 Functions

src/commands/dev/dev.ts

@@ -164,7 +164,6 @@ export const dev = async (options: OptionValues, command: BaseCommand) => {
   })
 
   const functionsRegistry = await startFunctionsServer({
-    api,
     blobsContext,
     command,
     config,

src/commands/functions/functions-serve.ts

@@ -2,9 +2,16 @@ import { join } from 'path'
 
 import { OptionValues } from 'commander'
 
+import { getBlobsContext } from '../../lib/blobs/blobs.js'
 import { startFunctionsServer } from '../../lib/functions/server.js'
 import { printBanner } from '../../utils/banner.js'
-import { acquirePort, getDotEnvVariables, getSiteInformation, injectEnvVariables } from '../../utils/dev.js'
+import {
+  UNLINKED_SITE_MOCK_ID,
+  acquirePort,
+  getDotEnvVariables,
+  getSiteInformation,
+  injectEnvVariables,
+} from '../../utils/dev.js'
 import { getFunctionsDir } from '../../utils/functions/index.js'
 import { getProxyUrl } from '../../utils/proxy.js'
 import BaseCommand from '../base-command.js'
@@ -35,19 +42,23 @@ export const functionsServe = async (options: OptionValues, command: BaseCommand
     errorMessage: 'Could not acquire configured functions port',
   })
 
+  const blobsContext = await getBlobsContext({
+    debug: options.debug,
+    projectRoot: command.workingDir,
+    siteID: site.id ?? UNLINKED_SITE_MOCK_ID,
+  })
+
   await startFunctionsServer({
+    blobsContext,
     config,
     debug: options.debug,
     command,
-    api,
     settings: { functions: functionsDir, functionsPort },
     site,
     siteInfo,
     siteUrl,
     capabilities,
     timeouts,
-    functionsPrefix: '/.netlify/functions/',
-    buildersPrefix: '/.netlify/builders/',
     geolocationMode: options.geo,
     geoCountry: options.country,
     offline: options.offline,

src/commands/serve/serve.ts

@@ -104,7 +104,6 @@ export const serve = async (options: OptionValues, command: BaseCommand) => {
   })
 
   const functionsRegistry = await startFunctionsServer({
-    api,
     blobsContext,
     command,
     config,

src/lib/functions/form-submissions-handler.ts

@@ -2,6 +2,7 @@ import { Readable } from 'stream'
 
 // @ts-expect-error TS(7016) FIXME: Could not find a declaration file for module 'cont... Remove this comment to see the full error message
 import { parse as parseContentType } from 'content-type'
+import type { RequestHandler } from 'express'
 // @ts-expect-error TS(7016) FIXME: Could not find a declaration file for module 'mult... Remove this comment to see the full error message
 import multiparty from 'multiparty'
 import getRawBody from 'raw-body'
@@ -10,6 +11,8 @@ import { warn } from '../../utils/command-helpers.js'
 import { BACKGROUND } from '../../utils/functions/index.js'
 import { capitalize } from '../string.js'
 
+import type { FunctionsRegistry } from './registry.js'
+
 // @ts-expect-error TS(7031) FIXME: Binding element 'functionsRegistry' implicitly has... Remove this comment to see the full error message
 const getFormHandler = function ({ functionsRegistry }) {
   const handlers = ['submission-created', `submission-created${BACKGROUND}`]
@@ -29,14 +32,18 @@ const getFormHandler = function ({ functionsRegistry }) {
   return handlers[0]
 }
 
-// @ts-expect-error TS(7031) FIXME: Binding element 'functionsRegistry' implicitly has... Remove this comment to see the full error message
-export const createFormSubmissionHandler = function ({ functionsRegistry, siteUrl }) {
-  // @ts-expect-error TS(7006) FIXME: Parameter 'req' implicitly has an 'any' type.
+export const createFormSubmissionHandler = function ({
+  functionsRegistry,
+  siteUrl,
+}: {
+  functionsRegistry: FunctionsRegistry
+  siteUrl: string
+}): RequestHandler {
   return async function formSubmissionHandler(req, res, next) {
     if (
       req.url.startsWith('/.netlify/') ||
       req.method !== 'POST' ||
-      (await functionsRegistry.getFunctionForURLPath(req.url, req.method))
+      (await functionsRegistry.getFunctionForURLPath(req.url, req.method, () => Promise.resolve(false)))
     )
       return next()
 
@@ -159,7 +166,7 @@ export const createFormSubmissionHandler = function ({ functionsRegistry, siteUr
     req.body = data
     req.headers = {
       ...req.headers,
-      'content-length': data.length,
+      'content-length': String(data.length),
       'content-type': 'application/json',
       'x-netlify-original-pathname': originalUrl.pathname,
       'x-netlify-original-search': originalUrl.search,

src/lib/functions/netlify-function.ts

@@ -40,7 +40,7 @@ export default class NetlifyFunction {
 
   // Determines whether this is a background function based on the function
   // name.
-  private readonly isBackground: boolean
+  public readonly isBackground: boolean
 
   private buildQueue?: Promise<$FIXME>
   private buildData?: $FIXME
@@ -270,7 +270,7 @@ export default class NetlifyFunction {
 
     let path = rawPath !== '/' && rawPath.endsWith('/') ? rawPath.slice(0, -1) : rawPath
     path = path.toLowerCase()
-    const { routes = [] } = this.buildData
+    const { routes = [] } = this.buildData ?? {}
     // @ts-expect-error TS(7031) FIXME: Binding element 'expression' implicitly has an 'an... Remove this comment to see the full error message
     const route = routes.find(({ expression, literal, methods }) => {
       if (methods.length !== 0 && !methods.includes(method)) {

src/lib/functions/registry.ts

@@ -277,7 +277,7 @@ export class FunctionsRegistry {
         return { func: null, route: null }
       }
 
-      const { routes = [] } = await func.getBuildData()
+      const { routes = [] } = (await func.getBuildData()) ?? {}
 
       if (routes.length !== 0) {
         // @ts-expect-error TS(7006) FIXME: Parameter 'route' implicitly has an 'any' type.

src/lib/functions/server.ts

@@ -2,11 +2,13 @@ import { Buffer } from 'buffer'
 import { promises as fs } from 'fs'
 import path from 'path'
 
-import express from 'express'
+import express, { type RequestHandler } from 'express'
 // @ts-expect-error TS(7016) FIXME: Could not find a declaration file for module 'expr... Remove this comment to see the full error message
 import expressLogging from 'express-logging'
 import jwtDecode from 'jwt-decode'
 
+import type BaseCommand from '../../commands/base-command.js'
+import type { $TSFixMe } from '../../commands/types.js'
 import { NETLIFYDEVERR, NETLIFYDEVLOG, error as errorExit, log } from '../../utils/command-helpers.js'
 import { isFeatureFlagEnabled } from '../../utils/feature-flags.js'
 import {
@@ -16,6 +18,7 @@ import {
   getInternalFunctionsDir,
 } from '../../utils/functions/index.js'
 import { NFFunctionName, NFFunctionRoute } from '../../utils/headers.js'
+import type { BlobsContext } from '../blobs/blobs.js'
 import { headers as efHeaders } from '../edge-functions/headers.js'
 import { getGeoLocation } from '../geo-location.js'
 
@@ -78,11 +81,9 @@ const hasBody = (req) =>
   // we expect a string or a buffer, because we use the two bodyParsers(text, raw) from express
   (typeof req.body === 'string' || Buffer.isBuffer(req.body))
 
-// @ts-expect-error TS(7006) FIXME: Parameter 'options' implicitly has an 'any' type.
-export const createHandler = function (options) {
+export const createHandler = function (options: GetFunctionsServerOptions): RequestHandler {
   const { functionsRegistry } = options
 
-  // @ts-expect-error TS(7006) FIXME: Parameter 'request' implicitly has an 'any' type.
   return async function handler(request, response) {
     // 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
@@ -92,15 +93,22 @@ export const createHandler = function (options) {
     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 there's still no function found, we check the functionsRegistry again.
+    // This is needed for the functions:serve command, where the dev server that normally does the matching doesn't run.
+    // It also matches the default URL (.netlify/functions/builders)
     if (!functionName) {
-      const cleanPath = request.path.replace(/^\/.netlify\/(functions|builders)/, '')
-
-      functionName = cleanPath.split('/').find(Boolean)
+      const match = await functionsRegistry.getFunctionForURLPath(
+        request.url,
+        request.method,
+        // we're pretending there's no static file at the same URL.
+        // This is wrong, but in local dev we already did the matching
+        // in a downstream server where we had access to the file system, so this never hits.
+        () => Promise.resolve(false),
+      )
+      functionName = match?.func?.name
     }
 
-    const func = functionsRegistry.get(functionName)
+    const func = functionsRegistry.get(functionName ?? '')
 
     if (func === undefined) {
       response.statusCode = 404
@@ -121,16 +129,14 @@ export const createHandler = function (options) {
     }
 
     let remoteAddress = request.header('x-forwarded-for') || request.connection.remoteAddress || ''
-    remoteAddress = remoteAddress
-      .split(remoteAddress.includes('.') ? ':' : ',')
-      .pop()
-      .trim()
-
-    let requestPath = request.path
-    if (request.header('x-netlify-original-pathname')) {
-      requestPath = request.header('x-netlify-original-pathname')
-      delete request.headers['x-netlify-original-pathname']
-    }
+    remoteAddress =
+      remoteAddress
+        .split(remoteAddress.includes('.') ? ':' : ',')
+        .pop()
+        ?.trim() ?? ''
+
+    const requestPath = request.header('x-netlify-original-pathname') ?? request.path
+    delete request.headers['x-netlify-original-pathname']
 
     let requestQuery = request.query
     if (request.header('x-netlify-original-search')) {
@@ -151,7 +157,7 @@ export const createHandler = function (options) {
       {},
     )
 
-    const geoLocation = await getGeoLocation({ ...options, mode: options.geo })
+    const geoLocation = await getGeoLocation({ ...options, mode: options.geolocationMode })
 
     const headers = Object.entries({
       ...request.headers,
@@ -161,7 +167,7 @@ export const createHandler = function (options) {
       'x-nf-site-id': [options?.siteInfo?.id ?? UNLINKED_SITE_MOCK_ID],
       [efHeaders.Geo]: Buffer.from(JSON.stringify(geoLocation)).toString('base64'),
     }).reduce((prev, [key, value]) => ({ ...prev, [key]: Array.isArray(value) ? value : [value] }), {})
-    const rawQuery = new URLSearchParams(requestQuery).toString()
+    const rawQuery = new URLSearchParams(requestQuery as Record<string, string>).toString()
     const protocol = options.config?.dev?.https ? 'https' : 'http'
     const url = new URL(requestPath, `${protocol}://${request.get('host') || 'localhost'}`)
     url.search = rawQuery
@@ -235,9 +241,20 @@ export const createHandler = function (options) {
   }
 }
 
-// @ts-expect-error TS(7006) FIXME: Parameter 'options' implicitly has an 'any' type.
-const getFunctionsServer = (options) => {
-  const { buildersPrefix = '', functionsPrefix = '', functionsRegistry, siteUrl } = options
+interface GetFunctionsServerOptions {
+  functionsRegistry: FunctionsRegistry
+  siteUrl: string
+  siteInfo?: $TSFixMe
+  accountId: string
+  geoCountry: string
+  offline: boolean
+  state: $TSFixMe
+  config: $TSFixMe
+  geolocationMode: 'cache' | 'update' | 'mock'
+}
+
+const getFunctionsServer = (options: GetFunctionsServerOptions) => {
+  const { functionsRegistry, siteUrl } = options
   const app = express()
   const functionHandler = createHandler(options)
 
@@ -257,30 +274,25 @@ const getFunctionsServer = (options) => {
     }),
   )
 
-  app.all(`${functionsPrefix}*`, functionHandler)
-  app.all(`${buildersPrefix}*`, functionHandler)
+  app.all('*', functionHandler)
 
   return app
 }
 
-/**
- *
- * @param {object} options
- * @param {import("../blobs/blobs.js").BlobsContext} options.blobsContext
- * @param {import('../../commands/base-command.js').default} options.command
- * @param {*} options.capabilities
- * @param {*} options.config
- * @param {boolean} options.debug
- * @param {*} options.loadDistFunctions
- * @param {*} options.settings
- * @param {*} options.site
- * @param {*} options.siteInfo
- * @param {string} options.siteUrl
- * @param {*} options.timeouts
- * @returns {Promise<import('./registry.js').FunctionsRegistry | undefined>}
- */
-// @ts-expect-error TS(7006) FIXME: Parameter 'options' implicitly has an 'any' type.
-export const startFunctionsServer = async (options) => {
+export const startFunctionsServer = async (
+  options: {
+    blobsContext: BlobsContext
+    command: BaseCommand
+    config: $TSFixMe
+    capabilities: $TSFixMe
+    debug: boolean
+    loadDistFunctions?: boolean
+    settings: $TSFixMe
+    site: $TSFixMe
+    siteInfo: $TSFixMe
+    timeouts: $TSFixMe
+  } & Omit<GetFunctionsServerOptions, 'functionsRegistry'>,
+): Promise<FunctionsRegistry | undefined> => {
   const {
     blobsContext,
     capabilities,
@@ -356,31 +368,30 @@ export const startFunctionsServer = async (options) => {
 
   await functionsRegistry.scan(functionsDirectories)
 
-  const server = getFunctionsServer(Object.assign(options, { functionsRegistry }))
+  const server = getFunctionsServer({ ...options, functionsRegistry })
 
   await startWebServer({ server, settings, debug })
 
   return functionsRegistry
 }
 
-/**
- *
- * @param {object} config
- * @param {boolean} config.debug
- * @param {ReturnType<Awaited<typeof getFunctionsServer>>} config.server
- * @param {*} config.settings
- */
-// @ts-expect-error TS(7031) FIXME: Binding element 'debug' implicitly has an 'any' ty... Remove this comment to see the full error message
-const startWebServer = async ({ debug, server, settings }) => {
-  await new Promise((/** @type {(resolve: void) => void} */ resolve) => {
+const startWebServer = async ({
+  debug,
+  server,
+  settings,
+}: {
+  debug: boolean
+  server: ReturnType<Awaited<typeof getFunctionsServer>>
+  settings: $TSFixMe
+}) => {
+  await new Promise<void>((resolve) => {
     // @ts-expect-error TS(7006) FIXME: Parameter 'err' implicitly has an 'any' type.
-    server.listen(settings.functionsPort, (/** @type {unknown} */ err) => {
+    server.listen(settings.functionsPort, (err) => {
       if (err) {
         errorExit(`${NETLIFYDEVERR} Unable to start functions server: ${err}`)
       } else if (debug) {
         log(`${NETLIFYDEVLOG} Functions server is listening on ${settings.functionsPort}`)
       }
-      // @ts-expect-error TS(2794) FIXME: Expected 1 arguments, but got 0. Did you forget to... Remove this comment to see the full error message
       resolve()
     })
   })

tests/integration/commands/dev/dev-miscellaneous.test.js

@@ -719,7 +719,7 @@ describe.concurrent('commands/dev-miscellaneous', () => {
   })
 
   test(`catches invalid function names`, async (t) => {
-    await withSiteBuilder('site-with-functions', async (builder) => {
+    await withSiteBuilder(t, async (builder) => {
       const functionsPort = 6667
       await builder
         .withNetlifyToml({ config: { functions: { directory: 'functions' }, dev: { functionsPort } } })
@@ -733,7 +733,7 @@ describe.concurrent('commands/dev-miscellaneous', () => {
         .buildAsync()
 
       await withDevServer({ cwd: builder.directory }, async ({ port, url }) => {
-        const response = await fetch(`${url.replace(port, functionsPort)}/exclamat!on`, {
+        const response = await fetch(`${url.replace(port, functionsPort)}/.netlify/functions/exclamat!on`, {
           method: 'POST',
           headers: {
             'Content-Type': 'application/json',