@xiboplayer/cache 0.5.8 → 0.5.10

package/src/cache-analyzer.js

@@ -5,7 +5,7 @@
  * 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,
+ * Works entirely through StoreClient (REST to proxy) — no IndexedDB,
  * no direct Cache API access.
  */
 
@@ -27,7 +27,7 @@ function formatBytes(bytes) {
 
 export class CacheAnalyzer {
   /**
-   * @param {import('./cache-proxy.js').CacheProxy} cache - CacheProxy instance
+   * @param {import('./store-client.js').StoreClient} cache - StoreClient instance
    * @param {object} [options]
    * @param {number} [options.threshold=80] - Storage usage % above which eviction triggers
    */
@@ -43,7 +43,7 @@ export class CacheAnalyzer {
    * @returns {Promise<object>} Analysis report
    */
   async analyze(requiredFiles) {
-    const cachedFiles = await this.cache.getAllFiles();
+    const cachedFiles = await this.cache.list();
     const storage = await this._getStorageEstimate();
 
     // Build set of required file IDs (as strings for consistent comparison)
@@ -64,6 +64,10 @@ export class CacheAnalyzer {
         } else {
           orphaned.push(file);
         }
+      } else if (file.type === 'static') {
+        // Static files (bundle.min.js, fonts.css, fonts, images) are shared widget
+        // dependencies — never orphan them, they're referenced from widget HTML
+        required.push(file);
       } else {
         orphaned.push(file);
       }
@@ -141,7 +145,7 @@ export class CacheAnalyzer {
 
   /**
    * Evict orphaned files (oldest first) until targetBytes are freed.
-   * Delegates deletion to CacheProxy.deleteFiles() which routes to SW.
+   * Delegates deletion to StoreClient.remove() which routes to proxy.
    *
    * @param {Array} orphanedFiles - Files to evict, sorted oldest-first
    * @param {number} targetBytes - Bytes to free
@@ -161,7 +165,7 @@ export class CacheAnalyzer {
 
     try {
       const filesToDelete = toEvict.map(f => ({ type: f.type, id: f.id }));
-      await this.cache.deleteFiles(filesToDelete);
+      await this.cache.remove(filesToDelete);
 
       for (const f of toEvict) {
         log.info(`  Evicted: ${f.type}/${f.id} (${formatBytes(f.size || 0)})`);

package/src/cache-analyzer.test.js

@@ -2,7 +2,7 @@
  * CacheAnalyzer Tests
  *
  * Tests for stale media detection, storage health reporting, and eviction logic.
- * Mock follows the CacheProxy interface (getAllFiles, deleteFiles).
+ * Mock follows the StoreClient interface (list, remove).
  */
 
 import { describe, it, expect, beforeEach, vi } from 'vitest';
@@ -13,12 +13,12 @@ describe('CacheAnalyzer', () => {
   let mockCache;
 
   beforeEach(() => {
-    // Mock CacheProxy with in-memory file store
+    // Mock StoreClient with in-memory file store
     const files = new Map();
 
     mockCache = {
-      getAllFiles: vi.fn(async () => [...files.values()]),
-      deleteFiles: vi.fn(async (filesToDelete) => ({
+      list: vi.fn(async () => [...files.values()]),
+      remove: vi.fn(async (filesToDelete) => ({
         deleted: filesToDelete.length,
         total: filesToDelete.length,
       })),
@@ -214,8 +214,8 @@ describe('CacheAnalyzer', () => {
       expect(report.evicted.length).toBeGreaterThan(0);
       // Should evict oldest first
       expect(report.evicted[0].id).toBe('old');
-      // deleteFiles should be called on the cache proxy
-      expect(mockCache.deleteFiles).toHaveBeenCalled();
+      // remove should be called on the store client
+      expect(mockCache.remove).toHaveBeenCalled();
 
       vi.unstubAllGlobals();
     });

package/src/cache-proxy.test.js

@@ -1,29 +1,200 @@
 /**
- * CacheProxy Tests
+ * StoreClient & DownloadClient Tests
  *
- * Contract-based testing for CacheProxy and ServiceWorkerBackend
- * Service Worker only architecture - no fallback
+ * StoreClient: pure REST client for ContentStore — no SW dependency
+ * DownloadClient: SW postMessage client for download orchestration
  */
 
 import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { CacheProxy } from './cache-proxy.js';
+import { StoreClient } from './store-client.js';
+import { DownloadClient } from './download-client.js';
 import { createTestBlob } from './test-utils.js';
 
-// The source computes BASE from window.location.pathname.
-// In jsdom the default pathname is '/' which resolves to '/player/pwa'.
-const BASE = '/player/pwa';
+/**
+ * Reset global.fetch between tests
+ */
+function resetMocks() {
+  global.fetch = vi.fn();
+  delete global.MessageChannel;
+}
+
+// ===========================================================================
+// StoreClient Tests
+// ===========================================================================
+
+describe('StoreClient', () => {
+  let store;
+
+  beforeEach(() => {
+    resetMocks();
+    store = new StoreClient();
+  });
+
+  describe('has()', () => {
+    it('should perform HEAD request to /store/:type/:id', async () => {
+      global.fetch = vi.fn((url, options) => {
+        if (url === '/store/media/123' && options?.method === 'HEAD') {
+          return Promise.resolve({ ok: true, status: 200 });
+        }
+        return Promise.resolve({ ok: false, status: 404 });
+      });
+
+      const exists = await store.has('media', '123');
+
+      expect(exists).toBe(true);
+      expect(global.fetch).toHaveBeenCalledWith('/store/media/123', { method: 'HEAD' });
+    });
+
+    it('should return false for 404', async () => {
+      global.fetch = vi.fn(() => Promise.resolve({ ok: false, status: 404 }));
+
+      const exists = await store.has('media', '123');
+
+      expect(exists).toBe(false);
+    });
+
+    it('should return false on fetch error', async () => {
+      global.fetch = vi.fn(() => Promise.reject(new Error('Network error')));
+
+      const exists = await store.has('media', '123');
+
+      expect(exists).toBe(false);
+    });
+  });
+
+  describe('get()', () => {
+    it('should fetch from /store/:type/:id and return blob', async () => {
+      const testBlob = createTestBlob(1024);
+      global.fetch = vi.fn((url) => {
+        if (url === '/store/media/123') {
+          return Promise.resolve({
+            ok: true,
+            status: 200,
+            blob: () => Promise.resolve(testBlob),
+          });
+        }
+        return Promise.resolve({ ok: false, status: 404 });
+      });
+
+      const blob = await store.get('media', '123');
+
+      expect(blob).toBe(testBlob);
+      expect(global.fetch).toHaveBeenCalledWith('/store/media/123');
+    });
+
+    it('should return null for 404', async () => {
+      global.fetch = vi.fn(() => Promise.resolve({ ok: false, status: 404 }));
+
+      const blob = await store.get('media', '123');
+
+      expect(blob).toBeNull();
+    });
+
+    it('should return null on fetch error', async () => {
+      global.fetch = vi.fn(() => Promise.reject(new Error('Network error')));
+
+      const blob = await store.get('media', '123');
+
+      expect(blob).toBeNull();
+    });
+  });
+
+  describe('put()', () => {
+    it('should PUT content to /store/:type/:id', async () => {
+      global.fetch = vi.fn(() => Promise.resolve({ ok: true }));
+
+      const result = await store.put('widget', '1/2/3', '<html>test</html>', 'text/html');
+
+      expect(result).toBe(true);
+      expect(global.fetch).toHaveBeenCalledWith('/store/widget/1/2/3', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'text/html' },
+        body: '<html>test</html>',
+      });
+    });
+
+    it('should use default content type when not specified', async () => {
+      global.fetch = vi.fn(() => Promise.resolve({ ok: true }));
+
+      await store.put('media', '42', new Blob([new Uint8Array(10)]));
+
+      expect(global.fetch).toHaveBeenCalledWith('/store/media/42', expect.objectContaining({
+        headers: { 'Content-Type': 'application/octet-stream' },
+      }));
+    });
+
+    it('should return false on error', async () => {
+      global.fetch = vi.fn(() => Promise.reject(new Error('Network error')));
+
+      const result = await store.put('widget', '1/2/3', 'data');
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('remove()', () => {
+    it('should POST to /store/delete with file list', async () => {
+      global.fetch = vi.fn(() => Promise.resolve({
+        ok: true,
+        json: () => Promise.resolve({ deleted: 2, total: 2 }),
+      }));
+
+      const files = [
+        { type: 'media', id: '1' },
+        { type: 'media', id: '2' },
+      ];
+      const result = await store.remove(files);
+
+      expect(result).toEqual({ deleted: 2, total: 2 });
+      expect(global.fetch).toHaveBeenCalledWith('/store/delete', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ files }),
+      });
+    });
+
+    it('should return zeros on error', async () => {
+      global.fetch = vi.fn(() => Promise.reject(new Error('fail')));
+
+      const result = await store.remove([{ type: 'media', id: '1' }]);
+
+      expect(result).toEqual({ deleted: 0, total: 1 });
+    });
+  });
+
+  describe('list()', () => {
+    it('should GET /store/list and return files', async () => {
+      const mockFiles = [
+        { id: '1', type: 'media', size: 1024 },
+        { id: '2', type: 'layout', size: 512 },
+      ];
+      global.fetch = vi.fn(() => Promise.resolve({
+        ok: true,
+        json: () => Promise.resolve({ files: mockFiles }),
+      }));
+
+      const files = await store.list();
+
+      expect(files).toEqual(mockFiles);
+      expect(global.fetch).toHaveBeenCalledWith('/store/list');
+    });
+
+    it('should return empty array on error', async () => {
+      global.fetch = vi.fn(() => Promise.reject(new Error('fail')));
+
+      const files = await store.list();
+
+      expect(files).toEqual([]);
+    });
+  });
+});
+
+// ===========================================================================
+// DownloadClient Tests
+// ===========================================================================
 
 /**
  * Helper: set up navigator.serviceWorker mock.
- *
- * Options:
- *   supported   – whether 'serviceWorker' exists on navigator (default true)
- *   controller  – the SW controller object (or null)
- *   active      – the active ServiceWorker object (derived from controller if omitted)
- *   installing  – registration.installing value (default null)
- *   waiting     – registration.waiting value (default null)
- *   registration – override the full registration object
- *   swReadyResolves – whether navigator.serviceWorker.ready resolves (default true)
  */
 function setupServiceWorker(opts = {}) {
   const {
@@ -36,8 +207,6 @@ function setupServiceWorker(opts = {}) {
   } = opts;
 
   if (!supported) {
-    // Must delete entirely so that ('serviceWorker' in navigator) is false.
-    // First make the property configurable if it isn't already, then delete.
     Object.defineProperty(navigator, 'serviceWorker', {
       value: undefined,
       configurable: true,
@@ -65,7 +234,7 @@ function setupServiceWorker(opts = {}) {
     controller,
     ready: swReadyResolves
       ? Promise.resolve(registration)
-      : new Promise(() => {}),  // never resolves
+      : new Promise(() => {}),
     getRegistration: vi.fn().mockResolvedValue(registration),
     addEventListener: vi.fn((event, handler) => {
       if (event === 'message') {
@@ -75,9 +244,7 @@ function setupServiceWorker(opts = {}) {
     removeEventListener: vi.fn(),
   };
 
-  // Expose the message listeners so tests can dispatch SW_READY
   swContainer._messageListeners = messageListeners;
-  // Also expose registration for manipulation
   swContainer._registration = registration;
 
   Object.defineProperty(navigator, 'serviceWorker', {
@@ -89,23 +256,13 @@ function setupServiceWorker(opts = {}) {
   return swContainer;
 }
 
-/**
- * Dispatch a simulated message event to all registered SW message listeners
- */
 function dispatchSWMessage(swContainer, data) {
   for (const listener of swContainer._messageListeners || []) {
     listener({ data });
   }
 }
 
-/**
- * Set up a mock MessageChannel (needed by requestDownload / prioritizeDownload).
- * Returns a factory that captures ports so tests can simulate SW responses.
- */
 function setupMessageChannel() {
-  // Each call to new MessageChannel() produces a linked pair.
-  // The implementation sends on port2 (transferred to SW), listens on port1.
-  // We capture the pair so the test can push a response into port1.onmessage.
   const channels = [];
 
   global.MessageChannel = class {
@@ -118,11 +275,9 @@ function setupMessageChannel() {
   };
 
   return {
-    /** The most recently created channel */
     get lastChannel() {
       return channels[channels.length - 1];
     },
-    /** Simulate SW replying through the channel */
     respondOnLastChannel(data) {
       const ch = channels[channels.length - 1];
       if (ch && ch.port1.onmessage) {
@@ -133,259 +288,106 @@ function setupMessageChannel() {
   };
 }
 
-/**
- * Reset navigator.serviceWorker and global.fetch between tests
- */
-function resetMocks() {
-  // Restore a bare serviceWorker so the next setupServiceWorker can override it
-  Object.defineProperty(navigator, 'serviceWorker', {
-    value: undefined,
-    configurable: true,
-    writable: true,
-  });
-  global.fetch = vi.fn();
-  delete global.MessageChannel;
-}
-
-// ---------------------------------------------------------------------------
-// Helper to create a fully initialised CacheProxy for the common "happy path"
-// where SW is active and ready.  Sends SW_READY so the fetchReadyPromise inside
-// ServiceWorkerBackend resolves, allowing getFile / hasFile / isCached to work.
-// ---------------------------------------------------------------------------
-async function createInitialisedProxy() {
+async function createInitialisedDownloadClient() {
   const controller = { postMessage: vi.fn() };
   const sw = setupServiceWorker({ controller });
 
-  const proxy = new CacheProxy();
-  const initPromise = proxy.init();
+  const client = new DownloadClient();
+  const initPromise = client.init();
 
-  // The backend's init() sets up a message listener then posts PING.
-  // We need to simulate the SW_READY response.
-  // Give init a microtask to register the listener, then fire SW_READY.
-  await Promise.resolve(); // let init() progress
+  await Promise.resolve();
   dispatchSWMessage(sw, { type: 'SW_READY' });
 
   await initPromise;
-  return { proxy, sw, controller };
+  return { client, sw, controller };
 }
 
-// ===========================================================================
-// Tests
-// ===========================================================================
-
-describe('CacheProxy', () => {
+describe('DownloadClient', () => {
   beforeEach(() => {
     resetMocks();
-  });
-
-  describe('Service Worker Requirement', () => {
-    it('should require Service Worker to be available', async () => {
-      setupServiceWorker({ supported: false });
-
-      const proxy = new CacheProxy();
-
-      await expect(proxy.init()).rejects.toThrow('Service Worker not supported');
-    });
-
-    it('should wait for Service Worker to be ready and controlling', async () => {
-      const { proxy } = await createInitialisedProxy();
-
-      expect(proxy.backendType).toBe('service-worker');
-      expect(proxy.backend).toBeTruthy();
-    });
-
-    it('should throw if Service Worker not controlling after ready', async () => {
-      // Provide a registration with no active SW and no controller.
-      // The slow path waits for ready, then ServiceWorkerBackend.init() will
-      // call getRegistration() which returns { active: null }, so it falls
-      // through to the ready path where controller is null -> throws.
-      const sw = setupServiceWorker({
-        controller: null,
-        active: null,
-      });
-
-      const proxy = new CacheProxy();
-
-      await expect(proxy.init()).rejects.toThrow('Service Worker not controlling page');
-    });
-  });
-
-  describe('Pre-condition: initialization required', () => {
-    it('should throw if getFile() called before init()', async () => {
-      const proxy = new CacheProxy();
-
-      await expect(proxy.getFile('media', '123')).rejects.toThrow('CacheProxy not initialized');
-    });
-
-    it('should throw if requestDownload() called before init()', async () => {
-      const proxy = new CacheProxy();
-
-      await expect(proxy.requestDownload([])).rejects.toThrow('CacheProxy not initialized');
-    });
-
-    it('should throw if isCached() called before init()', async () => {
-      const proxy = new CacheProxy();
-
-      await expect(proxy.isCached('media', '123')).rejects.toThrow('CacheProxy not initialized');
+    Object.defineProperty(navigator, 'serviceWorker', {
+      value: undefined,
+      configurable: true,
+      writable: true,
     });
   });
-});
-
-describe('ServiceWorkerBackend', () => {
-  beforeEach(() => {
-    resetMocks();
-    setupMessageChannel();
-  });
 
   describe('init()', () => {
     it('should initialize with SW controller', async () => {
-      const { proxy } = await createInitialisedProxy();
+      setupMessageChannel();
+      const { client } = await createInitialisedDownloadClient();
 
-      expect(proxy.backendType).toBe('service-worker');
+      expect(client.controller).toBeTruthy();
     });
 
     it('should throw if SW not supported', async () => {
       setupServiceWorker({ supported: false });
 
-      const proxy = new CacheProxy();
-
-      await expect(proxy.init()).rejects.toThrow('Service Worker not supported');
-    });
-
-    it('should throw if SW not controlling page', async () => {
-      setupServiceWorker({ controller: null, active: null });
+      const client = new DownloadClient();
 
-      const proxy = new CacheProxy();
-
-      await expect(proxy.init()).rejects.toThrow('Service Worker not controlling page');
+      await expect(client.init()).rejects.toThrow('Service Worker not supported');
     });
   });
 
-  describe('getFile()', () => {
-    it('should fetch from cache URL with correct BASE path', async () => {
-      const { proxy } = await createInitialisedProxy();
-
-      const testBlob = createTestBlob(1024);
-      global.fetch = vi.fn((url) => {
-        if (url === `${BASE}/cache/media/123`) {
-          return Promise.resolve({
-            ok: true,
-            status: 200,
-            blob: () => Promise.resolve(testBlob),
-          });
-        }
-        return Promise.resolve({ ok: false, status: 404 });
-      });
-
-      const blob = await proxy.getFile('media', '123');
-
-      expect(blob).toBe(testBlob);
-      expect(global.fetch).toHaveBeenCalledWith(`${BASE}/cache/media/123`);
-    });
-
-    it('should return null for 404', async () => {
-      const { proxy } = await createInitialisedProxy();
-
-      global.fetch = vi.fn(() => Promise.resolve({ ok: false, status: 404 }));
-
-      const blob = await proxy.getFile('media', '123');
-
-      expect(blob).toBeNull();
-    });
-
-    it('should return null on fetch error', async () => {
-      const { proxy } = await createInitialisedProxy();
-
-      global.fetch = vi.fn(() => Promise.reject(new Error('Network error')));
-
-      const blob = await proxy.getFile('media', '123');
-
-      expect(blob).toBeNull();
-    });
-  });
-
-  describe('requestDownload()', () => {
+  describe('download()', () => {
     it('should post DOWNLOAD_FILES message to SW', async () => {
-      const { proxy } = await createInitialisedProxy();
+      setupMessageChannel();
+      const { client } = await createInitialisedDownloadClient();
+
+      client.controller.postMessage = vi.fn();
 
       const files = [
-        { id: '1', type: 'media', path: 'http://test.com/file1.mp4', md5: 'abc123' },
-        { id: '2', type: 'media', path: 'http://test.com/file2.mp4', md5: 'def456' },
+        { id: '1', type: 'media', path: 'http://test.com/file1.mp4' },
+        { id: '2', type: 'media', path: 'http://test.com/file2.mp4' },
       ];
 
-      // Mock the backend method to verify call signature
-      proxy.backend.requestDownload = vi.fn().mockResolvedValue();
+      const mc = setupMessageChannel();
+      const downloadPromise = client.download(files);
 
-      await proxy.requestDownload(files);
-
-      expect(proxy.backend.requestDownload).toHaveBeenCalledWith(files);
-    });
-
-    it('should resolve when SW acknowledges', async () => {
-      const { proxy } = await createInitialisedProxy();
-
-      proxy.backend.requestDownload = vi.fn().mockResolvedValue();
-
-      const files = [{ id: '1', type: 'media', path: 'http://test.com/file.mp4' }];
+      // Simulate SW acknowledging the download
+      mc.respondOnLastChannel({
+        success: true,
+        enqueuedCount: 2,
+        activeCount: 2,
+        queuedCount: 0,
+      });
 
-      await expect(proxy.requestDownload(files)).resolves.toBeUndefined();
+      await expect(downloadPromise).resolves.toBeUndefined();
     });
 
     it('should reject when SW returns error', async () => {
-      const { proxy } = await createInitialisedProxy();
+      setupMessageChannel();
+      const { client } = await createInitialisedDownloadClient();
+
+      client.controller.postMessage = vi.fn();
 
-      proxy.backend.requestDownload = vi.fn().mockRejectedValue(new Error('Download failed'));
+      const mc = setupMessageChannel();
+      const downloadPromise = client.download([]);
 
-      const files = [{ id: '1', type: 'media', path: 'http://test.com/file.mp4' }];
+      mc.respondOnLastChannel({ success: false, error: 'Download failed' });
 
-      await expect(proxy.requestDownload(files)).rejects.toThrow('Download failed');
+      await expect(downloadPromise).rejects.toThrow('Download failed');
     });
 
     it('should throw if SW controller not available', async () => {
-      const { proxy } = await createInitialisedProxy();
+      setupMessageChannel();
+      const { client } = await createInitialisedDownloadClient();
 
-      // Simulate controller becoming null after init
-      proxy.backend.controller = null;
+      client.controller = null;
 
-      await expect(proxy.requestDownload([])).rejects.toThrow('Service Worker not available');
+      await expect(client.download([])).rejects.toThrow('Service Worker not available');
     });
   });
 
-  describe('isCached()', () => {
-    it('should perform HEAD request to check if cached', async () => {
-      const { proxy } = await createInitialisedProxy();
-
-      global.fetch = vi.fn((url, options) => {
-        if (url === `${BASE}/cache/media/123` && options?.method === 'HEAD') {
-          return Promise.resolve({ ok: true, status: 200 });
-        }
-        return Promise.resolve({ ok: false, status: 404 });
-      });
-
-      const cached = await proxy.isCached('media', '123');
-
-      expect(cached).toBe(true);
-      expect(global.fetch).toHaveBeenCalledWith(`${BASE}/cache/media/123`, { method: 'HEAD' });
-    });
-
-    it('should return false for 404', async () => {
-      const { proxy } = await createInitialisedProxy();
-
-      global.fetch = vi.fn(() => Promise.resolve({ ok: false, status: 404 }));
-
-      const cached = await proxy.isCached('media', '123');
-
-      expect(cached).toBe(false);
-    });
-
-    it('should return false on fetch error', async () => {
-      const { proxy } = await createInitialisedProxy();
-
-      global.fetch = vi.fn(() => Promise.reject(new Error('Network error')));
+  describe('getProgress()', () => {
+    it('should return empty object when controller is null', async () => {
+      setupMessageChannel();
+      const { client } = await createInitialisedDownloadClient();
+      client.controller = null;
 
-      const cached = await proxy.isCached('media', '123');
+      const progress = await client.getProgress();
 
-      expect(cached).toBe(false);
+      expect(progress).toEqual({});
     });
   });
 });