@underpostnet/underpost 2.97.1 → 2.98.0

package/src/client/services/file/file.service.js

@@ -29,24 +29,51 @@ const FileService = {
         }),
     ),
   get: (options = { id: '' }) =>
-    new Promise((resolve, reject) =>
-      fetch(getApiBaseUrl({ id: options.id, endpoint }), {
-        method: 'GET',
-        headers: headersFactory(),
-        credentials: 'include',
-      })
-        .then(async (res) => {
-          return await res.json();
+    new Promise((resolve, reject) => {
+      // Handle blob endpoint - fetch binary data directly
+      if (options.id && options.id.startsWith('blob/')) {
+        const blobId = options.id.substring(5); // Remove 'blob/' prefix
+        fetch(getApiBaseUrl({ id: blobId, endpoint: 'file/blob' }), {
+          method: 'GET',
+          headers: headersFactory(),
+          credentials: 'include',
         })
-        .then((res) => {
-          logger.info(res);
-          return resolve(res);
+          .then(async (res) => {
+            if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+            return await res.blob();
+          })
+          .then((blob) => {
+            logger.info('Blob fetched successfully');
+            return resolve({
+              status: 'success',
+              data: [blob],
+            });
+          })
+          .catch((error) => {
+            logger.error(error);
+            return reject(error);
+          });
+      } else {
+        // Handle regular metadata endpoint - fetch JSON
+        fetch(getApiBaseUrl({ id: options.id, endpoint }), {
+          method: 'GET',
+          headers: headersFactory(),
+          credentials: 'include',
         })
-        .catch((error) => {
-          logger.error(error);
-          return reject(error);
-        }),
-    ),
+          .then(async (res) => {
+            if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+            return await res.json();
+          })
+          .then((res) => {
+            logger.info(res);
+            return resolve(res);
+          })
+          .catch((error) => {
+            logger.error(error);
+            return reject(error);
+          });
+      }
+    }),
   delete: (options = { id: '', body: {} }) =>
     new Promise((resolve, reject) =>
       fetch(getApiBaseUrl({ id: options.id, endpoint }), {

package/src/client/services/user/user.service.js

@@ -1,6 +1,6 @@
 import { Auth } from '../../components/core/Auth.js';
 import { loggerFactory } from '../../components/core/Logger.js';
-import { getApiBaseUrl, headersFactory, payloadFactory } from '../core/core.service.js';
+import { getApiBaseUrl, headersFactory, payloadFactory, buildQueryUrl } from '../core/core.service.js';
 
 const logger = loggerFactory(import.meta);
 
@@ -37,15 +37,19 @@ const UserService = {
           return reject(error);
         }),
     ),
-  get: (options = { id: '', page: 1, limit: 10 }) => {
-    const { id = '', page, limit } = options;
-    const query = new URLSearchParams();
-    if (page) query.set('page', page);
-    if (limit) query.set('limit', limit);
-    const queryString = query.toString();
-    const url = `${getApiBaseUrl({ id, endpoint })}${queryString ? (id.includes('?') ? '&' : '?') + queryString : ''}`;
+  get: (options = {}) => {
+    const { id, page, limit, filterModel, sortModel, sort, asc, order } = options;
+    const url = buildQueryUrl(getApiBaseUrl({ id, endpoint }), {
+      page,
+      limit,
+      filterModel,
+      sortModel,
+      sort,
+      asc,
+      order,
+    });
     return new Promise((resolve, reject) =>
-      fetch(url, {
+      fetch(url.toString(), {
         method: 'GET',
         headers: headersFactory(),
         credentials: 'include',

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/db/DataBaseProvider.js

@@ -20,7 +20,7 @@ class DataBaseProviderService {
   /**
    * Internal storage for database connection instances, keyed by host+path.
    * @type {object.<string, object>}
-   * @private
+   * @method
    */
   #instance = {};
 

package/src/db/mongo/MongooseDB.js

@@ -28,7 +28,7 @@ class MongooseDBService {
    */
   async connect(host, name) {
     const uri = `${host}/${name}`;
-    logger.info('MongooseDB connect', { host, name, uri });
+    // logger.info('MongooseDB connect', { host, name, uri });
     return await mongoose
       .createConnection(uri, {
         serverSelectionTimeoutMS: 5000,

package/src/index.js

@@ -36,7 +36,7 @@ class Underpost {
    * @type {String}
    * @memberof Underpost
    */
-  static version = 'v2.97.1';
+  static version = 'v2.98.0';
   /**
    * Repository cli API
    * @static

package/src/mailer/MailerProvider.js

@@ -41,7 +41,7 @@ class MailerProviderService {
   /**
    * Internal storage for mailer instances (transporters, options, templates), keyed by ID.
    * @type {object.<string, object>}
-   * @private
+   * @method
    */
   #instance = {};
 
@@ -108,14 +108,14 @@ class MailerProviderService {
             P1: {
               en: `Email confirmed! Thanks.
                <br />
-             <span style="font-size: 12px; color: gray"> 
-                If it is not automatically verified, 
+             <span style="font-size: 12px; color: gray">
+                If it is not automatically verified,
                 please allow the image to be seen, thank you.
              </span>
               `,
               es: `Correo electrónico confirmado! Gracias.
               <br />
-              <span style="font-size: 12px; color: gray"> 
+              <span style="font-size: 12px; color: gray">
                Si no se verifica automáticamente, por favor permita que se vea la imagen, gracias.
               </span>
               `,

package/src/runtime/express/Express.js

@@ -180,6 +180,7 @@ class ExpressService {
 
       // Database and Valkey connections
       if (db && apis) await DataBaseProvider.load({ apis, host, path, db });
+
       if (valkey) await createValkeyConnection({ host, path }, valkey);
 
       // Mailer setup
@@ -202,7 +203,7 @@ class ExpressService {
         for (const api of apis) {
           logger.info(`Build api server`, `${host}${apiPath}/${api}`);
           const { ApiRouter } = await import(`../../api/${api}/${api}.router.js`);
-          const router = ApiRouter({ host, path, apiPath, mailer, db, authMiddleware, origins });
+          const router = ApiRouter({ app, host, path, apiPath, mailer, db, authMiddleware, origins });
           app.use(`${apiPath}/${api}`, router);
         }
       }

package/src/runtime/lampp/Lampp.js

@@ -20,7 +20,7 @@ const logger = loggerFactory(import.meta);
  */
 class LamppService {
   /**
-   * @private
+   * @method
    * @type {string | undefined}
    * @description Stores the accumulated Apache virtual host configuration (router definition).
    * @memberof LamppService
@@ -273,7 +273,7 @@ Listen ${port}
   ErrorDocument 504 ${path === '/' ? '' : path}/500.html
 
 </VirtualHost>
-            
+
 `);
 
     return { disabled: false };

package/src/server/auth.js

@@ -221,7 +221,7 @@ const authMiddlewareFactory = (options = { host: '', path: '' }) => {
 
       if (payload.userAgent && payload.userAgent !== req.headers['user-agent']) {
         logger.warn(`UA mismatch for ${payload._id}`);
-        return res.status(401).json({ status: 'error', message: 'unauthorized: user-agent mismatch' });
+        return res.status(401).json({ status: 'error', message: 'unauthorized device' });
       }
 
       // Non-guest verify session exists
@@ -247,7 +247,7 @@ const authMiddlewareFactory = (options = { host: '', path: '' }) => {
         // check session userAgent
         if (session.userAgent !== req.headers['user-agent']) {
           logger.warn(`UA mismatch for ${payload._id}`);
-          return res.status(401).json({ status: 'error', message: 'unauthorized: user-agent mismatch' });
+          return res.status(401).json({ status: 'error', message: 'unauthorized device' });
         }
 
         // compare payload host and path with session host and path
@@ -441,22 +441,19 @@ async function logoutSession(User, req, res) {
  * @param {import('express').Request} req The Express request object.
  * @param {import('express').Response} res The Express response object.
  * @param {import('mongoose').Model} User The Mongoose User model.
- * @param {import('mongoose').Model} File The Mongoose File model.
  * @param {object} [options={}] Additional options.
- * @param {Function} options.getDefaultProfileImageId Function to get the default profile image ID.
  * @param {string} options.host The host name.
  * @param {string} options.path The path name.
  * @returns {Promise<{token: string, user: object}>} The access token and user object.
  * @throws {Error} If password validation fails.
  * @memberof Auth
  */
-async function createUserAndSession(req, res, User, File, options = { host: '', path: '' }) {
+async function createUserAndSession(req, res, User, options = { host: '', path: '' }) {
   const pwdCheck = validatePasswordMiddleware(req);
   if (pwdCheck.status === 'error') throw new Error(pwdCheck.message);
 
   req.body.password = await hashPassword(req.body.password);
   req.body.role = req.body.role === 'guest' ? 'guest' : 'user';
-  req.body.profileImageId = await options.getDefaultProfileImageId(File);
 
   const saved = await new User(req.body).save();
   const user = await User.findOne({ _id: saved._id }).select(UserDto.select.get());