fix: ignore type-only errored modules from module graph (#7072)

Author: pieh

packages/edge-bundler/node/bundler.test.ts

@@ -1369,6 +1369,49 @@ describe.skipIf(lt(denoVersion, '2.4.2'))(
 
       await cleanup()
     })
+
+    test('With a type-only import from a directory', async () => {
+      const systemLogger = vi.fn()
+      const { basePath, cleanup, distPath } = await useFixture('import-types-directory', { copyDirectory: true })
+      const declarations: Declaration[] = [
+        {
+          function: 'func1',
+          path: '/func1',
+        },
+      ]
+
+      await bundle([join(basePath, 'netlify/edge-functions')], distPath, declarations, {
+        basePath,
+        featureFlags: {
+          edge_bundler_generate_tarball: true,
+        },
+        systemLogger,
+      })
+
+      expect(
+        systemLogger.mock.calls.find((call) => call[0] === 'Could not track dependencies in edge function:'),
+      ).toBeUndefined()
+
+      const expectedOutput = {
+        func1: 'ok',
+      }
+
+      const manifestFile = await readFile(resolve(distPath, 'manifest.json'), 'utf8')
+      const manifest = JSON.parse(manifestFile)
+
+      const tarballPath = join(distPath, manifest.bundles[0].asset)
+      const tarballResult = await runTarball(tarballPath)
+      expect(tarballResult).toStrictEqual(expectedOutput)
+
+      const eszipPath = join(distPath, manifest.bundles[1].asset)
+      const eszipResult = await runESZIP(eszipPath)
+      expect(eszipResult).toStrictEqual(expectedOutput)
+
+      // Both formats should produce identical output.
+      expect(tarballResult).toStrictEqual(eszipResult)
+
+      await cleanup()
+    })
   },
   50_000,
 )

packages/edge-bundler/node/formats/tarball.ts

@@ -252,17 +252,44 @@ async function getRequiredSourceFiles(
 
     const graph = JSON.parse(stdout) as ModuleGraphJson
 
+    // Collect the specifiers of every module reachable through a *code* (runtime)
+    // import edge. Deno's module graph classifies each dependency as either a `code`
+    // edge (a real runtime import) or a `type`-only edge (`import type`, `@deno-types`).
+    // Type-only edges are erased during transpilation and are never loaded at runtime
+    // (`deno run` doesn't type-check), so the files they point to don't belong in the
+    // bundle. The entry points themselves are always runtime.
+    const runtimeSpecifiers = new Set<string>(graph.roots)
+    for (const module of graph.modules) {
+      for (const dependency of module.dependencies ?? []) {
+        if (dependency.code?.specifier) {
+          runtimeSpecifiers.add(dependency.code.specifier)
+        }
+      }
+    }
+
     // Extract all local files from the module graph
     for (const module of graph.modules) {
-      if (module.specifier.startsWith('file://')) {
-        if (module.error?.startsWith('Module not found')) {
-          // Module graph contains all found imported/required modules, even if they don't actually exist
-          // This can happen for optional dependencies (dynamic import or require in try/catch).
+      if (!module.specifier.startsWith('file://')) {
+        continue
+      }
+
+      if (module.error) {
+        // A module reachable only through type-only edges (e.g. a directory specifier
+        // behind `import type`) can fail to resolve as an ES module. That's safe to
+        // ignore: the runtime never loads it.
+        if (!runtimeSpecifiers.has(module.specifier)) {
+          continue
+        }
+
+        if (module.error.startsWith('Module not found')) {
+          // Module graph contains all found imported/required modules, even if they don't
+          // actually exist. This can happen for optional dependencies (dynamic import or
+          // require in try/catch).
           continue
         }
-        const filePath = fileURLToPath(module.specifier)
-        localFiles.add(filePath)
       }
+
+      localFiles.add(fileURLToPath(module.specifier))
     }
   }
 

packages/edge-bundler/test/fixtures/import-types-directory/netlify/edge-functions/func1.ts

@@ -0,0 +1,5 @@
+import type { OK } from "../../types";
+
+export default function handler() {
+  return new Response("ok" satisfies OK);
+}

packages/edge-bundler/test/fixtures/import-types-directory/types/index.d.ts

@@ -0,0 +1 @@
+export type OK = "ok";