try filtering out types, why are they being collected anyways

Author: mmaietta

packages/app-builder-lib/src/node-module-collector/npmNodeModulesCollector.ts

@@ -36,6 +36,12 @@ export class NpmNodeModulesCollector extends NodeModulesCollector<NpmDependency,
 
   protected async collectAllDependencies(tree: NpmDependency) {
     for (const [, value] of Object.entries(tree.dependencies || {})) {
+      // Skip @types packages - they're type-only and not needed at runtime
+      if (value.name.startsWith('@types/')) {
+        log.debug({ name: value.name }, "skipping @types package")
+        continue
+      }
+
       const { _dependencies = {}, dependencies = {} } = value
       const isDuplicateDep = Object.keys(_dependencies).length > 0 && Object.keys(dependencies).length === 0
       if (isDuplicateDep) {
@@ -45,26 +51,48 @@ export class NpmNodeModulesCollector extends NodeModulesCollector<NpmDependency,
         ...value,
         path: tree.path,
       }
-      m.path = (await this.resolveModuleDir({ dependency: m, virtualPath: value.resolved }))!
+
+      try {
+        m.path = (await this.resolveModuleDir({ dependency: m, virtualPath: value.resolved }))!
+      } catch (err: any) {
+        // If we can't resolve it and it's a type-related package, skip it
+        if (value.name.includes('-types') || value.resolved?.includes('@types+')) {
+          log.debug({ name: value.name, err: err.message }, "skipping unresolvable type package")
+          continue
+        }
+        throw err
+      }
+
       this.allDependencies.set(this.cacheKey(m), m)
       await this.collectAllDependencies(m)
     }
 
     // Collect optional dependencies if they exist
     for (const [key, value] of Object.entries(tree.optionalDependencies || {})) {
+      // Skip @types packages
+      if (key.startsWith('@types/')) {
+        log.debug({ name: key }, "skipping @types optional package")
+        continue
+      }
+
       const m = {
         name: key,
         version: value,
         path: tree.path,
         resolved: tree.path,
       }
-      let p: string
+      let p: string | null
       try {
-        p = (await this.resolveModuleDir({ dependency: m, virtualPath: value, isOptionalDependency: true }))!
+        p = await this.resolveModuleDir({ dependency: m, virtualPath: value, isOptionalDependency: true })
       } catch {
         // ignore. optional dependency may not be installed (we throw in resolveModuleDir in this case)
         continue
       }
+
+      if (!p) {
+        continue
+      }
+
       m.path = p
       m.resolved = p
       const moduleKey = this.cacheKey(m)
@@ -83,12 +111,17 @@ export class NpmNodeModulesCollector extends NodeModulesCollector<NpmDependency,
     const { _dependencies: prodDependencies = {}, dependencies = {} } = tree
     const isDuplicateDep = Object.keys(prodDependencies).length > 0 && Object.keys(dependencies).length === 0
     const resolvedDeps = isDuplicateDep ? (this.allDependencies.get(dependencyId)?.dependencies ?? {}) : dependencies
-    // Initialize with empty dependencies array first to mark this dependency as "in progress"
-    // After initialization, if there are libraries with the same name+version later, they will not be searched recursively again
-    // This will prevents infinite loops when circular dependencies are encountered.
+
     this.productionGraph[dependencyId] = { dependencies: [] }
+
     const productionDeps = Object.entries(resolvedDeps)
-      .filter(([packageName]) => prodDependencies[packageName])
+      .filter(([packageName]) => {
+        // Filter out @types packages
+        if (packageName.startsWith('@types/')) {
+          return false
+        }
+        return prodDependencies[packageName]
+      })
       .map(async ([, dependency]) => {
         const childDependencyId = this.packageVersionString(dependency)
         const dep = {
@@ -98,9 +131,9 @@ export class NpmNodeModulesCollector extends NodeModulesCollector<NpmDependency,
         await this.extractProductionDependencyGraph(dep, childDependencyId)
         return childDependencyId
       })
+
     this.productionGraph[dependencyId] = { dependencies: await Promise.all(productionDeps) }
   }
-
   protected async parseDependenciesTree(jsonBlob: string): Promise<NpmDependency> {
     return Promise.resolve(JSON.parse(jsonBlob))
   }