@underpostnet/cyberia 3.2.90 → 3.3.73

package/src/client-builder/client-build.js

@@ -8,22 +8,23 @@
 
 import fs from 'fs-extra';
 import { transformClientJs, JSONweb } from './client-formatted.js';
-import { loggerFactory } from '../server/logger.js';
+import { loggerFactory } from '../server/ops/logger.js';
 import {
   getCapVariableName,
   newInstance,
   orderArrayFromAttrInt,
   uniqueArray,
 } from '../client/components/core/CommonJs.js';
-import { readConfJson } from '../server/conf.js';
+import { readConfJson } from '../server/runtime/conf.js';
 import { minify } from 'html-minifier-terser';
 import AdmZip from 'adm-zip';
 import * as dir from 'path';
-import { shellExec } from '../server/process.js';
+import { shellExec } from '../server/runtime/process.js';
 import { SitemapStream, streamToPromise } from 'sitemap';
 import { Readable } from 'stream';
 import { buildIcons } from './client-icons.js';
-import { statusPageBuildSegment } from '../server/underpost-gateway.js';
+import { statusPageBuildSegment } from '../server/network/underpost-gateway.js';
+import { repositoryIdentityFactory } from '../server/storage/repository.js';
 import Underpost from '../index.js';
 import { buildDocs } from './client-build-docs.js';
 import { ssrFactory } from './ssr.js';
@@ -525,6 +526,7 @@ const defaultSitemapXsl = `<?xml version="1.0" encoding="UTF-8"?>
  * @param {string|number} options.split - Optional zip split size in MB.
  * @param {boolean} options.fullBuild - Whether to perform a full build.
  * @param {boolean} options.iconsBuild - Whether to build icons.
+ * @param {boolean} options.ssrOnly - Whether to rebuild only views defined in `conf.ssr.json`.
  * @returns {Promise<void>} - Promise that resolves when the build is complete.
  * @throws {Error} - If the build fails.
  * @memberof clientBuild
@@ -532,6 +534,7 @@ const defaultSitemapXsl = `<?xml version="1.0" encoding="UTF-8"?>
 const buildClient = async (
   options = {
     deployId: '',
+    subConf: '',
     liveClientBuildPaths: [],
     instances: [],
     buildZip: false,
@@ -542,12 +545,17 @@ const buildClient = async (
 ) => {
   const logger = loggerFactory(import.meta);
   const deployId = options.deployId || process.env.DEPLOY_ID;
-  const confClient = readConfJson(deployId, 'client');
-  const confServer = readConfJson(deployId, 'server', { loadReplicas: true });
-  const confSSR = readConfJson(deployId, 'ssr');
+  // Carried as an argument rather than re-derived from DEPLOY_SUB_CONF: the caller already
+  // resolved which sub-configuration this build is for, and a build that reads a different
+  // conf.server than the one its caller loaded renders the wrong set of hosts.
+  const subConf = `${options.subConf ?? ''}`.trim();
+  const confClient = readConfJson(deployId, 'client', { subConf });
+  const confServer = readConfJson(deployId, 'server', { subConf, loadReplicas: true });
+  const confSSR = readConfJson(deployId, 'ssr', { subConf });
   const packageData = JSON.parse(fs.readFileSync(`./package.json`, 'utf8'));
   const acmeChallengePath = `/.well-known/acme-challenge`;
   const publicPath = `./public`;
+  const ssrOnly = options.ssrOnly === true;
 
   /**
    * @async
@@ -687,15 +695,27 @@ const buildClient = async (
       // ''; // process.env.NODE_ENV === 'production' ? `https://${host}` : ``;
       currentPort++;
 
+      // Every document this instance emits carries the same payload; the SSR
+      // views and the client index must never disagree about which repository
+      // published them.
+      const renderPayload = {
+        apiBaseProxyPath,
+        apiBaseHost,
+        apiBasePath: process.env.BASE_API,
+        version: Underpost.version,
+        repository: repositoryIdentityFactory(),
+        ...(isDevelopment ? { dev: true } : undefined),
+      };
+
       const acmeChallengeFullPath = directory
         ? `${directory}${acmeChallengePath}`
         : `${publicPath}/${host}${acmeChallengePath}`;
 
-      if (!enableLiveRebuild) buildAcmeChallengePath(acmeChallengeFullPath);
+      if (!enableLiveRebuild && !ssrOnly) buildAcmeChallengePath(acmeChallengeFullPath);
 
       if (redirect || disabledRebuild) continue;
 
-      if (fullBuildEnabled)
+      if (fullBuildEnabled && !ssrOnly)
         await fullBuild({
           path,
           logger,
@@ -710,7 +730,7 @@ const buildClient = async (
           publicCopyNonExistingFiles,
         });
 
-      if (components)
+      if (!ssrOnly && components)
         for (const module of Object.keys(components)) {
           if (!fs.existsSync(`${rootClientPath}/components/${module}`))
             fs.mkdirSync(`${rootClientPath}/components/${module}`, { recursive: true });
@@ -733,7 +753,7 @@ const buildClient = async (
           }
         }
 
-      if (services) {
+      if (!ssrOnly && services) {
         for (const module of services) {
           if (!fs.existsSync(`${rootClientPath}/services/${module}`))
             fs.mkdirSync(`${rootClientPath}/services/${module}`, { recursive: true });
@@ -796,7 +816,9 @@ const buildClient = async (
       const swSrcPath = `./src/client/sw/core.sw.js`;
       const swPublicPath = `${rootClientPath}/sw.js`;
       const swShouldRebuild =
-        views && !(enableLiveRebuild && !options.liveClientBuildPaths.find((p) => p.srcBuildPath === swSrcPath));
+        !ssrOnly &&
+        views &&
+        !(enableLiveRebuild && !options.liveClientBuildPaths.find((p) => p.srcBuildPath === swSrcPath));
       // Transformed SW JS is held in memory; it gets prepended with renderPayload
       // and written once below, after PRE_CACHED_RESOURCES are known.
       let swTransformedJs = '';
@@ -810,13 +832,15 @@ const buildClient = async (
         });
       }
 
-      if (views) {
-        if (!(
-          enableLiveRebuild &&
-          !options.liveClientBuildPaths.find(
-            (p) => p.srcBuildPath.startsWith(`./src/client/ssr`) || p.srcBuildPath.slice(-9) === '.index.js',
+      if (!ssrOnly && views) {
+        if (
+          !(
+            enableLiveRebuild &&
+            !options.liveClientBuildPaths.find(
+              (p) => p.srcBuildPath.startsWith(`./src/client/ssr`) || p.srcBuildPath.slice(-9) === '.index.js',
+            )
           )
-        ))
+        )
           for (const view of views) {
             const buildPath = `${
               rootClientPath[rootClientPath.length - 1] === '/' ? rootClientPath.slice(0, -1) : rootClientPath
@@ -848,7 +872,7 @@ const buildClient = async (
                 confSSR[view.ssr].head.unshift('Production');
 
               for (const ssrHeadComponent of confSSR[view.ssr].head) {
-                const SrrComponent = await ssrFactory(`./src/client/ssr/head/${ssrHeadComponent}.js`);
+                const SSRComponent = await ssrFactory(`./src/client/ssr/head/${ssrHeadComponent}.js`);
 
                 switch (ssrHeadComponent) {
                   case 'Pwa':
@@ -903,11 +927,11 @@ const buildClient = async (
                       // ],
                       // "prefer_related_applications": true
                     }
-                    if (validPwaBuild) ssrHeadComponents += SrrComponent({ title, ssrPath, canonicalURL, ...metadata });
+                    if (validPwaBuild) ssrHeadComponents += SSRComponent({ title, ssrPath, canonicalURL, ...metadata });
                     break;
                   case 'Seo':
                     if (metadata) {
-                      ssrHeadComponents += SrrComponent({ title, ssrPath, canonicalURL, ...metadata });
+                      ssrHeadComponents += SSRComponent({ title, ssrPath, canonicalURL, ...metadata });
                     }
                     break;
                   case 'Microdata':
@@ -919,18 +943,18 @@ const buildClient = async (
                       const microdata = JSON.parse(
                         fs.readFileSync(`./src/client/public/${publicClientId}/microdata.json`, 'utf8'),
                       );
-                      ssrHeadComponents += SrrComponent({ microdata });
+                      ssrHeadComponents += SSRComponent({ microdata });
                     }
                     break;
                   default:
-                    ssrHeadComponents += SrrComponent({ ssrPath, host, path });
+                    ssrHeadComponents += SSRComponent({ ssrPath, host, path });
                     break;
                 }
               }
 
               for (const ssrBodyComponent of confSSR[view.ssr].body) {
-                const SrrComponent = await ssrFactory(`./src/client/ssr/body/${ssrBodyComponent}.js`);
-                ssrBodyComponents += SrrComponent({
+                const SSRComponent = await ssrFactory(`./src/client/ssr/body/${ssrBodyComponent}.js`);
+                ssrBodyComponents += SSRComponent({
                   ...metadata,
                   ssrPath,
                   host,
@@ -956,13 +980,7 @@ const buildClient = async (
               ssrPath,
               ssrHeadComponents,
               ssrBodyComponents,
-              renderPayload: {
-                apiBaseProxyPath,
-                apiBaseHost,
-                apiBasePath: process.env.BASE_API,
-                version: Underpost.version,
-                ...(isDevelopment ? { dev: true } : undefined),
-              },
+              renderPayload,
               renderApi: {
                 JSONweb,
               },
@@ -983,7 +1001,7 @@ const buildClient = async (
             );
           }
       }
-      if (!enableLiveRebuild && siteMapLinks.length > 0) {
+      if (!ssrOnly && !enableLiveRebuild && siteMapLinks.length > 0) {
         const hasSitemapTemplate = fs.existsSync(`${rootClientPath}/sitemap`);
         const sitemapBaseUrl = `https://${host}${path === '/' ? '' : path}`;
         // Create a stream to write to — omit xslUrl so we can inject a relative href below
@@ -1020,11 +1038,13 @@ Sitemap: ${sitemapBaseUrl}/sitemap.xml`,
         );
       }
 
-      if (fullBuildEnabled && docs) {
+      if (!ssrOnly && fullBuildEnabled && docs) {
         await buildDocs({
           host,
           path,
           port,
+          apiBaseHost,
+          apiBaseProxyPath,
           metadata,
           apis,
           publicClientId,
@@ -1058,13 +1078,7 @@ Sitemap: ${sitemapBaseUrl}/sitemap.xml`,
             ssrPath,
             ssrHeadComponents: '<base target="_top">',
             ssrBodyComponents: SsrComponent(),
-            renderPayload: {
-              apiBaseProxyPath,
-              apiBaseHost,
-              apiBasePath: process.env.BASE_API,
-              version: Underpost.version,
-              ...(isDevelopment ? { dev: true } : undefined),
-            },
+            renderPayload,
             renderApi: { JSONweb },
           });
 
@@ -1110,7 +1124,7 @@ Sitemap: ${sitemapBaseUrl}/sitemap.xml`,
 
         if (swShouldRebuild) {
           const cacheScope = path === '/' ? 'root' : path.replaceAll('/', '_');
-          const renderPayload = {
+          const swRenderPayload = {
             PRE_CACHED_RESOURCES: uniqueArray(PRE_CACHED_RESOURCES),
             PROXY_PATH: path,
             CACHE_PREFIX: `engine-core-${cacheScope}`,
@@ -1121,14 +1135,14 @@ Sitemap: ${sitemapBaseUrl}/sitemap.xml`,
           // Single write: prepend the payload prelude to the transformed SW JS.
           fs.writeFileSync(
             swPublicPath,
-            `self.renderPayload = ${JSONweb(renderPayload)};
+            `self.renderPayload = ${JSONweb(swRenderPayload)};
 self.__WB_DISABLE_DEV_LOGS = true;
 ${swTransformedJs}`,
             'utf8',
           );
         }
       }
-      if (!enableLiveRebuild && options.buildZip) {
+      if (!ssrOnly && !enableLiveRebuild && options.buildZip) {
         logger.warn('build zip', rootClientPath);
 
         if (!fs.existsSync('./build')) fs.mkdirSync('./build');

package/src/client-builder/client-dev-server.js

@@ -6,8 +6,8 @@
 import fs from 'fs-extra';
 import nodemon from 'nodemon';
 import dotenv from 'dotenv';
-import { shellExec } from '../server/process.js';
-import { loggerFactory } from '../server/logger.js';
+import { shellExec } from '../server/runtime/process.js';
+import { loggerFactory } from '../server/ops/logger.js';
 import Underpost from '../index.js';
 
 const logger = loggerFactory(import.meta);
@@ -32,7 +32,7 @@ const createClientDevServer = async (
   const devClientEnvPath = `./engine-private/conf/${deployId}/.env.${process.env.NODE_ENV}.${subConf}-dev-client`;
   if (fs.existsSync(devClientEnvPath)) dotenv.config({ path: devClientEnvPath, override: true });
 
-  await Underpost.repo.client(deployId, `${subConf}-dev-client`.trim(), host, path);
+  await Underpost.client.callback(deployId, `${subConf}-dev-client`.trim(), host, path);
 
   shellExec(`node src/server ${deployId} ${subConf}-dev-client`.trim(), {
     async: true,

package/src/client-builder/client-icons.js

@@ -4,7 +4,7 @@
  * @namespace clientIcons
  */
 import { favicons } from 'favicons';
-import { loggerFactory } from '../server/logger.js';
+import { loggerFactory } from '../server/ops/logger.js';
 import fs from 'fs-extra';
 import { getCapVariableName } from '../client/components/core/CommonJs.js';
 
@@ -99,7 +99,7 @@ const buildIcons = async ({
 
     const ssrPath = `./src/client/ssr/head/Pwa${getCapVariableName(publicClientId)}.js`;
     if (!fs.existsSync(ssrPath))
-      fs.writeFileSync(ssrPath, 'SrrComponent = () => html`' + response.html.join(`\n`) + '`;', 'utf8');
+      fs.writeFileSync(ssrPath, 'SSRComponent = () => html`' + response.html.join(`\n`) + '`;', 'utf8');
   } catch (error) {
     logger.error(error.message); // Error description e.g. "An unknown error has occurred"
   }

package/src/client-builder/ssr.js

@@ -10,7 +10,7 @@ import vm from 'node:vm';
 import Underpost from '../index.js';
 
 import { srcFormatted } from './client-formatted.js';
-import { loggerFactory } from '../server/logger.js';
+import { loggerFactory } from '../server/ops/logger.js';
 
 const logger = loggerFactory(import.meta);
 
@@ -22,10 +22,10 @@ const logger = loggerFactory(import.meta);
  * @memberof ServerSideRendering
  */
 const ssrFactory = async (componentPath = `./src/client/ssr/RootDocument.js`) => {
-  const context = { SrrComponent: () => {}, npm_package_version: Underpost.version };
+  const context = { SSRComponent: () => {}, npm_package_version: Underpost.version };
   vm.createContext(context);
   vm.runInContext(await srcFormatted(fs.readFileSync(componentPath, 'utf8')), context);
-  return context.SrrComponent;
+  return context.SSRComponent;
 };
 
 /**

package/src/client.build.js

@@ -1,11 +1,8 @@
 'use strict';
 
-// https://nodejs.org/api
-// https://expressjs.com/en/4x/api.html
-
-import { loggerFactory } from './server/logger.js';
-import { Config } from './server/conf.js';
-import { ProcessController } from './server/process.js';
+import { loggerFactory } from './server/ops/logger.js';
+import { Config } from './server/runtime/conf.js';
+import { ProcessController } from './server/runtime/process.js';
 import { clientLiveBuild } from './client-builder/client-build-live.js';
 
 await Config.build();

package/src/client.dev.js

@@ -1,11 +1,8 @@
 'use strict';
 
-// https://nodejs.org/api
-// https://expressjs.com/en/4x/api.html
-
-import { loggerFactory } from './server/logger.js';
-import { ProcessController } from './server/process.js';
-import { Config, buildClientStaticConf } from './server/conf.js';
+import { loggerFactory } from './server/ops/logger.js';
+import { ProcessController } from './server/runtime/process.js';
+import { Config, buildClientStaticConf } from './server/runtime/conf.js';
 import { createClientDevServer } from './client-builder/client-dev-server.js';
 
 const logger = loggerFactory(import.meta);

package/src/db/DataBaseProvider.js

@@ -1,8 +1,9 @@
 import { MongooseDB } from './mongo/MongooseDB.js';
-import { loggerFactory } from '../server/logger.js';
+import { loggerFactory } from '../server/ops/logger.js';
 import { getCapVariableName } from '../client/components/core/CommonJs.js';
-import { resolveHostKeyContext } from '../server/conf.js';
+import { resolveHostKeyContext } from '../server/runtime/conf.js';
 import Underpost from '../index.js';
+import { latchRuntimeError } from '../server/runtime/runtime-status.js';
 
 /**
  * Module for managing and loading various database connections (e.g., Mongoose, MariaDB).
@@ -12,6 +13,60 @@ import Underpost from '../index.js';
 
 const logger = loggerFactory(import.meta);
 
+// Health watch defaults. `DB_HEALTH_INTERVAL_MS=0` disables the watch entirely.
+const HEALTH_INTERVAL_MS = Number(process.env.DB_HEALTH_INTERVAL_MS ?? 15000);
+const HEALTH_PING_TIMEOUT_MS = 5000;
+
+/**
+ * Bounds a liveness probe that would otherwise wait on the driver's own connection timeout.
+ * @param {Promise<boolean>} probe - Provider probe resolving to liveness.
+ * @returns {Promise<boolean>} `false` when the probe throws or outlives the bound.
+ */
+const withPingTimeout = async (probe) => {
+  let timer;
+  try {
+    return await Promise.race([
+      probe,
+      new Promise((resolve) => {
+        timer = setTimeout(() => resolve(false), HEALTH_PING_TIMEOUT_MS);
+      }),
+    ]);
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timer);
+  }
+};
+
+/**
+ * Per-provider health strategies, keyed by `db.provider`.
+ *
+ * A provider with no entry here gets no health watch and no reconnect: liveness probes,
+ * rebuild semantics, and teardown differ per client, so there is nothing generic to fall
+ * back on. Adding one (MariaDB, PostgreSQL, …) means adding its case here — the rest of the
+ * service dispatches through this table and needs no change.
+ *
+ * @type {object.<string, {isAlive: Function, rebuild: Function, close: Function}>}
+ */
+const PROVIDER_HEALTH = {
+  mongoose: {
+    isAlive: async (connection) => {
+      if (!connection || connection.readyState !== 1) return false;
+      return await withPingTimeout(
+        connection.db
+          .admin()
+          .command({ ping: 1 })
+          .then(() => true),
+      );
+    },
+    rebuild: async ({ apis, db }) => {
+      const connection = await MongooseDB.connect(db);
+      return { connection, models: await MongooseDB.loadModels({ conn: connection, apis }) };
+    },
+    close: async (connection) => await connection?.close(),
+  },
+};
+
 /**
  * @class
  * @alias DataBaseProviderService
@@ -126,6 +181,128 @@ class DataBaseProviderService {
     });
   }
 
+  /**
+   * Timers for the per-provider health watch, keyed by `<contextKey>:<provider>`.
+   * @type {object.<string, {timer: object, attempts: number, rebuilding: boolean}>}
+   */
+  static #watchers = {};
+
+  /**
+   * Rebuilds a loaded provider in place: new connection, freshly bound models, old
+   * connection closed once the replacement is live.
+   *
+   * A reconnect is not the same as letting the driver heal itself. For mongoose: after a
+   * replica set is reconfigured the driver can hold a topology it will never accept a primary
+   * for again — it records the highest `setVersion`/`electionId` it has seen and rejects
+   * anything lower for the rest of the process — so only a new client recovers. Every consumer
+   * resolves models through this bucket on each call, so swapping the fields in place is
+   * enough; nothing has to be re-registered.
+   *
+   * Only providers present in {@link PROVIDER_HEALTH} can be rebuilt.
+   *
+   * @param {{host?: string, path?: string}|string} context - Context object or key.
+   * @param {string} [provider='mongoose'] - Provider name.
+   * @returns {Promise<boolean>} `true` when the provider was rebuilt.
+   */
+  static async reconnect(context, provider = 'mongoose') {
+    const key = resolveHostKeyContext(context);
+    const strategy = PROVIDER_HEALTH[provider];
+    if (!strategy) {
+      logger.warn('No reconnect strategy for provider', { key, provider });
+      return false;
+    }
+
+    const bucket = this.#instance[key]?.[provider];
+    if (!bucket?.rebuild) {
+      logger.warn('Cannot reconnect a provider that was never loaded', { key, provider });
+      return false;
+    }
+
+    const previousConnection = bucket.connection;
+
+    try {
+      const { connection, models } = await strategy.rebuild(bucket.rebuild);
+
+      bucket.connection = connection;
+      bucket.models = models;
+      logger.info('Database connection rebuilt', { key, provider });
+    } catch (error) {
+      logger.error('Database reconnect failed, keeping the existing connection', {
+        key,
+        provider,
+        error: error.message,
+      });
+      return false;
+    }
+
+    // Closed last and best-effort: the replacement is already serving, and a close that
+    // hangs on a dead server must not take the recovery with it.
+    try {
+      await strategy.close(previousConnection);
+    } catch (error) {
+      logger.warn('Could not close the replaced connection', { key, provider, error: error.message });
+    }
+    return true;
+  }
+
+  /**
+   * Starts the health watch for a provider: pings on an interval and rebuilds the connection
+   * on every tick that finds it down, until it answers again. A provider with no
+   * {@link PROVIDER_HEALTH} entry is left unwatched.
+   * @param {string} key - Resolved context key.
+   * @param {string} provider - Provider name.
+   */
+  static #startHealthWatch(key, provider) {
+    const strategy = PROVIDER_HEALTH[provider];
+    if (!strategy || !(HEALTH_INTERVAL_MS > 0)) return;
+    const watchKey = `${key}:${provider}`;
+    if (this.#watchers[watchKey]) return;
+
+    const state = { attempts: 0, rebuilding: false, timer: null };
+    state.timer = setInterval(async () => {
+      // A rebuild can outlast the interval (the driver's own connect timeout is longer), so
+      // ticks that land mid-attempt are skipped rather than stacking attempts.
+      if (state.rebuilding) return;
+      const bucket = this.#instance[key]?.[provider];
+      if (!bucket) return;
+
+      if (await strategy.isAlive(bucket.connection)) {
+        if (state.attempts > 0)
+          logger.info('Database connection restored', { key, provider, attempts: state.attempts });
+        state.attempts = 0;
+        return;
+      }
+
+      // Every tick retries until the connection answers again: there is no attempt budget to
+      // exhaust, because giving up leaves the runtime permanently unable to reach its database.
+      state.rebuilding = true;
+      state.attempts++;
+      logger.warn('Database connection is down, rebuilding', { key, provider, attempt: state.attempts });
+      try {
+        await this.reconnect(key, provider);
+      } finally {
+        state.rebuilding = false;
+      }
+    }, HEALTH_INTERVAL_MS);
+
+    // Never hold the event loop open on account of a health check.
+    state.timer.unref?.();
+    this.#watchers[watchKey] = state;
+  }
+
+  /**
+   * Stops the health watch for a provider.
+   * @param {string} key - Resolved context key.
+   * @param {string} provider - Provider name.
+   */
+  static #stopHealthWatch(key, provider) {
+    const watchKey = `${key}:${provider}`;
+    const state = this.#watchers[watchKey];
+    if (!state) return;
+    clearInterval(state.timer);
+    delete this.#watchers[watchKey];
+  }
+
   /**
    * 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.
@@ -166,9 +343,12 @@ class DataBaseProviderService {
             const conn = await MongooseDB.connect(db);
             this.#instance[key][db.provider] = {
               dbSignature,
+              // Kept so the connection can be rebuilt later without the caller being present.
+              rebuild: { apis, host, path, db },
               models: await MongooseDB.loadModels({ conn, apis }),
               connection: conn,
               close: async () => {
+                this.#stopHealthWatch(key, db.provider);
                 return await new Promise((resolve) => {
                   this.#instance[key][db.provider].connection.close().then(() => {
                     // logger.info('Mongoose connection is disconnected', db);
@@ -182,6 +362,9 @@ class DataBaseProviderService {
         default:
           break;
       }
+      // Self-guarding: only providers with a PROVIDER_HEALTH entry are actually watched, so a
+      // provider added above does not have to remember to opt in here.
+      this.#startHealthWatch(key, db.provider);
       return this.#instance[key][db.provider];
     } catch (error) {
       // Sanitize options to prevent credential exposure in logs
@@ -200,7 +383,7 @@ class DataBaseProviderService {
           : {},
       };
       logger.error(error.message, { safeOptions });
-      if (Underpost.env.isInsideContainer()) Underpost.env.set('container-status', 'error');
+      latchRuntimeError();
       return undefined;
     }
   }

package/src/db/mariadb/MariaDB.js

@@ -1,6 +1,7 @@
 import { createPool } from 'mariadb';
 import Underpost from '../../index.js';
-import { loggerFactory } from '../../server/logger.js';
+import { loggerFactory } from '../../server/ops/logger.js';
+import { latchRuntimeError } from '../../server/runtime/runtime-status.js';
 
 /**
  * Module for interacting with MariaDB/MySQL databases using the mariadb connector.
@@ -51,7 +52,7 @@ class MariaDBService {
       console.log(result);
     } catch (error) {
       logger.error('MariaDB query failed', { error: error.message });
-      if (Underpost.env.isInsideContainer()) Underpost.env.set('container-status', 'error');
+      latchRuntimeError();
     } finally {
       if (conn) conn.release(); // release to pool
       await pool.end();