underpost 3.2.8 → 3.2.10

package/src/client/services/default/default.management.js

@@ -675,28 +675,27 @@ class DefaultManagement {
       EventsUI.onClick(`.management-table-btn-clear-filter-${id}`, async () => {
         try {
           const gridApi = AgGrid.grids[gridId];
-          // Clear all filters
-          DefaultManagement.clearIdFilter(id);
-          if (gridApi) {
-            gridApi.setFilterModel({});
-            gridApi.applyColumnState({ defaultState: { sort: null } });
-          }
-          // Clear token state
-          if (DefaultManagement.Tokens[id]) {
-            DefaultManagement.Tokens[id].filterModel = {};
-            DefaultManagement.Tokens[id].sortModel = [];
-          }
-          // Update URL - keep only page and limit
-          const queryParams = getQueryParams();
-          setQueryParams({
-            page: queryParams.page || 1,
-            limit: queryParams.limit || DefaultManagement.Tokens[id]?.limit || 10,
-            filterModel: null,
-            sortModel: null,
-            id: null,
+          await DefaultManagement.runIsolated(id, async () => {
+            // Clear all filters without letting grid/query listeners trigger their own reloads.
+            DefaultManagement.clearIdFilter(id);
+            if (gridApi) {
+              gridApi.setFilterModel({});
+              gridApi.applyColumnState({ defaultState: { sort: null } });
+            }
+            if (DefaultManagement.Tokens[id]) {
+              DefaultManagement.Tokens[id].filterModel = {};
+              DefaultManagement.Tokens[id].sortModel = [];
+            }
+            const queryParams = getQueryParams();
+            setQueryParams({
+              page: queryParams.page || 1,
+              limit: queryParams.limit || DefaultManagement.Tokens[id]?.limit || 10,
+              filterModel: null,
+              sortModel: null,
+              id: null,
+            });
+            await DefaultManagement.loadTable(id, { force: true, reload: true, skipUrlUpdate: true });
           });
-          // Reload table
-          await DefaultManagement.loadTable(id, { force: true, reload: true });
           NotificationManager.Push({
             html: Translate.instance('success-clear-filter') || 'Filters cleared',
             status: 'success',
@@ -729,15 +728,11 @@ class DefaultManagement {
       s(`#ag-pagination-${gridId}`).addEventListener('page-change', async (event) => {
         const token = DefaultManagement.Tokens[id];
         token.page = event.detail.page;
-        // Skip URL update since Pagination component already updated it
-        await DefaultManagement.loadTable(id, { skipUrlUpdate: true });
       });
       s(`#ag-pagination-${gridId}`).addEventListener('limit-change', async (event) => {
         const token = DefaultManagement.Tokens[id];
         token.limit = event.detail.limit;
         token.page = 1; // Reset to first page
-        // Skip URL update since Pagination component already updated it
-        await DefaultManagement.loadTable(id, { skipUrlUpdate: true });
       });
       RouterEvents[id] = async (...args) => {
         const queryParams = getQueryParams();

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

@@ -15,7 +15,14 @@ class SessionMetaDb extends Dexie {
   }
 }
 
-const db = new SessionMetaDb();
+// Lazy singleton — avoids opening IndexedDB at module-load time.
+// Firefox is measurably slower at IDB open than Chromium; deferring the
+// open until first actual read/write eliminates that latency from page startup.
+let _db = null;
+const getDb = () => {
+  if (!_db) _db = new SessionMetaDb();
+  return _db;
+};
 
 class GuestService {
   static setUserToken(value = '') {
@@ -59,7 +66,7 @@ class GuestService {
 
   static async setMeta(key, value) {
     try {
-      await db.meta.put({ key, value, updatedAt: Date.now() });
+      await getDb().meta.put({ key, value, updatedAt: Date.now() });
     } catch (error) {
       logger.warn('session meta write failed', { key, error: error?.message });
     }
@@ -67,7 +74,7 @@ class GuestService {
 
   static async getMeta(key) {
     try {
-      const row = await db.meta.get(key);
+      const row = await getDb().meta.get(key);
       return row ? row.value : null;
     } catch (error) {
       logger.warn('session meta read failed', { key, error: error?.message });

package/src/client/sw/core.sw.js

@@ -8,48 +8,108 @@ import { ExpirationPlugin } from 'workbox-expiration';
 import { BackgroundSyncPlugin } from 'workbox-background-sync';
 
 // ─── Runtime config injected by client-build.js ───────────────────────────────
-const CACHE_PREFIX = self.renderPayload?.CACHE_PREFIX || 'engine-core-v3';
-const PRE_CACHED_RESOURCES = Array.isArray(self.renderPayload?.PRE_CACHED_RESOURCES)
-  ? self.renderPayload.PRE_CACHED_RESOURCES
-  : [];
-const PROXY_PATH = self.renderPayload?.PROXY_PATH || '/';
-const OFFLINE_PATH = self.renderPayload?.OFFLINE_PATH || '/offline';
-const MAINTENANCE_PATH = self.renderPayload?.MAINTENANCE_PATH || '/maintenance';
-const proxyBase = PROXY_PATH === '/' ? '' : PROXY_PATH;
-const normalizeRoutePath = (candidatePath, fallbackPath) => {
-  const routePath = typeof candidatePath === 'string' && candidatePath.length > 0 ? candidatePath : fallbackPath;
-  const withLeadingSlash = routePath.startsWith('/') ? routePath : `/${routePath}`;
-  const withoutTrailingSlash = withLeadingSlash.replace(/\/+$/, '');
-  return withoutTrailingSlash.length > 0 ? withoutTrailingSlash : '/';
+// OFFLINE_URL and MAINTENANCE_URL are absolute (proxy-prefixed) index.html paths
+// resolved at build time from the SSR config's `fallbacks` map.
+const payload = self.renderPayload || {};
+const CACHE_PREFIX = payload.CACHE_PREFIX || 'engine-core';
+const PRE_CACHED_RESOURCES = Array.isArray(payload.PRE_CACHED_RESOURCES) ? payload.PRE_CACHED_RESOURCES : [];
+const OFFLINE_URL = payload.OFFLINE_URL || '/offline/index.html';
+const MAINTENANCE_URL = payload.MAINTENANCE_URL || '/maintenance/index.html';
+
+// Dedicated cache for fallback pages so they're available even if precacheAndRoute
+// fails (e.g. a precache manifest entry returns non-200 during install).
+const FALLBACK_CACHE = `${CACHE_PREFIX}-fallbacks`;
+
+/**
+ * Ultimate inline HTML fallback used ONLY when the network is unavailable and
+ * the custom SSR pages (NoNetworkConnection / Maintenance views from config)
+ * have not yet been cached. Once cached on first successful visit, the custom
+ * pages take over.
+ * @param {'offline'|'maintenance'} kind
+ * @returns {Response}
+ */
+const inlineFallback = (kind) => {
+  const title = kind === 'offline' ? 'Offline' : 'Maintenance';
+  const icon = kind === 'offline' ? '🌐' : '🔧';
+  const msg =
+    kind === 'offline'
+      ? 'You are offline. Please check your internet connection and try again.'
+      : 'The server is under maintenance. We\'ll be back shortly.';
+  const html = `<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1,viewport-fit=cover"><title>${title}</title><style>body{display:flex;flex-direction:column;align-items:center;justify-content:center;min-height:100vh;margin:0;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,sans-serif;background:#f5f5f5;color:#333;padding:1rem;text-align:center}h1{font-size:2rem;margin-bottom:.5rem}p{font-size:1rem;color:#666;max-width:24rem}</style></head><body><h1>${icon} ${title}</h1><p>${msg}</p></body></html>`;
+  return new Response(html, {
+    status: 200,
+    statusText: 'OK',
+    headers: { 'Content-Type': 'text/html; charset=utf-8' },
+  });
 };
-const offlinePath = normalizeRoutePath(OFFLINE_PATH, '/offline');
-const maintenancePath = normalizeRoutePath(MAINTENANCE_PATH, '/maintenance');
-const toRouteIndexUrl = (routePath) => `${proxyBase}${routePath === '/' ? '' : routePath}/index.html`;
-const offlineUrl = toRouteIndexUrl(offlinePath);
-const maintenanceUrl = toRouteIndexUrl(maintenancePath);
-
-// Dedicated cache for fallback pages — populated independently from precacheAndRoute
-// so offline/maintenance pages are always available even if the main precache install fails.
-const FALLBACK_CACHE_NAME = `${CACHE_PREFIX}-fallbacks`;
-
-const getFallbackResponse = async (preferMaintenance) => {
-  const cache = await caches.open(FALLBACK_CACHE_NAME);
-  if (preferMaintenance) {
-    return (
-      (await cache.match(maintenanceUrl)) ||
-      (await matchPrecache(maintenanceUrl)) ||
-      (await cache.match(offlineUrl)) ||
-      (await matchPrecache(offlineUrl)) ||
-      Response.error()
-    );
+
+/**
+ * Returns a Response for the cached fallback page.
+ * Tries (in order):
+ *   1. Dedicated FALLBACK_CACHE (primary & secondary URL)
+ *   2. Workbox precache (primary & secondary URL)
+ *   3. If online, fetches the custom SSR page from the server (caches it for next time)
+ *   4. Ultimate inline HTML string (never a browser error page)
+ *
+ * @param {'offline'|'maintenance'} kind
+ * @returns {Promise<Response>}
+ */
+const getFallback = async (kind) => {
+  const primary = kind === 'maintenance' ? MAINTENANCE_URL : OFFLINE_URL;
+  const secondary = kind === 'maintenance' ? OFFLINE_URL : MAINTENANCE_URL;
+  const cache = await caches.open(FALLBACK_CACHE);
+
+  // ── 1. Try cache (own + precache) ──────────────────────────────────────
+  const cached =
+    (await cache.match(primary)) ||
+    (await matchPrecache(primary)) ||
+    (await cache.match(secondary)) ||
+    (await matchPrecache(secondary));
+  if (cached) return cached;
+
+  // ── 2. If we appear online, try to fetch the custom SSR page from server ─
+  // This handles the case where the install-time caching didn't happen yet
+  // (e.g. first install while server was up, but fallback pages weren't cached).
+  if (typeof navigator === 'undefined' || navigator.onLine !== false) {
+    try {
+      const fetchResp = await fetch(primary, { credentials: 'same-origin' });
+      if (fetchResp.ok) {
+        cache.put(primary, fetchResp.clone()).catch(() => { });
+        return fetchResp;
+      }
+    } catch (_) { }
+    try {
+      const fetchResp = await fetch(secondary, { credentials: 'same-origin' });
+      if (fetchResp.ok) {
+        cache.put(secondary, fetchResp.clone()).catch(() => { });
+        return fetchResp;
+      }
+    } catch (_) { }
+  }
+
+  // ── 3. Ultimate inline fallback ────────────────────────────────────────
+  return inlineFallback(kind);
+};
+
+/**
+ * Background-caches the offline and maintenance SSR pages for future use.
+ * Called after each successful navigation so the custom views are available
+ * the next time the network is unreachable.
+ */
+const cacheFallbackPages = async () => {
+  const cache = await caches.open(FALLBACK_CACHE);
+  for (const url of [OFFLINE_URL, MAINTENANCE_URL]) {
+    try {
+      if (!(await cache.match(url))) {
+        const response = await fetch(url, { credentials: 'same-origin' });
+        if (response.ok) {
+          await cache.put(url, response);
+        }
+      }
+    } catch (_) {
+      // Network unavailable now — will try again on next navigation.
+    }
   }
-  return (
-    (await cache.match(offlineUrl)) ||
-    (await matchPrecache(offlineUrl)) ||
-    (await cache.match(maintenanceUrl)) ||
-    (await matchPrecache(maintenanceUrl)) ||
-    Response.error()
-  );
 };
 
 // ─── Core setup ───────────────────────────────────────────────────────────────
@@ -58,17 +118,10 @@ clientsClaim();
 
 self.addEventListener('install', (event) => {
   self.skipWaiting();
-  // Cache fallback pages in a dedicated cache so they are available even if
-  // precacheAndRoute fails (e.g. some asset in the manifest returns non-200).
-  event.waitUntil(
-    caches.open(FALLBACK_CACHE_NAME).then((cache) =>
-      // Try together first; fall back to individual adds so a single failure
-      // does not prevent the other page from being cached.
-      cache
-        .addAll([offlineUrl, maintenanceUrl])
-        .catch(() => Promise.all([cache.add(offlineUrl).catch(() => {}), cache.add(maintenanceUrl).catch(() => {})])),
-    ),
-  );
+  // Note: install-time caching of fallback pages is unreliable in some browsers.
+  // We rely on the post-navigation eager caching in the navigation handler.
+  // The inline HTML fallback ensures the user never sees a browser error page
+  // before the custom SSR pages are cached.
 });
 
 self.addEventListener('activate', (event) => {
@@ -82,21 +135,17 @@ self.addEventListener('activate', (event) => {
 });
 
 self.addEventListener('message', (event) => {
-  const payload = event.data || {};
-
-  if (payload.status === 'skipWaiting') {
+  const { status } = event.data || {};
+  if (status === 'skipWaiting') {
     self.skipWaiting();
     return;
   }
-
-  if (payload.status === 'workbox-reset') {
+  if (status === 'workbox-reset') {
     event.waitUntil(
       (async () => {
-        const cacheNames = await caches.keys();
-        await Promise.all(cacheNames.map((cacheName) => caches.delete(cacheName)));
-        if (event.ports && event.ports[0]) {
-          event.ports[0].postMessage({ status: 'workbox-reset-done', deleted: cacheNames.length });
-        }
+        const names = await caches.keys();
+        await Promise.all(names.map((name) => caches.delete(name)));
+        event.ports?.[0]?.postMessage({ status: 'workbox-reset-done', deleted: names.length });
       })(),
     );
   }
@@ -115,13 +164,8 @@ registerRoute(
   new StaleWhileRevalidate({
     cacheName: `${CACHE_PREFIX}-assets`,
     plugins: [
-      new CacheableResponsePlugin({
-        statuses: [0, 200],
-      }),
-      new ExpirationPlugin({
-        maxEntries: 350,
-        maxAgeSeconds: 30 * 24 * 60 * 60, // 30 days
-      }),
+      new CacheableResponsePlugin({ statuses: [0, 200] }),
+      new ExpirationPlugin({ maxEntries: 350, maxAgeSeconds: 30 * 24 * 60 * 60 }),
     ],
   }),
 );
@@ -133,13 +177,8 @@ registerRoute(
     cacheName: `${CACHE_PREFIX}-api-get`,
     networkTimeoutSeconds: 5,
     plugins: [
-      new CacheableResponsePlugin({
-        statuses: [0, 200],
-      }),
-      new ExpirationPlugin({
-        maxEntries: 120,
-        maxAgeSeconds: 5 * 60, // 5 minutes
-      }),
+      new CacheableResponsePlugin({ statuses: [0, 200] }),
+      new ExpirationPlugin({ maxEntries: 120, maxAgeSeconds: 5 * 60 }),
     ],
   }),
 );
@@ -148,65 +187,88 @@ registerRoute(
 registerRoute(
   ({ request, url }) => request.method !== 'GET' && url.pathname.includes('/api/'),
   new NetworkOnly({
-    plugins: [
-      new BackgroundSyncPlugin('api-mutation-queue', {
-        maxRetentionTime: 24 * 60, // 24 hours
-      }),
-    ],
+    plugins: [new BackgroundSyncPlugin('api-mutation-queue', { maxRetentionTime: 24 * 60 })],
   }),
 );
 
-// ─── Navigation: NetworkFirst with offline fallback ───────────────────────────
+// ─── Navigation with offline/maintenance dispatcher ─────────────────────────
+//
+// CRITICAL: We use direct fetch() instead of NetworkFirst for navigation so
+// that when the server is unreachable:
+//   - NetworkFirst would silently return a STALE cached real page (status 200)
+//     making it look like the app still works when it doesn't
+//   - fetch() throws on network failure → catch → fallback page
+//   - fetch() returns 5xx → maintenance fallback
+//
+// After each successful fetch, we eagerly cache the custom offline/maintenance
+// SSR pages so they're available when the network goes down.
+//
+// The dispatcher logic:
+//   1. If navigator.onLine === false → offline fallback immediately
+//   2. Try navigation preload — if it succeeds (< 500) use it, else fall through
+//   3. Try direct fetch() — if it succeeds (< 500) cache and return it
+//   4. If fetch returned 5xx → maintenance fallback
+//   5. If fetch threw (network down) → fallback based on connectivity
+// ─────────────────────────────────────────────────────────────────────────────
+
 registerRoute(
   ({ request }) => request.mode === 'navigate',
   async ({ event }) => {
-    const navigationStrategy = new NetworkFirst({
-      cacheName: `${CACHE_PREFIX}-pages`,
-      networkTimeoutSeconds: 4,
-      plugins: [
-        new CacheableResponsePlugin({
-          statuses: [0, 200],
-        }),
-        new ExpirationPlugin({
-          maxEntries: 60,
-          maxAgeSeconds: 12 * 60 * 60, // 12 hours
-        }),
-      ],
-    });
-
-    // Distinguish server-down (online but unreachable) from no-network (offline).
-    // navigator.onLine is false only when the device has no network at all.
-    const isOnline = () => typeof navigator !== 'undefined' && navigator.onLine !== false;
+    // ── 1. Check browser offline state ────────────────────────────────────
+    if (typeof navigator !== 'undefined' && navigator.onLine === false) {
+      return getFallback('offline');
+    }
 
+    // ── 2. Try navigation preload ────────────────────────────────────────
     try {
       const preload = await event.preloadResponse;
-      if (preload) {
-        if (preload.status >= 500) {
-          return getFallbackResponse(true);
-        }
+      if (preload && preload.status < 500) {
+        // Fire-and-forget: eagerly cache fallback pages in the background
+        // after a successful navigation so they're available when offline.
+        cacheFallbackPages().catch(() => { });
         return preload;
       }
+    } catch (_) {
+      // Preload threw — fall through to direct fetch
+    }
+
+    // ── 3. Try direct fetch to the server ─────────────────────────────────
+    try {
+      const response = await fetch(event.request);
+
+      if (response.status >= 500) {
+        return getFallback('maintenance');
+      }
+
+      if (response.ok) {
+        // Cache the successful response for future navigations
+        const cache = await caches.open(`${CACHE_PREFIX}-pages`);
+        cache.put(event.request, response.clone()).catch(() => { });
+
+        // Eagerly cache fallback pages in the background
+        cacheFallbackPages().catch(() => { });
 
-      const networkResponse = await navigationStrategy.handle({ event, request: event.request });
-      if (networkResponse && networkResponse.status >= 500) {
-        return getFallbackResponse(true);
+        return response;
       }
-      return networkResponse;
+
+      return response;
     } catch (_) {
-      // If device reports it has network but the request failed, it means the
-      // server is unreachable/down → show maintenance. True offline → show offline.
-      return getFallbackResponse(isOnline());
+      const reallyOffline =
+        typeof navigator !== 'undefined' && navigator.onLine === false;
+      return getFallback(reallyOffline ? 'offline' : 'maintenance');
     }
   },
 );
 
-// ─── Global catch handler ─────────────────────────────────────────────────────
+// ─── Global catch handler (non-navigation failures) ──────────────────────────
 setCatchHandler(async ({ request }) => {
   if (request.mode === 'navigate') {
-    return getFallbackResponse(typeof navigator !== 'undefined' && navigator.onLine !== false);
+    const reallyOffline =
+      typeof navigator !== 'undefined' && navigator.onLine === false;
+    return getFallback(reallyOffline ? 'offline' : 'maintenance');
   }
   return new Response(JSON.stringify({ status: 'error', message: 'request failed' }), {
     status: 503,
     headers: { 'Content-Type': 'application/json' },
   });
-});
+});

package/src/db/DataBaseProvider.js

@@ -1,5 +1,7 @@
 import { MongooseDB } from './mongo/MongooseDB.js';
 import { loggerFactory } from '../server/logger.js';
+import { getCapVariableName } from '../client/components/core/CommonJs.js';
+import { resolveHostKeyContext } from '../server/conf.js';
 
 /**
  * Module for managing and loading various database connections (e.g., Mongoose, MariaDB).
@@ -22,16 +24,108 @@ class DataBaseProviderService {
    * @type {object.<string, object>}
    * @method
    */
-  #instance = {};
+  static #instance = {};
 
   /**
    * Retrieves the internal instance storage for direct access (used for backward compatibility).
    * @returns {object.<string, object>} The internal connection instance map.
    */
-  get instance() {
+  static get instance() {
     return this.#instance;
   }
 
+
+  /**
+   * Retrieves a loaded provider bucket for a context.
+   * @param {{host?: string, path?: string}|string} [context={ host: '', path: '' }] - Context object or key.
+   * @param {string} [provider='mongoose'] - Provider name.
+   * @returns {{models: object, connection: object, close: Function, dbSignature?: string}} Provider bucket.
+   * @throws {Error} When the provider is not loaded for the context.
+   */
+  static getProvider(context = { host: '', path: '' }, provider = 'mongoose') {
+    const key = resolveHostKeyContext(context);
+    const entry = this.#instance[key]?.[provider];
+
+    if (!entry) throw new Error(`Database provider not loaded for context "${key}" (${provider})`);
+    return entry;
+  }
+
+  /**
+   * Returns the raw DB connection object for a context/provider.
+   * @param {{host?: string, path?: string}|string} [context={ host: '', path: '' }] - Context object or key.
+   * @param {string} [provider='mongoose'] - Provider name.
+   * @returns {object} Provider connection object.
+   */
+  static getConnection(context = { host: '', path: '' }, provider = 'mongoose') {
+    return this.getProvider(context, provider).connection;
+  }
+
+  /**
+   * Resolves a loaded model by name for a given context/provider.
+   * @param {string} modelName - API/model identifier.
+   * @param {{host?: string, path?: string}|string} [context={ host: '', path: '' }] - Context object or key.
+   * @param {string} [provider='mongoose'] - Provider name.
+   * @returns {object} Loaded model instance.
+   * @throws {Error} When the model is not loaded for the context.
+   */
+  static getModel(modelName, context = { host: '', path: '' }, provider = 'mongoose') {
+    const models = this.getProvider(context, provider).models || {};
+    const normalizedModelName = getCapVariableName(modelName);
+
+    // First try direct key (supports callers passing exact model names).
+    let model = models?.[modelName];
+    if (!model) {
+      model = models?.[normalizedModelName];
+    }
+
+    if (!model) {
+      // Final fallback: case-insensitive comparison without separators.
+      const target = String(modelName || '')
+        .replaceAll('-', '')
+        .replaceAll('_', '')
+        .replaceAll(' ', '')
+        .toLowerCase();
+      const resolvedModelName = Object.keys(models).find(
+        (key) => key.replaceAll('_', '').replaceAll(' ', '').toLowerCase() === target,
+      );
+      if (resolvedModelName) model = models[resolvedModelName];
+    }
+
+    if (!model) {
+      throw new Error(`Model not loaded for context "${resolveHostKeyContext(context)}": ${normalizedModelName}`);
+    }
+
+    return model;
+  }
+
+  /**
+   * Builds a minimal dispatcher bound to a specific context/provider.
+   * @param {{host?: string, path?: string}|string} [context={ host: '', path: '' }] - Context object or key.
+   * @param {string} [provider='mongoose'] - Provider name.
+   * @returns {{getConnection: () => object, getModel: (modelName: string) => object}} Bound accessor helpers.
+   */
+  static getDispatcher(context = { host: '', path: '' }, provider = 'mongoose') {
+    return {
+      getConnection: () => this.getConnection(context, provider),
+      getModel: (modelName) => this.getModel(modelName, context, provider),
+    };
+  }
+
+  /**
+   * Builds a stable signature used to detect provider configuration changes.
+   * @param {object} [db={}] - Database configuration object.
+   * @returns {string} Stringified signature for change detection.
+   */
+  static buildDbSignature(db = {}) {
+    return JSON.stringify({
+      authSource: db.authSource || '',
+      host: db.host || '',
+      name: db.name || '',
+      provider: db.provider || '',
+      replicaSet: db.replicaSet || '',
+    });
+  }
+
   /**
    * Loads and initializes a database provider based on the configuration.
    * If the connection is already loaded for the given host/path, it returns the existing instance.
@@ -48,21 +142,30 @@ class DataBaseProviderService {
    * @returns {Promise<object|undefined>} A promise that resolves to the initialized provider object
    * or `undefined` on error or if the provider is already loaded.
    */
-  async load(options = { apis: [], host: '', path: '', db: {} }) {
+  static async load(options = { apis: [], host: '', path: '', db: {} }) {
     try {
       const { apis, host, path, db } = options;
-      const key = `${host}${path}`;
+      const key = resolveHostKeyContext({ host, path });
+      const dbSignature = DataBaseProviderService.buildDbSignature(db);
 
       if (!this.#instance[key]) this.#instance[key] = {};
+      if (!db) return undefined;
 
-      if (!db || this.#instance[key][db.provider]) return this.#instance[key][db.provider];
+      const currentProvider = this.#instance[key][db.provider];
+      if (currentProvider && currentProvider.dbSignature === dbSignature) return currentProvider;
+
+      if (currentProvider && currentProvider.close) {
+        await currentProvider.close();
+        delete this.#instance[key][db.provider];
+      }
 
       // logger.info(`Load ${db.provider} provider`, key);
       switch (db.provider) {
         case 'mongoose':
           {
-            const conn = await MongooseDB.connect(db.host, db.name);
+            const conn = await MongooseDB.connect(db);
             this.#instance[key][db.provider] = {
+              dbSignature,
               models: await MongooseDB.loadModels({ conn, apis }),
               connection: conn,
               close: async () => {
@@ -88,12 +191,12 @@ class DataBaseProviderService {
         path: options.path,
         db: options.db
           ? {
-              provider: options.db.provider,
-              name: options.db.name ? '***' : undefined,
-              host: options.db.host ? '***' : undefined,
-              user: options.db.user ? '***' : undefined,
-              password: options.db.password ? '***' : undefined,
-            }
+            provider: options.db.provider,
+            name: options.db.name ? '***' : undefined,
+            host: options.db.host ? '***' : undefined,
+            user: options.db.user ? '***' : undefined,
+            password: options.db.password ? '***' : undefined,
+          }
           : {},
       };
       logger.error(error.message, { safeOptions });
@@ -102,12 +205,9 @@ class DataBaseProviderService {
   }
 }
 
-/**
- * Singleton instance of the DataBaseProviderService class for backward compatibility.
- * @alias DataBaseProvider
- * @memberof DataBaseProviderService
- * @type {DataBaseProviderService}
- */
-const DataBaseProvider = new DataBaseProviderService();
 
-export { DataBaseProvider, DataBaseProviderService as DataBaseProviderClass };
+export {
+  DataBaseProviderService as DataBaseProviderClass,
+  DataBaseProviderService as default,
+  DataBaseProviderService
+};