@netlify/cache-utils 4.0.0 → 4.1.3

package/README.md

@@ -8,20 +8,19 @@ Utility for caching files in Netlify Build.
 ## Simple
 
 ```js
-module.exports = {
-  // Restore file/directory cached in previous builds.
-  // Does not do anything if:
-  //  - the file/directory already exists locally
-  //  - the file/directory has not been cached yet
-  async onPreBuild({ utils }) {
-    await utils.cache.restore('./path/to/file')
-  },
-  // Cache file/directory for future builds.
-  // Does not do anything if:
-  //  - the file/directory does not exist locally
-  async onPostBuild({ utils }) {
-    await utils.cache.save('./path/to/file')
-  },
+// Restore file/directory cached in previous builds.
+// Does not do anything if:
+//  - the file/directory already exists locally
+//  - the file/directory has not been cached yet
+export const onPreBuild = async function ({ utils }) {
+  await utils.cache.restore('./path/to/file')
+}
+
+// Cache file/directory for future builds.
+// Does not do anything if:
+//  - the file/directory does not exist locally
+export const onPostBuild = async function ({ utils }) {
+  await utils.cache.save('./path/to/file')
 }
 ```
 
@@ -29,13 +28,12 @@ module.exports = {
 
 ```js
 // Restore/cache several files/directories
-module.exports = {
-  async onPreBuild({ utils }) {
-    await utils.cache.restore(['./path/to/file', './path/to/other'])
-  },
-  async onPostBuild({ utils }) {
-    await utils.cache.save(['./path/to/file', './path/to/other'])
-  },
+export const onPreBuild = async function ({ utils }) {
+  await utils.cache.restore(['./path/to/file', './path/to/other'])
+}
+
+export const onPostBuild = async function ({ utils }) {
+  await utils.cache.save(['./path/to/file', './path/to/other'])
 }
 ```
 
@@ -64,14 +62,13 @@ Only cache the file/directory for a specific amount of time.
 
 ```js
 // Only cache the following file/directory for 1 hour
-module.exports = {
-  async onPreBuild({ utils }) {
-    await utils.cache.restore('./path/to/file')
-  },
-  async onPostBuild({ utils }) {
-    const ttl = 3600
-    await utils.cache.save('./path/to/file', { ttl })
-  },
+export const onPreBuild = async function ({ utils }) {
+  await utils.cache.restore('./path/to/file')
+}
+
+export const onPostBuild = async function ({ utils }) {
+  const ttl = 3600
+  await utils.cache.save('./path/to/file', { ttl })
 }
 ```
 
@@ -88,15 +85,14 @@ speeds up caching.
 // contents has changed. This will speed up cache saving.
 // For example, `package-lock.json` and `yarn.lock` are digest files for the
 // `node_modules` directory.
-module.exports = {
-  async onPreBuild({ utils }) {
-    await utils.cache.restore('node_modules')
-  },
-  async onPostBuild({ utils }) {
-    await utils.cache.save('node_modules', {
-      digests: ['package-lock.json', 'yarn.lock'],
-    })
-  },
+export const onPreBuild = async function ({ utils }) {
+  await utils.cache.restore('node_modules')
+}
+
+export const onPostBuild = async function ({ utils }) {
+  await utils.cache.save('node_modules', {
+    digests: ['package-lock.json', 'yarn.lock'],
+  })
 }
 ```
 
@@ -139,10 +135,8 @@ Remove a file/directory from the cache. Useful for cache invalidation.
 Returns `false` if the file/directory was not cached yet. Returns `true` otherwise.
 
 ```js
-module.exports = {
-  async onPostBuild({ utils }) {
-    await utils.cache.remove('./path/to/file')
-  },
+export const onPostBuild = async function ({ utils }) {
+  await utils.cache.remove('./path/to/file')
 }
 ```
 
@@ -167,23 +161,22 @@ Returns whether a file/directory is currently cached.
 // previously cached or not
 const path = './path/to/file'
 
-module.exports = {
-  async onPreBuild({ utils }) {
-    if (!(await utils.cache.has(path))) {
-      console.log(`File ${path} not cached`)
-      return
-    }
-
-    console.log(`About to restore cached file ${path}...`)
-    if (await utils.cache.restore('./path/to/file')) {
-      console.log(`Restored cached file ${path}`)
-    }
-  },
-  async onPostBuild({ utils }) {
-    if (await utils.cache.save('./path/to/file')) {
-      console.log(`Saved cached file ${path}`)
-    }
-  },
+export const onPreBuild = async function ({ utils }) {
+  if (!(await utils.cache.has(path))) {
+    console.log(`File ${path} not cached`)
+    return
+  }
+
+  console.log(`About to restore cached file ${path}...`)
+  if (await utils.cache.restore('./path/to/file')) {
+    console.log(`Restored cached file ${path}`)
+  }
+}
+
+export const onPostBuild = async function ({ utils }) {
+  if (await utils.cache.save('./path/to/file')) {
+    console.log(`Saved cached file ${path}`)
+  }
 }
 ```
 
@@ -204,11 +197,9 @@ Returns the absolute paths of the files currently cached. Those are the paths of
 being restored), not while being cached.
 
 ```js
-module.exports = {
-  async onPreBuild({ utils }) {
-    const files = await utils.cache.list()
-    console.log('Cached files', files)
-  },
+export const onPreBuild = async function ({ utils }) {
+  const files = await utils.cache.list()
+  console.log('Cached files', files)
 }
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/cache-utils",
-  "version": "4.0.0",
+  "version": "4.1.3",
   "description": "Utility for caching files in Netlify Build",
   "type": "module",
   "exports": "./src/main.js",
@@ -46,14 +46,13 @@
   "license": "MIT",
   "dependencies": {
     "cpy": "^8.1.0",
-    "del": "^5.1.0",
+    "del": "^6.0.0",
     "get-stream": "^6.0.0",
     "globby": "^11.0.0",
     "junk": "^3.1.0",
-    "locate-path": "^6.0.0",
-    "make-dir": "^3.1.0",
+    "locate-path": "^7.0.0",
     "move-file": "^2.0.0",
-    "path-exists": "^4.0.0",
+    "path-exists": "^5.0.0",
     "readdirp": "^3.4.0"
   },
   "devDependencies": {

package/src/fs.js

@@ -1,14 +1,11 @@
-import { stat } from 'fs'
+import { promises as fs } from 'fs'
 import { basename, dirname } from 'path'
-import { promisify } from 'util'
 
 import cpy from 'cpy'
 import globby from 'globby'
 import junk from 'junk'
 import moveFile from 'move-file'
 
-const pStat = promisify(stat)
-
 // Move or copy a cached file/directory from/to a local one
 export const moveCacheFile = async function (src, dest, move) {
   // Moving is faster but removes the source files locally
@@ -58,6 +55,6 @@ const getSrcGlob = async function (src) {
 
 const getStat = async function (src) {
   try {
-    return await pStat(src)
-  } catch (error) {}
+    return await fs.stat(src)
+  } catch {}
 }

package/src/hash.js

@@ -2,7 +2,7 @@ import { createHash } from 'crypto'
 import { createReadStream } from 'fs'
 
 import getStream from 'get-stream'
-import locatePath from 'locate-path'
+import { locatePath } from 'locate-path'
 
 // Caching a big directory like `node_modules` is slow. However those can
 // sometime be represented by a digest file such as `package-lock.json`. If this

package/src/manifest.js

@@ -1,17 +1,12 @@
-import { writeFile, readFile } from 'fs'
+import { promises as fs } from 'fs'
 import { dirname } from 'path'
-import { promisify } from 'util'
 
 import del from 'del'
-import makeDir from 'make-dir'
-import pathExists from 'path-exists'
+import { pathExists } from 'path-exists'
 
 import { getExpires, checkExpires } from './expire.js'
 import { getHash } from './hash.js'
 
-const pWriteFile = promisify(writeFile)
-const pReadFile = promisify(readFile)
-
 // Retrieve cache manifest of a file to cache, which contains the file/directory
 // contents hash and the `expires` date.
 export const getManifestInfo = async function ({ cachePath, move, ttl, digests }) {
@@ -30,14 +25,14 @@ const isIdentical = async function ({ hash, manifestPath, manifestString }) {
     return false
   }
 
-  const oldManifestString = await pReadFile(manifestPath, 'utf8')
+  const oldManifestString = await fs.readFile(manifestPath, 'utf8')
   return oldManifestString === manifestString
 }
 
 // Persist the cache manifest to filesystem
 export const writeManifest = async function ({ manifestPath, manifestString }) {
-  await makeDir(dirname(manifestPath))
-  await pWriteFile(manifestPath, manifestString)
+  await fs.mkdir(dirname(manifestPath), { recursive: true })
+  await fs.writeFile(manifestPath, manifestString)
 }
 
 // Remove the cache manifest from filesystem
@@ -70,7 +65,7 @@ export const isExpired = async function (cachePath) {
 
 const readManifest = async function (cachePath) {
   const manifestPath = getManifestPath(cachePath)
-  const manifestString = await pReadFile(manifestPath, 'utf8')
+  const manifestString = await fs.readFile(manifestPath)
   const manifest = JSON.parse(manifestString)
   return manifest
 }

package/src/utils/cwd.js

@@ -1,7 +1,7 @@
 import { normalize } from 'path'
 import process from 'process'
 
-import pathExists from 'path-exists'
+import { pathExists } from 'path-exists'
 
 // Like `process.cwd()` but safer when current directory is wrong
 export const safeGetCwd = async function (cwdOpt) {
@@ -13,7 +13,7 @@ export const safeGetCwd = async function (cwdOpt) {
     }
 
     return cwd
-  } catch (error) {
+  } catch {
     return ''
   }
 }