Add `reeval` & `only-restore` boolean input parameters

* implement only-restore within save

.gitignore

@@ -94,3 +94,6 @@ typings/
 
 # Text editor files
 .vscode/
+
+# OS
+.DS_Store

action.yml

@@ -14,6 +14,14 @@ inputs:
   upload-chunk-size:
     description: 'The chunk size used to split up large files during upload, in bytes'
     required: false
+  reeval:
+    description: 'Boolean. Whether to reevaluate the key argument in post. Set to TRUE if you would like your cache key set after your job's steps are complete.'
+    required: false
+    default: false
+  only-restore:
+    description: 'Boolean. Whether to only perform cache restoration and NOT the save post run step.'
+    required: false
+    default: false
 outputs:
   cache-hit:
     description: 'A boolean value to indicate an exact match was found for the primary key'

src/constants.ts

@@ -1,6 +1,8 @@
 export enum Inputs {
     Key = "key",
+    OnlyRestore = "only-restore",
     Path = "path",
+    Reeval = "reeval",
     RestoreKeys = "restore-keys",
     UploadChunkSize = "upload-chunk-size"
 }

src/save.ts

@@ -10,57 +10,60 @@ import * as utils from "./utils/actionUtils";
 process.on("uncaughtException", e => utils.logWarning(e.message));
 
 async function run(): Promise<void> {
-    try {
+    const save = ! core.getBooleanInput(Inputs.OnlyRestore);
-        if (!utils.isCacheFeatureAvailable()) {
+    if (save) {
-            return;
+        try {
-        }
+            if (!utils.isCacheFeatureAvailable()) {
-
+                return;
-        if (!utils.isValidEvent()) {
+            }
-            utils.logWarning(
-                `Event Validation Error: The event type ${
-                    process.env[Events.Key]
-                } is not supported because it's not tied to a branch or tag ref.`
-            );
-            return;
-        }
     
-        const state = utils.getCacheState();
+            if (!utils.isValidEvent()) {
+                utils.logWarning(
+                    `Event Validation Error: The event type ${
+                        process.env[Events.Key]
+                    } is not supported because it's not tied to a branch or tag ref.`
+                );
+                return;
+            }
     
-        // Inputs are re-evaluted before the post action, so we want the original key used for restore
+            const state = utils.getCacheState();
-        const primaryKey = core.getState(State.CachePrimaryKey);
-        if (!primaryKey) {
-            utils.logWarning(`Error retrieving key from state.`);
-            return;
-        }
     
-        if (utils.isExactKeyMatch(primaryKey, state)) {
+            // Inputs are re-evaluted before the post action, so we want the original key used for restore
-            core.info(
+            const primaryKey = core.getState(State.CachePrimaryKey);
-                `Cache hit occurred on the primary key ${primaryKey}, not saving cache.`
+            if (!primaryKey) {
-            );
+                utils.logWarning(`Error retrieving key from state.`);
-            return;
+                return;
-        }
+            }
     
-        const cachePaths = utils.getInputAsArray(Inputs.Path, {
+            if (utils.isExactKeyMatch(primaryKey, state)) {
-            required: true
+                core.info(
-        });
+                    `Cache hit occurred on the primary key ${primaryKey}, not saving cache.`
+                );
+                return;
+            }
     
-        try {
+            const cachePaths = utils.getInputAsArray(Inputs.Path, {
-            await cache.saveCache(cachePaths, primaryKey, {
+                required: true
-                uploadChunkSize: utils.getInputAsInt(Inputs.UploadChunkSize)
             });
-            core.info(`Cache saved with key: ${primaryKey}`);
+    
-        } catch (error: unknown) {
+            try {
-            const typedError = error as Error;
+                await cache.saveCache(cachePaths, primaryKey, {
-            if (typedError.name === cache.ValidationError.name) {
+                    uploadChunkSize: utils.getInputAsInt(Inputs.UploadChunkSize)
-                throw error;
+                });
-            } else if (typedError.name === cache.ReserveCacheError.name) {
+                core.info(`Cache saved with key: ${primaryKey}`);
-                core.info(typedError.message);
+            } catch (error: unknown) {
-            } else {
+                const typedError = error as Error;
-                utils.logWarning(typedError.message);
+                if (typedError.name === cache.ValidationError.name) {
+                    throw error;
+                } else if (typedError.name === cache.ReserveCacheError.name) {
+                    core.info(typedError.message);
+                } else {
+                    utils.logWarning(typedError.message);
+                }
             }
+        } catch (error: unknown) {
+            utils.logWarning((error as Error).message);
         }
-    } catch (error: unknown) {
-        utils.logWarning((error as Error).message);
     }
 }