sw fix

frontend/public/sw.js

@@ -1,140 +1,103 @@
-const CACHE_NAME = 'promptaid-vision-v1';
-const STATIC_CACHE = 'static-v1';
-const DYNAMIC_CACHE = 'dynamic-v1';
+const STATIC_CACHE = 'static-v2';
+const DYNAMIC_CACHE = 'dynamic-v2';
 
-// Files to cache immediately - will be populated dynamically
-const STATIC_FILES = [
-  '/',
-  '/index.html',
-  '/vite.svg'
-];
+// Precache minimal shell (optional — you can skip if serving hashed assets)
+const PRECACHE = ['/', '/index.html', '/vite.svg'];
+
+const isHttpGet = (req) => {
+  try {
+    if (req.method !== 'GET') return false;
+    const u = new URL(req.url);
+    return u.protocol === 'http:' || u.protocol === 'https:';
+  } catch {
+    return false;
+  }
+};
 
-// Install event - cache static files
 self.addEventListener('install', (event) => {
   event.waitUntil(
-    caches.open(STATIC_CACHE).then((cache) => {
-      return cache.addAll(STATIC_FILES);
-    })
+    caches.open(STATIC_CACHE).then((cache) => cache.addAll(PRECACHE))
   );
   self.skipWaiting();
 });
 
-// Activate event - clean up old caches
 self.addEventListener('activate', (event) => {
   event.waitUntil(
-    caches.keys().then((cacheNames) => {
-      return Promise.all(
-        cacheNames.map((cacheName) => {
-          if (cacheName !== STATIC_CACHE && cacheName !== DYNAMIC_CACHE) {
-            return caches.delete(cacheName);
-          }
+    caches.keys().then((names) =>
+      Promise.all(
+        names.map((n) => {
+          if (n !== STATIC_CACHE && n !== DYNAMIC_CACHE) return caches.delete(n);
         })
-      );
-    })
+      )
+    )
   );
   self.clients.claim();
 });
 
-// Fetch event - serve from cache, fallback to network
+// Core fetch strategy
 self.addEventListener('fetch', (event) => {
   const { request } = event;
+
+  // Ignore non-GET or non-http(s)
+  if (!isHttpGet(request)) return;
+
   const url = new URL(request.url);
 
-  // Skip non-GET requests and non-HTTP(S) requests
-  if (request.method !== 'GET' || (url.protocol !== 'http:' && url.protocol !== 'https:')) {
+  // 1) SPA navigation fallback: serve index.html for client routes
+  if (request.mode === 'navigate') {
+    event.respondWith(
+      fetch(request).catch(() => caches.match('/index.html'))
+    );
     return;
   }
 
-  // Handle API requests - network first, cache fallback
+  // 2) API: Network-first, cache successful responses
   if (url.pathname.startsWith('/api/')) {
     event.respondWith(
       fetch(request)
-        .then((response) => {
-          // Cache successful API responses
-          if (response.ok) {
-            const responseClone = response.clone();
-            caches.open(DYNAMIC_CACHE).then((cache) => {
-              cache.put(request, responseClone);
-            });
+        .then((resp) => {
+          if (resp && resp.ok && isHttpGet(request)) {
+            const copy = resp.clone();
+            caches.open(DYNAMIC_CACHE).then((c) => c.put(request, copy));
           }
-          return response;
-        })
-        .catch(() => {
-          // Fallback to cached response
-          return caches.match(request);
+          return resp;
         })
+        .catch(() => caches.match(request))
     );
     return;
   }
 
-  // Handle static assets - cache first, network fallback
-  if (url.pathname.startsWith('/assets/') || url.pathname.startsWith('/')) {
-    event.respondWith(
-      caches.match(request).then((cachedResponse) => {
-        if (cachedResponse) {
-          // Return cached version immediately
-          return cachedResponse;
-        }
+  // 3) Static assets: Cache-first for script/style/image/font
+  const dest = request.destination;
+  const isAsset =
+    dest === 'script' || dest === 'style' || dest === 'image' || dest === 'font';
 
-        // Fetch from network and cache
-        return fetch(request).then((response) => {
-          if (response.ok) {
-            const responseClone = response.clone();
-            caches.open(STATIC_CACHE).then((cache) => {
-              cache.put(request, responseClone);
-            });
+  if (isAsset) {
+    event.respondWith(
+      caches.match(request).then((hit) => {
+        if (hit) return hit;
+        return fetch(request).then((resp) => {
+          if (resp && resp.ok && isHttpGet(request)) {
+            const copy = resp.clone();
+            caches.open(STATIC_CACHE).then((c) => c.put(request, copy));
           }
-          return response;
+          return resp;
         });
       })
     );
     return;
   }
 
-  // Default strategy - network first
+  // 4) Everything else: network-first with safe cache
   event.respondWith(
     fetch(request)
-      .then((response) => {
-        if (response.ok) {
-          const responseClone = response.clone();
-          caches.open(DYNAMIC_CACHE).then((cache) => {
-            cache.put(request, responseClone);
-          });
+      .then((resp) => {
+        if (resp && resp.ok && isHttpGet(request)) {
+          const copy = resp.clone();
+          caches.open(DYNAMIC_CACHE).then((c) => c.put(request, copy));
         }
-        return response;
+        return resp;
       })
-      .catch(() => {
-        return caches.match(request);
-      })
-  );
-});
-
-// Background sync for offline actions
-self.addEventListener('sync', (event) => {
-  if (event.tag === 'background-sync') {
-    event.waitUntil(doBackgroundSync());
-  }
-});
-
-async function doBackgroundSync() {
-  // Handle any pending offline actions
-  console.log('Background sync triggered');
-}
-
-// Push notifications (if needed later)
-self.addEventListener('push', (event) => {
-  const options = {
-    body: event.data ? event.data.text() : 'New update available',
-    icon: '/vite.svg',
-    badge: '/vite.svg',
-    vibrate: [100, 50, 100],
-    data: {
-      dateOfArrival: Date.now(),
-      primaryKey: 1
-    }
-  };
-
-  event.waitUntil(
-    self.registration.showNotification('PromptAid Vision', options)
+      .catch(() => caches.match(request))
   );
 });