@lage-run/cache 1.3.6 → 1.3.8

package/CHANGELOG.json

@@ -2,7 +2,37 @@
   "name": "@lage-run/cache",
   "entries": [
     {
-      "date": "Mon, 21 Oct 2024 22:18:24 GMT",
+      "date": "Fri, 08 Nov 2024 19:44:39 GMT",
+      "version": "1.3.8",
+      "tag": "@lage-run/cache_v1.3.8",
+      "comments": {
+        "patch": [
+          {
+            "author": "beachball",
+            "package": "@lage-run/cache",
+            "comment": "Bump @lage-run/target-graph to v0.10.0",
+            "commit": "not available"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Tue, 22 Oct 2024 15:19:29 GMT",
+      "version": "1.3.7",
+      "tag": "@lage-run/cache_v1.3.7",
+      "comments": {
+        "patch": [
+          {
+            "author": "beachball",
+            "package": "@lage-run/cache",
+            "comment": "Bump @lage-run/target-graph to v0.9.3",
+            "commit": "not available"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Mon, 21 Oct 2024 22:18:54 GMT",
       "version": "1.3.6",
       "tag": "@lage-run/cache_v1.3.6",
       "comments": {

package/CHANGELOG.md

@@ -1,12 +1,28 @@
 # Change Log - @lage-run/cache
 
-<!-- This log was last generated on Mon, 21 Oct 2024 22:18:24 GMT and should not be manually modified. -->
+<!-- This log was last generated on Fri, 08 Nov 2024 19:44:39 GMT and should not be manually modified. -->
 
 <!-- Start content -->
 
+## 1.3.8
+
+Fri, 08 Nov 2024 19:44:39 GMT
+
+### Patches
+
+- Bump @lage-run/target-graph to v0.10.0
+
+## 1.3.7
+
+Tue, 22 Oct 2024 15:19:29 GMT
+
+### Patches
+
+- Bump @lage-run/target-graph to v0.9.3
+
 ## 1.3.6
 
-Mon, 21 Oct 2024 22:18:24 GMT
+Mon, 21 Oct 2024 22:18:54 GMT
 
 ### Patches
 

package/lib/CredentialCache.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/CredentialCache.ts"],"sourcesContent":["import { DefaultAzureCredential } from \"@azure/identity\";\n\nexport class CredentialCache {\n  private static credential: DefaultAzureCredential | null = null;\n\n  public static getInstance(): DefaultAzureCredential {\n    if (!this.credential) {\n      this.credential = new DefaultAzureCredential();\n    }\n    return this.credential;\n  }\n}\n"],"names":["CredentialCache","getInstance","credential","DefaultAzureCredential"],"mappings":";;;;+BAEaA;;;eAAAA;;;0BAF0B;;;;;;;;;;;;;;AAEhC,MAAMA;IAGX,OAAcC,cAAsC;QAClD,IAAI,CAAC,IAAI,CAACC,UAAU,EAAE;YACpB,IAAI,CAACA,UAAU,GAAG,IAAIC,gCAAsB;QAC9C;QACA,OAAO,IAAI,CAACD,UAAU;IACxB;AACF;AARE,iBADWF,iBACIE,cAA4C"}

package/lib/backfillWrapper.js

@@ -11,11 +11,11 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    createBackfillLogger: function() {
-        return createBackfillLogger;
-    },
     createBackfillCacheConfig: function() {
         return createBackfillCacheConfig;
+    },
+    createBackfillLogger: function() {
+        return createBackfillLogger;
     }
 });
 const _os = /*#__PURE__*/ _interop_require_wildcard(require("os"));
@@ -43,7 +43,9 @@ function _interop_require_wildcard(obj, nodeInterop) {
     if (cache && cache.has(obj)) {
         return cache.get(obj);
     }
-    var newObj = {};
+    var newObj = {
+        __proto__: null
+    };
     var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
     for(var key in obj){
         if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {

package/lib/backfillWrapper.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/backfillWrapper.ts"],"sourcesContent":["/**\n * Backfill wrappers: some functions that uses the `backfill` library that doesn't require them to be inside a class\n */\n\nimport * as os from \"os\";\nimport { createDefaultConfig, getEnvConfig } from \"backfill-config\";\nimport { makeLogger } from \"backfill-logger\";\nimport { CacheStorageConfig } from \"backfill-config\";\nimport type { Logger as BackfillLogger } from \"backfill-logger\";\nimport type { CacheOptions } from \"./types/CacheOptions.js\";\nimport { CredentialCache } from \"./CredentialCache.js\";\n\nexport function createBackfillLogger() {\n  const stdout = process.stdout;\n  const stderr = process.stderr;\n  return makeLogger(\"error\", {\n    console: {\n      info(...args) {\n        stdout.write(args.join(\" \") + os.EOL);\n      },\n      warn(...args) {\n        stderr.write(args.join(\" \") + os.EOL);\n      },\n      error(...args) {\n        stderr.write(args.join(\" \") + os.EOL);\n      },\n    },\n  });\n}\n\nexport function createBackfillCacheConfig(cwd: string, cacheOptions: Partial<CacheOptions> = {}, backfillLogger: BackfillLogger) {\n  const envConfig = getEnvConfig(backfillLogger);\n  const mergedConfig = {\n    ...createDefaultConfig(cwd),\n    ...cacheOptions,\n    ...envConfig,\n  };\n\n  if (mergedConfig.cacheStorageConfig.provider === \"azure-blob\") {\n    if (\n      mergedConfig.cacheStorageConfig.options.connectionString &&\n      !isTokenConnectionString(mergedConfig.cacheStorageConfig.options.connectionString)\n    ) {\n      mergedConfig.cacheStorageConfig.options.credential = CredentialCache.getInstance();\n    }\n  }\n\n  return mergedConfig;\n}\n\nfunction isTokenConnectionString(connectionString: string) {\n  return connectionString.includes(\"SharedAccessSignature\");\n}\n"],"names":["createBackfillCacheConfig","createBackfillLogger","stdout","process","stderr","makeLogger","console","info","args","write","join","os","EOL","warn","error","cwd","cacheOptions","backfillLogger","envConfig","getEnvConfig","mergedConfig","createDefaultConfig","cacheStorageConfig","provider","options","connectionString","isTokenConnectionString","credential","CredentialCache","getInstance","includes"],"mappings":"AAAA;;CAEC;;;;;;;;;;;IA4BeA,yBAAyB;eAAzBA;;IAlBAC,oBAAoB;eAApBA;;;4DARI;gCAC8B;gCACvB;iCAIK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEzB,SAASA;IACd,MAAMC,SAASC,QAAQD,MAAM;IAC7B,MAAME,SAASD,QAAQC,MAAM;IAC7B,OAAOC,IAAAA,0BAAU,EAAC,SAAS;QACzBC,SAAS;YACPC,MAAK,GAAGC,IAAI;gBACVN,OAAOO,KAAK,CAACD,KAAKE,IAAI,CAAC,OAAOC,IAAGC,GAAG;YACtC;YACAC,MAAK,GAAGL,IAAI;gBACVJ,OAAOK,KAAK,CAACD,KAAKE,IAAI,CAAC,OAAOC,IAAGC,GAAG;YACtC;YACAE,OAAM,GAAGN,IAAI;gBACXJ,OAAOK,KAAK,CAACD,KAAKE,IAAI,CAAC,OAAOC,IAAGC,GAAG;YACtC;QACF;IACF;AACF;AAEO,SAASZ,0BAA0Be,GAAW,EAAEC,eAAsC,CAAC,CAAC,EAAEC,cAA8B;IAC7H,MAAMC,YAAYC,IAAAA,4BAAY,EAACF;IAC/B,MAAMG,eAAe;QACnB,GAAGC,IAAAA,mCAAmB,EAACN,IAAI;QAC3B,GAAGC,YAAY;QACf,GAAGE,SAAS;IACd;IAEA,IAAIE,aAAaE,kBAAkB,CAACC,QAAQ,KAAK,cAAc;QAC7D,IACEH,aAAaE,kBAAkB,CAACE,OAAO,CAACC,gBAAgB,IACxD,CAACC,wBAAwBN,aAAaE,kBAAkB,CAACE,OAAO,CAACC,gBAAgB,GACjF;YACAL,aAAaE,kBAAkB,CAACE,OAAO,CAACG,UAAU,GAAGC,gCAAe,CAACC,WAAW;QAClF;IACF;IAEA,OAAOT;AACT;AAEA,SAASM,wBAAwBD,gBAAwB;IACvD,OAAOA,iBAAiBK,QAAQ,CAAC;AACnC"}

package/lib/chunkPromise.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/chunkPromise.ts"],"sourcesContent":["type PromiseFn = () => Promise<unknown>;\n\nexport async function chunkPromise(promises: (Promise<unknown> | PromiseFn)[], limit = 5) {\n  for (let i = 0; i < promises.length; i += limit) {\n    await Promise.all(promises.slice(i, i + limit).map((p) => (typeof p === \"function\" ? p() : p)));\n  }\n}\n"],"names":["chunkPromise","promises","limit","i","length","Promise","all","slice","map","p"],"mappings":";;;;+BAEsBA;;;eAAAA;;;AAAf,eAAeA,aAAaC,QAA0C,EAAEC,QAAQ,CAAC;IACtF,IAAK,IAAIC,IAAI,GAAGA,IAAIF,SAASG,MAAM,EAAED,KAAKD,MAAO;QAC/C,MAAMG,QAAQC,GAAG,CAACL,SAASM,KAAK,CAACJ,GAAGA,IAAID,OAAOM,GAAG,CAAC,CAACC,IAAO,OAAOA,MAAM,aAAaA,MAAMA;IAC7F;AACF"}

package/lib/getCacheDirectory.js

@@ -9,12 +9,12 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    getCacheDirectoryRoot: function() {
-        return getCacheDirectoryRoot;
-    },
     getCacheDirectory: function() {
         return getCacheDirectory;
     },
+    getCacheDirectoryRoot: function() {
+        return getCacheDirectoryRoot;
+    },
     getLogsCacheDirectory: function() {
         return getLogsCacheDirectory;
     }

package/lib/getCacheDirectory.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/getCacheDirectory.ts"],"sourcesContent":["import path from \"path\";\n\nexport function getCacheDirectoryRoot(root: string) {\n  return path.join(root, \"node_modules\", \".cache\", \"lage\");\n}\n\nexport function getCacheDirectory(root: string, hash: string) {\n  return path.join(getCacheDirectoryRoot(root), \"cache\", hash.substring(0, 4));\n}\n\nexport function getLogsCacheDirectory(root: string, hash: string) {\n  return path.join(getCacheDirectoryRoot(root), \"logs\", hash.substring(0, 4));\n}\n"],"names":["getCacheDirectory","getCacheDirectoryRoot","getLogsCacheDirectory","root","path","join","hash","substring"],"mappings":";;;;;;;;;;;IAMgBA,iBAAiB;eAAjBA;;IAJAC,qBAAqB;eAArBA;;IAQAC,qBAAqB;eAArBA;;;6DAVC;;;;;;AAEV,SAASD,sBAAsBE,IAAY;IAChD,OAAOC,aAAI,CAACC,IAAI,CAACF,MAAM,gBAAgB,UAAU;AACnD;AAEO,SAASH,kBAAkBG,IAAY,EAAEG,IAAY;IAC1D,OAAOF,aAAI,CAACC,IAAI,CAACJ,sBAAsBE,OAAO,SAASG,KAAKC,SAAS,CAAC,GAAG;AAC3E;AAEO,SAASL,sBAAsBC,IAAY,EAAEG,IAAY;IAC9D,OAAOF,aAAI,CAACC,IAAI,CAACJ,sBAAsBE,OAAO,QAAQG,KAAKC,SAAS,CAAC,GAAG;AAC1E"}

package/lib/index.js

@@ -18,11 +18,11 @@ _export(exports, {
     getCacheDirectory: function() {
         return _getCacheDirectory.getCacheDirectory;
     },
-    getLogsCacheDirectory: function() {
-        return _getCacheDirectory.getLogsCacheDirectory;
-    },
     getCacheDirectoryRoot: function() {
         return _getCacheDirectory.getCacheDirectoryRoot;
+    },
+    getLogsCacheDirectory: function() {
+        return _getCacheDirectory.getLogsCacheDirectory;
     }
 });
 const _BackfillCacheProvider = require("./providers/BackfillCacheProvider.js");

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export { BackfillCacheProvider } from \"./providers/BackfillCacheProvider.js\";\nexport { RemoteFallbackCacheProvider } from \"./providers/RemoteFallbackCacheProvider.js\";\nexport type { CacheOptions } from \"./types/CacheOptions.js\";\nexport type { CacheProvider } from \"./types/CacheProvider.js\";\n\nexport { getCacheDirectory, getLogsCacheDirectory, getCacheDirectoryRoot } from \"./getCacheDirectory.js\";\n"],"names":["BackfillCacheProvider","RemoteFallbackCacheProvider","getCacheDirectory","getCacheDirectoryRoot","getLogsCacheDirectory"],"mappings":";;;;;;;;;;;IAASA,qBAAqB;eAArBA,4CAAqB;;IACrBC,2BAA2B;eAA3BA,wDAA2B;;IAI3BC,iBAAiB;eAAjBA,oCAAiB;;IAAyBC,qBAAqB;eAArBA,wCAAqB;;IAA5CC,qBAAqB;eAArBA,wCAAqB;;;uCALX;6CACM;mCAIoC"}

package/lib/providers/BackfillCacheProvider.js

@@ -49,7 +49,9 @@ function _interop_require_wildcard(obj, nodeInterop) {
     if (cache && cache.has(obj)) {
         return cache.get(obj);
     }
-    var newObj = {};
+    var newObj = {
+        __proto__: null
+    };
     var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
     for(var key in obj){
         if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
@@ -73,15 +75,15 @@ const stat = (0, _util.promisify)(_fs.stat);
 const MS_IN_A_DAY = 1000 * 60 * 60 * 24;
 class BackfillCacheProvider {
     getTargetCacheStorageProvider(cwd, hash) {
-        const { cacheOptions  } = this.options;
-        const { cacheStorageConfig , incrementalCaching  } = (0, _backfillWrapper.createBackfillCacheConfig)(cwd, cacheOptions, this.backfillLogger);
+        const { cacheOptions } = this.options;
+        const { cacheStorageConfig, incrementalCaching } = (0, _backfillWrapper.createBackfillCacheConfig)(cwd, cacheOptions, this.backfillLogger);
         const cachePath = this.getCachePath(cwd, hash);
         return (0, _backfillcache.getCacheStorageProvider)(cacheStorageConfig ?? {
             provider: "local"
         }, cachePath, this.backfillLogger, cwd, incrementalCaching);
     }
     async fetch(hash, target) {
-        const { logger  } = this.options;
+        const { logger } = this.options;
         if (!hash) {
             return false;
         }
@@ -101,7 +103,7 @@ class BackfillCacheProvider {
         }
     }
     async put(hash, target) {
-        const { logger  } = this.options;
+        const { logger } = this.options;
         if (!hash) {
             return;
         }

package/lib/providers/BackfillCacheProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/providers/BackfillCacheProvider.ts"],"sourcesContent":["import { createBackfillCacheConfig, createBackfillLogger } from \"../backfillWrapper.js\";\nimport { getCacheStorageProvider } from \"backfill-cache\";\nimport { promisify } from \"util\";\nimport * as fs from \"fs\";\nimport * as path from \"path\";\nimport type { CacheProvider, CacheProviderOptions } from \"../types/CacheProvider.js\";\nimport type { Logger as BackfillLogger } from \"backfill-logger\";\nimport type { Target } from \"@lage-run/target-graph\";\nimport type { Logger } from \"@lage-run/logger\";\nimport { getCacheDirectory, getCacheDirectoryRoot } from \"../getCacheDirectory.js\";\nimport { chunkPromise } from \"../chunkPromise.js\";\n\nconst rm = promisify(fs.rm);\nconst readdir = promisify(fs.readdir);\nconst stat = promisify(fs.stat);\n\nconst MS_IN_A_DAY = 1000 * 60 * 60 * 24;\n\nexport interface BackfillCacheProviderOptions {\n  root: string;\n  logger: Logger;\n  cacheOptions: Partial<CacheProviderOptions>;\n}\n\nexport class BackfillCacheProvider implements CacheProvider {\n  /**\n   * logger for backfill\n   */\n  private backfillLogger: BackfillLogger;\n\n  private getTargetCacheStorageProvider(cwd: string, hash: string) {\n    const { cacheOptions } = this.options;\n    const { cacheStorageConfig, incrementalCaching } = createBackfillCacheConfig(cwd, cacheOptions, this.backfillLogger);\n\n    const cachePath = this.getCachePath(cwd, hash);\n\n    return getCacheStorageProvider(cacheStorageConfig ?? { provider: \"local\" }, cachePath, this.backfillLogger, cwd, incrementalCaching);\n  }\n\n  constructor(private options: BackfillCacheProviderOptions) {\n    this.backfillLogger = createBackfillLogger();\n  }\n\n  async fetch(hash: string, target: Target): Promise<boolean> {\n    const { logger } = this.options;\n\n    if (!hash) {\n      return false;\n    }\n\n    const cacheStorage = this.getTargetCacheStorageProvider(target.cwd, hash);\n\n    try {\n      return await cacheStorage.fetch(hash);\n    } catch (error) {\n      let message;\n\n      if (error instanceof Error) {\n        message = error.message;\n      } else message = String(error);\n\n      logger.silly(`Cache fetch failed: ${message}`, { target });\n\n      // backfill fetch can error, but we should simply ignore and continue\n      return false;\n    }\n  }\n\n  async put(hash: string, target: Target): Promise<void> {\n    const { logger } = this.options;\n\n    if (!hash) {\n      return;\n    }\n\n    const cacheStorage = this.getTargetCacheStorageProvider(target.cwd, hash);\n\n    try {\n      await cacheStorage.put(hash, target.outputs ?? this.options.cacheOptions.outputGlob ?? [\"**/*\"]);\n    } catch (error) {\n      let message;\n\n      if (error instanceof Error) {\n        message = error.message;\n      } else message = String(error);\n\n      logger.silly(`Cache fetch failed: ${message}`, { target });\n\n      // backfill throws an error if outputGlob doesn't match any files, we will skip this error\n    }\n  }\n\n  async clear(concurrency = 10): Promise<void> {\n    return this.purge(0, concurrency);\n  }\n\n  async purge(prunePeriod = 30, concurrency = 10): Promise<void> {\n    const now = new Date();\n\n    const cacheTypes = [\"cache\", \"logs\"];\n    const entries: string[] = [];\n\n    for (const cacheType of cacheTypes) {\n      const cacheTypeDirectory = path.join(getCacheDirectoryRoot(this.options.root), cacheType);\n      if (fs.existsSync(cacheTypeDirectory)) {\n        const hashPrefixes = await readdir(cacheTypeDirectory);\n        for (const prefix of hashPrefixes) {\n          const cachePath = path.join(cacheTypeDirectory, prefix);\n          entries.push(cachePath);\n        }\n      }\n    }\n\n    await chunkPromise(\n      entries.map((entry) => {\n        return async () => {\n          const entryPath = entry;\n          const entryStat = await stat(entryPath);\n\n          if (now.getTime() - entryStat.mtime.getTime() > prunePeriod * MS_IN_A_DAY) {\n            await removeCache(entryPath, entryStat);\n          }\n        };\n      }),\n      concurrency\n    );\n  }\n\n  getCachePath(packagePath: string, hash: string) {\n    return path.relative(packagePath, getCacheDirectory(this.options.root, hash));\n  }\n}\n\nasync function removeCache(cachePath: string, entryStat: fs.Stats) {\n  if (entryStat.isDirectory()) {\n    return rm(cachePath, { recursive: true });\n  } else {\n    return rm(cachePath);\n  }\n}\n"],"names":["BackfillCacheProvider","rm","promisify","fs","readdir","stat","MS_IN_A_DAY","getTargetCacheStorageProvider","cwd","hash","cacheOptions","options","cacheStorageConfig","incrementalCaching","createBackfillCacheConfig","backfillLogger","cachePath","getCachePath","getCacheStorageProvider","provider","fetch","target","logger","cacheStorage","error","message","Error","String","silly","put","outputs","outputGlob","clear","concurrency","purge","prunePeriod","now","Date","cacheTypes","entries","cacheType","cacheTypeDirectory","path","join","getCacheDirectoryRoot","root","existsSync","hashPrefixes","prefix","push","chunkPromise","map","entry","entryPath","entryStat","getTime","mtime","removeCache","packagePath","relative","getCacheDirectory","constructor","createBackfillLogger","isDirectory","recursive"],"mappings":"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"}

package/lib/providers/RemoteFallbackCacheProvider.js

@@ -23,7 +23,7 @@ function _define_property(obj, key, value) {
 }
 class RemoteFallbackCacheProvider {
     async fetch(hash, target) {
-        const { logger , remoteCacheProvider , localCacheProvider  } = this.options;
+        const { logger, remoteCacheProvider, localCacheProvider } = this.options;
         if (localCacheProvider) {
             RemoteFallbackCacheProvider.localHits[hash] = await localCacheProvider.fetch(hash, target);
             logger.silly(`local cache fetch: ${hash} ${RemoteFallbackCacheProvider.localHits[hash]}`);
@@ -41,7 +41,7 @@ class RemoteFallbackCacheProvider {
         return RemoteFallbackCacheProvider.localHits[hash];
     }
     async put(hash, target) {
-        const { logger , remoteCacheProvider , localCacheProvider , writeRemoteCache  } = this.options;
+        const { logger, remoteCacheProvider, localCacheProvider, writeRemoteCache } = this.options;
         const putPromises = [];
         // Write local cache if it doesn't already exist, or if the the hash isn't in the localHits
         const shouldWriteLocalCache = !this.isLocalHit(hash) && !!localCacheProvider;
@@ -65,13 +65,13 @@ class RemoteFallbackCacheProvider {
         return hash in RemoteFallbackCacheProvider.localHits && RemoteFallbackCacheProvider.localHits[hash];
     }
     async clear() {
-        const { localCacheProvider  } = this.options;
+        const { localCacheProvider } = this.options;
         if (localCacheProvider) {
             return localCacheProvider.clear();
         }
     }
     async purge(sinceDays) {
-        const { localCacheProvider  } = this.options;
+        const { localCacheProvider } = this.options;
         if (localCacheProvider) {
             return localCacheProvider.purge(sinceDays);
         }

package/lib/providers/RemoteFallbackCacheProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/providers/RemoteFallbackCacheProvider.ts"],"sourcesContent":["import type { CacheProvider } from \"../types/CacheProvider.js\";\nimport type { Logger } from \"@lage-run/logger\";\nimport type { Target } from \"@lage-run/target-graph\";\n\nexport interface RemoteFallbackCacheProviderOptions {\n  root: string;\n  logger: Logger;\n\n  localCacheProvider?: CacheProvider;\n  remoteCacheProvider?: CacheProvider;\n\n  writeRemoteCache?: boolean;\n}\n\n/**\n * Remote Fallback Cache Provider\n *\n * This backfill cache provider will fallback to a remote cache provider if the local cache does not contain the item.\n * It will also automatically populate the local cache with the remote cache.\n */\nexport class RemoteFallbackCacheProvider implements CacheProvider {\n  private static localHits: { [hash: string]: boolean } = {};\n  private static remoteHits: { [hash: string]: boolean } = {};\n\n  constructor(private options: RemoteFallbackCacheProviderOptions) {}\n\n  async fetch(hash: string, target: Target) {\n    const { logger, remoteCacheProvider, localCacheProvider } = this.options;\n\n    if (localCacheProvider) {\n      RemoteFallbackCacheProvider.localHits[hash] = await localCacheProvider.fetch(hash, target);\n      logger.silly(`local cache fetch: ${hash} ${RemoteFallbackCacheProvider.localHits[hash]}`);\n    }\n\n    if (!RemoteFallbackCacheProvider.localHits[hash] && remoteCacheProvider) {\n      RemoteFallbackCacheProvider.remoteHits[hash] = await remoteCacheProvider.fetch(hash, target);\n      logger.silly(`remote fallback fetch: ${hash} ${RemoteFallbackCacheProvider.remoteHits[hash]}`);\n\n      // now save this into the localCacheProvider, if available\n      if (localCacheProvider && RemoteFallbackCacheProvider.remoteHits[hash]) {\n        logger.silly(`local cache put, fetched cache from remote: ${hash}`);\n        await localCacheProvider.put(hash, target);\n      }\n\n      return RemoteFallbackCacheProvider.remoteHits[hash];\n    }\n\n    return RemoteFallbackCacheProvider.localHits[hash];\n  }\n\n  async put(hash: string, target: Target) {\n    const { logger, remoteCacheProvider, localCacheProvider, writeRemoteCache } = this.options;\n    const putPromises: Promise<void>[] = [];\n\n    // Write local cache if it doesn't already exist, or if the the hash isn't in the localHits\n    const shouldWriteLocalCache = !this.isLocalHit(hash) && !!localCacheProvider;\n\n    if (shouldWriteLocalCache) {\n      logger.silly(`local cache put: ${hash}`);\n      putPromises.push(localCacheProvider.put(hash, target));\n    }\n\n    // Write to remote if there is a no hit in the remote cache, and remote cache storage provider, and that the \"writeRemoteCache\" config flag is set to true\n    const shouldWriteRemoteCache = !this.isRemoteHit(hash) && !!remoteCacheProvider && writeRemoteCache;\n\n    if (shouldWriteRemoteCache) {\n      logger.silly(`remote fallback put: ${hash}`);\n      const remotePut = remoteCacheProvider.put(hash, target);\n      putPromises.push(remotePut);\n    }\n\n    await Promise.all(putPromises);\n  }\n\n  private isRemoteHit(hash) {\n    return hash in RemoteFallbackCacheProvider.remoteHits && RemoteFallbackCacheProvider.remoteHits[hash];\n  }\n\n  private isLocalHit(hash) {\n    return hash in RemoteFallbackCacheProvider.localHits && RemoteFallbackCacheProvider.localHits[hash];\n  }\n\n  async clear(): Promise<void> {\n    const { localCacheProvider } = this.options;\n    if (localCacheProvider) {\n      return localCacheProvider.clear();\n    }\n  }\n\n  async purge(sinceDays: number): Promise<void> {\n    const { localCacheProvider } = this.options;\n    if (localCacheProvider) {\n      return localCacheProvider.purge(sinceDays);\n    }\n  }\n}\n"],"names":["RemoteFallbackCacheProvider","fetch","hash","target","logger","remoteCacheProvider","localCacheProvider","options","localHits","silly","remoteHits","put","writeRemoteCache","putPromises","shouldWriteLocalCache","isLocalHit","push","shouldWriteRemoteCache","isRemoteHit","remotePut","Promise","all","clear","purge","sinceDays","constructor"],"mappings":";;;;+BAoBaA;;;eAAAA;;;;;;;;;;;;;;;;AAAN,MAAMA;IAMX,MAAMC,MAAMC,IAAY,EAAEC,MAAc,EAAE;QACxC,MAAM,EAAEC,MAAM,EAAEC,mBAAmB,EAAEC,kBAAkB,EAAE,GAAG,IAAI,CAACC,OAAO;QAExE,IAAID,oBAAoB;YACtBN,4BAA4BQ,SAAS,CAACN,KAAK,GAAG,MAAMI,mBAAmBL,KAAK,CAACC,MAAMC;YACnFC,OAAOK,KAAK,CAAC,CAAC,mBAAmB,EAAEP,KAAK,CAAC,EAAEF,4BAA4BQ,SAAS,CAACN,KAAK,EAAE;QAC1F;QAEA,IAAI,CAACF,4BAA4BQ,SAAS,CAACN,KAAK,IAAIG,qBAAqB;YACvEL,4BAA4BU,UAAU,CAACR,KAAK,GAAG,MAAMG,oBAAoBJ,KAAK,CAACC,MAAMC;YACrFC,OAAOK,KAAK,CAAC,CAAC,uBAAuB,EAAEP,KAAK,CAAC,EAAEF,4BAA4BU,UAAU,CAACR,KAAK,EAAE;YAE7F,0DAA0D;YAC1D,IAAII,sBAAsBN,4BAA4BU,UAAU,CAACR,KAAK,EAAE;gBACtEE,OAAOK,KAAK,CAAC,CAAC,4CAA4C,EAAEP,MAAM;gBAClE,MAAMI,mBAAmBK,GAAG,CAACT,MAAMC;YACrC;YAEA,OAAOH,4BAA4BU,UAAU,CAACR,KAAK;QACrD;QAEA,OAAOF,4BAA4BQ,SAAS,CAACN,KAAK;IACpD;IAEA,MAAMS,IAAIT,IAAY,EAAEC,MAAc,EAAE;QACtC,MAAM,EAAEC,MAAM,EAAEC,mBAAmB,EAAEC,kBAAkB,EAAEM,gBAAgB,EAAE,GAAG,IAAI,CAACL,OAAO;QAC1F,MAAMM,cAA+B,EAAE;QAEvC,2FAA2F;QAC3F,MAAMC,wBAAwB,CAAC,IAAI,CAACC,UAAU,CAACb,SAAS,CAAC,CAACI;QAE1D,IAAIQ,uBAAuB;YACzBV,OAAOK,KAAK,CAAC,CAAC,iBAAiB,EAAEP,MAAM;YACvCW,YAAYG,IAAI,CAACV,mBAAmBK,GAAG,CAACT,MAAMC;QAChD;QAEA,0JAA0J;QAC1J,MAAMc,yBAAyB,CAAC,IAAI,CAACC,WAAW,CAAChB,SAAS,CAAC,CAACG,uBAAuBO;QAEnF,IAAIK,wBAAwB;YAC1Bb,OAAOK,KAAK,CAAC,CAAC,qBAAqB,EAAEP,MAAM;YAC3C,MAAMiB,YAAYd,oBAAoBM,GAAG,CAACT,MAAMC;YAChDU,YAAYG,IAAI,CAACG;QACnB;QAEA,MAAMC,QAAQC,GAAG,CAACR;IACpB;IAEQK,YAAYhB,IAAI,EAAE;QACxB,OAAOA,QAAQF,4BAA4BU,UAAU,IAAIV,4BAA4BU,UAAU,CAACR,KAAK;IACvG;IAEQa,WAAWb,IAAI,EAAE;QACvB,OAAOA,QAAQF,4BAA4BQ,SAAS,IAAIR,4BAA4BQ,SAAS,CAACN,KAAK;IACrG;IAEA,MAAMoB,QAAuB;QAC3B,MAAM,EAAEhB,kBAAkB,EAAE,GAAG,IAAI,CAACC,OAAO;QAC3C,IAAID,oBAAoB;YACtB,OAAOA,mBAAmBgB,KAAK;QACjC;IACF;IAEA,MAAMC,MAAMC,SAAiB,EAAiB;QAC5C,MAAM,EAAElB,kBAAkB,EAAE,GAAG,IAAI,CAACC,OAAO;QAC3C,IAAID,oBAAoB;YACtB,OAAOA,mBAAmBiB,KAAK,CAACC;QAClC;IACF;IAtEAC,YAAY,AAAQlB,OAA2C,CAAE;;aAA7CA,UAAAA;IAA8C;AAuEpE;AA1EE,iBADWP,6BACIQ,aAAyC,CAAC;AACzD,iBAFWR,6BAEIU,cAA0C,CAAC"}

package/lib/types/CacheOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":""}

package/lib/types/CacheProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lage-run/cache",
-  "version": "1.3.6",
+  "version": "1.3.8",
   "description": "Cache for Lage",
   "repository": {
     "type": "git",
@@ -19,7 +19,7 @@
   "dependencies": {
     "@azure/identity": "^4.0.1",
     "@lage-run/logger": "^1.3.1",
-    "@lage-run/target-graph": "^0.9.2",
+    "@lage-run/target-graph": "^0.10.0",
     "backfill-cache": "5.8.0",
     "backfill-config": "6.4.2",
     "backfill-logger": "5.2.1",