feat: add Generator to edge functions

packages/runtime/src/helpers/edge.ts

@@ -13,9 +13,9 @@ import { outdent } from 'outdent'
 import { IMAGE_FUNCTION_NAME } from '../constants'
 
 import { getRequiredServerFiles, NextConfig } from './config'
+import { writeEdgeFunctionConfiguration } from './functionsMetaData'
 import { makeLocaleOptional, stripLookahead, transformCaptureGroups } from './matchers'
 import { RoutesManifest } from './types'
-
 // This is the format as of [email protected]
 interface EdgeFunctionDefinitionV1 {
   env: string[]
@@ -57,12 +57,14 @@ export interface FunctionManifest {
         name?: string
         path: string
         cache?: 'manual'
+        generator?: string
       }
     | {
         function: string
         name?: string
         pattern: string
         cache?: 'manual'
+        generator?: string
       }
   >
   import_map?: string
@@ -220,15 +222,17 @@ const generateEdgeFunctionMiddlewareMatchers = ({
 const middlewareMatcherToEdgeFunctionDefinition = (
   matcher: MiddlewareMatcher,
   name: string,
+  generator: string,
   cache?: 'manual',
 ): {
   function: string
   name?: string
   pattern: string
   cache?: 'manual'
+  generator?: string
 } => {
   const pattern = transformCaptureGroups(stripLookahead(matcher.regexp))
-  return { function: name, pattern, name, cache }
+  return { function: name, pattern, name, cache, generator }
 }
 
 export const cleanupEdgeFunctions = ({
@@ -343,6 +347,8 @@ export const writeEdgeFunctions = async ({
   netlifyConfig: NetlifyConfig
   routesManifest: RoutesManifest
 }) => {
+  const nextjsPluginVersion = await writeEdgeFunctionConfiguration()
+
   const manifest: FunctionManifest = {
     functions: [],
     version: 1,
@@ -400,7 +406,9 @@ export const writeEdgeFunctions = async ({
     })
 
     manifest.functions.push(
-      ...matchers.map((matcher) => middlewareMatcherToEdgeFunctionDefinition(matcher, functionName)),
+      ...matchers.map((matcher) =>
+        middlewareMatcherToEdgeFunctionDefinition(matcher, functionName, nextjsPluginVersion),
+      ),
     )
   }
   // Functions (i.e. not middleware, but edge SSR and API routes)
@@ -440,6 +448,7 @@ export const writeEdgeFunctions = async ({
         pattern,
         // cache: "manual" is currently experimental, so we restrict it to sites that use experimental appDir
         cache: usesAppDir ? 'manual' : undefined,
+        generator: `${nextjsPluginVersion}`,
       })
       // pages-dir page routes also have a data route. If there's a match, add an entry mapping that to the function too
       const dataRoute = dataRoutesMap.get(edgeFunctionDefinition.page)
@@ -449,6 +458,7 @@ export const writeEdgeFunctions = async ({
           name: edgeFunctionDefinition.name,
           pattern: dataRoute,
           cache: usesAppDir ? 'manual' : undefined,
+          generator: `${nextjsPluginVersion}`,
         })
       }
     }
@@ -474,6 +484,7 @@ export const writeEdgeFunctions = async ({
       function: 'ipx',
       name: 'next/image handler',
       path: '/_next/image*',
+      generator: `${nextjsPluginVersion}`,
     })
   } else {
     console.log(
@@ -487,6 +498,5 @@ export const writeEdgeFunctions = async ({
       This feature is in beta. Please share your feedback here: https://ntl.fyi/next-netlify-edge
     `)
   }
-
   await writeJson(join(edgeFunctionRoot, 'manifest.json'), manifest)
 }

packages/runtime/src/helpers/functionsMetaData.ts

@@ -15,6 +15,19 @@ const getNextRuntimeVersion = async (packageJsonPath: string, useNodeModulesPath
   return useNodeModulesPath ? packagePlugin.version : packagePlugin.dependencies[NEXT_PLUGIN]
 }
 
+const pluginPackagePath = '.netlify/plugins/package.json'
+
+const nextPluginVersion = async () => {
+  const moduleRoot = resolveModuleRoot(NEXT_PLUGIN)
+  const nodeModulesPath = moduleRoot ? join(moduleRoot, 'package.json') : null
+
+  return (
+    (await getNextRuntimeVersion(nodeModulesPath, true)) ||
+    (await getNextRuntimeVersion(pluginPackagePath, false)) ||
+    // The runtime version should always be available, but if it's not, return 'unknown'
+    'unknown'
+  )
+}
 // The information needed to create a function configuration file
 export interface FunctionInfo {
   // The name of the function, e.g. `___netlify-handler`
@@ -34,23 +47,20 @@ export interface FunctionInfo {
  */
 export const writeFunctionConfiguration = async (functionInfo: FunctionInfo) => {
   const { functionName, functionTitle, functionsDir } = functionInfo
-  const pluginPackagePath = '.netlify/plugins/package.json'
-  const moduleRoot = resolveModuleRoot(NEXT_PLUGIN)
-  const nodeModulesPath = moduleRoot ? join(moduleRoot, 'package.json') : null
-
-  const nextPluginVersion =
-    (await getNextRuntimeVersion(nodeModulesPath, true)) ||
-    (await getNextRuntimeVersion(pluginPackagePath, false)) ||
-    // The runtime version should always be available, but if it's not, return 'unknown'
-    'unknown'
+  const pluginVersion = await nextPluginVersion()
 
   const metadata = {
     config: {
       name: functionTitle,
-      generator: `${NEXT_PLUGIN_NAME}@${nextPluginVersion}`,
+      generator: `${NEXT_PLUGIN_NAME}@${pluginVersion}`,
     },
     version: 1,
   }
 
   await writeFile(join(functionsDir, functionName, `${functionName}.json`), JSON.stringify(metadata))
 }
+
+export const writeEdgeFunctionConfiguration = async () => {
+  const pluginVersion = await nextPluginVersion()
+  return `${NEXT_PLUGIN_NAME}@${pluginVersion}`
+}

test/functionsMetaData.spec.ts

@@ -1,8 +1,9 @@
-import { readJSON } from 'fs-extra'
+import { readJSON, writeJSON } from 'fs-extra'
 import mock from 'mock-fs'
 import { join } from 'pathe'
 import { NEXT_PLUGIN_NAME } from '../packages/runtime/src/constants'
 import { writeFunctionConfiguration } from '../packages/runtime/src/helpers/functionsMetaData'
+import { writeEdgeFunctionConfiguration } from '../packages/runtime/src/helpers/functionsMetaData'
 
 describe('writeFunctionConfiguration', () => {
   afterEach(() => {
@@ -17,7 +18,7 @@ describe('writeFunctionConfiguration', () => {
         name: 'test',
         version: '1.0.0',
         dependencies: {
-          '@netlify/plugin-nextjs': '29.3.4',
+          // '@netlify/plugin-nextjs': '29.3.4',
         },
       }),
       'node_modules/@netlify/plugin-nextjs/package.json': JSON.stringify({
@@ -103,3 +104,160 @@ describe('writeFunctionConfiguration', () => {
     expect(actual).toEqual(expected)
   })
 })
+
+// EDGE FUNCTIONS
+
+describe('writeEdgeFunctionConfiguration', () => {
+  afterEach(() => {
+    mock.restore()
+  })
+
+  it('should write the configuration for an edge function using node modules version of @netlify/plugin-nextjs', async () => {
+    const nextRuntimeVersion = '23.4.5'
+
+    mock({
+      '.netlify/plugins/package.json': JSON.stringify({
+        name: 'test',
+        version: '1.0.0',
+        dependencies: {
+          '@netlify/plugin-nextjs': '29.3.4',
+        },
+      }),
+      'node_modules/@netlify/plugin-nextjs/package.json': JSON.stringify({
+        name: '@netlify/plugin-nextjs',
+        version: nextRuntimeVersion,
+      }),
+      '.netlify/edge-functions/manifest.json': JSON.stringify({
+        "functions":[],
+        "version":1
+      }),
+    })
+
+    const manifest = {
+    functions:[],
+    version:1
+    }
+
+    const functionName = 'someFunction'
+    const name = 'someFunctionName'
+
+    const pluginVersion = await writeEdgeFunctionConfiguration()
+
+    manifest.functions.push({
+      functions: functionName,
+      name: name,
+      generator: pluginVersion
+    })
+
+    const expected = {
+      functions: [
+        {
+          functions: functionName,
+          name: name,
+          generator: `${NEXT_PLUGIN_NAME}@${nextRuntimeVersion}`,
+        }
+    ],
+      version: 1,
+    }
+
+    const filePathToSaveTo = '.netlify/edge-functions/manifest.json'
+    await writeJSON(filePathToSaveTo, manifest)
+    const actual = await readJSON(filePathToSaveTo)
+
+    expect(actual).toEqual(expected)
+  })
+
+  it('should write the configuration for a function using version of @netlify/plugin-nextjs in package.json', async () => {
+    const nextRuntimeVersion = '23.4.5'
+
+    mock({
+      '.netlify/plugins/package.json': JSON.stringify({
+        name: 'test',
+        version: '1.0.0',
+        dependencies: {
+          '@netlify/plugin-nextjs': nextRuntimeVersion,
+        },
+      }),
+      '.netlify/edge-functions/manifest.json': JSON.stringify({
+        "functions":[],
+        "version":1
+      }),
+    })
+
+    const manifest = {
+      functions:[],
+      version:1
+      }
+
+      const functionName = 'someFunction'
+      const name = 'someFunctionName'
+
+      const pluginVersion = await writeEdgeFunctionConfiguration()
+
+      manifest.functions.push({
+        functions: functionName,
+        name: name,
+        generator: pluginVersion
+      })
+
+      const expected = {
+        functions: [
+          {
+            functions: functionName,
+            name: name,
+            generator: `${NEXT_PLUGIN_NAME}@${nextRuntimeVersion}`,
+          }
+      ],
+        version: 1,
+      }
+
+      const filePathToSaveTo = '.netlify/edge-functions/manifest.json'
+      await writeJSON(filePathToSaveTo, manifest)
+      const actual = await readJSON(filePathToSaveTo)
+
+    expect(actual).toEqual(expected)
+  })
+
+  it('should write the configuration for an edge function with runtime version not found', async () => {
+    mock({
+      '.netlify/edge-functions/manifest.json': JSON.stringify({
+        "functions":[],
+        "version":1
+      }),
+    })
+
+    const manifest = {
+      functions:[],
+      version:1
+      }
+
+      const functionName = 'someFunction'
+      const name = 'someFunctionName'
+
+      const pluginVersion = await writeEdgeFunctionConfiguration()
+
+      manifest.functions.push({
+        functions: functionName,
+        name: name,
+        generator: pluginVersion
+      })
+
+      const expected = {
+        functions: [
+          {
+            functions: functionName,
+            name: name,
+            generator: '@netlify/next-runtime@unknown',
+          }
+      ],
+        version: 1,
+      }
+
+      const filePathToSaveTo = '.netlify/edge-functions/manifest.json'
+      await writeJSON(filePathToSaveTo, manifest)
+      const actual = await readJSON(filePathToSaveTo)
+
+    expect(actual).toEqual(expected)
+  })
+})
+