Detect cached folders from multiple directories (#735)

* Add project-dir

* Fix find lock file

* Remove package-dir input

* format & resolve conflicts

* Add unit tests

* build dist

* Apply change request fixes

* handle non-dir cache-dependency-path

* bump cache version

* run checks

* Handle globs in cacheDependencyPath

* refactor, introduce `cacheDependencyPathToProjectsDirectories`

it is necessary for the next PR related yarn optimization

* Changes requests

* Apply fixes

* review fixes

* add e2e

* Add unique

* review updates

* review updates second stage

* Review fixes 3

* imporve e2e tests

src/cache-utils.ts

@@ -1,40 +1,79 @@
 import * as core from '@actions/core';
 import * as exec from '@actions/exec';
 import * as cache from '@actions/cache';
-
-type SupportedPackageManagers = {
-  [prop: string]: PackageManagerInfo;
-};
+import * as glob from '@actions/glob';
+import path from 'path';
+import fs from 'fs';
+import {unique} from './util';
 
 export interface PackageManagerInfo {
+  name: string;
   lockFilePatterns: Array<string>;
-  getCacheFolderCommand: string;
+  getCacheFolderPath: (projectDir?: string) => Promise<string>;
 }
 
+interface SupportedPackageManagers {
+  npm: PackageManagerInfo;
+  pnpm: PackageManagerInfo;
+  yarn: PackageManagerInfo;
+}
 export const supportedPackageManagers: SupportedPackageManagers = {
   npm: {
+    name: 'npm',
     lockFilePatterns: ['package-lock.json', 'npm-shrinkwrap.json', 'yarn.lock'],
-    getCacheFolderCommand: 'npm config get cache'
+    getCacheFolderPath: () =>
+      getCommandOutputNotEmpty(
+        'npm config get cache',
+        'Could not get npm cache folder path'
+      )
   },
   pnpm: {
+    name: 'pnpm',
     lockFilePatterns: ['pnpm-lock.yaml'],
-    getCacheFolderCommand: 'pnpm store path --silent'
+    getCacheFolderPath: () =>
+      getCommandOutputNotEmpty(
+        'pnpm store path --silent',
+        'Could not get pnpm cache folder path'
+      )
   },
-  yarn1: {
+  yarn: {
+    name: 'yarn',
     lockFilePatterns: ['yarn.lock'],
-    getCacheFolderCommand: 'yarn cache dir'
-  },
-  yarn2: {
-    lockFilePatterns: ['yarn.lock'],
-    getCacheFolderCommand: 'yarn config get cacheFolder'
+    getCacheFolderPath: async projectDir => {
+      const yarnVersion = await getCommandOutputNotEmpty(
+        `yarn --version`,
+        'Could not retrieve version of yarn',
+        projectDir
+      );
+
+      core.debug(
+        `Consumed yarn version is ${yarnVersion} (working dir: "${
+          projectDir || ''
+        }")`
+      );
+
+      const stdOut = yarnVersion.startsWith('1.')
+        ? await getCommandOutput('yarn cache dir', projectDir)
+        : await getCommandOutput('yarn config get cacheFolder', projectDir);
+
+      if (!stdOut) {
+        throw new Error(
+          `Could not get yarn cache folder path for ${projectDir}`
+        );
+      }
+      return stdOut;
+    }
   }
 };
 
-export const getCommandOutput = async (toolCommand: string) => {
+export const getCommandOutput = async (
+  toolCommand: string,
+  cwd?: string
+): Promise<string> => {
   let {stdout, stderr, exitCode} = await exec.getExecOutput(
     toolCommand,
     undefined,
-    {ignoreReturnCode: true}
+    {ignoreReturnCode: true, ...(cwd && {cwd})}
   );
 
   if (exitCode) {
@@ -47,16 +86,15 @@ export const getCommandOutput = async (toolCommand: string) => {
   return stdout.trim();
 };
 
-const getPackageManagerVersion = async (
-  packageManager: string,
-  command: string
-) => {
-  const stdOut = await getCommandOutput(`${packageManager} ${command}`);
-
+export const getCommandOutputNotEmpty = async (
+  toolCommand: string,
+  error: string,
+  cwd?: string
+): Promise<string> => {
+  const stdOut = getCommandOutput(toolCommand, cwd);
   if (!stdOut) {
-    throw new Error(`Could not retrieve version of ${packageManager}`);
+    throw new Error(error);
   }
-
   return stdOut;
 };
 
@@ -66,35 +104,102 @@ export const getPackageManagerInfo = async (packageManager: string) => {
   } else if (packageManager === 'pnpm') {
     return supportedPackageManagers.pnpm;
   } else if (packageManager === 'yarn') {
-    const yarnVersion = await getPackageManagerVersion('yarn', '--version');
-
-    core.debug(`Consumed yarn version is ${yarnVersion}`);
-
-    if (yarnVersion.startsWith('1.')) {
-      return supportedPackageManagers.yarn1;
-    } else {
-      return supportedPackageManagers.yarn2;
-    }
+    return supportedPackageManagers.yarn;
   } else {
     return null;
   }
 };
 
-export const getCacheDirectoryPath = async (
+/**
+ * Expands (converts) the string input `cache-dependency-path` to list of directories that
+ * may be project roots
+ * @param cacheDependencyPath - either a single string or multiline string with possible glob patterns
+ *                              expected to be the result of `core.getInput('cache-dependency-path')`
+ * @return list of directories and possible
+ */
+const getProjectDirectoriesFromCacheDependencyPath = async (
+  cacheDependencyPath: string
+): Promise<string[]> => {
+  const globber = await glob.create(cacheDependencyPath);
+  const cacheDependenciesPaths = await globber.glob();
+
+  const existingDirectories: string[] = cacheDependenciesPaths
+    .map(path.dirname)
+    .filter(unique())
+    .filter(directory => fs.lstatSync(directory).isDirectory());
+
+  if (!existingDirectories.length)
+    core.warning(
+      `No existing directories found containing cache-dependency-path="${cacheDependencyPath}"`
+    );
+
+  return existingDirectories;
+};
+
+/**
+ * Finds the cache directories configured for the repo if cache-dependency-path is not empty
+ * @param packageManagerInfo - an object having getCacheFolderPath method specific to given PM
+ * @param cacheDependencyPath - either a single string or multiline string with possible glob patterns
+ *                              expected to be the result of `core.getInput('cache-dependency-path')`
+ * @return list of files on which the cache depends
+ */
+const getCacheDirectoriesFromCacheDependencyPath = async (
   packageManagerInfo: PackageManagerInfo,
-  packageManager: string
-) => {
-  const stdOut = await getCommandOutput(
-    packageManagerInfo.getCacheFolderCommand
+  cacheDependencyPath: string
+): Promise<string[]> => {
+  const projectDirectories = await getProjectDirectoriesFromCacheDependencyPath(
+    cacheDependencyPath
   );
+  const cacheFoldersPaths = await Promise.all(
+    projectDirectories.map(async projectDirectory => {
+      const cacheFolderPath =
+        packageManagerInfo.getCacheFolderPath(projectDirectory);
+      core.debug(
+        `${packageManagerInfo.name}'s cache folder "${cacheFolderPath}" configured for the directory "${projectDirectory}"`
+      );
+      return cacheFolderPath;
+    })
+  );
+  // uniq in order to do not cache the same directories twice
+  return cacheFoldersPaths.filter(unique());
+};
 
-  if (!stdOut) {
-    throw new Error(`Could not get cache folder path for ${packageManager}`);
+/**
+ * Finds the cache directories configured for the repo ignoring cache-dependency-path
+ * @param packageManagerInfo - an object having getCacheFolderPath method specific to given PM
+ * @return list of files on which the cache depends
+ */
+const getCacheDirectoriesForRootProject = async (
+  packageManagerInfo: PackageManagerInfo
+): Promise<string[]> => {
+  const cacheFolderPath = await packageManagerInfo.getCacheFolderPath();
+  core.debug(
+    `${packageManagerInfo.name}'s cache folder "${cacheFolderPath}" configured for the root directory`
+  );
+  return [cacheFolderPath];
+};
+
+/**
+ * A function to find the cache directories configured for the repo
+ * currently it handles only the case of PM=yarn && cacheDependencyPath is not empty
+ * @param packageManagerInfo - an object having getCacheFolderPath method specific to given PM
+ * @param cacheDependencyPath - either a single string or multiline string with possible glob patterns
+ *                              expected to be the result of `core.getInput('cache-dependency-path')`
+ * @return list of files on which the cache depends
+ */
+export const getCacheDirectories = async (
+  packageManagerInfo: PackageManagerInfo,
+  cacheDependencyPath: string
+): Promise<string[]> => {
+  // For yarn, if cacheDependencyPath is set, ask information about cache folders in each project
+  // folder satisfied by cacheDependencyPath https://github.com/actions/setup-node/issues/488
+  if (packageManagerInfo.name === 'yarn' && cacheDependencyPath) {
+    return getCacheDirectoriesFromCacheDependencyPath(
+      packageManagerInfo,
+      cacheDependencyPath
+    );
   }
-
-  core.debug(`${packageManager} path is ${stdOut}`);
-
-  return stdOut.trim();
+  return getCacheDirectoriesForRootProject(packageManagerInfo);
 };
 
 export function isGhes(): boolean {