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 { verifyCharactersDiskCachediskCache } 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 verifyCharactersDiskCachediskCache.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 diskCacheclass =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#removeCacheEntries() {
         try {
             if (!useDiskCache || this.removalQueue.size === 0) {
                 return;
+            }
             const keys = await diskCachethis.instance().then(i => i.keys());
             for (const item of this.removalQueue) {
                 const key = keys.find(k => k.startsWith(item));
                 if (key) {
                     await diskCachethis.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 functioninstance() {
         if (this._instance#instance) {
             return this._instance#instance;
+        }
         const cacheDir = path.join(globalThis.DATA_ROOT, '_cache', 'characters'DiskCache.DIRECTORY);
         this._instance#instance = storage.create({ dir: cacheDir, ttl: false });
         await this._instance#instance.init();
         this._removalInterval#removalInterval = setInterval(this._removeCacheEntries#removeCacheEntries.bind(this), 60000DiskCache.REMOVAL_INTERVAL);
         return this._instance#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 verifyCharactersDiskCacheverify(directoriesList) {
         if (!useDiskCache) {
             return;
+        }
             const cache = await diskCachethis.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