@underpostnet/underpost 2.97.5 → 2.98.1

package/src/client/sw/default.sw.js

@@ -6,199 +6,122 @@
  * @namespace PwaServiceWorker
  */
 
-/**
- * Class representing a Progressive Web App (PWA) Service Worker with caching strategies.
- * @class
- * @memberof PwaServiceWorker
- */
-class PwaServiceWorker {
-  /**
-   * Initializes the service worker configuration by reading from self.renderPayload.
-   * If properties are not found, defaults are used.
-   * @constructor
-   * @property {Array<string>} PRE_CACHED_RESOURCES - List of resources to precache.
-   * @property {string} CACHE_NAME - Name of the cache storage.
-   * @property {string} PROXY_PATH - Base path for proxying requests.
-   */
-  constructor() {
-    // Configuration properties equivalent to the original global constants
-    this.PRE_CACHED_RESOURCES = self.renderPayload?.PRE_CACHED_RESOURCES ?? [];
-    this.CACHE_NAME = self.renderPayload?.CACHE_NAME ?? 'app-cache';
-    this.PROXY_PATH = self.renderPayload?.PROXY_PATH ?? '/';
-
-    console.log(`Service Worker Initialized. Cache: ${this.CACHE_NAME}, Proxy: ${this.PROXY_PATH}`);
-  }
-
-  /**
-   * Registers event listeners for the service worker lifecycle and requests.
-   * @method
-   * @memberof PwaServiceWorker
-   */
-  run() {
-    // Bind methods to 'this' (the instance) before attaching to self
-    self.addEventListener('install', this._onInstall.bind(this));
-    self.addEventListener('activate', this._onActivate.bind(this));
-    self.addEventListener('fetch', this._onFetch.bind(this));
-  }
-
-  /**
-   * Handles the 'install' event. Skips waiting and precaches static assets.
-   * @param {ExtendableEvent} event
-   * @memberof PwaServiceWorker
-   */
-  _onInstall(event) {
-    // Activate right away
-    self.skipWaiting();
-
-    event.waitUntil(
-      (async () => {
-        // Open the app's cache using the configured name.
-        const cache = await caches.open(this.CACHE_NAME);
-        // Cache all static resources.
-        try {
-          console.log(`Precaching ${this.PRE_CACHED_RESOURCES.length} resources...`);
-          await cache.addAll(this.PRE_CACHED_RESOURCES);
-        } catch (error) {
-          console.error('Error during precaching resources:', error);
-        }
-      })(),
-    );
-  }
-
-  /**
-   * Handles the 'activate' event. Enables navigation preload and takes control
-   * of uncontrolled clients immediately.
-   * @param {ExtendableEvent} event
-   * @memberof PwaServiceWorker
-   */
-  _onActivate(event) {
-    event.waitUntil(
-      (async () => {
-        // Enable navigation preload if it's supported.
-        if ('navigationPreload' in self.registration) {
-          await self.registration.navigationPreload.enable();
-          console.log('Navigation Preload enabled.');
-        }
-      })(),
-    );
-    // Tell the active service worker to take control of the page immediately.
-    self.clients.claim();
-  }
-
-  /**
-   * Handles the 'fetch' event, implementing the Cache-First strategy with
-   * complex offline and maintenance fallbacks.
-   * @param {FetchEvent} event
-   * @memberof PwaServiceWorker
-   */
-  _onFetch(event) {
-    // Only handle HTTP/HTTPS requests that are not cross-origin (optional, but robust)
-    if (event.request.url.startsWith('http')) {
-      event.respondWith(this._handleFetchRequest(event));
-    }
-  }
-
-  /**
-   * Core logic to handle fetching, caching, and fallbacks.
-   * @param {FetchEvent} event
-   * @returns {Promise<Response>}
-   * @memberof PwaServiceWorker
-   */
-  async _handleFetchRequest(event) {
-    // 1. Try Navigation Preload (if available) or network first
-    try {
-      const preloadResponse = await event.preloadResponse;
-      if (preloadResponse) return preloadResponse;
-
-      // Fall through to network request if no preload response
-      const networkResponse = await fetch(event.request);
-
-      // OPTIONAL: If the network request is successful, cache it for future use (stale-while-revalidate logic)
-      // Omitted for strict equivalence, as original only had complex fallback, not runtime caching.
-
-      return networkResponse;
-    } catch (error) {
-      console.error('Network request failed. Attempting cache/fallback logic.', event.request.url, error);
-
-      // 2. Try to match the request in the cache
+const PRE_CACHED_RESOURCES = self.renderPayload?.PRE_CACHED_RESOURCES ? self.renderPayload.PRE_CACHED_RESOURCES : [];
+const CACHE_NAME = self.renderPayload?.CACHE_NAME ? self.renderPayload.CACHE_NAME : 'app-cache';
+const PROXY_PATH = self.renderPayload?.PROXY_PATH ? self.renderPayload.PROXY_PATH : '/';
+self.addEventListener('install', (event) => {
+  // Activate right away
+  self.skipWaiting();
+
+  event.waitUntil(
+    (async () => {
+      // Open the app's cache.
+      const cache = await caches.open(CACHE_NAME);
+      // Cache all static resources.
       try {
-        const cachedResponse = await caches.match(event.request);
-        if (cachedResponse) {
-          console.log(`Cache hit for: ${event.request.url}`);
-          return cachedResponse;
-        }
-
-        // 3. Try to match a precached resource path (e.g., if requesting /page, match /page/index.html)
-        const path = this.PRE_CACHED_RESOURCES.find((p) => event.request.url.match(p.replaceAll('/index.html', '')));
-
-        if (path) {
-          const cache = await caches.open(this.CACHE_NAME);
-          const preCachedResponse = await cache.match(path);
-          if (preCachedResponse) {
-            console.log(`Matched precached resource for: ${event.request.url} via path: ${path}`);
-            return preCachedResponse;
+        await cache.addAll(PRE_CACHED_RESOURCES);
+      } catch (error) {
+        console.error(error);
+      }
+      // for (const cacheKey of PRE_CACHED_RESOURCES) {
+      //   try {
+      //     await cache.add(cacheKey);
+      //   } catch (error) {
+      //     console.error(error, cacheKey);
+      //   }
+      // }
+    })(),
+  );
+});
+
+self.addEventListener('activate', (event) => {
+  event.waitUntil(
+    (async () => {
+      // Enable navigation preload if it's supported.
+      // See https://developers.google.com/web/updates/2017/02/navigation-preload
+      if ('navigationPreload' in self.registration) {
+        await self.registration.navigationPreload.enable();
+      }
+    })(),
+  );
+  // Tell the active service worker to take control of the page immediately.
+  self.clients.claim();
+});
+
+self.addEventListener('fetch', (event) => {
+  // Cache-First Strategy
+  event.respondWith(
+    (async () => {
+      // First, try to use the navigation preload response if it's supported.
+      try {
+        (async () => {
+          // Get the client.
+          if (event.request.url.match(location.origin)) {
+            const client = await clients.get(event.clientId);
+            if (client)
+              client.postMessage({
+                status: 'loader',
+                path: event.request.url.slice(location.origin.length),
+              });
           }
-        }
-
-        // If neither cache match nor precache path match worked, fall through to complex fallback
-        throw new Error('Cache miss and no precache match.');
-      } catch (cacheError) {
-        console.error('Error in primary cache lookup. Falling back to offline/maintenance pages.', {
-          url: event.request.url,
-          cacheError,
-          onLine: navigator.onLine,
-        });
+        })();
+        const preloadResponse = await event.preloadResponse;
+        if (preloadResponse) return preloadResponse;
+        return await fetch(event.request);
+      } catch (error) {
+        console.error('Fetch failed; returning offline page instead.', event.request.url, error);
+        // Fallback to the offline page.
+        const path = PRE_CACHED_RESOURCES.find((path) => event.request.url.match(path.replaceAll('/index.html', '')));
 
-        // 4. Complex Fallback Logic (Offline or Maintenance)
         try {
-          const cache = await caches.open(this.CACHE_NAME);
-
-          if (!navigator.onLine) {
-            // A. OFFLINE FALLBACK
+          const cachedResponse = await caches.match(event.request);
+          if (cachedResponse) return cachedResponse;
+          const cache = await caches.open(CACHE_NAME);
+          const preCachedResponse = await cache.match(path);
+          if (!preCachedResponse) throw new Error(error.message);
+          return preCachedResponse;
+        } catch (error) {
+          console.error('Error opening cache for pre cached page', {
+            url: event.request.url,
+            error,
+            onLine: navigator.onLine,
+          });
+          try {
+            if (!navigator.onLine) {
+              if (event.request.method.toUpperCase() === 'GET') {
+                const cache = await caches.open(CACHE_NAME);
+                const preCachedResponse = await cache.match(
+                  `${PROXY_PATH === '/' ? '' : PROXY_PATH}/offline/index.html`,
+                );
+                if (!preCachedResponse) throw new Error(error.message);
+                return preCachedResponse;
+              }
+              const response = new Response(JSON.stringify({ status: 'error', message: 'offline test response' }));
+              // response.status = 200;
+              response.headers.set('Content-Type', 'application/json');
+              return response;
+            }
             if (event.request.method.toUpperCase() === 'GET') {
-              const offlinePath = `${this.PROXY_PATH === '/' ? '' : this.PROXY_PATH}/offline/index.html`;
-              const preCachedResponse = await cache.match(offlinePath);
-
-              if (!preCachedResponse) throw new Error(`Offline page not found in cache: ${offlinePath}`);
-
-              console.log('Serving offline HTML page.');
+              const cache = await caches.open(CACHE_NAME);
+              const preCachedResponse = await cache.match(
+                `${PROXY_PATH === '/' ? '' : PROXY_PATH}/maintenance/index.html`,
+              );
+              if (!preCachedResponse) throw new Error(error.message);
               return preCachedResponse;
             }
-
-            // B. OFFLINE API FALLBACK (Non-GET requests)
-            console.log('Serving offline JSON response for non-GET request.');
-            const response = new Response(JSON.stringify({ status: 'error', message: 'offline test response' }));
+            const response = new Response(JSON.stringify({ status: 'error', message: 'server in maintenance' }));
+            // response.status = 200;
+            response.headers.set('Content-Type', 'application/json');
+            return response;
+          } catch (error) {
+            console.error('Error opening cache for offline page', event.request.url, error);
+            const response = new Response(JSON.stringify({ status: 'error', message: error.message }));
+            // response.status = 200;
             response.headers.set('Content-Type', 'application/json');
             return response;
           }
-
-          // C. MAINTENANCE FALLBACK (Online, but network failed - interpreted as maintenance)
-          if (event.request.method.toUpperCase() === 'GET') {
-            const maintenancePath = `${this.PROXY_PATH === '/' ? '' : this.PROXY_PATH}/maintenance/index.html`;
-            const preCachedResponse = await cache.match(maintenancePath);
-
-            if (!preCachedResponse) throw new Error(`Maintenance page not found in cache: ${maintenancePath}`);
-
-            console.log('Serving maintenance HTML page.');
-            return preCachedResponse;
-          }
-
-          // D. MAINTENANCE API FALLBACK (Non-GET requests)
-          console.log('Serving maintenance JSON response for non-GET request.');
-          const response = new Response(JSON.stringify({ status: 'error', message: 'server in maintenance' }));
-          response.headers.set('Content-Type', 'application/json');
-          return response;
-        } catch (finalError) {
-          // 5. Final fail-safe response
-          console.error('Final fail-safe execution failed.', event.request.url, finalError);
-          const response = new Response(JSON.stringify({ status: 'error', message: finalError.message }));
-          response.headers.set('Content-Type', 'application/json');
-          return response;
         }
       }
-    }
-  }
-}
-
-// Instantiate and run the service worker class
-new PwaServiceWorker().run();
+    })(),
+  );
+});

package/src/index.js

@@ -36,42 +36,52 @@ class Underpost {
    * @type {String}
    * @memberof Underpost
    */
-  static version = 'v2.97.5';
+  static version = 'v2.98.1';
   /**
    * Repository cli API
    * @static
    * @type {UnderpostRepository.API}
    * @memberof Underpost
    */
-  static repo = UnderpostRepository.API;
+  static get repo() {
+    return UnderpostRepository.API;
+  }
   /**
    * Root Env cli API
    * @static
    * @type {UnderpostRootEnv.API}
    * @memberof Underpost
    */
-  static env = UnderpostRootEnv.API;
+  static get env() {
+    return UnderpostRootEnv.API;
+  }
   /**
    * Test cli API
    * @static
    * @type {UnderpostTest.API}
    * @memberof Underpost
    */
-  static test = UnderpostTest.API;
+  static get test() {
+    return UnderpostTest.API;
+  }
   /**
    * Underpost Start Up cli API
    * @static
    * @type {UnderpostStartUp.API}
    * @memberof Underpost
    */
-  static start = UnderpostStartUp.API;
+  static get start() {
+    return UnderpostStartUp.API;
+  }
   /**
    * Static cli API
    * @static
    * @type {UnderpostStatic.API}
    * @memberof Underpost
    */
-  static static = UnderpostStatic.API;
+  static get static() {
+    return UnderpostStatic.API;
+  }
 
   /**
    * Cluster cli API
@@ -79,77 +89,99 @@ class Underpost {
    * @type {UnderpostCluster.API}
    * @memberof Underpost
    */
-  static cluster = UnderpostCluster.API;
+  static get cluster() {
+    return UnderpostCluster.API;
+  }
   /**
    * Image cli API
    * @static
    * @type {UnderpostImage.API}
    * @memberof Underpost
    */
-  static image = UnderpostImage.API;
+  static get image() {
+    return UnderpostImage.API;
+  }
   /**
    * Secrets cli API
    * @static
    * @type {UnderpostSecret.API}
    * @memberof Underpost
    */
-  static secret = UnderpostSecret.API;
+  static get secret() {
+    return UnderpostSecret.API;
+  }
   /**
    * Scripts cli API
    * @static
    * @type {UnderpostScript.API}
    * @memberof Underpost
    */
-  static script = UnderpostScript.API;
+  static get script() {
+    return UnderpostScript.API;
+  }
   /**
    * Database cli API
    * @static
    * @type {UnderpostDB.API}
    * @memberof Underpost
    */
-  static db = UnderpostDB.API;
+  static get db() {
+    return UnderpostDB.API;
+  }
   /**
    * Deployment cli API
    * @static
    * @type {UnderpostDeploy.API}
    * @memberof Underpost
    */
-  static deploy = UnderpostDeploy.API;
+  static get deploy() {
+    return UnderpostDeploy.API;
+  }
   /**
    * Cron cli API
    * @static
    * @type {UnderpostCron.API}
    * @memberof Underpost
    */
-  static cron = UnderpostCron.API;
+  static get cron() {
+    return UnderpostCron.API;
+  }
   /**
    * File Storage cli API
    * @static
    * @type {UnderpostFileStorage.API}
    * @memberof Underpost
    */
-  static fs = UnderpostFileStorage.API;
+  static get fs() {
+    return UnderpostFileStorage.API;
+  }
   /**
    * Monitor cli API
    * @static
    * @type {UnderpostMonitor.API}
    * @memberof Underpost
    */
-  static monitor = UnderpostMonitor.API;
+  static get monitor() {
+    return UnderpostMonitor.API;
+  }
   /**
    * SSH cli API
    * @static
    * @type {UnderpostSSH.API}
    * @memberof Underpost
    */
-  static ssh = UnderpostSSH.API;
+  static get ssh() {
+    return UnderpostSSH.API;
+  }
   /**
    * LXD cli API
    * @static
    * @type {UnderpostLxd.API}
    * @memberof Underpost
    */
-  static lxd = UnderpostLxd.API;
+  static get lxd() {
+    return UnderpostLxd.API;
+  }
 
   /**
    * Cloud Init cli API
@@ -157,7 +189,9 @@ class Underpost {
    * @type {UnderpostCloudInit.API}
    * @memberof Underpost
    */
-  static cloudInit = UnderpostCloudInit.API;
+  static get cloudInit() {
+    return UnderpostCloudInit.API;
+  }
 
   /**
    * Run cli API
@@ -165,7 +199,9 @@ class Underpost {
    * @type {UnderpostRun.API}
    * @memberof Underpost
    */
-  static run = UnderpostRun.API;
+  static get run() {
+    return UnderpostRun.API;
+  }
 
   /**
    * Baremetal cli API
@@ -173,7 +209,9 @@ class Underpost {
    * @type {UnderpostBaremetal.API}
    * @memberof Underpost
    */
-  static baremetal = UnderpostBaremetal.API;
+  static get baremetal() {
+    return UnderpostBaremetal.API;
+  }
 }
 
 const up = Underpost;