refactor: streamline error handling and cache fetching logic for Always Online domains

Author: JamesDAdams

custom-redirect.js

@@ -126,65 +126,38 @@ function hostMatchesAny(host, patterns) {
 }
 
 /**
- * Try to fetch cached version from Cloudflare Cache
+ * Try to fetch cached version from Cloudflare Cache (only called on error)
+ * Uses the native Cloudflare cache that was populated during normal operation
  * @param {Request} request - Incoming request
  * @returns {Promise<Response|null>} Cached response or null
  */
 async function tryFetchAlwaysOnlineCache(request) {
   try {
     console.log('Trying to fetch from Cloudflare cache for:', request.url);
 
-    // Strategy 1: Try to fetch with cache-first approach using cf options
-    try {
-      const cacheFirstResponse = await fetch(request.url, {
-        method: 'GET',
-        cf: {
-          cacheEverything: true,
-          cacheTtl: 86400, // 1 day
-          cacheKey: request.url
-        }
-      });
-
-      // If we get a valid response (even from cache), use it
-      if (cacheFirstResponse && cacheFirstResponse.ok) {
-        const headers = new Headers(cacheFirstResponse.headers);
-        headers.set('X-Served-From-Cache', 'cloudflare-cache-strategy-1');
-        headers.set('X-Worker-Handled', 'true');
-
-        console.log('Cache hit from strategy 1');
-        return new Response(cacheFirstResponse.body, {
-          status: 200,
-          statusText: 'OK',
-          headers: headers
-        });
-      }
-    } catch (fetchErr) {
-      console.log('Strategy 1 failed, trying strategy 2');
-    }
-
-    // Strategy 2: Try to get from Workers Cache API
+    // Try to access Cloudflare's cache directly via Cache API
+    // This will use the cache that Cloudflare populates automatically
     const cache = caches.default;
     const cacheKey = new Request(request.url, {
-      method: 'GET',
-      headers: request.headers
+      method: 'GET'
     });
 
     const cachedResponse = await cache.match(cacheKey);
 
-    if (cachedResponse && cachedResponse.ok) {
+    if (cachedResponse) {
       const headers = new Headers(cachedResponse.headers);
-      headers.set('X-Served-From-Cache', 'cloudflare-cache-strategy-2');
+      headers.set('X-Served-From-Cache', 'cloudflare-always-online');
       headers.set('X-Worker-Handled', 'true');
 
-      console.log('Cache hit from strategy 2');
+      console.log('Cache hit! Serving cached version');
       return new Response(cachedResponse.body, {
         status: 200,
         statusText: 'OK',
         headers: headers
       });
     }
 
-    console.log('No cache found');
+    console.log('No cache found for this URL');
   } catch (err) {
     console.error('Always Online cache fetch failed:', err);
   }

worker.js

@@ -258,32 +258,10 @@ export default {
       return await handleApi(request, url, host, env, state);
     }
 
-    // Check if Always Online is enabled for this domain
-    const alwaysOnlineDomains = env.ALWAYS_ONLINE_DOMAINS || [];
-    const useAlwaysOnline = hostMatchesAny(host, alwaysOnlineDomains);
-
     // Custom error/redirect handling
     let response;
     try {
-      // For Always Online domains, use cache-first strategy with longer TTL
-      if (useAlwaysOnline) {
-        response = await fetch(request, {
-          cf: {
-            cacheEverything: true,
-            cacheTtl: 86400, // 24 hours
-            cacheKey: request.url
-          }
-        });
-
-        // Store successful responses in cache for later use
-        if (response.ok) {
-          const cache = caches.default;
-          const cacheKey = new Request(request.url, { method: 'GET', headers: request.headers });
-          ctx.waitUntil(cache.put(cacheKey, response.clone()));
-        }
-      } else {
-        response = await fetch(request);
-      }
+      response = await fetch(request);
     } catch (err) {
       const redirectResponse = await c_redirect(request, null, err, isMaintenance, env);
       if (redirectResponse) return redirectResponse;