@actions/cache: abstract @actions/cache

In a similar way to @actions/core, we abstract the @actions/cache
functions.

Signed-off-by: Matthew John Cheetham <[email protected]>

Author: mjcheetham

main.ts

@@ -1,7 +1,6 @@
 import {ICore} from './src/core'
 import {ActionsCore} from './src/actions_core'
 import {mkdirp} from './src/downloader'
-import {restoreCache, saveCache} from '@actions/cache'
 import process from 'process'
 import {spawnSync} from 'child_process'
 import {
@@ -67,9 +66,13 @@ async function setup(
         useCache = false
     }
 
+    if (!core.isCacheAvailable()) {
+      useCache = false
+    }
+
     let needToDownload = true
     try {
-      if (useCache && (await restoreCache([outputDirectory], id))) {
+      if (useCache && (await core.restoreCache([outputDirectory], id))) {
         core.info(`Cached ${id} was successfully restored`)
         needToDownload = false
       }
@@ -86,7 +89,7 @@ async function setup(
       )
 
       try {
-        if (useCache && !(await saveCache([outputDirectory], id))) {
+        if (useCache && !(await core.saveCache([outputDirectory], id))) {
           core.warning(`Failed to cache ${id}`)
         }
       } catch (e) {

src/actions_core.ts

@@ -1,7 +1,23 @@
 import {ICore} from '../src/core'
 import * as core from '@actions/core'
+import * as cache from '@actions/cache'
 
 export class ActionsCore implements ICore {
+  isCacheAvailable(): boolean {
+    return cache.isFeatureAvailable()
+  }
+
+  async restoreCache(
+    paths: string[],
+    primaryKey: string
+  ): Promise<string | undefined> {
+    return cache.restoreCache(paths, primaryKey)
+  }
+
+  async saveCache(paths: string[], key: string): Promise<number> {
+    return cache.saveCache(paths, key)
+  }
+
   getInput(name: string): string {
     return core.getInput(name)
   }

src/core.ts

@@ -3,6 +3,29 @@
  * This allows us to avoid module shimming and provide clean implementations for different platforms.
  */
 export interface ICore {
+  /**
+   * Checks if caching is available.
+   */
+  isCacheAvailable(): boolean
+
+  /**
+   * Restores cache from keys
+   *
+   * @param paths a list of file paths to restore from the cache
+   * @param primaryKey an explicit key for restoring the cache. Lookup is done with prefix matching.
+   * @returns string returns the key for the cache hit, otherwise returns undefined
+   */
+  restoreCache(paths: string[], primaryKey: string): Promise<string | undefined>
+
+  /**
+   * Saves a list of files with the specified key
+   *
+   * @param paths a list of file paths to be cached
+   * @param key an explicit key for restoring the cache
+   * @returns number returns cacheId if the cache was saved successfully and throws an error if save fails
+   */
+  saveCache(paths: string[], key: string): Promise<number>
+
   /**
    * Gets an input from the action/task configuration.
    * @param name The name of the input