snyk 1.1294.1 → 1.1294.2

package/dist/cli/464.index.js

@@ -202349,6 +202349,7 @@ const Debug = __webpack_require__(15158);
 const promises_1 = __webpack_require__(73292);
 const path = __webpack_require__(71017);
 const debug = Debug("snyk");
+const nodeModulesRegex = /^(.*?)(?:[\\\/]node_modules)/;
 async function createTempProjectDir(projectDir) {
     const tmpDir = await (0, promises_1.mkdtemp)("snyk");
     const tempProjectRoot = path.join(tmpDir, projectDir);
@@ -202367,11 +202368,19 @@ async function fileExists(path) {
 async function createSyntheticManifest(tempRootManifestDir) {
     const tempRootManifestPath = path.join(tempRootManifestDir, manifestName);
     debug(`Creating an empty synthetic manifest file: ${tempRootManifestPath}`);
-    await (0, promises_1.writeFile)(tempRootManifestPath, "{}", "utf-8");
+    try {
+        await (0, promises_1.writeFile)(tempRootManifestPath, "{}", "utf-8");
+    }
+    catch (error) {
+        debug(`Error while writing file ${tempRootManifestPath} : ${error.message}`);
+    }
 }
 async function saveOnDisk(tempDir, modules, filePathToContent) {
     for (const module of modules) {
         const manifestContent = filePathToContent[module];
+        if (!manifestContent) {
+            continue;
+        }
         await createFile(path.join(tempDir, module), manifestContent);
     }
 }
@@ -202411,16 +202420,72 @@ async function persistNodeModules(project, filePathToContent, fileNamesGroupedBy
 }
 exports.persistNodeModules = persistNodeModules;
 async function createFile(filePath, fileContent) {
-    await (0, promises_1.mkdir)(path.dirname(filePath), { recursive: true });
-    await (0, promises_1.writeFile)(filePath, fileContent, "utf-8");
+    try {
+        await (0, promises_1.mkdir)(path.dirname(filePath), { recursive: true });
+        await (0, promises_1.writeFile)(filePath, fileContent, "utf-8");
+    }
+    catch (error) {
+        debug(`Error while creating file ${filePath} : ${error.message}`);
+    }
+}
+function isYarnCacheDependency(filePath) {
+    if (filePath.includes(".yarn/cache") ||
+        filePath.includes(".cache/yarn") ||
+        filePath.includes("yarn\\cache") ||
+        filePath.includes("cache\\yarn") ||
+        filePath.includes("Cache\\Yarn") ||
+        filePath.includes("Yarn\\Cache")) {
+        return true;
+    }
+    return false;
+}
+function isNpmCacheDependency(filePath) {
+    if (filePath.includes(".npm/") || filePath.includes("\\npm-cache")) {
+        return true;
+    }
+    return false;
+}
+function isPnpmCacheDependency(filePath) {
+    if (filePath.includes("pnpm-store") ||
+        filePath.includes("pnpm/store") ||
+        filePath.includes("pnpm\\store")) {
+        return true;
+    }
+    return false;
+}
+function getNodeModulesParentDir(filePath) {
+    const nodeModulesParentDirMatch = nodeModulesRegex.exec(filePath);
+    if (nodeModulesParentDirMatch && nodeModulesParentDirMatch.length > 1) {
+        const nodeModulesParentDir = nodeModulesParentDirMatch[1];
+        if (nodeModulesParentDir === "") {
+            return "/"; // ensuring the same behavior of path.dirname for '/' dir
+        }
+        return nodeModulesParentDir;
+    }
+    return null;
+}
+function getGroupingDir(filePath) {
+    const nodeModulesParentDir = getNodeModulesParentDir(filePath);
+    if (nodeModulesParentDir) {
+        return nodeModulesParentDir;
+    }
+    return path.dirname(filePath);
 }
 function groupFilesByDirectory(filePathToContent) {
     var _a;
     const filesByDir = new Map();
-    for (const filePath of Object.keys(filePathToContent)) {
-        const directory = filePath.includes("node_modules")
-            ? filePath.split("/node_modules")[0]
-            : path.dirname(filePath);
+    const filePaths = Object.keys(filePathToContent);
+    for (const filePath of filePaths) {
+        if (isNpmCacheDependency(filePath)) {
+            continue;
+        }
+        if (isYarnCacheDependency(filePath)) {
+            continue;
+        }
+        if (isPnpmCacheDependency(filePath)) {
+            continue;
+        }
+        const directory = getGroupingDir(filePath);
         if (!filesByDir.has(directory)) {
             filesByDir.set(directory, new Set());
         }
@@ -202430,8 +202495,11 @@ function groupFilesByDirectory(filePathToContent) {
 }
 exports.groupFilesByDirectory = groupFilesByDirectory;
 async function cleanupAppNodeModules(appRootDir) {
+    if (!appRootDir) {
+        return;
+    }
     try {
-        (0, promises_1.rm)(appRootDir, { recursive: true });
+        await (0, promises_1.rm)(appRootDir, { recursive: true });
     }
     catch (error) {
         debug(`Error while removing ${appRootDir} : ${error.message}`);
@@ -202485,6 +202553,9 @@ async function depGraphFromNodeModules(filePathToContent, nodeProjects, fileName
     const scanResults = [];
     for (const project of nodeProjects) {
         const { tempDir, tempProjectPath, manifestPath } = await (0, node_modules_utils_1.persistNodeModules)(project, filePathToContent, fileNamesGroupedByDirectory);
+        if (!tempDir) {
+            continue;
+        }
         if (!tempProjectPath) {
             await (0, node_modules_utils_1.cleanupAppNodeModules)(tempDir);
             continue;
@@ -202494,6 +202565,10 @@ async function depGraphFromNodeModules(filePathToContent, nodeProjects, fileName
                 dev: false,
                 noFromArrays: true,
             });
+            if (pkgTree.numDependencies === 0) {
+                await (0, node_modules_utils_1.cleanupAppNodeModules)(tempDir);
+                continue;
+            }
             const depGraph = await dep_graph_1.legacy.depTreeToGraph(pkgTree, pkgTree.type || "npm");
             scanResults.push({
                 facts: [
@@ -202571,27 +202646,23 @@ function findProjectsAndManifests(fileNamesGroupedByDirectory) {
         const expectedManifest = path.join(directoryPath, "package.json");
         const expectedNpmLockFile = path.join(directoryPath, "package-lock.json");
         const expectedYarnLockFile = path.join(directoryPath, "yarn.lock");
-        const hasManifestFileOnly = filesInDirectory.has(expectedManifest) &&
-            !(filesInDirectory.has(expectedNpmLockFile) ||
-                filesInDirectory.has(expectedYarnLockFile));
-        const hasNoManifestFile = !filesInDirectory.has(expectedManifest);
-        if (hasManifestFileOnly && filesInDirectory.size === 1) {
-            continue;
-        }
-        if (hasManifestFileOnly || hasNoManifestFile) {
-            nodeProjects.push(directoryPath);
+        const hasManifestFile = filesInDirectory.has(expectedManifest);
+        const hasLockFile = filesInDirectory.has(expectedNpmLockFile) ||
+            filesInDirectory.has(expectedYarnLockFile);
+        if (hasManifestFile && hasLockFile) {
+            manifestLockPathPairs.push({
+                manifest: expectedManifest,
+                // TODO: correlate filtering action with expected lockfile types
+                lock: filesInDirectory.has(expectedNpmLockFile)
+                    ? expectedNpmLockFile
+                    : expectedYarnLockFile,
+                lockType: filesInDirectory.has(expectedNpmLockFile)
+                    ? lockFileParser.LockfileType.npm
+                    : lockFileParser.LockfileType.yarn,
+            });
             continue;
         }
-        manifestLockPathPairs.push({
-            manifest: expectedManifest,
-            // TODO: correlate filtering action with expected lockfile types
-            lock: filesInDirectory.has(expectedNpmLockFile)
-                ? expectedNpmLockFile
-                : expectedYarnLockFile,
-            lockType: filesInDirectory.has(expectedNpmLockFile)
-                ? lockFileParser.LockfileType.npm
-                : lockFileParser.LockfileType.yarn,
-        });
+        nodeProjects.push(directoryPath);
     }
     return [manifestLockPathPairs, nodeProjects];
 }