@netlify/cache-utils 3.0.0 → 4.1.1

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,8 +1,10 @@
 {
   "name": "@netlify/cache-utils",
-  "version": "3.0.0",
+  "version": "4.1.1",
   "description": "Utility for caching files in Netlify Build",
-  "main": "src/main.js",
+  "type": "module",
+  "exports": "./src/main.js",
+  "main": "./src/main.js",
   "files": [
     "src/**/*.js"
   ],
@@ -43,14 +45,12 @@
   },
   "license": "MIT",
   "dependencies": {
-    "array-flat-polyfill": "^1.0.1",
     "cpy": "^8.1.0",
     "del": "^5.1.0",
     "get-stream": "^6.0.0",
     "globby": "^11.0.0",
     "junk": "^3.1.0",
     "locate-path": "^6.0.0",
-    "make-dir": "^3.1.0",
     "move-file": "^2.0.0",
     "path-exists": "^4.0.0",
     "readdirp": "^3.4.0"

package/src/dir.js

@@ -1,12 +1,8 @@
-'use strict'
-
-const { resolve } = require('path')
+import { resolve } from 'path'
 
 // Retrieve the cache directory location
-const getCacheDir = function ({ cacheDir = DEFAULT_CACHE_DIR, cwd = '.' } = {}) {
+export const getCacheDir = function ({ cacheDir = DEFAULT_CACHE_DIR, cwd = '.' } = {}) {
   return resolve(cwd, cacheDir)
 }
 
 const DEFAULT_CACHE_DIR = '.netlify/cache/'
-
-module.exports = { getCacheDir }

package/src/expire.js

@@ -1,7 +1,5 @@
-'use strict'
-
 // Retrieve the expiration date when caching a file
-const getExpires = function (ttl) {
+export const getExpires = function (ttl) {
   if (!Number.isInteger(ttl) || ttl < 1) {
     return
   }
@@ -12,8 +10,6 @@ const getExpires = function (ttl) {
 const SECS_TO_MSECS = 1e3
 
 // Check if a file about to be restored is expired
-const checkExpires = function (expires) {
+export const checkExpires = function (expires) {
   return expires !== undefined && Date.now() > expires
 }
-
-module.exports = { getExpires, checkExpires }

package/src/fs.js

@@ -1,18 +1,13 @@
-'use strict'
+import { promises as fs } from 'fs'
+import { basename, dirname } from 'path'
 
-const { stat } = require('fs')
-const { basename, dirname } = require('path')
-const { promisify } = require('util')
-
-const cpy = require('cpy')
-const globby = require('globby')
-const junk = require('junk')
-const moveFile = require('move-file')
-
-const pStat = promisify(stat)
+import cpy from 'cpy'
+import globby from 'globby'
+import junk from 'junk'
+import moveFile from 'move-file'
 
 // Move or copy a cached file/directory from/to a local one
-const moveCacheFile = async function (src, dest, move) {
+export const moveCacheFile = async function (src, dest, move) {
   // Moving is faster but removes the source files locally
   if (move) {
     return moveFile(src, dest, { overwrite: false })
@@ -23,7 +18,7 @@ const moveCacheFile = async function (src, dest, move) {
 }
 
 // Non-existing files and empty directories are always skipped
-const hasFiles = async function (src) {
+export const hasFiles = async function (src) {
   const { srcGlob, cwd, isDir } = await getSrcGlob(src)
   return srcGlob !== undefined && !(await isEmptyDir({ srcGlob, cwd, isDir }))
 }
@@ -60,8 +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 {}
 }
-
-module.exports = { moveCacheFile, hasFiles }

package/src/hash.js

@@ -1,15 +1,13 @@
-'use strict'
+import { createHash } from 'crypto'
+import { createReadStream } from 'fs'
 
-const { createHash } = require('crypto')
-const { createReadStream } = require('fs')
-
-const getStream = require('get-stream')
-const locatePath = require('locate-path')
+import getStream from 'get-stream'
+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
 // has not changed, we don't need to save cache again.
-const getHash = async function (digests, move) {
+export const getHash = async function (digests, move) {
   // Moving files is faster than computing hashes
   if (move || digests.length === 0) {
     return
@@ -36,5 +34,3 @@ const hashFile = async function (path) {
 // We need a hashing algoritm that's as fast as possible.
 // Userland CRC32 implementations are actually slower than Node.js SHA1.
 const HASH_ALGO = 'sha1'
-
-module.exports = { getHash }

package/src/list.js

@@ -1,15 +1,13 @@
-'use strict'
+import { join } from 'path'
 
-const { join } = require('path')
+import readdirp from 'readdirp'
 
-const readdirp = require('readdirp')
-
-const { getCacheDir } = require('./dir')
-const { isManifest } = require('./manifest')
-const { getBases } = require('./path')
+import { getCacheDir } from './dir.js'
+import { isManifest } from './manifest.js'
+import { getBases } from './path.js'
 
 // List all cached files/directories, at the top-level
-const list = async function ({ cacheDir, cwd: cwdOpt, depth = DEFAULT_DEPTH } = {}) {
+export const list = async function ({ cacheDir, cwd: cwdOpt, depth = DEFAULT_DEPTH } = {}) {
   const bases = await getBases(cwdOpt)
   const cacheDirA = getCacheDir({ cacheDir, cwd: cwdOpt })
   const files = await Promise.all(bases.map(({ name, base }) => listBase({ name, base, cacheDir: cacheDirA, depth })))
@@ -29,5 +27,3 @@ const listBase = async function ({ name, base, cacheDir, depth }) {
 const fileFilter = function ({ basename }) {
   return !isManifest(basename)
 }
-
-module.exports = { list }

package/src/main.js

@@ -1,14 +1,13 @@
-'use strict'
+import del from 'del'
 
-require('./utils/polyfills')
+import { getCacheDir } from './dir.js'
+import { moveCacheFile, hasFiles } from './fs.js'
+import { list } from './list.js'
+import { getManifestInfo, writeManifest, removeManifest, isExpired } from './manifest.js'
+import { parsePath } from './path.js'
 
-const del = require('del')
-
-const { getCacheDir } = require('./dir')
-const { moveCacheFile, hasFiles } = require('./fs')
-const { list } = require('./list')
-const { getManifestInfo, writeManifest, removeManifest, isExpired } = require('./manifest')
-const { parsePath } = require('./path')
+export { getCacheDir } from './dir.js'
+export { list } from './list.js'
 
 // Cache a file
 const saveOne = async function (
@@ -86,13 +85,13 @@ const allowMany = async function (func, paths, ...args) {
   return results.some(Boolean)
 }
 
-const save = allowMany.bind(null, saveOne)
-const restore = allowMany.bind(null, restoreOne)
-const remove = allowMany.bind(null, removeOne)
-const has = allowMany.bind(null, hasOne)
+export const save = allowMany.bind(null, saveOne)
+export const restore = allowMany.bind(null, restoreOne)
+export const remove = allowMany.bind(null, removeOne)
+export const has = allowMany.bind(null, hasOne)
 
 // Change `opts` default values
-const bindOpts = function (opts) {
+export const bindOpts = function (opts) {
   return {
     save: (paths, optsA) => save(paths, { ...opts, ...optsA }),
     restore: (paths, optsA) => restore(paths, { ...opts, ...optsA }),
@@ -102,5 +101,3 @@ const bindOpts = function (opts) {
     getCacheDir: (optsA) => getCacheDir({ ...opts, ...optsA }),
   }
 }
-
-module.exports = { save, restore, remove, has, list, getCacheDir, bindOpts }

package/src/manifest.js

@@ -1,22 +1,15 @@
-'use strict'
+import { promises as fs } from 'fs'
+import { dirname } from 'path'
 
-const { writeFile, readFile } = require('fs')
-const { dirname } = require('path')
-const { promisify } = require('util')
+import del from 'del'
+import pathExists from 'path-exists'
 
-const del = require('del')
-const makeDir = require('make-dir')
-const pathExists = require('path-exists')
-
-const { getExpires, checkExpires } = require('./expire')
-const { getHash } = require('./hash')
-
-const pWriteFile = promisify(writeFile)
-const pReadFile = promisify(readFile)
+import { getExpires, checkExpires } from './expire.js'
+import { getHash } from './hash.js'
 
 // Retrieve cache manifest of a file to cache, which contains the file/directory
 // contents hash and the `expires` date.
-const getManifestInfo = async function ({ cachePath, move, ttl, digests }) {
+export const getManifestInfo = async function ({ cachePath, move, ttl, digests }) {
   const manifestPath = getManifestPath(cachePath)
   const expires = getExpires(ttl)
   const hash = await getHash(digests, move)
@@ -32,18 +25,18 @@ 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
-const writeManifest = async function ({ manifestPath, manifestString }) {
-  await makeDir(dirname(manifestPath))
-  await pWriteFile(manifestPath, manifestString)
+export const writeManifest = async function ({ manifestPath, manifestString }) {
+  await fs.mkdir(dirname(manifestPath), { recursive: true })
+  await fs.writeFile(manifestPath, manifestString)
 }
 
 // Remove the cache manifest from filesystem
-const removeManifest = async function (cachePath) {
+export const removeManifest = async function (cachePath) {
   const manifestPath = getManifestPath(cachePath)
   await del(manifestPath, { force: true })
 }
@@ -53,14 +46,14 @@ const getManifestPath = function (cachePath) {
   return `${cachePath}${CACHE_EXTENSION}`
 }
 
-const isManifest = function (filePath) {
+export const isManifest = function (filePath) {
   return filePath.endsWith(CACHE_EXTENSION)
 }
 
 const CACHE_EXTENSION = '.netlify.cache.json'
 
 // Check whether a file/directory is expired by checking its cache manifest
-const isExpired = async function (cachePath) {
+export const isExpired = async function (cachePath) {
   const manifestPath = getManifestPath(cachePath)
   if (!(await pathExists(manifestPath))) {
     return false
@@ -72,9 +65,7 @@ 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
 }
-
-module.exports = { getManifestInfo, writeManifest, removeManifest, isManifest, isExpired }

package/src/path.js

@@ -1,13 +1,11 @@
-'use strict'
+import { homedir } from 'os'
+import { resolve, isAbsolute, join, sep } from 'path'
 
-const { homedir } = require('os')
-const { resolve, isAbsolute, join, sep } = require('path')
-
-const { getCacheDir } = require('./dir')
-const { safeGetCwd } = require('./utils/cwd')
+import { getCacheDir } from './dir.js'
+import { safeGetCwd } from './utils/cwd.js'
 
 // Find the paths of the file before/after caching
-const parsePath = async function ({ path, cacheDir, cwdOpt }) {
+export const parsePath = async function ({ path, cacheDir, cwdOpt }) {
   const srcPath = await getSrcPath(path, cwdOpt)
   const cachePath = await getCachePath({ srcPath, cacheDir, cwdOpt })
   return { srcPath, cachePath }
@@ -94,7 +92,7 @@ const parseBase = function (name, base, srcPath) {
   return { name, relPath }
 }
 
-const getBases = async function (cwdOpt) {
+export const getBases = async function (cwdOpt) {
   const cwdBase = await getCwdBase(cwdOpt)
   return [...cwdBase, { name: 'home', base: homedir() }, { name: 'root', base: sep }]
 }
@@ -107,5 +105,3 @@ const getCwdBase = async function (cwdOpt) {
 
   return [{ name: 'cwd', base: cwd }]
 }
-
-module.exports = { parsePath, getBases }

package/src/utils/cwd.js

@@ -1,12 +1,10 @@
-'use strict'
+import { normalize } from 'path'
+import process from 'process'
 
-const { normalize } = require('path')
-const process = require('process')
-
-const pathExists = require('path-exists')
+import pathExists from 'path-exists'
 
 // Like `process.cwd()` but safer when current directory is wrong
-const safeGetCwd = async function (cwdOpt) {
+export const safeGetCwd = async function (cwdOpt) {
   try {
     const cwd = getCwdValue(cwdOpt)
 
@@ -15,7 +13,7 @@ const safeGetCwd = async function (cwdOpt) {
     }
 
     return cwd
-  } catch (error) {
+  } catch {
     return ''
   }
 }
@@ -23,5 +21,3 @@ const safeGetCwd = async function (cwdOpt) {
 const getCwdValue = function (cwdOpt = process.cwd()) {
   return normalize(cwdOpt)
 }
-
-module.exports = { safeGetCwd }

package/src/utils/polyfills.js

@@ -1,5 +0,0 @@
-'use strict'
-
-// Patches `Array.flat()` and `Array.flatMap()`
-// TODO: remove after dropping Node <12 support
-require('array-flat-polyfill')