Add check-only mode

src/constants.ts

@@ -1,7 +1,8 @@
 export enum Inputs {
     Key = "key",
     Path = "path",
-    RestoreKeys = "restore-keys"
+    RestoreKeys = "restore-keys",
+    OnlyCheckKey = "only-check-key"
 }
 
 export enum Outputs {

src/restore.ts

@@ -1,4 +1,6 @@
 import * as cache from "@actions/cache";
+import { getCacheEntry } from "@actions/cache/lib/internal/cacheHttpClient";
+import { getCompressionMethod } from "@actions/cache/lib/internal/cacheUtils";
 import * as core from "@actions/core";
 
 import { Events, Inputs, State } from "./constants";
@@ -23,30 +25,48 @@ async function run(): Promise<void> {
         const cachePaths = utils.getInputAsArray(Inputs.Path, {
             required: true
         });
+        const onlyCheck = utils.getInputAsBool(Inputs.OnlyCheckKey);
 
         try {
-            const cacheKey = await cache.restoreCache(
+            if (onlyCheck) {
-                cachePaths,
+                const entry = await getCacheEntry([primaryKey], cachePaths, {
-                primaryKey,
+                    compressionMethod: await getCompressionMethod()
-                restoreKeys
+                });
-            );
+
-            if (!cacheKey) {
+                if (entry && entry.archiveLocation) {
-                core.info(
+                    core.info(`Cache found for key: ${primaryKey}`);
-                    `Cache not found for input keys: ${[
+                    utils.setCacheHitOutput(true);
-                        primaryKey,
+                } else {
-                        ...restoreKeys
+                    core.info(`Cache not found for key: ${primaryKey}`);
-                    ].join(", ")}`
+                    utils.setCacheHitOutput(false);
+                }
+            } else {
+                const cacheKey = await cache.restoreCache(
+                    cachePaths,
+                    primaryKey,
+                    restoreKeys
                 );
-                return;
+                if (!cacheKey) {
-            }
+                    core.info(
+                        `Cache not found for input keys: ${[
+                            primaryKey,
+                            ...restoreKeys
+                        ].join(", ")}`
+                    );
+                    return;
+                }
 
-            // Store the matched cache key
+                // Store the matched cache key
-            utils.setCacheState(cacheKey);
+                utils.setCacheState(cacheKey);
 
-            const isExactKeyMatch = utils.isExactKeyMatch(primaryKey, cacheKey);
+                const isExactKeyMatch = utils.isExactKeyMatch(
-            utils.setCacheHitOutput(isExactKeyMatch);
+                    primaryKey,
+                    cacheKey
+                );
+                utils.setCacheHitOutput(isExactKeyMatch);
 
-            core.info(`Cache restored from key: ${cacheKey}`);
+                core.info(`Cache restored from key: ${cacheKey}`);
+            }
         } catch (error) {
             if (error.name === cache.ValidationError.name) {
                 throw error;

src/utils/actionUtils.ts

@@ -56,3 +56,10 @@ export function getInputAsArray(
         .map(s => s.trim())
         .filter(x => x !== "");
 }
+
+export function getInputAsBool(
+    name: string,
+    options?: core.InputOptions
+): boolean {
+    return core.getInput(name, options) === "true";
+}