adding wrapper to save-only and testcases

.github/workflows/check-dist.yml

@@ -27,7 +27,6 @@ jobs:
         uses: actions/setup-node@v3
         with:
           node-version: 16.x
-          cache: npm
       - name: Install dependencies
         run: npm ci
       - name: Rebuild the dist/ directory

.github/workflows/workflow.yml

@@ -25,7 +25,17 @@ jobs:
       uses: actions/setup-node@v3
       with:
         node-version: 16.x
-        cache: npm
+    - name: Determine npm cache directory
+      id: npm-cache
+      run: |
+        echo "::set-output name=dir::$(npm config get cache)"
+    - name: Restore npm cache
+      uses: actions/cache@v3
+      with:
+        path: ${{ steps.npm-cache.outputs.dir }}
+        key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
+        restore-keys: |
+          ${{ runner.os }}-node-
     - run: npm ci
     - name: Prettier Format Check
       run: npm run format-check

__tests__/restore.test.ts

@@ -102,7 +102,7 @@ test("restore on GHES with AC available ", async () => {
     const infoMock = jest.spyOn(core, "info");
     const failedMock = jest.spyOn(core, "setFailed");
     const stateMock = jest.spyOn(core, "saveState");
-    const setCacheHitOutputMock = jest.spyOn(core, "setOutput");
+    const setCacheHitOutputMock = jest.spyOn(actionUtils, "setCacheHitOutput");
     const restoreCacheMock = jest
         .spyOn(cache, "restoreCache")
         .mockImplementationOnce(() => {
@@ -116,7 +116,7 @@ test("restore on GHES with AC available ", async () => {
 
     expect(stateMock).toHaveBeenCalledWith("CACHE_KEY", key);
     expect(setCacheHitOutputMock).toHaveBeenCalledTimes(1);
-    expect(setCacheHitOutputMock).toHaveBeenCalledWith("cache-hit", "true");
+    expect(setCacheHitOutputMock).toHaveBeenCalledWith(true);
 
     expect(infoMock).toHaveBeenCalledWith(`Cache restored from key: ${key}`);
     expect(failedMock).toHaveBeenCalledTimes(0);
@@ -270,7 +270,7 @@ test("restore with cache found for key", async () => {
     const infoMock = jest.spyOn(core, "info");
     const failedMock = jest.spyOn(core, "setFailed");
     const stateMock = jest.spyOn(core, "saveState");
-    const setCacheHitOutputMock = jest.spyOn(core, "setOutput");
+    const setCacheHitOutputMock = jest.spyOn(actionUtils, "setCacheHitOutput");
     const restoreCacheMock = jest
         .spyOn(cache, "restoreCache")
         .mockImplementationOnce(() => {
@@ -284,7 +284,7 @@ test("restore with cache found for key", async () => {
 
     expect(stateMock).toHaveBeenCalledWith("CACHE_KEY", key);
     expect(setCacheHitOutputMock).toHaveBeenCalledTimes(1);
-    expect(setCacheHitOutputMock).toHaveBeenCalledWith("cache-hit", "true");
+    expect(setCacheHitOutputMock).toHaveBeenCalledWith(true);
 
     expect(infoMock).toHaveBeenCalledWith(`Cache restored from key: ${key}`);
     expect(failedMock).toHaveBeenCalledTimes(0);
@@ -303,7 +303,7 @@ test("restore with cache found for restore key", async () => {
     const infoMock = jest.spyOn(core, "info");
     const failedMock = jest.spyOn(core, "setFailed");
     const stateMock = jest.spyOn(core, "saveState");
-    const setCacheHitOutputMock = jest.spyOn(core, "setOutput");
+    const setCacheHitOutputMock = jest.spyOn(actionUtils, "setCacheHitOutput");
     const restoreCacheMock = jest
         .spyOn(cache, "restoreCache")
         .mockImplementationOnce(() => {
@@ -317,9 +317,120 @@ test("restore with cache found for restore key", async () => {
 
     expect(stateMock).toHaveBeenCalledWith("CACHE_KEY", key);
     expect(setCacheHitOutputMock).toHaveBeenCalledTimes(1);
-    expect(setCacheHitOutputMock).toHaveBeenCalledWith("cache-hit", "false");
+    expect(setCacheHitOutputMock).toHaveBeenCalledWith(false);
+
     expect(infoMock).toHaveBeenCalledWith(
         `Cache restored from key: ${restoreKey}`
     );
     expect(failedMock).toHaveBeenCalledTimes(0);
 });
+
+test("restore with enabling save on any failure feature", async () => {
+    const path = "node_modules";
+    const key = "node-test";
+    const restoreKey = "node-";
+    testUtils.setInputs({
+        path: path,
+        key,
+        restoreKeys: [restoreKey],
+        saveOnAnyFailure: true
+    });
+
+    const debugMock = jest.spyOn(core, "debug");
+    const infoMock = jest.spyOn(core, "info");
+    const failedMock = jest.spyOn(core, "setFailed");
+    const stateMock = jest.spyOn(core, "saveState");
+    const setCacheHitOutputMock = jest.spyOn(actionUtils, "setCacheHitOutput");
+    const restoreCacheMock = jest
+        .spyOn(cache, "restoreCache")
+        .mockImplementationOnce(() => {
+            return Promise.resolve(restoreKey);
+        });
+
+    await run();
+
+    expect(restoreCacheMock).toHaveBeenCalledTimes(1);
+    expect(restoreCacheMock).toHaveBeenCalledWith([path], key, [restoreKey]);
+
+    expect(stateMock).toHaveBeenCalledWith("CACHE_KEY", key);
+    expect(setCacheHitOutputMock).toHaveBeenCalledTimes(1);
+    expect(setCacheHitOutputMock).toHaveBeenCalledWith(false);
+
+    expect(debugMock).toHaveBeenCalledWith(
+        `Exporting environment variable SAVE_CACHE_ON_ANY_FAILURE`
+    );
+
+    expect(infoMock).toHaveBeenCalledWith(
+        `Input Variable SAVE_CACHE_ON_ANY_FAILURE is set to true, the cache will be saved despite of any failure in the build.`
+    );
+    expect(failedMock).toHaveBeenCalledTimes(0);
+});
+
+test("Fail restore when fail on cache miss is enabled and primary key not found", async () => {
+    const path = "node_modules";
+    const key = "node-test";
+    const restoreKey = "node-";
+    testUtils.setInputs({
+        path: path,
+        key,
+        restoreKeys: [restoreKey],
+        failOnCacheMiss: true
+    });
+
+    const failedMock = jest.spyOn(core, "setFailed");
+    const stateMock = jest.spyOn(core, "saveState");
+    const setCacheHitOutputMock = jest.spyOn(actionUtils, "setCacheHitOutput");
+    const restoreCacheMock = jest
+        .spyOn(cache, "restoreCache")
+        .mockImplementationOnce(() => {
+            return Promise.resolve(undefined);
+        });
+
+    await run();
+
+    expect(restoreCacheMock).toHaveBeenCalledTimes(1);
+    expect(restoreCacheMock).toHaveBeenCalledWith([path], key, [restoreKey]);
+
+    expect(stateMock).toHaveBeenCalledWith("CACHE_KEY", key);
+    expect(setCacheHitOutputMock).toHaveBeenCalledTimes(0);
+
+    expect(failedMock).toHaveBeenCalledWith(
+        `Cache with the given input key ${key} is not found, hence exiting the workflow as the fail-on-cache-miss requirement is not met.`
+    );
+    expect(failedMock).toHaveBeenCalledTimes(1);
+});
+
+test("Fail restore when fail on cache miss is enabled and primary key doesn't match restored key", async () => {
+    const path = "node_modules";
+    const key = "node-test";
+    const restoreKey = "node-";
+    testUtils.setInputs({
+        path: path,
+        key,
+        restoreKeys: [restoreKey],
+        failOnCacheMiss: true
+    });
+
+    const failedMock = jest.spyOn(core, "setFailed");
+    const stateMock = jest.spyOn(core, "saveState");
+    const setCacheHitOutputMock = jest.spyOn(actionUtils, "setCacheHitOutput");
+    const restoreCacheMock = jest
+        .spyOn(cache, "restoreCache")
+        .mockImplementationOnce(() => {
+            return Promise.resolve(restoreKey);
+        });
+
+    await run();
+
+    expect(restoreCacheMock).toHaveBeenCalledTimes(1);
+    expect(restoreCacheMock).toHaveBeenCalledWith([path], key, [restoreKey]);
+
+    expect(stateMock).toHaveBeenCalledWith("CACHE_KEY", key);
+    expect(setCacheHitOutputMock).toHaveBeenCalledTimes(1);
+    expect(setCacheHitOutputMock).toHaveBeenCalledWith(false);
+
+    expect(failedMock).toHaveBeenCalledWith(
+        `Restored cache key doesn't match the given input key ${key}, hence exiting the workflow as the fail-on-cache-miss requirement is not met.`
+    );
+    expect(failedMock).toHaveBeenCalledTimes(1);
+});

__tests__/save-only.test.ts

@@ -0,0 +1,165 @@
+import * as cache from "@actions/cache";
+import * as core from "@actions/core";
+
+import { Events, Inputs, RefKey } from "../src/constants";
+import run from "../src/save-only";
+import * as actionUtils from "../src/utils/actionUtils";
+import * as testUtils from "../src/utils/testUtils";
+
+jest.mock("@actions/core");
+jest.mock("@actions/cache");
+jest.mock("../src/utils/actionUtils");
+
+beforeAll(() => {
+    jest.spyOn(core, "getInput").mockImplementation((name, options) => {
+        return jest.requireActual("@actions/core").getInput(name, options);
+    });
+
+    jest.spyOn(actionUtils, "getCacheState").mockImplementation(() => {
+        return jest.requireActual("../src/utils/actionUtils").getCacheState();
+    });
+
+    jest.spyOn(actionUtils, "getInputAsArray").mockImplementation(
+        (name, options) => {
+            return jest
+                .requireActual("../src/utils/actionUtils")
+                .getInputAsArray(name, options);
+        }
+    );
+
+    jest.spyOn(actionUtils, "getInputAsInt").mockImplementation(
+        (name, options) => {
+            return jest
+                .requireActual("../src/utils/actionUtils")
+                .getInputAsInt(name, options);
+        }
+    );
+
+    jest.spyOn(actionUtils, "isExactKeyMatch").mockImplementation(
+        (key, cacheResult) => {
+            return jest
+                .requireActual("../src/utils/actionUtils")
+                .isExactKeyMatch(key, cacheResult);
+        }
+    );
+
+    jest.spyOn(actionUtils, "isValidEvent").mockImplementation(() => {
+        const actualUtils = jest.requireActual("../src/utils/actionUtils");
+        return actualUtils.isValidEvent();
+    });
+});
+
+beforeEach(() => {
+    process.env[Events.Key] = Events.Push;
+    process.env[RefKey] = "refs/heads/feature-branch";
+
+    jest.spyOn(actionUtils, "isGhes").mockImplementation(() => false);
+    jest.spyOn(actionUtils, "isCacheFeatureAvailable").mockImplementation(
+        () => true
+    );
+});
+
+afterEach(() => {
+    testUtils.clearInputs();
+    delete process.env[Events.Key];
+    delete process.env[RefKey];
+});
+
+test("save cache when save-only is required", async () => {
+    const failedMock = jest.spyOn(core, "setFailed");
+
+    const primaryKey = "Linux-node-bb828da54c148048dd17899ba9fda624811cfb43";
+    const savedCacheKey = "Linux-node-";
+
+    jest.spyOn(core, "getInput")
+        // Cache Entry State
+        .mockImplementationOnce(() => {
+            return savedCacheKey;
+        })
+        // Cache Key
+        .mockImplementationOnce(() => {
+            return primaryKey;
+        });
+
+    const inputPath = "node_modules";
+    testUtils.setInput(Inputs.Path, inputPath);
+    testUtils.setInput(Inputs.UploadChunkSize, "4000000");
+
+    const cacheId = 4;
+    const saveCacheMock = jest
+        .spyOn(cache, "saveCache")
+        .mockImplementationOnce(() => {
+            return Promise.resolve(cacheId);
+        });
+
+    await run();
+
+    expect(saveCacheMock).toHaveBeenCalledTimes(1);
+    expect(saveCacheMock).toHaveBeenCalledWith([inputPath], primaryKey, {
+        uploadChunkSize: 4000000
+    });
+
+    expect(failedMock).toHaveBeenCalledTimes(0);
+});
+
+test("save when save on any failure is true", async () => {
+    const logWarningMock = jest.spyOn(actionUtils, "logWarning");
+    const failedMock = jest.spyOn(core, "setFailed");
+
+    const savedCacheKey = "Linux-node-bb828da54c148048dd17899ba9fda624811cfb43";
+    const primaryKey = "Linux-node-";
+    const inputPath = "node_modules";
+
+    jest.spyOn(core, "getInput")
+        // Cache Entry State
+        .mockImplementationOnce(() => {
+            return savedCacheKey;
+        })
+        // Cache Key
+        .mockImplementationOnce(() => {
+            return primaryKey;
+        });
+
+    testUtils.setInput(Inputs.Path, inputPath);
+    testUtils.setInput(Inputs.UploadChunkSize, "4000000");
+    testUtils.setInput(Inputs.SaveOnAnyFailure, "true");
+
+    const cacheId = 4;
+    const saveCacheMock = jest
+        .spyOn(cache, "saveCache")
+        .mockImplementationOnce(() => {
+            return Promise.resolve(cacheId);
+        });
+
+    await run();
+
+    expect(saveCacheMock).toHaveBeenCalledTimes(1);
+    expect(logWarningMock).toHaveBeenCalledTimes(0);
+    expect(failedMock).toHaveBeenCalledTimes(0);
+});
+
+test("save with no primary key in input outputs warning", async () => {
+    const logWarningMock = jest.spyOn(actionUtils, "logWarning");
+    const failedMock = jest.spyOn(core, "setFailed");
+
+    const savedCacheKey = "Linux-node-bb828da54c148048dd17899ba9fda624811cfb43";
+    jest.spyOn(core, "getState")
+        // Cache Entry State
+        .mockImplementationOnce(() => {
+            return savedCacheKey;
+        })
+        // Cache Key
+        .mockImplementationOnce(() => {
+            return "";
+        });
+    const saveCacheMock = jest.spyOn(cache, "saveCache");
+
+    await run();
+
+    expect(saveCacheMock).toHaveBeenCalledTimes(0);
+    expect(logWarningMock).toHaveBeenCalledWith(
+        `Error retrieving key from inputs.`
+    );
+    expect(logWarningMock).toHaveBeenCalledTimes(1);
+    expect(failedMock).toHaveBeenCalledTimes(0);
+});

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
+  exit-on-cache-miss:
+    description: 'Fail the workflow if the cache is not found for the primary key'
+    required: false
+    default: false
+  save-on-any-failure:
+    description: 'Save cache (on cache miss) despite of any failure during the workflow run'
+    required: false
+    default: false
 outputs:
   cache-hit:
     description: 'A boolean value to indicate an exact match was found for the primary key'
@@ -21,7 +29,7 @@ runs:
   using: 'node16'
   main: 'dist/restore/index.js'
   post: 'dist/save/index.js'
-  post-if: success()
+  post-if: (success() || (env.SAVE_CACHE_ON_ANY_FAILURE == 'yes'))
 branding:
   icon: 'archive'
   color: 'gray-dark'

dist/save/index.js

@@ -4964,13 +4964,15 @@ exports.checkBypass = checkBypass;
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RefKey = exports.Events = exports.State = exports.Outputs = exports.Inputs = void 0;
+exports.RefKey = exports.Variables = exports.Events = exports.State = exports.Outputs = exports.Inputs = void 0;
 var Inputs;
 (function (Inputs) {
     Inputs["Key"] = "key";
     Inputs["Path"] = "path";
     Inputs["RestoreKeys"] = "restore-keys";
     Inputs["UploadChunkSize"] = "upload-chunk-size";
+    Inputs["FailOnCacheMiss"] = "fail-on-cache-miss";
+    Inputs["SaveOnAnyFailure"] = "save-on-any-failure";
 })(Inputs = exports.Inputs || (exports.Inputs = {}));
 var Outputs;
 (function (Outputs) {
@@ -4987,6 +4989,10 @@ var Events;
     Events["Push"] = "push";
     Events["PullRequest"] = "pull_request";
 })(Events = exports.Events || (exports.Events = {}));
+var Variables;
+(function (Variables) {
+    Variables["SaveCacheOnAnyFailure"] = "SAVE_CACHE_ON_ANY_FAILURE";
+})(Variables = exports.Variables || (exports.Variables = {}));
 exports.RefKey = "GITHUB_REF";
 
 
@@ -9344,76 +9350,7 @@ function expand(str, isTop) {
 /***/ }),
 /* 307 */,
 /* 308 */,
-/* 309 */
-/***/ (function(__unusedmodule, exports, __webpack_require__) {
-
-"use strict";
-
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NullStateProvider = exports.StateProvider = void 0;
-const core = __importStar(__webpack_require__(470));
-const constants_1 = __webpack_require__(196);
-class StateProviderBase {
-    constructor() {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-empty-function
-        this.setState = (key, value) => { };
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        this.getState = (key) => "";
-    }
-    getCacheState() {
-        const cacheKey = this.getState(constants_1.State.CacheMatchedKey);
-        if (cacheKey) {
-            core.debug(`Cache state/key: ${cacheKey}`);
-            return cacheKey;
-        }
-        return undefined;
-    }
-}
-class StateProvider extends StateProviderBase {
-    constructor() {
-        super(...arguments);
-        //setOutput = core.setOutput;
-        this.setState = core.saveState;
-        this.getState = core.getState;
-    }
-}
-exports.StateProvider = StateProvider;
-class NullStateProvider extends StateProviderBase {
-    constructor() {
-        super(...arguments);
-        //setOutput = core.setOutput;
-        this.setState = core.setOutput;
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        this.getState = (key) => "";
-    }
-}
-exports.NullStateProvider = NullStateProvider;
-
-
-/***/ }),
+/* 309 */,
 /* 310 */,
 /* 311 */,
 /* 312 */
@@ -38491,7 +38428,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isCacheFeatureAvailable = exports.getInputAsInt = exports.getInputAsArray = exports.isValidEvent = exports.logWarning = exports.setCacheHitOutput = exports.isExactKeyMatch = exports.isGhes = void 0;
+exports.isCacheFeatureAvailable = exports.getInputAsInt = exports.getInputAsArray = exports.isValidEvent = exports.logWarning = exports.getCacheState = exports.setOutputAndState = exports.setCacheHitOutput = exports.setCacheState = exports.isExactKeyMatch = exports.isGhes = void 0;
 const cache = __importStar(__webpack_require__(692));
 const core = __importStar(__webpack_require__(470));
 const constants_1 = __webpack_require__(196);
@@ -38507,10 +38444,29 @@ function isExactKeyMatch(key, cacheKey) {
         }) === 0);
 }
 exports.isExactKeyMatch = isExactKeyMatch;
+function setCacheState(state) {
+    core.saveState(constants_1.State.CacheMatchedKey, state);
+}
+exports.setCacheState = setCacheState;
 function setCacheHitOutput(isCacheHit) {
     core.setOutput(constants_1.Outputs.CacheHit, isCacheHit.toString());
 }
 exports.setCacheHitOutput = setCacheHitOutput;
+function setOutputAndState(key, cacheKey) {
+    setCacheHitOutput(isExactKeyMatch(key, cacheKey));
+    // Store the matched cache key if it exists
+    cacheKey && setCacheState(cacheKey);
+}
+exports.setOutputAndState = setOutputAndState;
+function getCacheState() {
+    const cacheKey = core.getState(constants_1.State.CacheMatchedKey);
+    if (cacheKey) {
+        core.debug(`Cache state/key: ${cacheKey}`);
+        return cacheKey;
+    }
+    return undefined;
+}
+exports.getCacheState = getCacheState;
 function logWarning(message) {
     const warningPrefix = "[warning]";
     core.info(`${warningPrefix}${message}`);
@@ -38539,16 +38495,17 @@ function getInputAsInt(name, options) {
 }
 exports.getInputAsInt = getInputAsInt;
 function isCacheFeatureAvailable() {
-    if (cache.isFeatureAvailable()) {
-        return true;
-    }
-    if (isGhes()) {
-        logWarning(`Cache action is only supported on GHES version >= 3.5. If you are on version >=3.5 Please check with GHES admin if Actions cache service is enabled or not.
+    if (!cache.isFeatureAvailable()) {
+        if (isGhes()) {
+            logWarning(`Cache action is only supported on GHES version >= 3.5. If you are on version >=3.5 Please check with GHES admin if Actions cache service is enabled or not.
 Otherwise please upgrade to GHES version >= 3.5 and If you are also using Github Connect, please unretire the actions/cache namespace before upgrade (see https://docs.github.com/en/enterprise-server@3.5/admin/github-actions/managing-access-to-actions-from-githubcom/enabling-automatic-access-to-githubcom-actions-using-github-connect#automatic-retirement-of-namespaces-for-actions-accessed-on-githubcom)`);
+        }
+        else {
+            logWarning("An internal error has occurred in cache backend. Please check https://www.githubstatus.com/ for any ongoing issue in actions.");
+        }
         return false;
     }
-    logWarning("An internal error has occurred in cache backend. Please check https://www.githubstatus.com/ for any ongoing issue in actions.");
-    return false;
+    return true;
 }
 exports.isCacheFeatureAvailable = isCacheFeatureAvailable;
 
@@ -40942,96 +40899,7 @@ Object.defineProperty(exports, "toPlatformPath", { enumerable: true, get: functi
 //# sourceMappingURL=core.js.map
 
 /***/ }),
-/* 471 */
-/***/ (function(__unusedmodule, exports, __webpack_require__) {
-
-"use strict";
-
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const cache = __importStar(__webpack_require__(692));
-const core = __importStar(__webpack_require__(470));
-const constants_1 = __webpack_require__(196);
-const utils = __importStar(__webpack_require__(443));
-// Catch and log any unhandled exceptions.  These exceptions can leak out of the uploadChunk method in
-// @actions/toolkit when a failed upload closes the file descriptor causing any in-process reads to
-// throw an uncaught exception.  Instead of failing this action, just warn.
-process.on("uncaughtException", e => utils.logWarning(e.message));
-function saveImpl(stateProvider) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            if (!utils.isCacheFeatureAvailable()) {
-                return;
-            }
-            if (!utils.isValidEvent()) {
-                utils.logWarning(`Event Validation Error: The event type ${process.env[constants_1.Events.Key]} is not supported because it's not tied to a branch or tag ref.`);
-                return;
-            }
-            // If restore has stored a primary key in state, reuse that
-            // Else re-evaluate from inputs
-            const primaryKey = stateProvider.getState(constants_1.State.CachePrimaryKey) ||
-                core.getInput(constants_1.Inputs.Key);
-            if (!primaryKey) {
-                utils.logWarning(`Error retrieving key from state.`);
-                return;
-            }
-            // If matched restore key is same as primary key, then do not save cache
-            // NO-OP in case of SaveOnly action
-            const state = stateProvider.getCacheState();
-            if (utils.isExactKeyMatch(primaryKey, state)) {
-                core.info(`Cache hit occurred on the primary key ${primaryKey}, not saving cache.`);
-                return;
-            }
-            const cachePaths = utils.getInputAsArray(constants_1.Inputs.Path, {
-                required: true
-            });
-            const cacheId = yield cache.saveCache(cachePaths, primaryKey, {
-                uploadChunkSize: utils.getInputAsInt(constants_1.Inputs.UploadChunkSize)
-            });
-            if (cacheId != -1) {
-                core.info(`Cache saved with key: ${primaryKey}`);
-            }
-        }
-        catch (error) {
-            utils.logWarning(error.message);
-        }
-    });
-}
-exports.default = saveImpl;
-
-
-/***/ }),
+/* 471 */,
 /* 472 */,
 /* 473 */,
 /* 474 */,
@@ -47407,6 +47275,29 @@ exports.default = _default;
 
 "use strict";
 
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -47416,18 +47307,54 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const saveImpl_1 = __importDefault(__webpack_require__(471));
-const stateProvider_1 = __webpack_require__(309);
+const cache = __importStar(__webpack_require__(692));
+const core = __importStar(__webpack_require__(470));
+const constants_1 = __webpack_require__(196);
+const save_only_1 = __webpack_require__(973);
+const utils = __importStar(__webpack_require__(443));
+// Catch and log any unhandled exceptions.  These exceptions can leak out of the uploadChunk method in
+// @actions/toolkit when a failed upload closes the file descriptor causing any in-process reads to
+// throw an uncaught exception.  Instead of failing this action, just warn.
+process.on("uncaughtException", e => utils.logWarning(e.message));
 function run() {
     return __awaiter(this, void 0, void 0, function* () {
-        yield (0, saveImpl_1.default)(new stateProvider_1.StateProvider());
+        try {
+            if (!utils.isCacheFeatureAvailable()) {
+                return;
+            }
+            if (!utils.isValidEvent()) {
+                utils.logWarning(`Event Validation Error: The event type ${process.env[constants_1.Events.Key]} is not supported because it's not tied to a branch or tag ref.`);
+                return;
+            }
+            const state = utils.getCacheState();
+            // Inputs are re-evaluted before the post action, so we want the original key used for restore
+            const primaryKey = save_only_1.saveOnly === true
+                ? core.getInput(constants_1.Inputs.Key)
+                : core.getState(constants_1.State.CachePrimaryKey);
+            if (!primaryKey) {
+                utils.logWarning(`Error retrieving key from state.`);
+                return;
+            }
+            if (utils.isExactKeyMatch(primaryKey, state)) {
+                core.info(`Cache hit occurred on the primary key ${primaryKey}, not saving cache.`);
+                return;
+            }
+            const cachePaths = utils.getInputAsArray(constants_1.Inputs.Path, {
+                required: true
+            });
+            const cacheId = yield cache.saveCache(cachePaths, primaryKey, {
+                uploadChunkSize: utils.getInputAsInt(constants_1.Inputs.UploadChunkSize)
+            });
+            if (cacheId != -1) {
+                core.info(`Cache saved with key: ${primaryKey}`);
+            }
+        }
+        catch (error) {
+            utils.logWarning(error.message);
+        }
     });
 }
-run();
 exports.default = run;
 
 
@@ -55297,7 +55224,67 @@ exports.safeTrimTrailingSeparator = safeTrimTrailingSeparator;
 //# sourceMappingURL=internal-path-helper.js.map
 
 /***/ }),
-/* 973 */,
+/* 973 */
+/***/ (function(__unusedmodule, exports, __webpack_require__) {
+
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveOnly = void 0;
+const core = __importStar(__webpack_require__(470));
+const constants_1 = __webpack_require__(196);
+const save_1 = __importDefault(__webpack_require__(681));
+const utils = __importStar(__webpack_require__(443));
+function runSaveAction() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!core.getInput(constants_1.Inputs.Key)) {
+            utils.logWarning(`Error retrieving key from inputs.`);
+            return;
+        }
+        exports.saveOnly = true;
+        yield (0, save_1.default)();
+    });
+}
+runSaveAction();
+exports.default = runSaveAction;
+
+
+/***/ }),
 /* 974 */,
 /* 975 */
 /***/ (function(__unusedmodule, exports) {

package.json

@@ -5,7 +5,7 @@
   "description": "Cache dependencies and build outputs",
   "main": "dist/restore/index.js",
   "scripts": {
-    "build": "tsc && ncc build -o dist/restore src/restore.ts && ncc build -o dist/save src/save.ts",
+    "build": "tsc && ncc build -o dist/restore src/restore.ts && ncc build -o dist/save src/save.ts && ncc build -o dist/save-only src/save-only.ts",
     "test": "tsc --noEmit && jest --coverage",
     "lint": "eslint **/*.ts --cache",
     "format": "prettier --write **/*.ts",
@@ -29,23 +29,23 @@
     "@actions/io": "^1.1.2"
   },
   "devDependencies": {
-    "@types/jest": "^27.5.2",
+    "@types/jest": "^27.5.0",
     "@types/nock": "^11.1.0",
-    "@types/node": "^16.18.3",
-    "@typescript-eslint/eslint-plugin": "^5.45.0",
-    "@typescript-eslint/parser": "^5.45.0",
+    "@types/node": "^16.11.33",
+    "@typescript-eslint/eslint-plugin": "^5.22.0",
+    "@typescript-eslint/parser": "^5.22.0",
     "@zeit/ncc": "^0.20.5",
-    "eslint": "^8.28.0",
+    "eslint": "^8.14.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-import": "^2.26.0",
-    "eslint-plugin-jest": "^26.9.0",
-    "eslint-plugin-prettier": "^4.2.1",
+    "eslint-plugin-jest": "^26.1.5",
+    "eslint-plugin-prettier": "^4.0.0",
     "eslint-plugin-simple-import-sort": "^7.0.0",
-    "jest": "^28.1.3",
+    "jest": "^28.0.3",
     "jest-circus": "^27.5.1",
-    "nock": "^13.2.9",
-    "prettier": "^2.8.0",
-    "ts-jest": "^28.0.8",
-    "typescript": "^4.9.3"
+    "nock": "^13.2.4",
+    "prettier": "^2.6.2",
+    "ts-jest": "^28.0.2",
+    "typescript": "^4.6.4"
   }
 }

restore/action.yml

@@ -3,14 +3,18 @@ description: 'Restore Cache artifacts like dependencies and build outputs to imp
 author: 'GitHub'
 inputs:
   path:
-    description: 'The same list of files, directories, and wildcard patterns to restore cache that were used while saving it'
+    description: 'A list of files, directories, and wildcard patterns to cache and restore'
     required: true
   key:
-    description: 'An explicit key for restoring the cache'
+    description: 'An explicit key for restoring and saving the cache'
     required: true
   restore-keys:
     description: 'An ordered list of keys to use for restoring stale cache if no cache hit occurred for key. Note `cache-hit` returns false in this case.'
     required: false
+  exit-on-cache-miss:
+    description: 'Fail the workflow if the cache is not found for the primary key'
+    required: false
+    default: false
 outputs:
   cache-hit:
     description: 'A boolean value to indicate an exact match was found for the primary key'

save/action.yml

@@ -3,10 +3,10 @@ description: 'Save Cache artifacts like dependencies and build outputs to improv
 author: 'GitHub'
 inputs:
   path:
-    description: 'A list of files, directories, and wildcard patterns to cache'
+    description: 'A list of files, directories, and wildcard patterns to cache and restore'
     required: true
   key:
-    description: 'An explicit key for saving the cache'
+    description: 'An explicit key for restoring and saving the cache'
     required: true
   upload-chunk-size:
     description: 'The chunk size used to split up large files during upload, in bytes'

src/constants.ts

@@ -2,7 +2,9 @@ export enum Inputs {
     Key = "key",
     Path = "path",
     RestoreKeys = "restore-keys",
-    UploadChunkSize = "upload-chunk-size"
+    UploadChunkSize = "upload-chunk-size",
+    FailOnCacheMiss = "fail-on-cache-miss",
+    SaveOnAnyFailure = "save-on-any-failure"
 }
 
 export enum Outputs {
@@ -20,4 +22,8 @@ export enum Events {
     PullRequest = "pull_request"
 }
 
+export enum Variables {
+    SaveCacheOnAnyFailure = "SAVE_CACHE_ON_ANY_FAILURE"
+}
+
 export const RefKey = "GITHUB_REF";

src/restore.ts

@@ -1,8 +1,84 @@
-import { StateProvider } from "./stateProvider";
-import restoreImpl from "./restoreImpl";
+import * as cache from "@actions/cache";
+import * as core from "@actions/core";
+
+import { Events, Inputs, State, Variables } from "./constants";
+import * as utils from "./utils/actionUtils";
 
 async function run(): Promise<void> {
-    await restoreImpl(new StateProvider());
+    try {
+        if (!utils.isCacheFeatureAvailable()) {
+            utils.setCacheHitOutput(false);
+            return;
+        }
+
+        // Validate inputs, this can cause task failure
+        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 primaryKey = core.getInput(Inputs.Key, { required: true });
+        core.saveState(State.CachePrimaryKey, primaryKey);
+
+        const restoreKeys = utils.getInputAsArray(Inputs.RestoreKeys);
+        const cachePaths = utils.getInputAsArray(Inputs.Path, {
+            required: true
+        });
+
+        const cacheKey = await cache.restoreCache(
+            cachePaths,
+            primaryKey,
+            restoreKeys
+        );
+
+        //Check if user wants to save cache despite of failure in any previous job
+        const saveCache = core.getBooleanInput(Inputs.SaveOnAnyFailure);
+        if (saveCache == true) {
+            core.debug(
+                `Exporting environment variable ${Variables.SaveCacheOnAnyFailure}`
+            );
+            core.exportVariable(Variables.SaveCacheOnAnyFailure, saveCache);
+            core.info(
+                `Input Variable ${Variables.SaveCacheOnAnyFailure} is set to true, the cache will be saved despite of any failure in the build.`
+            );
+        }
+
+        if (!cacheKey) {
+            if (core.getBooleanInput(Inputs.FailOnCacheMiss) == true) {
+                throw new Error(
+                    `Cache with the given input key ${primaryKey} is not found, hence exiting the workflow as the fail-on-cache-miss requirement is not met.`
+                );
+            }
+            core.info(
+                `Cache not found for input keys: ${[
+                    primaryKey,
+                    ...restoreKeys
+                ].join(", ")}`
+            );
+            return;
+        }
+        // Store the matched cache key
+        utils.setCacheState(cacheKey);
+
+        const isExactKeyMatch = utils.isExactKeyMatch(primaryKey, cacheKey);
+        utils.setCacheHitOutput(isExactKeyMatch);
+
+        if (
+            !isExactKeyMatch &&
+            core.getBooleanInput(Inputs.FailOnCacheMiss) == true
+        ) {
+            throw new Error(
+                `Restored cache key doesn't match the given input key ${primaryKey}, hence exiting the workflow as the fail-on-cache-miss requirement is not met.`
+            );
+        }
+        core.info(`Cache restored from key: ${cacheKey}`);
+    } catch (error: unknown) {
+        core.setFailed((error as Error).message);
+    }
 }
 
 run();

src/restoreImpl.ts

@@ -1,67 +0,0 @@
-import * as cache from "@actions/cache";
-import * as core from "@actions/core";
-
-import { Events, Inputs, Outputs, State } from "./constants";
-import { IStateProvider } from "./stateProvider";
-import * as utils from "./utils/actionUtils";
-
-async function restoreImpl(stateProvider: IStateProvider): Promise<string | undefined> {
-    try {
-        if (!utils.isCacheFeatureAvailable()) {
-            utils.setCacheHitOutput(false);
-            return;
-        }
-
-        // Validate inputs, this can cause task failure
-        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 primaryKey = core.getInput(Inputs.Key, { required: true });
-        stateProvider.setState(State.CachePrimaryKey, primaryKey);
-
-        const restoreKeys = utils.getInputAsArray(Inputs.RestoreKeys);
-        const cachePaths = utils.getInputAsArray(Inputs.Path, {
-            required: true
-        });
-
-        const cacheKey = await cache.restoreCache(
-            cachePaths,
-            primaryKey,
-            restoreKeys
-        );
-
-        if (!cacheKey) {
-            core.info(
-                `Cache not found for input keys: ${[
-                    primaryKey,
-                    ...restoreKeys
-                ].join(", ")}`
-            );
-
-            return;
-        }
-
-        // Store the matched cache key in states
-        stateProvider.setState(State.CacheMatchedKey, cacheKey);
-
-        const isExactKeyMatch = utils.isExactKeyMatch(
-            core.getInput(Inputs.Key, { required: true }),
-            cacheKey
-        );
-
-        core.setOutput(Outputs.CacheHit, isExactKeyMatch.toString());
-        core.info(`Cache restored from key: ${cacheKey}`);
-
-        return cacheKey;
-    } catch (error: unknown) {
-        core.setFailed((error as Error).message);
-    }
-}
-
-export default restoreImpl;

src/restoreOnly.ts

@@ -1,10 +0,0 @@
-import restoreImpl from "./restoreImpl";
-import { NullStateProvider } from "./stateProvider";
-
-async function run(): Promise<void> {
-    await restoreImpl(new NullStateProvider());
-}
-
-run();
-
-export default run;

src/save-only.ts

@@ -0,0 +1,20 @@
+import * as core from "@actions/core";
+
+import { Inputs } from "./constants";
+import save from "./save";
+import * as utils from "./utils/actionUtils";
+
+async function runSaveAction(): Promise<void> {
+    if (!core.getInput(Inputs.Key)) {
+        utils.logWarning(`Error retrieving key from inputs.`);
+        return;
+    }
+    saveOnly = true;
+
+    await save();
+}
+
+runSaveAction();
+
+export default runSaveAction;
+export let saveOnly: boolean;

src/save.ts

@@ -1,10 +1,64 @@
-import saveImpl from "./saveImpl";
-import { StateProvider } from "./stateProvider";
+import * as cache from "@actions/cache";
+import * as core from "@actions/core";
+
+import { Events, Inputs, State } from "./constants";
+import { saveOnly } from "./save-only";
+import * as utils from "./utils/actionUtils";
+
+// Catch and log any unhandled exceptions.  These exceptions can leak out of the uploadChunk method in
+// @actions/toolkit when a failed upload closes the file descriptor causing any in-process reads to
+// throw an uncaught exception.  Instead of failing this action, just warn.
+process.on("uncaughtException", e => utils.logWarning(e.message));
 
 async function run(): Promise<void> {
-    await saveImpl(new StateProvider());
+    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();
+
+        // Inputs are re-evaluted before the post action, so we want the original key used for restore
+        const primaryKey =
+            saveOnly === true
+                ? core.getInput(Inputs.Key)
+                : core.getState(State.CachePrimaryKey);
+
+        if (!primaryKey) {
+            utils.logWarning(`Error retrieving key from state.`);
+            return;
+        }
+
+        if (utils.isExactKeyMatch(primaryKey, state)) {
+            core.info(
+                `Cache hit occurred on the primary key ${primaryKey}, not saving cache.`
+            );
+            return;
+        }
+
+        const cachePaths = utils.getInputAsArray(Inputs.Path, {
+            required: true
+        });
+
+        const cacheId = await cache.saveCache(cachePaths, primaryKey, {
+            uploadChunkSize: utils.getInputAsInt(Inputs.UploadChunkSize)
+        });
+
+        if (cacheId != -1) {
+            core.info(`Cache saved with key: ${primaryKey}`);
+        }
+    } catch (error: unknown) {
+        utils.logWarning((error as Error).message);
+    }
 }
 
-run();
-
 export default run;

src/saveImpl.ts

@@ -1,65 +0,0 @@
-import * as cache from "@actions/cache";
-import * as core from "@actions/core";
-
-import { Events, Inputs, State } from "./constants";
-import { IStateProvider } from "./stateProvider";
-import * as utils from "./utils/actionUtils";
-
-// Catch and log any unhandled exceptions.  These exceptions can leak out of the uploadChunk method in
-// @actions/toolkit when a failed upload closes the file descriptor causing any in-process reads to
-// throw an uncaught exception.  Instead of failing this action, just warn.
-process.on("uncaughtException", e => utils.logWarning(e.message));
-
-async function saveImpl(stateProvider: IStateProvider): Promise<void> {
-    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;
-        }
-
-        // If restore has stored a primary key in state, reuse that
-        // Else re-evaluate from inputs
-        const primaryKey =
-            stateProvider.getState(State.CachePrimaryKey) ||
-            core.getInput(Inputs.Key);
-
-        if (!primaryKey) {
-            utils.logWarning(`Error retrieving key from state.`);
-            return;
-        }
-
-        // If matched restore key is same as primary key, then do not save cache
-        // NO-OP in case of SaveOnly action
-        const state = stateProvider.getCacheState();
-        if (utils.isExactKeyMatch(primaryKey, state)) {
-            core.info(
-                `Cache hit occurred on the primary key ${primaryKey}, not saving cache.`
-            );
-            return;
-        }
-
-        const cachePaths = utils.getInputAsArray(Inputs.Path, {
-            required: true
-        });
-
-        const cacheId = await cache.saveCache(cachePaths, primaryKey, {
-            uploadChunkSize: utils.getInputAsInt(Inputs.UploadChunkSize)
-        });
-
-        if (cacheId != -1) {
-            core.info(`Cache saved with key: ${primaryKey}`);
-        }
-    } catch (error: unknown) {
-        utils.logWarning((error as Error).message);
-    }
-}
-
-export default saveImpl;

src/saveOnly.ts

@@ -1,10 +0,0 @@
-import saveImpl from "./saveImpl";
-import { NullStateProvider } from "./stateProvider";
-
-async function run(): Promise<void> {
-    await saveImpl(new NullStateProvider());
-}
-
-run();
-
-export default run;

src/stateProvider.ts

@@ -1,42 +0,0 @@
-import * as core from "@actions/core";
-
-import { State } from "./constants";
-
-export interface IStateProvider {
-    //setOutput(key: string, value: string): void;
-    setState(key: string, value: string): void;
-    getState(key: string): string;
-
-    getCacheState(): string | undefined;
-}
-
-class StateProviderBase implements IStateProvider {
-    getCacheState(): string | undefined {
-        const cacheKey = this.getState(State.CacheMatchedKey);
-        if (cacheKey) {
-            core.debug(`Cache state/key: ${cacheKey}`);
-            return cacheKey;
-        }
-
-        return undefined;
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-empty-function
-    setState = (key: string, value: string) => {};
-
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    getState = (key: string) => "";
-}
-
-export class StateProvider extends StateProviderBase {
-    //setOutput = core.setOutput;
-    setState = core.saveState;
-    getState = core.getState;
-}
-
-export class NullStateProvider extends StateProviderBase {
-    //setOutput = core.setOutput;
-    setState = core.setOutput;
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    getState = (key: string) => "";
-}

src/utils/actionUtils.ts

@@ -1,7 +1,7 @@
 import * as cache from "@actions/cache";
 import * as core from "@actions/core";
 
-import { Outputs, RefKey } from "../constants";
+import { Outputs, RefKey, State } from "../constants";
 
 export function isGhes(): boolean {
     const ghUrl = new URL(
@@ -19,10 +19,30 @@ export function isExactKeyMatch(key: string, cacheKey?: string): boolean {
     );
 }
 
+export function setCacheState(state: string): void {
+    core.saveState(State.CacheMatchedKey, state);
+}
+
 export function setCacheHitOutput(isCacheHit: boolean): void {
     core.setOutput(Outputs.CacheHit, isCacheHit.toString());
 }
 
+export function setOutputAndState(key: string, cacheKey?: string): void {
+    setCacheHitOutput(isExactKeyMatch(key, cacheKey));
+    // Store the matched cache key if it exists
+    cacheKey && setCacheState(cacheKey);
+}
+
+export function getCacheState(): string | undefined {
+    const cacheKey = core.getState(State.CacheMatchedKey);
+    if (cacheKey) {
+        core.debug(`Cache state/key: ${cacheKey}`);
+        return cacheKey;
+    }
+
+    return undefined;
+}
+
 export function logWarning(message: string): void {
     const warningPrefix = "[warning]";
     core.info(`${warningPrefix}${message}`);
@@ -57,20 +77,19 @@ export function getInputAsInt(
 }
 
 export function isCacheFeatureAvailable(): boolean {
-    if (cache.isFeatureAvailable()) {
-        return true;
-    }
-
-    if (isGhes()) {
-        logWarning(
-            `Cache action is only supported on GHES version >= 3.5. If you are on version >=3.5 Please check with GHES admin if Actions cache service is enabled or not.
+    if (!cache.isFeatureAvailable()) {
+        if (isGhes()) {
+            logWarning(
+                `Cache action is only supported on GHES version >= 3.5. If you are on version >=3.5 Please check with GHES admin if Actions cache service is enabled or not.
 Otherwise please upgrade to GHES version >= 3.5 and If you are also using Github Connect, please unretire the actions/cache namespace before upgrade (see https://docs.github.com/en/enterprise-server@3.5/admin/github-actions/managing-access-to-actions-from-githubcom/enabling-automatic-access-to-githubcom-actions-using-github-connect#automatic-retirement-of-namespaces-for-actions-accessed-on-githubcom)`
-        );
+            );
+        } else {
+            logWarning(
+                "An internal error has occurred in cache backend. Please check https://www.githubstatus.com/ for any ongoing issue in actions."
+            );
+        }
         return false;
     }
 
-    logWarning(
-        "An internal error has occurred in cache backend. Please check https://www.githubstatus.com/ for any ongoing issue in actions."
-    );
-    return false;
+    return true;
 }

src/utils/testUtils.ts

@@ -13,18 +13,28 @@ interface CacheInput {
     path: string;
     key: string;
     restoreKeys?: string[];
+    failOnCacheMiss?: boolean;
+    saveOnAnyFailure?: boolean;
 }
 
 export function setInputs(input: CacheInput): void {
     setInput(Inputs.Path, input.path);
     setInput(Inputs.Key, input.key);
+    setInput(Inputs.SaveOnAnyFailure, "false");
+    setInput(Inputs.FailOnCacheMiss, "false");
     input.restoreKeys &&
         setInput(Inputs.RestoreKeys, input.restoreKeys.join("\n"));
+    input.failOnCacheMiss &&
+        setInput(Inputs.FailOnCacheMiss, String(input.failOnCacheMiss));
+    input.saveOnAnyFailure &&
+        setInput(Inputs.SaveOnAnyFailure, String(input.saveOnAnyFailure));
 }
 
 export function clearInputs(): void {
     delete process.env[getInputName(Inputs.Path)];
     delete process.env[getInputName(Inputs.Key)];
     delete process.env[getInputName(Inputs.RestoreKeys)];
+    delete process.env[getInputName(Inputs.FailOnCacheMiss)];
+    delete process.env[getInputName(Inputs.SaveOnAnyFailure)];
     delete process.env[getInputName(Inputs.UploadChunkSize)];
 }