feat: load generated functions from Netlify Build

src/commands/dev/dev.ts

@@ -191,7 +191,7 @@ export const dev = async (options: OptionValues, command: BaseCommand) => {
 
   log(`${NETLIFYDEVLOG} Setting up local dev server`)
 
-  const { configMutations, configPath: configPathOverride } = await runDevTimeline({
+  const { configMutations, generatedFunctions } = await runDevTimeline({
     command,
     options,
     settings,
@@ -208,7 +208,7 @@ export const dev = async (options: OptionValues, command: BaseCommand) => {
     blobsContext,
     command,
     config: mutatedConfig,
-
+    generatedFunctions,
     debug: options.debug,
     settings,
     site,
@@ -247,7 +247,6 @@ export const dev = async (options: OptionValues, command: BaseCommand) => {
     blobsContext,
     command,
     config: mutatedConfig,
-    configPath: configPathOverride,
     debug: options.debug,
     disableEdgeFunctions: options.internalDisableEdgeFunctions,
     projectDir: command.workingDir,

src/commands/functions/functions-serve.ts

@@ -61,6 +61,7 @@ export const functionsServe = async (options: OptionValues, command: BaseCommand
     siteUrl,
     capabilities,
     timeouts,
+    generatedFunctions: [],
     geolocationMode: options.geo,
     geoCountry: options.country,
     offline: options.offline,

src/commands/serve/serve.ts

@@ -110,7 +110,7 @@ export const serve = async (options: OptionValues, command: BaseCommand) => {
   // which is what build plugins use.
   process.env[BLOBS_CONTEXT_VARIABLE] = encodeBlobsContext(await getBlobsContextWithAPIAccess(blobsOptions))
 
-  const { configPath: configPathOverride } = await runBuildTimeline({
+  const { configPath: configPathOverride, generatedFunctions } = await runBuildTimeline({
     command,
     settings,
     options,
@@ -130,6 +130,7 @@ export const serve = async (options: OptionValues, command: BaseCommand) => {
     command,
     config: mergedConfig,
     debug: options.debug,
+    generatedFunctions,
     loadDistFunctions: true,
     settings,
     site,

src/lib/functions/netlify-function.ts

@@ -56,6 +56,11 @@ export default class NetlifyFunction<BuildResult extends BaseBuildResult> {
   public readonly runtime: Runtime<BuildResult>
   public schedule?: string
 
+  // The path to the function boundary: if the function is in a sub-directory,
+  // this will hold the path to the sub-directory; if not, it's the path to the
+  // main file.
+  public readonly srcPath: string
+
   // Determines whether this is a background function based on the function
   // name.
   public readonly isBackground: boolean
@@ -78,6 +83,7 @@ export default class NetlifyFunction<BuildResult extends BaseBuildResult> {
     projectRoot,
     runtime,
     settings,
+    srcPath,
     timeoutBackground,
     timeoutSynchronous,
   }: {
@@ -91,6 +97,7 @@ export default class NetlifyFunction<BuildResult extends BaseBuildResult> {
     runtime: Runtime<BuildResult>
     // TODO(serhalp): This is confusing. Refactor to accept entire settings or rename or something?
     settings: Pick<ServerSettings, 'functions' | 'functionsPort'>
+    srcPath: string
     timeoutBackground?: number
     timeoutSynchronous?: number
   }) {
@@ -105,6 +112,7 @@ export default class NetlifyFunction<BuildResult extends BaseBuildResult> {
     this.timeoutBackground = timeoutBackground
     this.timeoutSynchronous = timeoutSynchronous
     this.settings = settings
+    this.srcPath = srcPath
 
     this.isBackground = name.endsWith(BACKGROUND)
 

src/lib/functions/registry.ts

@@ -3,6 +3,7 @@ import { createRequire } from 'module'
 import { basename, extname, isAbsolute, join, resolve } from 'path'
 import { env } from 'process'
 
+import type { GeneratedFunction } from '@netlify/build'
 import { type ListedFunction, listFunctions, type Manifest } from '@netlify/zip-it-and-ship-it'
 import extractZip from 'extract-zip'
 
@@ -74,6 +75,7 @@ export class FunctionsRegistry {
   private config: NormalizedCachedConfigConfig
   private debug: boolean
   private frameworksAPIPaths: ReturnType<typeof getFrameworksAPIPaths>
+  private generatedFunctions: GeneratedFunction[]
   private isConnected: boolean
   private logLambdaCompat: boolean
   private manifest?: Manifest
@@ -88,6 +90,7 @@ export class FunctionsRegistry {
     config,
     debug = false,
     frameworksAPIPaths,
+    generatedFunctions,
     isConnected = false,
     logLambdaCompat,
     manifest,
@@ -103,6 +106,7 @@ export class FunctionsRegistry {
     config: NormalizedCachedConfigConfig
     debug?: boolean
     frameworksAPIPaths: ReturnType<typeof getFrameworksAPIPaths>
+    generatedFunctions: GeneratedFunction[]
     isConnected?: boolean
     logLambdaCompat: boolean
     manifest?: Manifest
@@ -115,6 +119,7 @@ export class FunctionsRegistry {
     this.config = config
     this.debug = debug
     this.frameworksAPIPaths = frameworksAPIPaths
+    this.generatedFunctions = generatedFunctions ?? []
     this.isConnected = isConnected
     this.projectRoot = projectRoot
     this.timeouts = timeouts
@@ -465,14 +470,32 @@ export class FunctionsRegistry {
 
     await Promise.all(directories.map((path) => FunctionsRegistry.prepareDirectory(path)))
 
-    const functions = await this.listFunctions(directories, {
-      featureFlags: {
-        buildRustSource: env.NETLIFY_EXPERIMENTAL_BUILD_RUST_SOURCE === 'true',
+    const functions = await this.listFunctions(
+      {
+        generated: {
+          functions: this.generatedFunctions.map((func) => func.path),
+        },
+        user: {
+          // In reality, `directories` contains both directories with user and
+          // generated functions. The registry currently lacks knowledge about
+          // the contents of each directory, so we put them in the same bag and
+          // rely on the order of the directories to get the priority right.
+          // But now that zip-it-and-ship-it accepts an object with mixed paths
+          // that lets us specify exactly which paths contain user functions or
+          // generated functions, we should refactor this call so it encodes
+          // that distiction.
+          directories,
+        },
       },
-      configFileDirectories: [getPathInProject([INTERNAL_FUNCTIONS_FOLDER])],
-      // @ts-expect-error -- TODO(serhalp): Function config types do not match. Investigate and fix.
-      config: this.config.functions,
-    })
+      {
+        featureFlags: {
+          buildRustSource: env.NETLIFY_EXPERIMENTAL_BUILD_RUST_SOURCE === 'true',
+        },
+        configFileDirectories: [getPathInProject([INTERNAL_FUNCTIONS_FOLDER])],
+        // @ts-expect-error -- TODO(serhalp): Function config types do not match. Investigate and fix.
+        config: this.config.functions,
+      },
+    )
 
     // user-defined functions take precedence over internal functions,
     // so we want to ignore any internal functions where there's a user-defined one with the same name
@@ -506,7 +529,7 @@ export class FunctionsRegistry {
       // zip-it-and-ship-it returns an array sorted based on which extension should have precedence,
       // where the last ones precede the previous ones. This is why
       // we reverse the array so we get the right functions precedence in the CLI.
-      functions.reverse().map(async ({ displayName, mainFile, name, runtime: runtimeName }) => {
+      functions.reverse().map(async ({ displayName, mainFile, name, runtime: runtimeName, srcPath }) => {
         if (ignoredFunctions.has(name)) {
           return
         }
@@ -527,7 +550,6 @@ export class FunctionsRegistry {
         const func = new NetlifyFunction({
           blobsContext: this.blobsContext,
           config: this.config,
-          directory: directories.find((directory) => mainFile.startsWith(directory)),
           mainFile,
           name,
           displayName,
@@ -539,6 +561,7 @@ export class FunctionsRegistry {
           timeoutBackground: this.timeouts.backgroundFunctions,
           timeoutSynchronous: this.timeouts.syncFunctions,
           settings: this.settings,
+          srcPath,
         })
 
         // If a function we're registering was also unregistered in this run,

src/lib/functions/runtimes/js/builders/zisi.ts

@@ -39,7 +39,6 @@ const addFunctionsConfigDefaults = (config: NormalizedFunctionsConfig) => ({
 const buildFunction = async ({
   cache,
   config,
-  directory,
   featureFlags,
   func,
   hasTypeModule,
@@ -48,7 +47,6 @@ const buildFunction = async ({
 }: {
   cache: BuildCommandCache<FunctionResult>
   config: NormalizedFunctionsConfig
-  directory?: string | undefined
   featureFlags: FeatureFlags
   // This seems like it should be `ZisiBuildResult` but it's technically referenced from `detectZisiBuilder` so TS
   // can't know at that point that we'll only end up calling it with a `ZisiBuildResult`... Consider refactoring?
@@ -63,16 +61,6 @@ const buildFunction = async ({
     config,
     featureFlags: { ...featureFlags, zisi_functions_api_v2: true },
   }
-  const functionDirectory = path.dirname(func.mainFile)
-
-  // If we have a function at `functions/my-func/index.js` and we pass
-  // that path to `zipFunction`, it will lack the context of the whole
-  // functions directory and will infer the name of the function to be
-  // `index`, not `my-func`. Instead, we need to pass the directory of
-  // the function. The exception is when the function is a file at the
-  // root of the functions directory (e.g. `functions/my-func.js`). In
-  // this case, we use `mainFile` as the function path of `zipFunction`.
-  const entryPath = functionDirectory === directory ? func.mainFile : functionDirectory
   const {
     entryFilename,
     excludedRoutes,
@@ -86,9 +74,9 @@ const buildFunction = async ({
     schedule,
   } = await memoizedBuild({
     cache,
-    cacheKey: `zisi-${entryPath}`,
+    cacheKey: `zisi-${func.srcPath}`,
     command: async () => {
-      const result = await zipFunction(entryPath, targetDirectory, zipOptions)
+      const result = await zipFunction(func.srcPath, targetDirectory, zipOptions)
       if (result == null) {
         throw new Error('Failed to build function')
       }
@@ -179,7 +167,6 @@ const netlifyConfigToZisiConfig = ({
 
 export default async function detectZisiBuilder({
   config,
-  directory,
   errorExit,
   func,
   metadata,
@@ -233,7 +220,6 @@ export default async function detectZisiBuilder({
     buildFunction({
       cache,
       config: functionsConfig,
-      directory,
       func,
       projectRoot,
       targetDirectory,

src/lib/functions/runtimes/js/index.ts

@@ -1,5 +1,4 @@
 import { createConnection } from 'net'
-import { dirname } from 'path'
 import { pathToFileURL } from 'url'
 import { Worker } from 'worker_threads'
 
@@ -30,25 +29,19 @@ lambdaLocal.getLogger().level = 'alert'
 
 export async function getBuildFunction({
   config,
-  directory,
   errorExit,
   func,
   projectRoot,
 }: Parameters<GetBuildFunction<JsBuildResult>>[0]) {
   const metadata = await getFunctionMetadata({ mainFile: func.mainFile, config, projectRoot })
-  const zisiBuilder = await detectZisiBuilder({ config, directory, errorExit, func, metadata, projectRoot })
+  const zisiBuilder = await detectZisiBuilder({ config, errorExit, func, metadata, projectRoot })
 
   if (zisiBuilder) {
     return zisiBuilder.build
   }
 
-  // If there's no function builder, we create a simple one on-the-fly which
-  // returns as `srcFiles` the function directory, if there is one, or its
-  // main file otherwise.
-  const functionDirectory = dirname(func.mainFile)
-  const srcFiles = functionDirectory === directory ? [func.mainFile] : [functionDirectory]
-
-  const build: BuildFunction<JsBuildResult> = () => Promise.resolve({ schedule: metadata?.schedule, srcFiles })
+  const build: BuildFunction<JsBuildResult> = () =>
+    Promise.resolve({ schedule: metadata?.schedule, srcFiles: [func.srcPath] })
   return build
 }
 

src/lib/functions/server.ts

@@ -3,6 +3,7 @@ import { promises as fs } from 'fs'
 import type { IncomingHttpHeaders } from 'http'
 import path from 'path'
 
+import type { GeneratedFunction } from '@netlify/build'
 import express, { type Request, type RequestHandler } from 'express'
 import expressLogging from 'express-logging'
 import { jwtDecode } from 'jwt-decode'
@@ -305,6 +306,7 @@ export const startFunctionsServer = async (
       backgroundFunctions?: boolean
     }
     debug: boolean
+    generatedFunctions: GeneratedFunction[]
     loadDistFunctions?: boolean
     // TODO(serhalp): This is confusing. Refactor to accept entire settings or rename or something?
     settings: Pick<ServerSettings, 'functions' | 'functionsPort'>
@@ -319,6 +321,7 @@ export const startFunctionsServer = async (
     command,
     config,
     debug,
+    generatedFunctions,
     loadDistFunctions,
     settings,
     site,
@@ -380,6 +383,7 @@ export const startFunctionsServer = async (
     config,
     debug,
     frameworksAPIPaths: command.netlify.frameworksAPIPaths,
+    generatedFunctions,
     isConnected: Boolean(siteUrl),
     logLambdaCompat: isFeatureFlagEnabled('cli_log_lambda_compat', siteInfo),
     manifest,