@chriscdn/file-cache 0.0.3 → 0.0.5

package/README.md

@@ -61,9 +61,8 @@ const options: FileCacheOptions<MyCallbackArgs> = {
     await downloadAndConvertToJPG(url, filePath);
   },
 
-  // Specifies the file extension for each cached file.
-  // Currently, all files share the same extension (this may change in the future).
-  ext: ".jpg",
+  // Specifies the file extension for the cached file. Can be synchronous or asynchronous.
+  ext: (context: MyCallbackArgs) => ".jpg",
 
   // Determines the time-to-live (TTL) of a cached file, in milliseconds,
   // based on when it was last accessed.

package/__tests__/file-cache.test.ts

@@ -18,7 +18,7 @@ describe("Cache Expiration", async () => {
         filePath,
       );
     },
-    ext: "pdf",
+    ext: () => ".pdf",
     ttl: Duration.toMilliseconds({ seconds: 1 }),
     cleanupInterval: Duration.toMilliseconds({ seconds: 2 }),
   });

package/lib/index.d.ts

@@ -5,9 +5,9 @@ export type FileCacheOptions<T extends Record<string, any>> = {
     cachePath: DirectoryPath;
     autoCreateCachePath?: boolean;
     cb: (filePath: FilePath, context: T, cache: FileCache<T>) => Promise<void>;
-    ext: string;
-    cleanupInterval?: Milliseconds;
+    ext: (context: T) => string | Promise<string>;
     ttl: Milliseconds;
+    cleanupInterval?: Milliseconds;
 };
 declare class FileCache<T extends Record<string, any>> {
     private _cachePath;
@@ -60,7 +60,6 @@ declare class FileCache<T extends Record<string, any>> {
      * @param args The arguments used to resolve the file path
      * @returns The full path to the cached file
      */
-    resolveFilePath(args: T): FilePath;
-    resolveCreateFilePath(args: T): Promise<FilePath>;
+    resolveFilePath(args: T): Promise<FilePath>;
 }
 export { type DirectoryPath, FileCache, type FilePath };

package/lib/index.js

@@ -7,10 +7,10 @@ import touch from "touch";
 import { findNuke } from "@chriscdn/find-nuke";
 import { Duration } from "@chriscdn/duration";
 import { rimraf } from "rimraf";
+import { Memoize } from "@chriscdn/memoize";
 const fsp = fs.promises;
 class FileCache {
     _cachePath;
-    // private _resolveFileName: FileCacheOptions<T>["resolveFileName"];
     _cb;
     _ext;
     _ttl;
@@ -20,30 +20,25 @@ class FileCache {
     _cleanupSemaphore = new Semaphore();
     constructor({ cachePath, autoCreateCachePath, cb, ext, ttl, cleanupInterval }) {
         this._cachePath = cachePath;
-        // this._resolveFileName = resolveFileName;
         this._cb = cb;
         this._ext = ext;
         this._ttl = ttl;
         this._cleanupInterval = cleanupInterval ??
             Duration.toMilliseconds({ days: 1 });
-        (async () => {
-            if (!(await pathExists(cachePath))) {
-                throw new Error("💥 FileCache error: cachePath does not exist.");
-                // process.exit(1); // or throw new Error() if you want to let it bubble
-            }
-        })();
         if ((pathExistsSync(cachePath))) {
+            // we're good
         }
         else if (autoCreateCachePath) {
             fs.mkdirSync(cachePath, { recursive: true });
         }
         else {
             throw new Error("💥 FileCache error: cachePath does not exist.");
-            // process.exit(1); // or throw new Error() if you want to let it bubble
         }
         // fire and forget
         this.cleanup();
         this._intervalId = setInterval(this.cleanup.bind(this), this._cleanupInterval);
+        this.resolveFileName = Memoize(this.resolveFileName.bind(this));
+        this.resolveFilePath = Memoize(this.resolveFilePath.bind(this));
     }
     /**
      * Runs a cleanup pass to remove files older than 1 day from the cache.
@@ -73,18 +68,18 @@ class FileCache {
      * @returns The path to the cached or newly created file
      */
     async getFile(args) {
-        const filePath = this.resolveFilePath(args);
+        const filePath = await this.resolveFilePath(args);
         try {
             await Promise.all([
                 this._semaphore.acquire(filePath),
-                this._cleanupSemaphore.wait(),
+                this._cleanupSemaphore.wait(), // wait for any cleanup task to end
             ]);
             if (await pathExists(filePath)) {
                 // fire and forget
                 touch(filePath);
             }
             else {
-                await fs.mkdirSync(path.dirname(filePath), { recursive: true });
+                await fsp.mkdir(path.dirname(filePath), { recursive: true });
                 await this._cb(filePath, args, this);
             }
         }
@@ -94,7 +89,7 @@ class FileCache {
         return filePath;
     }
     async has(args) {
-        const filePath = this.resolveFilePath(args);
+        const filePath = await this.resolveFilePath(args);
         return await pathExists(filePath);
     }
     /**
@@ -104,13 +99,19 @@ class FileCache {
      * @returns True if the file was deleted, false if it didn't exist
      */
     async expire(args) {
-        const filePath = this.resolveFilePath(args);
-        if (await pathExists(filePath)) {
-            await rimraf(filePath);
-            return true;
+        const filePath = await this.resolveFilePath(args);
+        try {
+            await this._semaphore.acquire(filePath);
+            if (await pathExists(filePath)) {
+                await rimraf(filePath);
+                return true;
+            }
+            else {
+                return false;
+            }
         }
-        else {
-            return false;
+        finally {
+            this._semaphore.release(filePath);
         }
     }
     /**
@@ -128,16 +129,12 @@ class FileCache {
      * Uses the provided `resolveFileName` function if available, or falls back to
      * generating a hash from the arguments to create a unique file name.
      */
-    resolveFileName(args) {
+    async resolveFileName(args) {
         const baseName = sha1(JSON.stringify(args));
         return path.format({
-            // dir: path.dirname(filePath),
             name: baseName,
-            ext: this._ext,
+            ext: await this._ext(args),
         });
-        // return this._resolveFileName
-        //   ? this._resolveFileName(args)
-        //   : `${sha1(JSON.stringify(args, Object.keys(args).sort()))}${this._ext}`;
     }
     /**
      * Resolves the full file path for the cached file based on the provided arguments.
@@ -145,17 +142,13 @@ class FileCache {
      * @param args The arguments used to resolve the file path
      * @returns The full path to the cached file
      */
-    resolveFilePath(args) {
-        const fileName = this.resolveFileName(args);
+    async resolveFilePath(args) {
+        const fileName = await this.resolveFileName(args);
         const filePath = path.resolve(this._cachePath, fileName[0], fileName[1], fileName[2], 
         // fileName[3],
         fileName);
         return filePath;
     }
-    async resolveCreateFilePath(args) {
-        const filePath = this.resolveFilePath(args);
-        await fsp.mkdir(path.dirname(filePath), { recursive: true });
-        return filePath;
-    }
 }
 export { FileCache };
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -1,7 +1 @@
-{
-  "version": 3,
-  "sources": ["../src/index.ts"],
-  "sourcesContent": ["import path from \"path\";\nimport fs from \"fs\";\nimport { pathExists, pathExistsSync } from \"path-exists\";\nimport sha1 from \"sha1\";\nimport Semaphore from \"@chriscdn/promise-semaphore\";\nimport touch from \"touch\";\nimport { findNuke } from \"@chriscdn/find-nuke\";\nimport { Duration } from \"@chriscdn/duration\";\nimport { rimraf } from \"rimraf\";\n\nconst fsp = fs.promises;\n\ntype DirectoryPath = string;\ntype FilePath = string;\ntype Milliseconds = number;\n\nexport type FileCacheOptions<T extends Record<string, any>> = {\n  cachePath: DirectoryPath;\n  autoCreateCachePath?: boolean;\n  cb: (filePath: FilePath, context: T, cache: FileCache<T>) => Promise<void>;\n  ext: string;\n  cleanupInterval?: Milliseconds;\n  ttl: Milliseconds;\n  // resolveFileName?: (args: T) => FilePath;\n};\n\nclass FileCache<T extends Record<string, any>> {\n  private _cachePath: FileCacheOptions<T>[\"cachePath\"];\n  // private _resolveFileName: FileCacheOptions<T>[\"resolveFileName\"];\n  private _cb: FileCacheOptions<T>[\"cb\"];\n  private _ext: FileCacheOptions<T>[\"ext\"];\n  private _ttl: FileCacheOptions<T>[\"ttl\"];\n  private _cleanupInterval: FileCacheOptions<T>[\"cleanupInterval\"];\n\n  private _intervalId: ReturnType<typeof setInterval> | null = null;\n\n  private _semaphore: Semaphore = new Semaphore();\n  private _cleanupSemaphore: Semaphore = new Semaphore();\n\n  constructor(\n    { cachePath, autoCreateCachePath, cb, ext, ttl, cleanupInterval }:\n      FileCacheOptions<T>,\n  ) {\n    this._cachePath = cachePath;\n    // this._resolveFileName = resolveFileName;\n    this._cb = cb;\n    this._ext = ext;\n    this._ttl = ttl;\n    this._cleanupInterval = cleanupInterval ??\n      Duration.toMilliseconds({ days: 1 });\n\n    (async () => {\n      if (!(await pathExists(cachePath))) {\n        throw new Error(\"\uD83D\uDCA5 FileCache error: cachePath does not exist.\");\n        // process.exit(1); // or throw new Error() if you want to let it bubble\n      }\n    })();\n\n    if ((pathExistsSync(cachePath))) {\n    } else if (autoCreateCachePath) {\n      fs.mkdirSync(cachePath, { recursive: true });\n    } else {\n      throw new Error(\"\uD83D\uDCA5 FileCache error: cachePath does not exist.\");\n      // process.exit(1); // or throw new Error() if you want to let it bubble\n    }\n\n    // fire and forget\n    this.cleanup();\n\n    this._intervalId = setInterval(\n      this.cleanup.bind(this),\n      this._cleanupInterval,\n    );\n  }\n\n  /**\n   * Runs a cleanup pass to remove files older than 1 day from the cache.\n   * This is called periodically, but can be triggered manually.\n   */\n  async cleanup() {\n    try {\n      await this._cleanupSemaphore.acquire();\n      await findNuke(this._cachePath, {\n        olderThan: this._ttl,\n        verbose: true,\n        deleteEmptyDirectories: true,\n      });\n    } finally {\n      this._cleanupSemaphore.release();\n    }\n  }\n\n  /**\n   * Retrieves a cached file for the given arguments.\n   * If the file doesn't exist, it is generated by the callback and stored.\n   *\n   * Concurrency-safe, ensuring no conflicts when multiple requests are made\n   * for the same file.\n   *\n   * @param args The arguments used to determine the file's identity and generation\n   * @returns The path to the cached or newly created file\n   */\n  async getFile(args: T): Promise<FilePath> {\n    const filePath = this.resolveFilePath(args);\n\n    try {\n      await Promise.all([\n        this._semaphore.acquire(filePath),\n        this._cleanupSemaphore.wait(),\n      ]);\n\n      if (await pathExists(filePath)) {\n        // fire and forget\n        touch(filePath);\n      } else {\n        await fs.mkdirSync(path.dirname(filePath), { recursive: true });\n        await this._cb(filePath, args, this);\n      }\n    } finally {\n      this._semaphore.release(filePath);\n    }\n\n    return filePath;\n  }\n\n  async has(args: T): Promise<boolean> {\n    const filePath = this.resolveFilePath(args);\n    return await pathExists(filePath);\n  }\n\n  /**\n   * Deletes a file from the cache if it exists.\n   *\n   * @param args The arguments used to determine the file's identity\n   * @returns True if the file was deleted, false if it didn't exist\n   */\n  async expire(args: T): Promise<boolean> {\n    const filePath = this.resolveFilePath(args);\n\n    if (await pathExists(filePath)) {\n      await rimraf(filePath);\n      return true;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Stops the background cleanup process, but does not delete any cached files.\n   */\n  destroy() {\n    if (this._intervalId) {\n      clearInterval(this._intervalId);\n      this._intervalId = null;\n    }\n  }\n\n  /**\n   * Resolves the filename for the cache based on the provided arguments.\n   *\n   * Uses the provided `resolveFileName` function if available, or falls back to\n   * generating a hash from the arguments to create a unique file name.\n   */\n  private resolveFileName(args: T): string {\n    const baseName = sha1(JSON.stringify(args));\n\n    return path.format({\n      // dir: path.dirname(filePath),\n      name: baseName,\n      ext: this._ext,\n    });\n\n    // return this._resolveFileName\n    //   ? this._resolveFileName(args)\n    //   : `${sha1(JSON.stringify(args, Object.keys(args).sort()))}${this._ext}`;\n  }\n\n  /**\n   * Resolves the full file path for the cached file based on the provided arguments.\n   *\n   * @param args The arguments used to resolve the file path\n   * @returns The full path to the cached file\n   */\n  resolveFilePath(args: T): FilePath {\n    const fileName = this.resolveFileName(args);\n\n    const filePath = path.resolve(\n      this._cachePath,\n      fileName[0],\n      fileName[1],\n      fileName[2],\n      // fileName[3],\n      fileName,\n    );\n\n    return filePath;\n  }\n\n  async resolveCreateFilePath(args: T): Promise<FilePath> {\n    const filePath = this.resolveFilePath(args);\n\n    await fsp.mkdir(path.dirname(filePath), { recursive: true });\n\n    return filePath;\n  }\n}\n\nexport { type DirectoryPath, FileCache, type FilePath };\n"],
-  "mappings": ";AAAA,OAAO,UAAU;AACjB,OAAO,QAAQ;AACf,SAAS,YAAY,sBAAsB;AAC3C,OAAO,UAAU;AACjB,OAAO,eAAe;AACtB,OAAO,WAAW;AAClB,SAAS,gBAAgB;AACzB,SAAS,gBAAgB;AACzB,SAAS,cAAc;AAEvB,IAAM,MAAM,GAAG;AAgBf,IAAM,YAAN,MAA+C;AAAA,EACrC;AAAA;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAEA,cAAqD;AAAA,EAErD,aAAwB,IAAI,UAAU;AAAA,EACtC,oBAA+B,IAAI,UAAU;AAAA,EAErD,YACE,EAAE,WAAW,qBAAqB,IAAI,KAAK,KAAK,gBAAgB,GAEhE;AACA,SAAK,aAAa;AAElB,SAAK,MAAM;AACX,SAAK,OAAO;AACZ,SAAK,OAAO;AACZ,SAAK,mBAAmB,mBACtB,SAAS,eAAe,EAAE,MAAM,EAAE,CAAC;AAErC,KAAC,YAAY;AACX,UAAI,CAAE,MAAM,WAAW,SAAS,GAAI;AAClC,cAAM,IAAI,MAAM,sDAA+C;AAAA,MAEjE;AAAA,IACF,GAAG;AAEH,QAAK,eAAe,SAAS,GAAI;AAAA,IACjC,WAAW,qBAAqB;AAC9B,SAAG,UAAU,WAAW,EAAE,WAAW,KAAK,CAAC;AAAA,IAC7C,OAAO;AACL,YAAM,IAAI,MAAM,sDAA+C;AAAA,IAEjE;AAGA,SAAK,QAAQ;AAEb,SAAK,cAAc;AAAA,MACjB,KAAK,QAAQ,KAAK,IAAI;AAAA,MACtB,KAAK;AAAA,IACP;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAM,UAAU;AACd,QAAI;AACF,YAAM,KAAK,kBAAkB,QAAQ;AACrC,YAAM,SAAS,KAAK,YAAY;AAAA,QAC9B,WAAW,KAAK;AAAA,QAChB,SAAS;AAAA,QACT,wBAAwB;AAAA,MAC1B,CAAC;AAAA,IACH,UAAE;AACA,WAAK,kBAAkB,QAAQ;AAAA,IACjC;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYA,MAAM,QAAQ,MAA4B;AACxC,UAAM,WAAW,KAAK,gBAAgB,IAAI;AAE1C,QAAI;AACF,YAAM,QAAQ,IAAI;AAAA,QAChB,KAAK,WAAW,QAAQ,QAAQ;AAAA,QAChC,KAAK,kBAAkB,KAAK;AAAA,MAC9B,CAAC;AAED,UAAI,MAAM,WAAW,QAAQ,GAAG;AAE9B,cAAM,QAAQ;AAAA,MAChB,OAAO;AACL,cAAM,GAAG,UAAU,KAAK,QAAQ,QAAQ,GAAG,EAAE,WAAW,KAAK,CAAC;AAC9D,cAAM,KAAK,IAAI,UAAU,MAAM,IAAI;AAAA,MACrC;AAAA,IACF,UAAE;AACA,WAAK,WAAW,QAAQ,QAAQ;AAAA,IAClC;AAEA,WAAO;AAAA,EACT;AAAA,EAEA,MAAM,IAAI,MAA2B;AACnC,UAAM,WAAW,KAAK,gBAAgB,IAAI;AAC1C,WAAO,MAAM,WAAW,QAAQ;AAAA,EAClC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAM,OAAO,MAA2B;AACtC,UAAM,WAAW,KAAK,gBAAgB,IAAI;AAE1C,QAAI,MAAM,WAAW,QAAQ,GAAG;AAC9B,YAAM,OAAO,QAAQ;AACrB,aAAO;AAAA,IACT,OAAO;AACL,aAAO;AAAA,IACT;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,UAAU;AACR,QAAI,KAAK,aAAa;AACpB,oBAAc,KAAK,WAAW;AAC9B,WAAK,cAAc;AAAA,IACrB;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQQ,gBAAgB,MAAiB;AACvC,UAAM,WAAW,KAAK,KAAK,UAAU,IAAI,CAAC;AAE1C,WAAO,KAAK,OAAO;AAAA;AAAA,MAEjB,MAAM;AAAA,MACN,KAAK,KAAK;AAAA,IACZ,CAAC;AAAA,EAKH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,gBAAgB,MAAmB;AACjC,UAAM,WAAW,KAAK,gBAAgB,IAAI;AAE1C,UAAM,WAAW,KAAK;AAAA,MACpB,KAAK;AAAA,MACL,SAAS,CAAC;AAAA,MACV,SAAS,CAAC;AAAA,MACV,SAAS,CAAC;AAAA;AAAA,MAEV;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AAAA,EAEA,MAAM,sBAAsB,MAA4B;AACtD,UAAM,WAAW,KAAK,gBAAgB,IAAI;AAE1C,UAAM,IAAI,MAAM,KAAK,QAAQ,QAAQ,GAAG,EAAE,WAAW,KAAK,CAAC;AAE3D,WAAO;AAAA,EACT;AACF;",
-  "names": []
-}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,EAAE,MAAM,IAAI,CAAC;AACpB,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AACzD,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,SAAS,MAAM,6BAA6B,CAAC;AACpD,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC5C,MAAM,GAAG,GAAG,EAAE,CAAC,QAAQ,CAAC;AAexB,MAAM,SAAS;IACL,UAAU,CAAmC;IAE7C,GAAG,CAA4B;IAC/B,IAAI,CAA6B;IACjC,IAAI,CAA6B;IACjC,gBAAgB,CAAyC;IAEzD,WAAW,GAA0C,IAAI,CAAC;IAE1D,UAAU,GAAc,IAAI,SAAS,EAAE,CAAC;IACxC,iBAAiB,GAAc,IAAI,SAAS,EAAE,CAAC;IAEvD,YACE,EAAE,SAAS,EAAE,mBAAmB,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,eAAe,EAC1C;QAErB,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;QAC5B,IAAI,CAAC,GAAG,GAAG,EAAE,CAAC;QACd,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC;QAChB,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC;QAChB,IAAI,CAAC,gBAAgB,GAAG,eAAe;YACrC,QAAQ,CAAC,cAAc,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC;QAEvC,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC;YAChC,aAAa;QACf,CAAC;aAAM,IAAI,mBAAmB,EAAE,CAAC;YAC/B,EAAE,CAAC,SAAS,CAAC,SAAS,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QAC/C,CAAC;aAAM,CAAC;YACN,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;QACnE,CAAC;QAED,kBAAkB;QAClB,IAAI,CAAC,OAAO,EAAE,CAAC;QAEf,IAAI,CAAC,WAAW,GAAG,WAAW,CAC5B,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,EACvB,IAAI,CAAC,gBAAgB,CACtB,CAAC;QAEF,IAAI,CAAC,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;QAChE,IAAI,CAAC,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;IAClE,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,OAAO;QACX,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,EAAE,CAAC;YACvC,MAAM,QAAQ,CAAC,IAAI,CAAC,UAAU,EAAE;gBAC9B,SAAS,EAAE,IAAI,CAAC,IAAI;gBACpB,OAAO,EAAE,IAAI;gBACb,sBAAsB,EAAE,IAAI;aAC7B,CAAC,CAAC;QACL,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,iBAAiB,CAAC,OAAO,EAAE,CAAC;QACnC,CAAC;IACH,CAAC;IAED;;;;;;;;;OASG;IACH,KAAK,CAAC,OAAO,CAAC,IAAO;QACnB,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;QAElD,IAAI,CAAC;YACH,MAAM,OAAO,CAAC,GAAG,CAAC;gBAChB,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,QAAQ,CAAC;gBACjC,IAAI,CAAC,iBAAiB,CAAC,IAAI,EAAE,EAAE,mCAAmC;aACnE,CAAC,CAAC;YAEH,IAAI,MAAM,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;gBAC/B,kBAAkB;gBAClB,KAAK,CAAC,QAAQ,CAAC,CAAC;YAClB,CAAC;iBAAM,CAAC;gBACN,MAAM,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;gBAC7D,MAAM,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;YACvC,CAAC;QACH,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QACpC,CAAC;QAED,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,KAAK,CAAC,GAAG,CAAC,IAAO;QACf,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;QAClD,OAAO,MAAM,UAAU,CAAC,QAAQ,CAAC,CAAC;IACpC,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,MAAM,CAAC,IAAO;QAClB,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;QAElD,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;YAExC,IAAI,MAAM,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;gBAC/B,MAAM,MAAM,CAAC,QAAQ,CAAC,CAAC;gBACvB,OAAO,IAAI,CAAC;YACd,CAAC;iBAAM,CAAC;gBACN,OAAO,KAAK,CAAC;YACf,CAAC;QACH,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QACpC,CAAC;IACH,CAAC;IAED;;OAEG;IACH,OAAO;QACL,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;YACrB,aAAa,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YAChC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;QAC1B,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACK,KAAK,CAAC,eAAe,CAAC,IAAO;QACnC,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;QAE5C,OAAO,IAAI,CAAC,MAAM,CAAC;YACjB,IAAI,EAAE,QAAQ;YACd,GAAG,EAAE,MAAM,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;SAC3B,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,eAAe,CAAC,IAAO;QAC3B,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;QAElD,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAC3B,IAAI,CAAC,UAAU,EACf,QAAQ,CAAC,CAAC,CAAC,EACX,QAAQ,CAAC,CAAC,CAAC,EACX,QAAQ,CAAC,CAAC,CAAC;QACX,eAAe;QACf,QAAQ,CACT,CAAC;QAEF,OAAO,QAAQ,CAAC;IAClB,CAAC;CASF;AAED,OAAO,EAAsB,SAAS,EAAiB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chriscdn/file-cache",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "File cache ",
   "repository": "https://github.com/chriscdn/file-cache",
   "author": "Christopher Meyer <chris@schwiiz.org>",
@@ -10,18 +10,17 @@
   "module": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "exports": {
-    "types": "./lib/index.d.ts",
     "default": "./lib/index.js"
   },
   "scripts": {
-    "build": "rimraf ./lib/ && node ./esbuild.mjs && tsc --declaration",
-    "dev": "microbundle watch",
+    "build": "rimraf ./lib/ && tsc",
     "test": "vitest"
   },
   "dependencies": {
     "@chriscdn/duration": "^1.0.3",
     "@chriscdn/find-nuke": "^0.0.4",
-    "@chriscdn/promise-semaphore": "^2.0.11",
+    "@chriscdn/memoize": "^1.0.9",
+    "@chriscdn/promise-semaphore": "^2.0.12",
     "path-exists": "^5.0.0",
     "rimraf": "^6.0.1",
     "sha1": "^1.1.1",
@@ -29,9 +28,9 @@
     "touch": "^3.1.1"
   },
   "devDependencies": {
+    "@tsconfig/node22": "^22.0.1",
     "@types/sha1": "^1.1.5",
     "@types/touch": "^3.1.5",
-    "esbuild": "^0.25.3",
     "typescript": "^5.8.3",
     "vitest": "^3.1.2"
   }

package/src/index.ts

@@ -7,7 +7,7 @@ import touch from "touch";
 import { findNuke } from "@chriscdn/find-nuke";
 import { Duration } from "@chriscdn/duration";
 import { rimraf } from "rimraf";
-
+import { Memoize } from "@chriscdn/memoize";
 const fsp = fs.promises;
 
 type DirectoryPath = string;
@@ -18,15 +18,14 @@ export type FileCacheOptions<T extends Record<string, any>> = {
   cachePath: DirectoryPath;
   autoCreateCachePath?: boolean;
   cb: (filePath: FilePath, context: T, cache: FileCache<T>) => Promise<void>;
-  ext: string;
-  cleanupInterval?: Milliseconds;
+  ext: (context: T) => string | Promise<string>;
   ttl: Milliseconds;
-  // resolveFileName?: (args: T) => FilePath;
+  cleanupInterval?: Milliseconds;
 };
 
 class FileCache<T extends Record<string, any>> {
   private _cachePath: FileCacheOptions<T>["cachePath"];
-  // private _resolveFileName: FileCacheOptions<T>["resolveFileName"];
+
   private _cb: FileCacheOptions<T>["cb"];
   private _ext: FileCacheOptions<T>["ext"];
   private _ttl: FileCacheOptions<T>["ttl"];
@@ -42,26 +41,18 @@ class FileCache<T extends Record<string, any>> {
       FileCacheOptions<T>,
   ) {
     this._cachePath = cachePath;
-    // this._resolveFileName = resolveFileName;
     this._cb = cb;
     this._ext = ext;
     this._ttl = ttl;
     this._cleanupInterval = cleanupInterval ??
       Duration.toMilliseconds({ days: 1 });
 
-    (async () => {
-      if (!(await pathExists(cachePath))) {
-        throw new Error("💥 FileCache error: cachePath does not exist.");
-        // process.exit(1); // or throw new Error() if you want to let it bubble
-      }
-    })();
-
     if ((pathExistsSync(cachePath))) {
+      // we're good
     } else if (autoCreateCachePath) {
       fs.mkdirSync(cachePath, { recursive: true });
     } else {
       throw new Error("💥 FileCache error: cachePath does not exist.");
-      // process.exit(1); // or throw new Error() if you want to let it bubble
     }
 
     // fire and forget
@@ -71,6 +62,9 @@ class FileCache<T extends Record<string, any>> {
       this.cleanup.bind(this),
       this._cleanupInterval,
     );
+
+    this.resolveFileName = Memoize(this.resolveFileName.bind(this));
+    this.resolveFilePath = Memoize(this.resolveFilePath.bind(this));
   }
 
   /**
@@ -101,19 +95,19 @@ class FileCache<T extends Record<string, any>> {
    * @returns The path to the cached or newly created file
    */
   async getFile(args: T): Promise<FilePath> {
-    const filePath = this.resolveFilePath(args);
+    const filePath = await this.resolveFilePath(args);
 
     try {
       await Promise.all([
         this._semaphore.acquire(filePath),
-        this._cleanupSemaphore.wait(),
+        this._cleanupSemaphore.wait(), // wait for any cleanup task to end
       ]);
 
       if (await pathExists(filePath)) {
         // fire and forget
         touch(filePath);
       } else {
-        await fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        await fsp.mkdir(path.dirname(filePath), { recursive: true });
         await this._cb(filePath, args, this);
       }
     } finally {
@@ -124,7 +118,7 @@ class FileCache<T extends Record<string, any>> {
   }
 
   async has(args: T): Promise<boolean> {
-    const filePath = this.resolveFilePath(args);
+    const filePath = await this.resolveFilePath(args);
     return await pathExists(filePath);
   }
 
@@ -135,13 +129,19 @@ class FileCache<T extends Record<string, any>> {
    * @returns True if the file was deleted, false if it didn't exist
    */
   async expire(args: T): Promise<boolean> {
-    const filePath = this.resolveFilePath(args);
+    const filePath = await this.resolveFilePath(args);
 
-    if (await pathExists(filePath)) {
-      await rimraf(filePath);
-      return true;
-    } else {
-      return false;
+    try {
+      await this._semaphore.acquire(filePath);
+
+      if (await pathExists(filePath)) {
+        await rimraf(filePath);
+        return true;
+      } else {
+        return false;
+      }
+    } finally {
+      this._semaphore.release(filePath);
     }
   }
 
@@ -161,18 +161,13 @@ class FileCache<T extends Record<string, any>> {
    * Uses the provided `resolveFileName` function if available, or falls back to
    * generating a hash from the arguments to create a unique file name.
    */
-  private resolveFileName(args: T): string {
+  private async resolveFileName(args: T): Promise<string> {
     const baseName = sha1(JSON.stringify(args));
 
     return path.format({
-      // dir: path.dirname(filePath),
       name: baseName,
-      ext: this._ext,
+      ext: await this._ext(args),
     });
-
-    // return this._resolveFileName
-    //   ? this._resolveFileName(args)
-    //   : `${sha1(JSON.stringify(args, Object.keys(args).sort()))}${this._ext}`;
   }
 
   /**
@@ -181,8 +176,8 @@ class FileCache<T extends Record<string, any>> {
    * @param args The arguments used to resolve the file path
    * @returns The full path to the cached file
    */
-  resolveFilePath(args: T): FilePath {
-    const fileName = this.resolveFileName(args);
+  async resolveFilePath(args: T): Promise<FilePath> {
+    const fileName = await this.resolveFileName(args);
 
     const filePath = path.resolve(
       this._cachePath,
@@ -196,13 +191,13 @@ class FileCache<T extends Record<string, any>> {
     return filePath;
   }
 
-  async resolveCreateFilePath(args: T): Promise<FilePath> {
-    const filePath = this.resolveFilePath(args);
+  // async resolveCreateFilePath(args: T): Promise<FilePath> {
+  //   const filePath = this.resolveFilePath(args);
 
-    await fsp.mkdir(path.dirname(filePath), { recursive: true });
+  //   await fsp.mkdir(path.dirname(filePath), { recursive: true });
 
-    return filePath;
-  }
+  //   return filePath;
+  // }
 }
 
 export { type DirectoryPath, FileCache, type FilePath };

package/tsconfig.json

@@ -1,15 +1,11 @@
 {
+  "extends": "@tsconfig/node22/tsconfig.json",
   "compilerOptions": {
-    "target": "ESNext",
-    "lib": ["ESNext"],
-    "module": "ESNext",
-    "moduleResolution": "node",
-    "strict": true,
     "allowSyntheticDefaultImports": true,
     "outDir": "./lib",
-    "declaration": true, // Generate declaration files
+    "declaration": true,
     "declarationDir": "./lib",
-    "skipLibCheck": true
+    "sourceMap": true
   },
   "include": ["./src/**/*"]
 }

package/esbuild.mjs

@@ -1,19 +0,0 @@
-import { build } from "esbuild";
-
-import pkg from "./package.json" with { type: "json" };
-
-const external = [
-  ...Object.keys(pkg.dependencies || {}),
-  ...Object.keys(pkg.devDependencies || {}),
-];
-
-build({
-  entryPoints: ["./src/index.ts"],
-  bundle: true,
-  platform: "node",
-  format: "esm", // or 'esm' if you prefer
-  outfile: "./lib/index.js",
-  external,
-  minify: false,
-  sourcemap: true,
-}).catch(() => process.exit(1));