Formatting and stylistic cleanup

packages/cache/__tests__/cacheHttpClient.test.ts

@@ -1,8 +1,8 @@
-import { downloadCache } from '../src/internal/cacheHttpClient'
+import {downloadCache} from '../src/internal/cacheHttpClient'
-import { getCacheVersion } from '../src/internal/cacheUtils'
+import {getCacheVersion} from '../src/internal/cacheUtils'
-import { CompressionMethod } from '../src/internal/constants'
+import {CompressionMethod} from '../src/internal/constants'
 import * as downloadUtils from '../src/internal/downloadUtils'
-import { DownloadOptions, getDownloadOptions } from '../src/options'
+import {DownloadOptions, getDownloadOptions} from '../src/options'
 
 jest.mock('../src/internal/downloadUtils')
 
@@ -129,7 +129,7 @@ test('downloadCache passes options to download methods', async () => {
 
   const archiveLocation = 'http://foo.blob.core.windows.net/bar/baz'
   const archivePath = '/foo/bar'
-  const options: DownloadOptions = { downloadConcurrency: 4 }
+  const options: DownloadOptions = {downloadConcurrency: 4}
 
   await downloadCache(archiveLocation, archivePath, options)
 

packages/cache/src/cache.ts

@@ -4,8 +4,8 @@ import * as config from './internal/config'
 import * as utils from './internal/cacheUtils'
 import * as cacheHttpClient from './internal/cacheHttpClient'
 import * as cacheTwirpClient from './internal/shared/cacheTwirpClient'
-import { DownloadOptions, UploadOptions } from './options'
+import {DownloadOptions, UploadOptions} from './options'
-import { createTar, extractTar, listTar } from './internal/tar'
+import {createTar, extractTar, listTar} from './internal/tar'
 import {
   CreateCacheEntryRequest,
   CreateCacheEntryResponse,
@@ -14,9 +14,9 @@ import {
   GetCacheEntryDownloadURLRequest,
   GetCacheEntryDownloadURLResponse
 } from './generated/results/api/v1/cache'
-import { CacheFileSizeLimit } from './internal/constants'
+import {CacheFileSizeLimit} from './internal/constants'
-import { UploadCacheFile } from './internal/blob/upload-cache'
+import {UploadCacheFile} from './internal/blob/upload-cache'
-import { DownloadCacheFile } from './internal/blob/download-cache'
+import {DownloadCacheFile} from './internal/blob/download-cache'
 export class ValidationError extends Error {
   constructor(message: string) {
     super(message)
@@ -86,11 +86,23 @@ export async function restoreCache(
   const cacheServiceVersion: string = config.getCacheServiceVersion()
   console.debug(`Cache service version: ${cacheServiceVersion}`)
   switch (cacheServiceVersion) {
-    case "v2":
+    case 'v2':
-      return await restoreCachev2(paths, primaryKey, restoreKeys, options, enableCrossOsArchive)
+      return await restoreCachev2(
-    case "v1":
+        paths,
+        primaryKey,
+        restoreKeys,
+        options,
+        enableCrossOsArchive
+      )
+    case 'v1':
     default:
-      return await restoreCachev1(paths, primaryKey, restoreKeys, options, enableCrossOsArchive)
+      return await restoreCachev1(
+        paths,
+        primaryKey,
+        restoreKeys,
+        options,
+        enableCrossOsArchive
+      )
   }
 }
 
@@ -238,12 +250,15 @@ async function restoreCachev2(
       version: utils.getCacheVersion(
         paths,
         compressionMethod,
-        enableCrossOsArchive,
+        enableCrossOsArchive
-      ),
+      )
     }
 
-    core.debug(`GetCacheEntryDownloadURLRequest: ${JSON.stringify(twirpClient)}`)
+    core.debug(
-    const response: GetCacheEntryDownloadURLResponse = await twirpClient.GetCacheEntryDownloadURL(request)
+      `GetCacheEntryDownloadURLRequest: ${JSON.stringify(twirpClient)}`
+    )
+    const response: GetCacheEntryDownloadURLResponse =
+      await twirpClient.GetCacheEntryDownloadURL(request)
     core.debug(`GetCacheEntryDownloadURLResponse: ${JSON.stringify(response)}`)
 
     if (!response.ok) {
@@ -266,10 +281,7 @@ async function restoreCachev2(
 
     core.debug(`Starting download of artifact to: ${archivePath}`)
 
-    await DownloadCacheFile(
+    await DownloadCacheFile(response.signedDownloadUrl, archivePath)
-      response.signedDownloadUrl,
-      archivePath
-    )
 
     const archiveFileSize = utils.getArchiveFileSizeInBytes(archivePath)
     core.info(
@@ -320,9 +332,9 @@ export async function saveCache(
   const cacheServiceVersion: string = config.getCacheServiceVersion()
   console.debug(`Cache Service Version: ${cacheServiceVersion}`)
   switch (cacheServiceVersion) {
-    case "v2":
+    case 'v2':
       return await saveCachev2(paths, key, options, enableCrossOsArchive)
-    case "v1":
+    case 'v1':
     default:
       return await saveCachev1(paths, key, options, enableCrossOsArchive)
   }
@@ -500,7 +512,8 @@ async function saveCachev2(
       key: key,
       version: version
     }
-    const response: CreateCacheEntryResponse = await twirpClient.CreateCacheEntry(request)
+    const response: CreateCacheEntryResponse =
+      await twirpClient.CreateCacheEntry(request)
     if (!response.ok) {
       throw new ReserveCacheError(
         `Unable to reserve cache with key ${key}, another job may be creating this cache.`
@@ -508,21 +521,21 @@ async function saveCachev2(
     }
 
     core.debug(`Saving Cache to: ${core.setSecret(response.signedUploadUrl)}`)
-    await UploadCacheFile(
+    await UploadCacheFile(response.signedUploadUrl, archivePath)
-      response.signedUploadUrl,
-      archivePath,
-    )
 
     const finalizeRequest: FinalizeCacheEntryUploadRequest = {
       workflowRunBackendId: backendIds.workflowRunBackendId,
       workflowJobRunBackendId: backendIds.workflowJobRunBackendId,
       key: key,
       version: version,
-      sizeBytes: `${archiveFileSize}`,
+      sizeBytes: `${archiveFileSize}`
     }
 
-    const finalizeResponse: FinalizeCacheEntryUploadResponse = await twirpClient.FinalizeCacheEntryUpload(finalizeRequest)
+    const finalizeResponse: FinalizeCacheEntryUploadResponse =
-    core.debug(`FinalizeCacheEntryUploadResponse: ${JSON.stringify(finalizeResponse)}`)
+      await twirpClient.FinalizeCacheEntryUpload(finalizeRequest)
+    core.debug(
+      `FinalizeCacheEntryUploadResponse: ${JSON.stringify(finalizeResponse)}`
+    )
 
     if (!finalizeResponse.ok) {
       throw new Error(

packages/cache/src/internal/blob/download-cache.ts

@@ -3,15 +3,15 @@ import * as core from '@actions/core'
 import {
   BlobClient,
   BlockBlobClient,
-  BlobDownloadOptions,
+  BlobDownloadOptions
 } from '@azure/storage-blob'
 
 export async function DownloadCacheFile(
   signedUploadURL: string,
-  archivePath: string,
+  archivePath: string
 ): Promise<{}> {
   const downloadOptions: BlobDownloadOptions = {
-    maxRetryRequests: 5,
+    maxRetryRequests: 5
   }
 
   // TODO: tighten the configuration and pass the appropriate user-agent
@@ -21,5 +21,10 @@ export async function DownloadCacheFile(
   core.debug(`BlobClient: ${JSON.stringify(blobClient)}`)
   core.debug(`blockBlobClient: ${JSON.stringify(blockBlobClient)}`)
 
-  return blockBlobClient.downloadToFile(archivePath, 0, undefined, downloadOptions)
+  return blockBlobClient.downloadToFile(
+    archivePath,
+    0,
+    undefined,
+    downloadOptions
+  )
 }

packages/cache/src/internal/blob/upload-cache.ts

@@ -7,15 +7,15 @@ import {
 
 export async function UploadCacheFile(
   signedUploadURL: string,
-  archivePath: string,
+  archivePath: string
 ): Promise<{}> {
   // TODO: tighten the configuration and pass the appropriate user-agent
   // Specify data transfer options
   const uploadOptions: BlockBlobParallelUploadOptions = {
     blockSize: 4 * 1024 * 1024, // 4 MiB max block size
     concurrency: 4, // maximum number of parallel transfer workers
-    maxSingleShotSize: 8 * 1024 * 1024, // 8 MiB initial transfer size
+    maxSingleShotSize: 8 * 1024 * 1024 // 8 MiB initial transfer size
-  };
+  }
 
   const blobClient: BlobClient = new BlobClient(signedUploadURL)
   const blockBlobClient: BlockBlobClient = blobClient.getBlockBlobClient()
@@ -23,5 +23,5 @@ export async function UploadCacheFile(
   core.debug(`BlobClient: ${JSON.stringify(blobClient)}`)
   core.debug(`blockBlobClient: ${JSON.stringify(blockBlobClient)}`)
 
-  return blockBlobClient.uploadFile(archivePath, uploadOptions);
+  return blockBlobClient.uploadFile(archivePath, uploadOptions)
 }

packages/cache/src/internal/cacheHttpClient.ts

@@ -1,12 +1,12 @@
 import * as core from '@actions/core'
-import { HttpClient } from '@actions/http-client'
+import {HttpClient} from '@actions/http-client'
-import { BearerCredentialHandler } from '@actions/http-client/lib/auth'
+import {BearerCredentialHandler} from '@actions/http-client/lib/auth'
 import {
   RequestOptions,
   TypedResponse
 } from '@actions/http-client/lib/interfaces'
 import * as fs from 'fs'
-import { URL } from 'url'
+import {URL} from 'url'
 import * as utils from './cacheUtils'
 import {
   ArtifactCacheEntry,
@@ -33,7 +33,7 @@ import {
   retryHttpClientResponse,
   retryTypedResponse
 } from './requestUtils'
-import { getCacheServiceURL } from './config'
+import {getCacheServiceURL} from './config'
 
 function getCacheApiUrl(resource: string): string {
   const baseUrl: string = getCacheServiceURL()
@@ -216,7 +216,8 @@ async function uploadChunk(
   end: number
 ): Promise<void> {
   core.debug(
-    `Uploading chunk of size ${end - start + 1
+    `Uploading chunk of size ${
+      end - start + 1
     } bytes at offset ${start} with content range: ${getContentRange(
       start,
       end
@@ -312,7 +313,7 @@ async function commitCache(
   cacheId: number,
   filesize: number
 ): Promise<TypedResponse<null>> {
-  const commitCacheRequest: CommitCacheRequest = { size: filesize }
+  const commitCacheRequest: CommitCacheRequest = {size: filesize}
   return await retryTypedResponse('commitCache', async () =>
     httpClient.postJson<null>(
       getCacheApiUrl(`caches/${cacheId.toString()}`),

packages/cache/src/internal/config.ts

@@ -7,16 +7,20 @@ export function getRuntimeToken(): string {
 }
 
 export function getCacheServiceVersion(): string {
-  return process.env['ACTIONS_CACHE_SERVICE_V2'] ? 'v2' : 'v1';
+  return process.env['ACTIONS_CACHE_SERVICE_V2'] ? 'v2' : 'v1'
 }
 
 export function getCacheServiceURL(): string {
   const version = getCacheServiceVersion()
   switch (version) {
     case 'v1':
-      return process.env['ACTIONS_CACHE_URL'] || process.env['ACTIONS_RESULTS_URL'] || ""
+      return (
+        process.env['ACTIONS_CACHE_URL'] ||
+        process.env['ACTIONS_RESULTS_URL'] ||
+        ''
+      )
     case 'v2':
-      return process.env['ACTIONS_RESULTS_URL'] || ""
+      return process.env['ACTIONS_RESULTS_URL'] || ''
     default:
       throw new Error(`Unsupported cache service version: ${version}`)
   }

packages/cache/src/internal/shared/cacheTwirpClient.ts

@@ -1,10 +1,10 @@
-import { info, debug } from '@actions/core'
+import {info, debug} from '@actions/core'
-import { getUserAgentString } from './user-agent'
+import {getUserAgentString} from './user-agent'
-import { NetworkError, UsageError } from './errors'
+import {NetworkError, UsageError} from './errors'
-import { getRuntimeToken, getCacheServiceURL } from '../config'
+import {getRuntimeToken, getCacheServiceURL} from '../config'
-import { BearerCredentialHandler } from '@actions/http-client/lib/auth'
+import {BearerCredentialHandler} from '@actions/http-client/lib/auth'
-import { HttpClient, HttpClientResponse, HttpCodes } from '@actions/http-client'
+import {HttpClient, HttpClientResponse, HttpCodes} from '@actions/http-client'
-import { CacheServiceClientJSON } from '../../generated/results/api/v1/cache.twirp'
+import {CacheServiceClientJSON} from '../../generated/results/api/v1/cache.twirp'
 
 // The twirp http client must implement this interface
 interface Rpc {
@@ -67,7 +67,7 @@ class CacheServiceClient implements Rpc {
       'Content-Type': contentType
     }
     try {
-            const { body } = await this.retryableRequest(async () =>
+      const {body} = await this.retryableRequest(async () =>
         this.httpClient.post(url, JSON.stringify(data), headers)
       )
 
@@ -79,7 +79,7 @@ class CacheServiceClient implements Rpc {
 
   async retryableRequest(
     operation: () => Promise<HttpClientResponse>
-    ): Promise<{ response: HttpClientResponse; body: object }> {
+  ): Promise<{response: HttpClientResponse; body: object}> {
     let attempt = 0
     let errorMessage = ''
     let rawBody = ''
@@ -95,7 +95,7 @@ class CacheServiceClient implements Rpc {
         const body = JSON.parse(rawBody)
         debug(`Body: ${JSON.stringify(body, null, 2)}`)
         if (this.isSuccessStatusCode(statusCode)) {
-                    return { response, body }
+          return {response, body}
         }
         isRetryable = this.isRetryableHttpStatusCode(statusCode)
         errorMessage = `Failed request: (${statusCode}) ${response.message.statusMessage}`
@@ -136,7 +136,8 @@ class CacheServiceClient implements Rpc {
       const retryTimeMilliseconds =
         this.getExponentialRetryTimeMilliseconds(attempt)
       info(
-                `Attempt ${attempt + 1} of ${this.maxAttempts
+        `Attempt ${attempt + 1} of ${
+          this.maxAttempts
         } failed with error: ${errorMessage}. Retrying request in ${retryTimeMilliseconds} ms...`
       )
       await this.sleep(retryTimeMilliseconds)