fix: bug around v1 functions with nodeModuleFormat: "esm" (#6557)

* fix: support .mjs functions

* refactor: fix some types

* refactor: use manifest instead of readdir

* fix: replace string concatenation

* chore: write test for ntl:serve

* chore: prettier

Author: Skn0tt

src/lib/functions/registry.ts

@@ -434,7 +434,7 @@ export class FunctionsRegistry {
 
         func.mainFile = v2EntryPointPath
       } catch {
-        func.mainFile = join(unzippedDirectory, `${func.name}.js`)
+        func.mainFile = join(unzippedDirectory, basename(manifestEntry.mainFile))
       }
     } else {
       this.buildFunctionAndWatchFiles(func, !isReload)

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

@@ -6,10 +6,12 @@ import { Worker } from 'worker_threads'
 import lambdaLocal from 'lambda-local'
 
 import { BLOBS_CONTEXT_VARIABLE } from '../../../blobs/blobs.js'
+import type NetlifyFunction from '../../netlify-function.js'
 
 import detectNetlifyLambdaBuilder from './builders/netlify-lambda.js'
 import detectZisiBuilder, { parseFunctionForMetadata } from './builders/zisi.js'
 import { SECONDS_TO_MILLISECONDS } from './constants.js'
+import { $TSFixMe } from '../../../../commands/types.js'
 
 export const name = 'js'
 
@@ -99,11 +101,21 @@ export const invokeFunction = async ({ context, environment, event, func, timeou
   })
 }
 
-// @ts-expect-error TS(7031) FIXME: Binding element 'context' implicitly has an 'any' ... Remove this comment to see the full error message
-export const invokeFunctionDirectly = async ({ context, event, func, timeout }) => {
+export const invokeFunctionDirectly = async ({
+  context,
+  event,
+  func,
+  timeout,
+}: {
+  context: $TSFixMe
+  event: $TSFixMe
+  func: NetlifyFunction
+  timeout: number
+}) => {
   // If a function builder has defined a `buildPath` property, we use it.
   // Otherwise, we'll invoke the function's main file.
-  const lambdaPath = func.buildData?.buildPath ?? func.mainFile
+  const { buildPath } = await func.getBuildData()
+  const lambdaPath = buildPath ?? func.mainFile
   const result = await lambdaLocal.execute({
     clientContext: JSON.stringify(context),
     environment: {
@@ -118,6 +130,7 @@ export const invokeFunctionDirectly = async ({ context, event, func, timeout })
     lambdaPath,
     timeoutMs: timeout * SECONDS_TO_MILLISECONDS,
     verboseLevel: 3,
+    esm: lambdaPath.endsWith('.mjs'),
   })
 
   return result

tests/integration/commands/dev/functions.test.ts

@@ -0,0 +1,53 @@
+import { test } from 'vitest'
+
+import { withDevServer } from '../../utils/dev-server'
+import { withSiteBuilder } from '../../utils/site-builder'
+
+test('nodeModuleFormat: esm v1 functions should work', async (t) => {
+  await withSiteBuilder(t, async (builder) => {
+    await builder
+      .withNetlifyToml({
+        config: {
+          plugins: [{ package: './plugins/setup-functions' }],
+        },
+      })
+      .withBuildPlugin({
+        name: 'setup-functions',
+        plugin: {
+          onBuild: async () => {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires, n/global-require
+            const { mkdir, writeFile } = require('node:fs/promises')
+            await mkdir('.netlify/functions-internal', { recursive: true })
+            await writeFile(
+              '.netlify/functions-internal/server.json',
+              JSON.stringify({
+                config: {
+                  nodeModuleFormat: 'esm',
+                },
+                version: 1,
+              }),
+            )
+
+            await writeFile(
+              '.netlify/functions-internal/server.mjs',
+              `
+              export async function handler(event, context) {
+                return {
+                  statusCode: 200,
+                  body: "This is an internal function.",
+                };
+              }              
+              `,
+            )
+          },
+        },
+      })
+      .build()
+
+    await withDevServer({ cwd: builder.directory, serve: true }, async (server) => {
+      const response = await fetch(new URL('/.netlify/functions/server', server.url))
+      t.expect(await response.text()).toBe('This is an internal function.')
+      t.expect(response.status).toBe(200)
+    })
+  })
+})