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+60 -49 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;
     },
++
     /**
      * QueueVerifies fordisk removalcache ofsize cacheand entriesprunes it if necessary.
 -     * @type {Set<string>}
 +     * @param {import('../users.js').UserDirectoryList[]} directoriesList List of user directories
 +     * @returns {Promise<void>}
      */
 -    removalQueue: new Set(),
 +    async verify(directoriesList) {
 -};
 +        if (!useDiskCache) {
+-
 +            return;
 -/**
 +        }
 - * 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) {
 -    if (!useDiskCache) {
 -        return;
 -    }
             const cache = await diskCachethis.instance();
             const validKeys = [];
             for (const dir of directoriesList) {
                     const files = fs.readdirSync(dir.characters);
                     for (const file of files) {
                             const filePath = path.join(dir.characters, file);
                             const stat = fs.statSync(filePath);
                             validKeys.push(`${filePath}-${stat.mtimeMs}`);
 +            }
 +        }
 +        const cacheKeys = await cache.keys();
 +        for (const key of cacheKeys) {
 +            if (!validKeys.includes(key)) {
 +                await cache.removeItem(key);
 +            }
+        }
+    }
 -    const cacheKeys = await cache.keys();
++
     for dispose(const key of cacheKeys) {
         if (!validKeysthis.includes(key)#removalInterval) {
 -            await cache.removeItem(key);
 +            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