@xiboplayer/cache 0.3.5 → 0.3.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xiboplayer/cache",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "description": "Offline caching and download management with parallel chunk downloads",
   "type": "module",
   "main": "./src/index.js",
@@ -12,7 +12,7 @@
   },
   "dependencies": {
     "spark-md5": "^3.0.2",
-    "@xiboplayer/utils": "0.3.5"
+    "@xiboplayer/utils": "0.3.7"
   },
   "devDependencies": {
     "vitest": "^2.0.0",

package/src/cache-analyzer.js

@@ -4,6 +4,9 @@
  * Compares cached files against RequiredFiles from the CMS to identify
  * orphaned media that is no longer needed. Logs a summary every collection
  * cycle. Only evicts when storage pressure exceeds a configurable threshold.
+ *
+ * Works entirely through CacheProxy (postMessage to SW) — no IndexedDB,
+ * no direct Cache API access.
  */
 
 import { createLogger } from '@xiboplayer/utils';
@@ -24,7 +27,7 @@ function formatBytes(bytes) {
 
 export class CacheAnalyzer {
   /**
-   * @param {import('./cache.js').CacheManager} cache - CacheManager instance
+   * @param {import('./cache-proxy.js').CacheProxy} cache - CacheProxy instance
    * @param {object} [options]
    * @param {number} [options.threshold=80] - Storage usage % above which eviction triggers
    */
@@ -130,59 +133,43 @@ export class CacheAnalyzer {
 
   /**
    * Evict orphaned files (oldest first) until targetBytes are freed.
-   *
-   * Deletes from both IndexedDB metadata and Cache API.
+   * Delegates deletion to CacheProxy.deleteFiles() which routes to SW.
    *
    * @param {Array} orphanedFiles - Files to evict, sorted oldest-first
    * @param {number} targetBytes - Bytes to free
    * @returns {Promise<Array>} Evicted file records
    */
   async _evict(orphanedFiles, targetBytes) {
-    const evicted = [];
-    let freedBytes = 0;
+    const toEvict = [];
+    let plannedBytes = 0;
 
     for (const file of orphanedFiles) {
-      if (freedBytes >= targetBytes) break;
-
-      try {
-        // Delete from IndexedDB metadata
-        await this._deleteFileMetadata(file.id);
-
-        // Delete from Cache API
-        const cacheKey = this.cache.getCacheKey(file.type, file.id);
-        if (this.cache.cache) {
-          await this.cache.cache.delete(cacheKey);
-        }
-
-        freedBytes += file.size || 0;
-        evicted.push({
-          id: file.id,
-          type: file.type,
-          size: file.size || 0,
-          cachedAt: file.cachedAt || 0,
-        });
-
-        log.info(`  Evicted: ${file.type}/${file.id} (${formatBytes(file.size || 0)})`);
-      } catch (err) {
-        log.warn(`  Failed to evict ${file.type}/${file.id}:`, err.message);
-      }
+      if (plannedBytes >= targetBytes) break;
+      toEvict.push(file);
+      plannedBytes += file.size || 0;
     }
 
-    log.info(`Evicted ${evicted.length} files, freed ${formatBytes(freedBytes)}`);
-    return evicted;
-  }
+    if (toEvict.length === 0) return [];
 
-  /**
-   * Delete a file record from IndexedDB.
-   */
-  async _deleteFileMetadata(id) {
-    return new Promise((resolve, reject) => {
-      const tx = this.cache.db.transaction('files', 'readwrite');
-      const store = tx.objectStore('files');
-      const request = store.delete(id);
-      request.onsuccess = () => resolve();
-      request.onerror = () => reject(request.error);
-    });
+    try {
+      const filesToDelete = toEvict.map(f => ({ type: f.type, id: f.id }));
+      await this.cache.deleteFiles(filesToDelete);
+
+      for (const f of toEvict) {
+        log.info(`  Evicted: ${f.type}/${f.id} (${formatBytes(f.size || 0)})`);
+      }
+      log.info(`Evicted ${toEvict.length} files, freed ${formatBytes(plannedBytes)}`);
+    } catch (err) {
+      log.warn('Eviction failed:', err.message);
+      return [];
+    }
+
+    return toEvict.map(f => ({
+      id: f.id,
+      type: f.type,
+      size: f.size || 0,
+      cachedAt: f.cachedAt || 0,
+    }));
   }
 }
 

package/src/cache-analyzer.test.js

@@ -2,6 +2,7 @@
  * CacheAnalyzer Tests
  *
  * Tests for stale media detection, storage health reporting, and eviction logic.
+ * Mock follows the CacheProxy interface (getAllFiles, deleteFiles).
  */
 
 import { describe, it, expect, beforeEach, vi } from 'vitest';
@@ -12,17 +13,15 @@ describe('CacheAnalyzer', () => {
   let mockCache;
 
   beforeEach(() => {
-    // Mock CacheManager with in-memory file store
+    // Mock CacheProxy with in-memory file store
     const files = new Map();
-    const cacheStore = new Map();
 
     mockCache = {
-      db: null, // Will be set up per-test if eviction is tested
-      cache: {
-        delete: vi.fn(async (key) => cacheStore.delete(key)),
-      },
       getAllFiles: vi.fn(async () => [...files.values()]),
-      getCacheKey: vi.fn((type, id) => `/player/pwa/cache/${type}/${id}`),
+      deleteFiles: vi.fn(async (filesToDelete) => ({
+        deleted: filesToDelete.length,
+        total: filesToDelete.length,
+      })),
       // Helper to add test files
       _files: files,
       _addFile(record) {
@@ -184,25 +183,6 @@ describe('CacheAnalyzer', () => {
   });
 
   describe('eviction', () => {
-    let deletedIds;
-
-    beforeEach(() => {
-      deletedIds = [];
-
-      // Mock IndexedDB transaction for metadata deletion
-      const mockStore = {
-        delete: vi.fn((id) => {
-          deletedIds.push(id);
-          return { set onsuccess(fn) { fn(); }, set onerror(_) {} };
-        }),
-      };
-      mockCache.db = {
-        transaction: vi.fn(() => ({
-          objectStore: vi.fn(() => mockStore),
-        })),
-      };
-    });
-
     it('should evict orphaned files when storage exceeds threshold', async () => {
       mockCache._addFile({ id: 'old', type: 'media', size: 500, cachedAt: 1000 });
       mockCache._addFile({ id: 'newer', type: 'media', size: 300, cachedAt: 2000 });
@@ -220,9 +200,8 @@ describe('CacheAnalyzer', () => {
       expect(report.evicted.length).toBeGreaterThan(0);
       // Should evict oldest first
       expect(report.evicted[0].id).toBe('old');
-      expect(deletedIds).toContain('old');
-      // Cache API delete should also be called
-      expect(mockCache.cache.delete).toHaveBeenCalled();
+      // deleteFiles should be called on the cache proxy
+      expect(mockCache.deleteFiles).toHaveBeenCalled();
 
       vi.unstubAllGlobals();
     });

package/src/cache-proxy.js

@@ -416,6 +416,32 @@ export class CacheProxy extends EventEmitter {
     return this.backendType === 'service-worker';
   }
 
+  /**
+   * Get all cached files from Service Worker
+   * @returns {Promise<Array<{id: string, type: string, size: number, cachedAt: number}>>}
+   */
+  async getAllFiles() {
+    if (!this.backend) {
+      throw new Error('CacheProxy not initialized');
+    }
+
+    return new Promise((resolve) => {
+      const channel = new MessageChannel();
+
+      channel.port1.onmessage = (event) => {
+        const { success, files } = event.data;
+        resolve(success ? files : []);
+      };
+
+      navigator.serviceWorker.controller.postMessage(
+        { type: 'GET_ALL_FILES' },
+        [channel.port2]
+      );
+
+      setTimeout(() => resolve([]), 5000);
+    });
+  }
+
   /**
    * Delete files from cache (purge obsolete media)
    * @param {Array<{type: string, id: string}>} files - Files to delete