Convert to class

3355c682ca1b0e88ede899ee0e4c4e975c9867fd

Cohee <18619528+Cohee1207@users.noreply.github.com>

Parents: df4700914cbe4679f34e77fdb27ac4d833d0516e

server.js+2 -2 Viewed

 import { checkForNewContent } from './src/endpoints/content-manager.js';
 import { init as settingsInit } from './src/endpoints/settings.js';
 import { redirectDeprecatedEndpoints, ServerStartup, setupPrivateEndpoints } from './src/server-startup.js';
-import { verifyCharactersDiskCache } from './src/endpoints/characters.js';
+import { diskCache } from './src/endpoints/characters.js';
 // Unrestrict console logs display limit
 util.inspect.defaultOptions.maxArrayLength = null;

     const directories = await getUserDirectoriesList();
     await checkForNewContent(directories);
     await ensureThumbnailCache();
-    await verifyCharactersDiskCache(directories);
+    await diskCache.verify(directories);
     cleanUploads();
     migrateAccessLog();

src/endpoints/characters.js+42 -31 Viewed

 const useShallowCharacters = !!getConfigValue('performance.lazyLoadCharacters', false, 'boolean');
 const useDiskCache = !!getConfigValue('performance.useDiskCache', true, 'boolean');
-const diskCache = {
+class DiskCache {
-    /**
+    /** @type {string} */
-     * @type {import('node-persist').LocalStorage?}
+    static DIRECTORY = 'characters';
-     * @private
-     */
+    /** @type {number} */
-    _instance: null,
+    static REMOVAL_INTERVAL = 60000;
+    /** @type {import('node-persist').LocalStorage} */
+    #instance;
+    /** @type {NodeJS.Timeout} */
+    #removalInterval;
     /**
-     * @type {NodeJS.Timeout?}
+     * Queue for removal of cache entries.
-     * @private
+     * @type {Set<string>}
      */
-    _removalInterval: null,
+    removalQueue = new Set();
     /**
      * Processes the removal queue.
      * @returns {Promise<void>}
-     * @private
      */
-    _removeCacheEntries: async function() {
+    async #removeCacheEntries() {
         try {
             if (!useDiskCache || this.removalQueue.size === 0) {
                 return;
+            }
-            const keys = await diskCache.instance().then(i => i.keys());
+            const keys = await this.instance().then(i => i.keys());
             for (const item of this.removalQueue) {
                 const key = keys.find(k => k.startsWith(item));
                 if (key) {
-                    await diskCache.instance().then(i => i.removeItem(key));
+                    await this.instance().then(i => i.removeItem(key));
+                }
+            }
             this.removalQueue.clear();
         } catch (error) {
             console.error('Error while removing cache entries:', error);
+        }
-    },
+    };
     /**
      * Gets the disk cache instance.
      * @returns {Promise<import('node-persist').LocalStorage>}
      */
-    instance: async function() {
+    async instance() {
-        if (this._instance) {
+        if (this.#instance) {
-            return this._instance;
+            return this.#instance;
+        }
-        const cacheDir = path.join(globalThis.DATA_ROOT, '_cache', 'characters');
+        const cacheDir = path.join(globalThis.DATA_ROOT, '_cache', DiskCache.DIRECTORY);
-        this._instance = storage.create({ dir: cacheDir, ttl: false });
+        this.#instance = storage.create({ dir: cacheDir, ttl: false });
-        await this._instance.init();
+        await this.#instance.init();
-        this._removalInterval = setInterval(this._removeCacheEntries.bind(this), 60000);
+        this.#removalInterval = setInterval(this.#removeCacheEntries.bind(this), DiskCache.REMOVAL_INTERVAL);
-        return this._instance;
+        return this.#instance;
-    },
+    }
-    /**
-     * Queue for removal of cache entries.
-     * @type {Set<string>}
-     */
-    removalQueue: new Set(),
-};
     /**
      * Verifies disk cache size and prunes it if necessary.
      * @param {import('../users.js').UserDirectoryList[]} directoriesList List of user directories
      * @returns {Promise<void>}
      */
-export async function verifyCharactersDiskCache(directoriesList) {
+    async verify(directoriesList) {
         if (!useDiskCache) {
             return;
+        }
-    const cache = await diskCache.instance();
+        const cache = await this.instance();
         const validKeys = [];
         for (const dir of directoriesList) {
             const files = fs.readdirSync(dir.characters);

+        }
+    }
+    dispose() {
+        if (this.#removalInterval) {
+            clearInterval(this.#removalInterval);
+        }
+    }
+}
+export const diskCache = new DiskCache();
 /**
  * Reads the character card from the specified image file.
  * @param {string} inputFile - Path to the image file