npm - underpost - Versions diffs - 3.2.9 → 3.2.10 - Mend

underpost 3.2.9 → 3.2.10

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (81) hide show

package/.github/workflows/npmpkg.ci.yml +1 -0
package/.github/workflows/pwa-microservices-template-test.ci.yml +1 -1
package/.github/workflows/release.cd.yml +1 -0
package/.vscode/settings.json +10 -5
package/CHANGELOG.md +122 -1
package/CLI-HELP.md +22 -7
package/README.md +37 -8
package/bin/build.js +26 -9
package/bin/deploy.js +20 -21
package/bin/file.js +31 -13
package/bin/index.js +2 -1
package/bin/vs.js +1 -1
package/bump.config.js +26 -0
package/conf.js +20 -4
package/manifests/cronjobs/dd-cron/dd-cron-backup.yaml +1 -1
package/manifests/cronjobs/dd-cron/dd-cron-dns.yaml +1 -1
package/manifests/deployment/dd-default-development/deployment.yaml +2 -2
package/manifests/deployment/dd-test-development/deployment.yaml +4 -2
package/manifests/kind-config-dev.yaml +8 -0
package/manifests/mongodb/pv-pvc.yaml +44 -8
package/manifests/mongodb/statefulset.yaml +55 -68
package/package.json +27 -12
package/scripts/k3s-node-setup.sh +28 -9
package/src/api/core/core.router.js +19 -14
package/src/api/core/core.service.js +5 -5
package/src/api/default/default.router.js +22 -18
package/src/api/default/default.service.js +5 -5
package/src/api/document/document.router.js +28 -23
package/src/api/document/document.service.js +100 -23
package/src/api/file/file.router.js +19 -13
package/src/api/file/file.service.js +9 -7
package/src/api/test/test.router.js +17 -12
package/src/api/types.js +24 -0
package/src/api/user/guest.service.js +5 -4
package/src/api/user/user.router.js +297 -288
package/src/api/user/user.service.js +100 -35
package/src/cli/baremetal.js +20 -11
package/src/cli/cluster.js +196 -55
package/src/cli/db.js +59 -60
package/src/cli/deploy.js +273 -159
package/src/cli/fs.js +3 -1
package/src/cli/index.js +16 -9
package/src/cli/ipfs.js +4 -6
package/src/cli/kubectl.js +4 -1
package/src/cli/lxd.js +217 -135
package/src/cli/release.js +289 -131
package/src/cli/repository.js +58 -7
package/src/cli/run.js +152 -25
package/src/cli/test.js +9 -3
package/src/client/Default.index.js +9 -3
package/src/client/components/core/Auth.js +4 -0
package/src/client/components/core/PanelForm.js +56 -52
package/src/client/components/core/Worker.js +162 -363
package/src/client/sw/core.sw.js +174 -112
package/src/db/DataBaseProvider.js +120 -20
package/src/db/mongo/MongoBootstrap.js +587 -0
package/src/db/mongo/MongooseDB.js +126 -22
package/src/index.js +1 -1
package/src/runtime/express/Express.js +2 -2
package/src/runtime/wp/Wp.js +8 -5
package/src/server/auth.js +2 -2
package/src/server/client-build-docs.js +1 -1
package/src/server/client-build.js +94 -129
package/src/server/conf.js +20 -65
package/src/server/process.js +180 -19
package/src/server/runtime.js +1 -1
package/src/server/start.js +12 -4
package/src/ws/IoInterface.js +16 -16
package/src/ws/core/channels/core.ws.chat.js +11 -11
package/src/ws/core/channels/core.ws.mailer.js +29 -29
package/src/ws/core/channels/core.ws.stream.js +19 -19
package/src/ws/core/core.ws.connection.js +8 -8
package/src/ws/core/core.ws.server.js +6 -5
package/src/ws/default/channels/default.ws.main.js +10 -10
package/src/ws/default/default.ws.connection.js +4 -4
package/src/ws/default/default.ws.server.js +4 -3
package/src/client/ssr/email/DefaultRecoverEmail.js +0 -21
package/src/client/ssr/email/DefaultVerifyEmail.js +0 -17
/package/src/client/ssr/{offline → views}/Maintenance.js +0 -0
/package/src/client/ssr/{offline → views}/NoNetworkConnection.js +0 -0
/package/src/client/ssr/{pages → views}/Test.js +0 -0

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

@@ -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 CHANGED Viewed

@@ -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
+};