fix: bundle edge functions if they exist on deploy --no-build

src/commands/deploy/deploy.ts

@@ -53,6 +53,7 @@ import { SiteInfo } from '../../utils/types.js'
 import type { DeployOptionValues } from './option_values.js'
 import boxen from 'boxen'
 import terminalLink from 'terminal-link'
+import { anyEdgeFunctionsDirectoryExists } from '../../lib/edge-functions/get-directories.js'
 
 const triggerDeploy = async ({
   api,
@@ -727,8 +728,11 @@ const bundleEdgeFunctions = async (options: DeployOptionValues, command: BaseCom
     // We log our own progress so we don't want this as well. Plus, this logs much of the same
     // information as the build that (likely) came before this as part of the deploy build.
     quiet: options.debug ?? true,
-    // @ts-expect-error FIXME(serhalp): This is missing from the `runCoreSteps` type in @netlify/build
+    // (cachedConfig type error hides this one, but it still is valid) @ts-expect-error FIXME(serhalp): This is missing from the `runCoreSteps` type in @netlify/build
     edgeFunctionsBootstrapURL: await getBootstrapURL(),
+    // @ts-expect-error 'CachedConfig' is not assignable to type 'Record<string, unknown>'.
+    // Index signature for type 'string' is missing in type 'CachedConfig'.
+    cachedConfig: command.netlify.cachedConfig,
   })
 
   if (!success) {
@@ -867,10 +871,11 @@ const prepAndRunDeploy = async ({
   const functionsFolder = getFunctionsFolder({ workingDir, options, config, site, siteData })
   const { configPath } = site
 
-  const edgeFunctionsConfig = command.netlify.config.edge_functions
-
-  // build flag wasn't used and edge functions exist
-  if (!options.build && edgeFunctionsConfig && edgeFunctionsConfig.length !== 0) {
+  // build flag wasn't used and edge functions directories exist
+  if (!options.build && (await anyEdgeFunctionsDirectoryExists(command))) {
+    // for the case of directories existing but not containing any edge functions,
+    // there is early bail in edge functions bundling after scanning for edge functions
+    // for this case and to avoid replicating scanning logic here, we defer to the bundling step
     await bundleEdgeFunctions(options, command)
   }
 

src/lib/edge-functions/get-directories.ts

@@ -0,0 +1,32 @@
+import { join } from 'path'
+
+import { getPathInProject } from '../settings.js'
+import { INTERNAL_EDGE_FUNCTIONS_FOLDER } from './consts.js'
+import BaseCommand from '../../commands/base-command.js'
+import { fileExistsAsync } from '../fs.js'
+
+export const getUserEdgeFunctionsDirectory = (command: BaseCommand): string | undefined => {
+  return command.netlify.config.build.edge_functions
+}
+
+export const getInternalEdgeFunctionsDirectory = (command: BaseCommand): string => {
+  return join(command.workingDir, getPathInProject([INTERNAL_EDGE_FUNCTIONS_FOLDER]))
+}
+
+export const getFrameworkEdgeFunctionsDirectory = (command: BaseCommand): string => {
+  return command.netlify.frameworksAPIPaths.edgeFunctions.path
+}
+
+const getAllEdgeFunctionsDirectories = (command: BaseCommand) => {
+  return [
+    getUserEdgeFunctionsDirectory(command),
+    getInternalEdgeFunctionsDirectory(command),
+    getFrameworkEdgeFunctionsDirectory(command),
+  ].filter(Boolean) as string[]
+}
+
+export const anyEdgeFunctionsDirectoryExists = async (command: BaseCommand): Promise<boolean> => {
+  const directoriesToCheck = getAllEdgeFunctionsDirectories(command)
+
+  return (await Promise.all(directoriesToCheck.map(fileExistsAsync))).some(Boolean)
+}

src/lib/edge-functions/proxy.ts

@@ -117,7 +117,6 @@ export const initializeProxy = async ({
   siteInfo: $TSFixMe
   state: LocalState
 }) => {
-  const userFunctionsPath = config.build.edge_functions
   const isolatePort = await getAvailablePort()
   const runtimeFeatureFlags = ['edge_functions_bootstrap_failure_mode', 'edge_functions_bootstrap_populate_environment']
   const protocol = settings.https ? 'https' : 'http'
@@ -132,7 +131,6 @@ export const initializeProxy = async ({
     config,
     configPath,
     debug,
-    directory: userFunctionsPath,
     env: configEnv,
     featureFlags: buildFeatureFlags,
     getUpdatedConfig,
@@ -207,7 +205,6 @@ const prepareServer = async ({
   config,
   configPath,
   debug,
-  directory,
   env: configEnv,
   featureFlags,
   getUpdatedConfig,
@@ -221,7 +218,6 @@ const prepareServer = async ({
   config: NormalizedCachedConfigConfig
   configPath: string
   debug: boolean
-  directory?: string
   env: Record<string, { sources: string[]; value: string }>
   featureFlags: FeatureFlags
   getUpdatedConfig: () => Promise<NormalizedCachedConfigConfig>
@@ -261,7 +257,6 @@ const prepareServer = async ({
       config,
       configPath,
       debug,
-      directories: directory ? [directory] : [],
       env: configEnv,
       featureFlags,
       getUpdatedConfig,

src/lib/edge-functions/registry.ts

@@ -22,7 +22,12 @@ import type { FeatureFlags } from '../../utils/feature-flags.js'
 import { MultiMap } from '../../utils/multimap.js'
 import { getPathInProject } from '../settings.js'
 
-import { DIST_IMPORT_MAP_PATH, INTERNAL_EDGE_FUNCTIONS_FOLDER } from './consts.js'
+import { DIST_IMPORT_MAP_PATH } from './consts.js'
+import {
+  getFrameworkEdgeFunctionsDirectory,
+  getInternalEdgeFunctionsDirectory,
+  getUserEdgeFunctionsDirectory,
+} from './get-directories.js'
 
 type DependencyCache = Record<string, string[]>
 type EdgeFunctionEvent = 'buildError' | 'loaded' | 'reloaded' | 'reloading' | 'removed'
@@ -38,7 +43,6 @@ interface EdgeFunctionsRegistryOptions {
   config: NormalizedCachedConfigConfig
   configPath: string
   debug: boolean
-  directories: string[]
   env: Record<string, { sources: string[]; value: string }>
   featureFlags: FeatureFlags
   getUpdatedConfig: () => Promise<NormalizedCachedConfigConfig>
@@ -105,7 +109,6 @@ export class EdgeFunctionsRegistry {
   // Mapping file URLs to names of functions that use them as dependencies.
   private dependencyPaths = new MultiMap<string, string>()
 
-  private directories: string[]
   private directoryWatchers = new Map<string, import('chokidar').FSWatcher>()
   private env: Record<string, string>
   private featureFlags: FeatureFlags
@@ -133,7 +136,6 @@ export class EdgeFunctionsRegistry {
     command,
     config,
     configPath,
-    directories,
     env,
     featureFlags,
     getUpdatedConfig,
@@ -146,7 +148,6 @@ export class EdgeFunctionsRegistry {
     this.command = command
     this.bundler = bundler
     this.configPath = configPath
-    this.directories = directories
     this.featureFlags = featureFlags
     this.getUpdatedConfig = getUpdatedConfig
     this.runIsolate = runIsolate
@@ -563,16 +564,12 @@ export class EdgeFunctionsRegistry {
     return { functionsConfig, graph, success }
   }
 
-  private get internalDirectory() {
-    return join(this.projectDir, getPathInProject([INTERNAL_EDGE_FUNCTIONS_FOLDER]))
-  }
-
   private get internalImportMapPath() {
     return join(this.projectDir, getPathInProject([DIST_IMPORT_MAP_PATH]))
   }
 
   private async readDeployConfig() {
-    const manifestPath = join(this.internalDirectory, 'manifest.json')
+    const manifestPath = join(getInternalEdgeFunctionsDirectory(this.command), 'manifest.json')
     try {
       const contents = await readFile(manifestPath, 'utf8')
       const manifest = JSON.parse(contents)
@@ -592,15 +589,16 @@ export class EdgeFunctionsRegistry {
 
     this.declarationsFromDeployConfig = deployConfig.functions
     this.importMapFromDeployConfig = deployConfig.import_map
-      ? join(this.internalDirectory, deployConfig.import_map)
+      ? join(getInternalEdgeFunctionsDirectory(this.command), deployConfig.import_map)
       : undefined
   }
 
   private async scanForFunctions() {
+    const userFunctionDirectory = getUserEdgeFunctionsDirectory(this.command)
     const [frameworkFunctions, integrationFunctions, userFunctions] = await Promise.all([
-      this.usesFrameworksAPI ? this.bundler.find([this.command.netlify.frameworksAPIPaths.edgeFunctions.path]) : [],
-      this.bundler.find([this.internalDirectory]),
-      this.bundler.find(this.directories),
+      this.usesFrameworksAPI ? this.bundler.find([getFrameworkEdgeFunctionsDirectory(this.command)]) : [],
+      this.bundler.find([getInternalEdgeFunctionsDirectory(this.command)]),
+      userFunctionDirectory ? this.bundler.find([userFunctionDirectory]) : [],
       this.scanForDeployConfig(),
     ])
     const internalFunctions = [...frameworkFunctions, ...integrationFunctions]