Fix script invocations, lint and format.

Signed-off-by: Gregorio Litenstein <g.litenstein@gmail.com>

.github/workflows/publish-immutable-actions.yml

@@ -2,7 +2,7 @@ name: 'Publish Immutable Action Version'
 
 on:
   release:
-    types: [published]
+    types: [released]
 
 jobs:
   publish:

.prettierrc.json

@@ -7,5 +7,6 @@
     "trailingComma": "none",
     "bracketSpacing": true,
     "arrowParens": "avoid",
-    "parser": "typescript"
+    "parser": "typescript",
+    "endOfLine": "lf"
 }

RELEASES.md

@@ -1,5 +1,17 @@
 # Releases
 
+### 4.2.3
+
+- Bump `@actions/cache` to v4.0.3 (obfuscates SAS token in debug logs for cache entries)
+
+### 4.2.2
+
+- Bump `@actions/cache` to v4.0.2
+
+### 4.2.1
+
+- Bump `@actions/cache` to v4.0.1
+
 ### 4.2.0
 
 TLDR; The cache backend service has been rewritten from the ground up for improved performance and reliability. [actions/cache](https://github.com/actions/cache) now integrates with the new cache service (v2) APIs.

package.json

@@ -1,15 +1,15 @@
 {
   "name": "cache",
-  "version": "4.2.0",
+  "version": "4.2.3",
   "private": true,
   "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 && ncc build -o dist/restore-only src/restoreOnly.ts && ncc build -o dist/save-only src/saveOnly.ts",
     "test": "tsc --noEmit && jest --coverage",
-    "lint": "eslint **/*.ts --cache",
+    "lint": "eslint src/**/*.ts --cache __tests__/*.ts --cache",
-    "format": "prettier --write **/*.ts",
+    "format": "prettier --write **/**/*.ts",
-    "format-check": "prettier --check **/*.ts"
+    "format-check": "prettier --check **/**/*.ts"
   },
   "repository": {
     "type": "git",
@@ -23,11 +23,11 @@
   "author": "GitHub",
   "license": "MIT",
   "dependencies": {
-    "@actions/cache": "^4.0.0",
+    "@actions/cache": "^4.0.3",
     "@actions/core": "^1.11.1",
     "@actions/exec": "^1.1.1",
     "@actions/io": "^1.1.2",
-    "@octokit/action": "^4.0.10"
+    "@octokit/action": "^5.0.6"
   },
   "devDependencies": {
     "@types/jest": "^27.5.2",

src/utils/actionUtils.ts

@@ -1,10 +1,9 @@
 import * as cache from "@actions/cache";
 import * as core from "@actions/core";
-import { RequestError } from "@octokit/request-error"
+import { Octokit } from "@octokit/action";
-import { OctokitResponse } from "@octokit/types"
+import { RequestError } from "@octokit/request-error";
 
 import { RefKey } from "../constants";
-const { Octokit } = require("@octokit/action");
 
 export function isGhes(): boolean {
     const ghUrl = new URL(
@@ -33,54 +32,69 @@ export function logWarning(message: string): void {
     core.info(`${warningPrefix}${message}`);
 }
 
-export async function deleteCacheByKey(key: string, owner: string, repo: string) : Promise <number | void> {
+export async function deleteCacheByKey(
+    key: string,
+    owner: string,
+    repo: string
+): Promise<number | void> {
     const octokit = new Octokit();
     let response;
     try {
         const gitRef = process.env[RefKey];
-        let cacheEntry = await octokit.rest.actions.getActionsCacheList({
+        const cacheEntry = await octokit.rest.actions.getActionsCacheList({
             owner: owner,
             repo: repo,
             key: key,
             ref: gitRef
-            });
+        });
-        const { data: {
+        const {
-            total_count,
+            data: { total_count, actions_caches }
-            actions_caches
-            }
         } = cacheEntry;
-        if (total_count !== 1 || total_count !== actions_caches.length) { // leave all find logic to the actual cache implementation. We just want to make sure we're returned a single element so we don't accidentally delete an entry that belongs to a different gitref.
+        if (total_count !== 1 || total_count !== actions_caches.length) {
+            // leave all find logic to the actual cache implementation. We just want to make sure we're returned a single element so we don't accidentally delete an entry that belongs to a different gitref.
             if (total_count > 1) {
-                exports.logWarning(`More than one cache entry found for key ${key}`);
+                exports.logWarning(
-            }
+                    `More than one cache entry found for key ${key}`
-            else if (total_count === 0 || actions_caches.length === 0) {
+                );
-                exports.logWarning(`No cache entries for key ${key} belong to gitref ${gitRef}.`);
+            } else if (total_count === 0 || actions_caches.length === 0) {
+                exports.logWarning(
+                    `No cache entries for key ${key} belong to gitref ${gitRef}.`
+                );
             }
             // This situation is likely never actually going to come up.
             // Istanbul is being dumb and I can't ignore this path.
             else if (total_count !== actions_caches.length) {
-                exports.logWarning(`Reported cache entry matches for ${key} does not match length of 'actions_caches' array in API response.`);
+                exports.logWarning(
+                    `Reported cache entry matches for ${key} does not match length of 'actions_caches' array in API response.`
+                );
             }
-            core.info(`Skip trying to delete cache entry for key ${key}.`)
+            core.info(`Skip trying to delete cache entry for key ${key}.`);
             return;
         }
-        let id = actions_caches[0].id;
+        const id = actions_caches[0].id;
-        response = await octokit.rest.actions.deleteActionsCacheById({
+        if (id) {
-            owner: owner,
+            response = await octokit.rest.actions.deleteActionsCacheById({
-            repo: repo,
+                owner: owner,
-            cache_id: id
+                repo: repo,
+                cache_id: id
             });
-        if (response.status === 204) {
+            if (response.status === 204) {
-            core.info(`Succesfully deleted cache with key: ${key}, id: ${id}`);
+                core.info(
-             return 204;
+                    `Succesfully deleted cache with key: ${key}, id: ${id}`
+                );
+                return 204;
+            }
         }
     } catch (e) {
         if (e instanceof RequestError) {
-            let err = e as RequestError;
+            const err = e as RequestError;
-            let errData = err.response?.data as any | undefined;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            exports.logWarning(`Github API reported error: ${err.name} '${err.status}: ${errData?.message}'`);
+            const errMessage = (err.response?.data as any).message;
+            exports.logWarning(
+                `Github API reported error: ${err.name} '${err.status}: ${errMessage}'`
+            );
         }
-        core.info(`Couldn't delete cache entry for key ${key}.`)
+        core.info(`Couldn't delete cache entry for key ${key}.`);
         return;
     }
 }

src/utils/testUtils.ts

@@ -1,14 +1,18 @@
 /* istanbul ignore file */
 
-import { Inputs } from "../constants";
 import { rest } from "msw";
 import { setupServer } from "msw/node";
-import nock from "nock";
 
-export const successCacheKey = "Linux-node-bb828da54c148048dd17899ba9fda624811cfb43";
+import { Inputs } from "../constants";
-export const wrongRefCacheKey = "Linux-latest-node-bb828da54c148048dd17899ba9fda624811cfb43";
+
-export const failureCacheKey = "Windows-node-bb828da54c148048dd17899ba9fda624811cfb43";
+export const successCacheKey =
-export const passThroughCacheKey = "macOS-node-bb828da54c148048dd17899ba9fda624811cfb43";
+    "Linux-node-bb828da54c148048dd17899ba9fda624811cfb43";
+export const wrongRefCacheKey =
+    "Linux-latest-node-bb828da54c148048dd17899ba9fda624811cfb43";
+export const failureCacheKey =
+    "Windows-node-bb828da54c148048dd17899ba9fda624811cfb43";
+export const passThroughCacheKey =
+    "macOS-node-bb828da54c148048dd17899ba9fda624811cfb43";
 const successCacheId = 1337;
 const failureCacheId = 69;
 
@@ -61,79 +65,109 @@ export function clearInputs(): void {
 }
 
 export const mockServer = setupServer(
-    rest.delete('https://api.github.com/repos/owner/repo/actions/caches/', (req, res, ctx) => {
+    rest.delete(
-        return res(ctx.status(422),
+        "https://api.github.com/repos/owner/repo/actions/caches/",
-            ctx.json({
+        (req, res, ctx) => {
-                message: "Invalid request.\n\nMissing required query parameter key",
+            return res(
-                documentation_url: "https://docs.github.com/rest/actions/cache#delete-github-actions-caches-for-a-repository-using-a-cache-key",
+                ctx.status(422),
-            })
-        )
-    }),
-    rest.delete('https://api.github.com/repos/owner/repo/actions/caches/:id', (req, res, ctx) => {
-        const { id } = req.params;
-        if (parseInt(id as string) === failureCacheId) {
-            return res(ctx.status(404),
                 ctx.json({
-                    message: "Not Found",
+                    message:
-                    documentation_url: "https://docs.github.com/rest/actions/cache#delete-a-github-actions-cache-for-a-repository-using-a-cache-id"
+                        "Invalid request.\n\nMissing required query parameter key",
-                }));
+                    documentation_url:
+                        "https://docs.github.com/rest/actions/cache#delete-github-actions-caches-for-a-repository-using-a-cache-key"
+                })
+            );
         }
-        return res(ctx.status(204));
+    ),
-    }),
+    rest.delete(
+        "https://api.github.com/repos/owner/repo/actions/caches/:id",
+        (req, res, ctx) => {
+            const { id } = req.params;
+            if (parseInt(id as string) === failureCacheId) {
+                return res(
+                    ctx.status(404),
+                    ctx.json({
+                        message: "Not Found",
+                        documentation_url:
+                            "https://docs.github.com/rest/actions/cache#delete-a-github-actions-cache-for-a-repository-using-a-cache-id"
+                    })
+                );
+            }
+            return res(ctx.status(204));
+        }
+    ),
     // This endpoint always returns 200/OK, what we're checking here is whether we can get a unique cache ID, to avoid deleting the wrong entry.
-    rest.get('https://api.github.com/repos/owner/repo/actions/caches', (req, res, ctx) => {
+    rest.get(
-        let key : string = req.url?.searchParams?.get('key') || '';
+        "https://api.github.com/repos/owner/repo/actions/caches",
-        let ref : string = req.url?.searchParams?.get('ref') || '';
+        (req, res, ctx) => {
-        if (key === '' || ref === '') {
+            const key: string = req.url?.searchParams?.get("key") || "";
-            return res(ctx.status(200),
+            const ref: string = req.url?.searchParams?.get("ref") || "";
-                ctx.json({
+            if (key === "" || ref === "") {
-                    total_count: 2,
+                return res(
-                    actions_caches: [{
+                    ctx.status(200),
-                        id: 15,
+                    ctx.json({
-                        ref: "refs/heads/main",
+                        total_count: 2,
-                        key: failureCacheKey,
+                        actions_caches: [
-                        version: "73885106f58cc52a7df9ec4d4a5622a5614813162cb516c759a30af6bf56e6f0",
+                            {
-                        last_accessed_at: "2022-12-29T22:06:42.683333300Z",
+                                id: 15,
-                        created_at: "2022-12-29T22:06:42.683333300Z",
+                                ref: "refs/heads/main",
-                        size_in_bytes: 6057793
+                                key: failureCacheKey,
-                    },
+                                version:
-                    {
+                                    "73885106f58cc52a7df9ec4d4a5622a5614813162cb516c759a30af6bf56e6f0",
-                        id: 16,
+                                last_accessed_at:
-                        ref: "refs/heads/another-feature-branch",
+                                    "2022-12-29T22:06:42.683333300Z",
-                        key: failureCacheKey,
+                                created_at: "2022-12-29T22:06:42.683333300Z",
-                        version: "73885106f58cc52a7df9ec4d4a5622a5614813162cb516c759a30af6bf56e6f0",
+                                size_in_bytes: 6057793
-                        last_accessed_at: "2022-12-29T22:06:42.683333300Z",
+                            },
-                        created_at: "2022-12-29T22:06:42.683333300Z",
+                            {
-                        size_in_bytes: 6057793
+                                id: 16,
-                    }]
+                                ref: "refs/heads/another-feature-branch",
-                })
+                                key: failureCacheKey,
-            );
+                                version:
+                                    "73885106f58cc52a7df9ec4d4a5622a5614813162cb516c759a30af6bf56e6f0",
+                                last_accessed_at:
+                                    "2022-12-29T22:06:42.683333300Z",
+                                created_at: "2022-12-29T22:06:42.683333300Z",
+                                size_in_bytes: 6057793
+                            }
+                        ]
+                    })
+                );
+            }
+            // This is the behavior seen when search doesn't find anything, but it is seen both when no key matches, as well as when the key matches but the entry belongs to another (likely the base) branch.
+            else if (key === wrongRefCacheKey) {
+                return res(
+                    ctx.status(200),
+                    ctx.json({
+                        total_count: 0,
+                        actions_caches: []
+                    })
+                );
+            } else if (key === successCacheKey || key === failureCacheKey) {
+                return res(
+                    ctx.status(200),
+                    ctx.json({
+                        total_count: 1,
+                        actions_caches: [
+                            {
+                                id:
+                                    key === successCacheKey
+                                        ? successCacheId
+                                        : failureCacheId,
+                                ref: ref,
+                                key: key,
+                                version:
+                                    "93a0f912fdb70083e929c1bf564bca2050be1c4e0932f7f9e78465ddcfbcc8f6",
+                                last_accessed_at:
+                                    "2022-12-29T22:06:42.683333300Z",
+                                created_at: "2022-12-29T22:06:42.683333300Z",
+                                size_in_bytes: 6057793
+                            }
+                        ]
+                    })
+                );
+            }
+            return req.passthrough();
         }
-        // This is the behavior seen when search doesn't find anything, but it is seen both when no key matches, as well as when the key matches but the entry belongs to another (likely the base) branch.
+    )
-        else if (key === wrongRefCacheKey) {
-            return res(ctx.status(200),
-                ctx.json({
-                    total_count: 0,
-                    actions_caches: []
-                })
-            );
-        }
-        else if (key === successCacheKey || key === failureCacheKey) {
-            return res(ctx.status(200),
-                ctx.json({
-                    total_count: 1,
-                    actions_caches: [{
-                        id: (key === successCacheKey ? successCacheId : failureCacheId),
-                        ref: ref,
-                        key: key,
-                        version: "93a0f912fdb70083e929c1bf564bca2050be1c4e0932f7f9e78465ddcfbcc8f6",
-                        last_accessed_at: "2022-12-29T22:06:42.683333300Z",
-                        created_at: "2022-12-29T22:06:42.683333300Z",
-                        size_in_bytes: 6057793
-                    }]
-                })
-            );
-        }
-        return req.passthrough();
-    })
 );

tips-and-workarounds.md

@@ -38,9 +38,8 @@ From `v3.2.3` cache is cross-os compatible when `enableCrossOsArchive` input is
 
 ## Force deletion of caches overriding default cache eviction policy
 
-Caches have [branch scope restriction](https://docs.github.com/en/actions/using-workflows/caching-dependencies-to-speed-up-workflows#restrictions-for-accessing-a-cache) in place. This means that if caches for a specific branch are using a lot of storage quota, it may result into more frequently used caches from `default` branch getting thrashed. For example, if there are many pull requests happening on a repo and are creating caches, these cannot be used in default branch scope but will still occupy a lot of space till they get cleaned up by [eviction policy](https://docs.github.com/en/actions/using-workflows/caching-dependencies-to-speed-up-workflows#usage-limits-and-eviction-policy). But sometime we want to clean them up on a faster cadence so as to ensure default branch is not thrashing. In order to achieve this, [gh-actions-cache cli](https://github.com/actions/gh-actions-cache/) can be used to delete caches for specific branches.
+Caches have [branch scope restriction](https://docs.github.com/en/actions/using-workflows/caching-dependencies-to-speed-up-workflows#restrictions-for-accessing-a-cache) in place. This means that if caches for a specific branch are using a lot of storage quota, it may result into more frequently used caches from `default` branch getting thrashed. For example, if there are many pull requests happening on a repo and are creating caches, these cannot be used in default branch scope but will still occupy a lot of space till they get cleaned up by [eviction policy](https://docs.github.com/en/actions/using-workflows/caching-dependencies-to-speed-up-workflows#usage-limits-and-eviction-policy). But sometime we want to clean them up on a faster cadence so as to ensure default branch is not thrashing.
 
-This workflow uses `gh-actions-cache` to delete all the caches created by a branch.
 <details>
   <summary>Example</summary>
 
@@ -61,29 +60,23 @@ jobs:
       actions: write
       contents: read
     steps:
-      - name: Check out code
-        uses: actions/checkout@v4
-
       - name: Cleanup
         run: |
-          gh extension install actions/gh-actions-cache
-          
-          REPO=${{ github.repository }}
-          BRANCH=refs/pull/${{ github.event.pull_request.number }}/merge
-
           echo "Fetching list of cache key"
-          cacheKeysForPR=$(gh actions-cache list -R $REPO -B $BRANCH | cut -f 1 )
+          cacheKeysForPR=$(gh cache list --ref $BRANCH --limit 100 --json id --jq '.[].id')
 
           ## Setting this to not fail the workflow while deleting cache keys.
           set +e
           echo "Deleting caches..."
           for cacheKey in $cacheKeysForPR
           do
-              gh actions-cache delete $cacheKey -R $REPO -B $BRANCH --confirm
+              gh cache delete $cacheKey
           done
           echo "Done"
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GH_REPO: ${{ github.repository }}
+          BRANCH: refs/pull/${{ github.event.pull_request.number }}/merge
 ```
 
 </details>