feat!: remove support for deprecated netlify-lambda package (#7236)

* feat!: remove support for deprecated netlify-lambda package

https://github.com/netlify/netlify-lambda was deprecated in Feb 2023

This removes support for it from Netlify CLI.

To migrate away from netlify-lambda, see https://github.com/netlify/netlify-lambda/blob/main/MIGRATE.md.

* fix: restore hidden important side effect

* style: change todo comment style

Author: serhalp

docs/commands/deploy.md

@@ -32,7 +32,7 @@ Build binaries of your Go language functions into the functions folder as part o
 Single file Node.js functions:
 -----------------------------
 
-Build dependency bundled Node.js lambda functions with tools like netlify-lambda, webpack or browserify into the function folder as part of your build process.
+Build dependency bundled Node.js lambda functions with tools like webpack or browserify into the function folder as part of your build process.
 
 ```
 functions/

src/commands/deploy/index.ts

@@ -35,7 +35,7 @@ Build binaries of your Go language functions into the functions folder as part o
 Single file Node.js functions:
 -----------------------------
 
-Build dependency bundled Node.js lambda functions with tools like netlify-lambda, webpack or browserify into the function folder as part of your build process.
+Build dependency bundled Node.js lambda functions with tools like webpack or browserify into the function folder as part of your build process.
 
 \`\`\`
 functions/

src/lib/functions/registry.ts

@@ -167,26 +167,9 @@ export class FunctionsRegistry {
     }
   }
 
-  /**
-   * Runs before `scan` and calls any `onDirectoryScan` hooks defined by the
-   * runtime before the directory is read. This gives runtime the opportunity
-   * to run additional logic when a directory is scanned.
-   */
-  static async prepareDirectoryScan(directory: string) {
+  // TODO(serhalp): Is this really the right place to do this mutation? Should we do this at all?
+  static async prepareDirectory(directory: string) {
     await mkdir(directory, { recursive: true })
-
-    // We give runtimes the opportunity to react to a directory scan and run
-    // additional logic before the directory is read. So if they implement a
-    // `onDirectoryScan` hook, we run it.
-    await Promise.all(
-      Object.values(runtimes).map((runtime) => {
-        if (!('onDirectoryScan' in runtime)) {
-          return null
-        }
-
-        return runtime.onDirectoryScan({ directory })
-      }),
-    )
   }
 
   /**
@@ -480,7 +463,7 @@ export class FunctionsRegistry {
       return
     }
 
-    await Promise.all(directories.map((path) => FunctionsRegistry.prepareDirectoryScan(path)))
+    await Promise.all(directories.map((path) => FunctionsRegistry.prepareDirectory(path)))
 
     const functions = await this.listFunctions(directories, {
       featureFlags: {

src/lib/functions/runtimes/index.ts

@@ -54,16 +54,13 @@ export type InvokeFunction<BuildResult extends BaseBuildResult> = (params: {
   timeout: number
 }) => Promise<InvokeFunctionResult>
 
-export type OnDirectoryScanFunction = (params: { directory: string }) => Promise<void>
-
 export type OnRegisterFunction<BuildResult extends BaseBuildResult> = (
   func: NetlifyFunction<BuildResult>,
 ) => NetlifyFunction<BuildResult> | null
 
 export interface Runtime<BuildResult extends BaseBuildResult> {
   getBuildFunction: GetBuildFunction<BuildResult>
   invokeFunction: InvokeFunction<BuildResult>
-  onDirectoryScan?: OnDirectoryScanFunction
   onRegister?: OnRegisterFunction<BuildResult>
   name: string
 }

src/lib/functions/runtimes/js/builders/netlify-lambda.ts

@@ -5,54 +5,36 @@ import { Worker } from 'worker_threads'
 
 import lambdaLocal, { type LambdaEvent } from 'lambda-local'
 
-import type { BuildFunction, GetBuildFunction, InvokeFunction, OnDirectoryScanFunction } from '../index.js'
+import type { BuildFunction, GetBuildFunction, InvokeFunction } from '../index.js'
 import { BLOBS_CONTEXT_VARIABLE } from '../../../blobs/blobs.js'
 import type NetlifyFunction from '../../netlify-function.js'
 
-import detectNetlifyLambdaBuilder, {
-  type NetlifyLambdaBuildResult,
-  type NetlifyLambdaBuilder,
-} from './builders/netlify-lambda.js'
 import detectZisiBuilder, { getFunctionMetadata, ZisiBuildResult } from './builders/zisi.js'
 import { SECONDS_TO_MILLISECONDS } from './constants.js'
 import type { WorkerMessage } from './worker.js'
 
 export const name = 'js'
 
-export type JsBuildResult = ZisiBuildResult | NetlifyLambdaBuildResult
+type SimpleJsBuildResult = {
+  schedule?: string
+  srcFiles: string[]
+}
+
+export type JsBuildResult = ZisiBuildResult | SimpleJsBuildResult
 
 // TODO(serhalp): Unify these. This is bonkers that the two underlying invocation mechanisms are encapsulated but we
 // return slightly different shapes for them.
 export type JsInvokeFunctionResult = WorkerMessage | LambdaEvent
 
-let netlifyLambdaDetectorCache: undefined | NetlifyLambdaBuilder
-
 lambdaLocal.getLogger().level = 'alert'
 
-// The netlify-lambda builder can't be enabled or disabled on a per-function
-// basis and its detection mechanism is also quite expensive, so we detect
-// it once and cache the result.
-const detectNetlifyLambdaWithCache = async () => {
-  if (netlifyLambdaDetectorCache === undefined) {
-    netlifyLambdaDetectorCache = await detectNetlifyLambdaBuilder()
-  }
-
-  return netlifyLambdaDetectorCache
-}
-
 export async function getBuildFunction({
   config,
   directory,
   errorExit,
   func,
   projectRoot,
 }: Parameters<GetBuildFunction<JsBuildResult>>[0]) {
-  const netlifyLambdaBuilder = await detectNetlifyLambdaWithCache()
-
-  if (netlifyLambdaBuilder) {
-    return netlifyLambdaBuilder.build
-  }
-
   const metadata = await getFunctionMetadata({ mainFile: func.mainFile, config, projectRoot })
   const zisiBuilder = await detectZisiBuilder({ config, directory, errorExit, func, metadata, projectRoot })
 
@@ -168,14 +150,3 @@ export const invokeFunctionDirectly = async <BuildResult extends JsBuildResult>(
 
   return result
 }
-
-export const onDirectoryScan: OnDirectoryScanFunction = async () => {
-  const netlifyLambdaBuilder = await detectNetlifyLambdaWithCache()
-
-  // Before we start a directory scan, we check whether netlify-lambda is being
-  // used. If it is, we run it, so that the functions directory is populated
-  // with the compiled files before the scan begins.
-  if (netlifyLambdaBuilder) {
-    await netlifyLambdaBuilder.build()
-  }
-}

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

@@ -57,9 +57,7 @@ test('registry should only pass functions config to zip-it-and-ship-it', async (
       plugins: ['test'],
     },
   })
-  const prepareDirectoryScanStub = vi
-    .spyOn(FunctionsRegistry, 'prepareDirectoryScan')
-    .mockImplementation(async () => {})
+  const prepareDirectoryStub = vi.spyOn(FunctionsRegistry, 'prepareDirectory').mockImplementation(async () => {})
   const setupDirectoryWatcherStub = vi
     .spyOn(functionsRegistry, 'setupDirectoryWatcher')
     .mockImplementation(async () => {})
@@ -69,7 +67,7 @@ test('registry should only pass functions config to zip-it-and-ship-it', async (
   t.onTestFinished(() => {
     listFunctionsStub.mockRestore()
     setupDirectoryWatcherStub.mockRestore()
-    prepareDirectoryScanStub.mockRestore()
+    prepareDirectoryStub.mockRestore()
   })
 
   await functionsRegistry.scan([
@@ -112,16 +110,14 @@ describe('the registry handles duplicate functions based on extension precedence
       },
       frameworksAPIPaths: getFrameworksAPIPaths(projectRoot),
     })
-    const prepareDirectoryScanStub = vi
-      .spyOn(FunctionsRegistry, 'prepareDirectoryScan')
-      .mockImplementation(async () => {})
+    const prepareDirectoryStub = vi.spyOn(FunctionsRegistry, 'prepareDirectory').mockImplementation(async () => {})
     const setupDirectoryWatcherStub = vi
       .spyOn(functionsRegistry, 'setupDirectoryWatcher')
       .mockImplementation(async () => {})
 
     t.onTestFinished(() => {
       setupDirectoryWatcherStub.mockRestore()
-      prepareDirectoryScanStub.mockRestore()
+      prepareDirectoryStub.mockRestore()
     })
 
     await functionsRegistry.scan([functionsDirectory])