cyberia 3.2.9 → 3.2.12

package/scripts/maas-nat-firewalld.sh

@@ -0,0 +1,145 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# MAAS NAT + firewall helper
+# - Enables IPv4 forwarding and masquerading for the MAAS/provisioning subnet
+# - Opens the MAAS API on the uplink zone when requested
+# - Opens provisioning and optional NFS services on the zone bound to MAAS_LAN_CIDR
+#
+# Usage examples:
+#   sudo MAAS_LAN_CIDR="192.168.1.0/24" PUBLIC_ZONE="public" ./maas-nat-firewalld.sh
+#   sudo NFS_MODE="v3" CONFIGURE_NFS_V3_PORTS="true" ./maas-nat-firewalld.sh
+
+MAAS_LAN_CIDR="${MAAS_LAN_CIDR:-192.168.1.0/24}"
+PUBLIC_ZONE="${PUBLIC_ZONE:-public}"
+TRUSTED_ZONE="${TRUSTED_ZONE:-trusted}"
+NFS_MODE="${NFS_MODE:-v4}"                    # v4 or v3
+CONFIGURE_NFS_V3_PORTS="${CONFIGURE_NFS_V3_PORTS:-false}"
+EXPOSE_MAAS_API_PUBLIC="${EXPOSE_MAAS_API_PUBLIC:-true}"
+
+# Fixed NFSv3 ports (only used when CONFIGURE_NFS_V3_PORTS=true)
+NFS_MOUNTD_PORT="${NFS_MOUNTD_PORT:-20048}"
+NFS_STATD_PORT="${NFS_STATD_PORT:-32765}"
+# Outgoing port must differ from the listen port; rpc.statd exits 255 if they match.
+NFS_STATD_OUTGOING_PORT="${NFS_STATD_OUTGOING_PORT:-32766}"
+NFS_LOCKD_PORT="${NFS_LOCKD_PORT:-32803}"
+NFS_LOCKD_UDP_PORT="${NFS_LOCKD_UDP_PORT:-${NFS_LOCKD_PORT}}"
+NFS_CONF_DROPIN="/etc/nfs.conf.d/99-maas-nfs-v3-ports.conf"
+
+case "${NFS_MODE}" in
+    v3|v4) ;;
+    *)
+        echo "[ERROR] NFS_MODE must be 'v3' or 'v4'." >&2
+        exit 1
+    ;;
+esac
+
+# Ensure the kernel NFS server is enabled and actually running. `exportfs -rav` only populates the
+# export table; it does not start nfsd, and `systemctl try-restart` is a no-op when the unit is
+# stopped. Without this, clients hang on mount because nothing listens on 2049/mountd.
+ensure_nfs_server_running() {
+    if [[ "${NFS_MODE}" == "v3" ]]; then
+        # NFSv3 depends on the portmapper and the status monitor.
+        sudo systemctl enable --now rpcbind 2>/dev/null || true
+        sudo systemctl enable --now rpc-statd 2>/dev/null || true
+    fi
+    
+    local unit=""
+    for candidate in nfs-server nfs-kernel-server; do
+        if systemctl cat "${candidate}.service" >/dev/null 2>&1; then
+            unit="${candidate}"
+            break
+        fi
+    done
+    if [[ -z "${unit}" ]]; then
+        echo "[ERROR] No NFS server unit found (nfs-server/nfs-kernel-server). Install nfs-utils or nfs-kernel-server." >&2
+        return 1
+    fi
+    
+    echo "[INFO] Enabling and (re)starting ${unit} to apply exports and fixed ports..."
+    sudo systemctl enable "${unit}" 2>/dev/null || true
+    sudo systemctl restart "${unit}"
+}
+
+echo "[INFO] Enabling firewalld..."
+sudo systemctl enable --now firewalld
+
+echo "[INFO] Enabling kernel forwarding..."
+sudo tee /etc/sysctl.d/99-maas-nat.conf >/dev/null <<'EOF'
+net.ipv4.ip_forward = 1
+EOF
+
+sudo sysctl --system >/dev/null
+
+echo "[INFO] Allowing NAT for the MAAS LAN..."
+sudo firewall-cmd --permanent --zone="${PUBLIC_ZONE}" --add-masquerade
+sudo firewall-cmd --permanent --zone="${TRUSTED_ZONE}" --add-source="${MAAS_LAN_CIDR}"
+
+echo "[INFO] Opening MAAS services on the MAAS LAN zone..."
+sudo firewall-cmd --permanent --zone="${TRUSTED_ZONE}" --add-port=5240/tcp
+for service in dns dhcp tftp; do
+    sudo firewall-cmd --permanent --zone="${TRUSTED_ZONE}" --add-service="${service}"
+done
+
+if [[ "${EXPOSE_MAAS_API_PUBLIC}" == "true" ]]; then
+    echo "[INFO] Opening MAAS API on the uplink zone..."
+    sudo firewall-cmd --permanent --zone="${PUBLIC_ZONE}" --add-port=5240/tcp
+fi
+
+echo "[INFO] Opening NFS ports on the MAAS LAN zone..."
+
+if [[ "${NFS_MODE}" == "v4" ]]; then
+    # NFSv4 normally needs only TCP 2049.
+    sudo firewall-cmd --permanent --zone="${TRUSTED_ZONE}" --add-port=2049/tcp
+else
+    # NFSv3 side-band daemons need fixed ports for deterministic firewall rules.
+    if [[ "${CONFIGURE_NFS_V3_PORTS}" != "true" ]]; then
+        echo "[ERROR] NFSv3 requires CONFIGURE_NFS_V3_PORTS=true for consistent firewalld rules." >&2
+        echo "[ERROR] Re-run with CONFIGURE_NFS_V3_PORTS=true or switch to NFS_MODE=v4." >&2
+        exit 1
+    fi
+    
+    echo "[INFO] Writing fixed NFSv3 port configuration..."
+    sudo install -d -m 0755 /etc/nfs.conf.d
+        sudo tee "${NFS_CONF_DROPIN}" >/dev/null <<EOF
+[nfsd]
+vers3=y
+
+[mountd]
+port=${NFS_MOUNTD_PORT}
+
+[statd]
+port=${NFS_STATD_PORT}
+outgoing-port=${NFS_STATD_OUTGOING_PORT}
+
+[lockd]
+port=${NFS_LOCKD_PORT}
+udp-port=${NFS_LOCKD_UDP_PORT}
+EOF
+    
+    sudo firewall-cmd --permanent --zone="${TRUSTED_ZONE}" --add-service=rpc-bind
+    sudo firewall-cmd --permanent --zone="${TRUSTED_ZONE}" --add-port=2049/tcp
+    for proto in tcp udp; do
+        sudo firewall-cmd --permanent --zone="${TRUSTED_ZONE}" --add-port="${NFS_MOUNTD_PORT}/${proto}"
+        sudo firewall-cmd --permanent --zone="${TRUSTED_ZONE}" --add-port="${NFS_STATD_PORT}/${proto}"
+        # Outgoing port is the fixed source for SM_NOTIFY; peers need to reach it.
+        sudo firewall-cmd --permanent --zone="${TRUSTED_ZONE}" --add-port="${NFS_STATD_OUTGOING_PORT}/${proto}"
+    done
+    sudo firewall-cmd --permanent --zone="${TRUSTED_ZONE}" --add-port="${NFS_LOCKD_PORT}/tcp"
+    sudo firewall-cmd --permanent --zone="${TRUSTED_ZONE}" --add-port="${NFS_LOCKD_UDP_PORT}/udp"
+fi
+
+ensure_nfs_server_running
+
+echo "[INFO] Reloading firewall..."
+sudo firewall-cmd --reload
+
+echo
+echo "[INFO] Firewall status:"
+sudo firewall-cmd --zone="${PUBLIC_ZONE}" --list-all
+echo
+echo "[INFO] MAAS LAN zone (${TRUSTED_ZONE}):"
+sudo firewall-cmd --zone="${TRUSTED_ZONE}" --list-all
+
+echo
+echo "[INFO] MAAS NAT + firewall configuration completed."

package/src/api/atlas-sprite-sheet/atlas-sprite-sheet.router.js

@@ -4,39 +4,44 @@ import express from 'express';
 
 const logger = loggerFactory(import.meta);
 
-const AtlasSpriteSheetRouter = (options) => {
-  const router = express.Router();
-  const authMiddleware = options.authMiddleware;
-  router.post(
-    `/generate/:id`,
-    authMiddleware,
-    async (req, res) => await AtlasSpriteSheetController.generate(req, res, options),
-  );
-  router.delete(
-    `/object-layer/:id`,
-    authMiddleware,
-    async (req, res) => await AtlasSpriteSheetController.deleteByObjectLayerId(req, res, options),
-  );
-  router.post(`/:id`, authMiddleware, async (req, res) => await AtlasSpriteSheetController.post(req, res, options));
-  router.post(`/`, authMiddleware, async (req, res) => await AtlasSpriteSheetController.post(req, res, options));
-  router.get(`/blob/:itemKey`, async (req, res) => await AtlasSpriteSheetController.blob(req, res, options));
-  // Metadata endpoints: returns itemKey, atlasWidth, atlasHeight, cellPixelDim, frames (no fileId).
-  // Client fetches /metadata/:itemKey once, caches it, then fetches /blob/:itemKey for the PNG.
-  router.get(`/metadata/:itemKey`, async (req, res) => await AtlasSpriteSheetController.getMetadata(req, res, options));
-  router.get(`/metadata`, async (req, res) => await AtlasSpriteSheetController.getMetadata(req, res, options));
-  router.get(
-    `/:id`,
-    // authMiddleware,
-    async (req, res) => await AtlasSpriteSheetController.get(req, res, options),
-  );
-  router.get(`/`, async (req, res) => await AtlasSpriteSheetController.get(req, res, options));
-  router.put(`/:id`, authMiddleware, async (req, res) => await AtlasSpriteSheetController.put(req, res, options));
-  router.put(`/`, authMiddleware, async (req, res) => await AtlasSpriteSheetController.put(req, res, options));
-  router.delete(`/:id`, authMiddleware, async (req, res) => await AtlasSpriteSheetController.delete(req, res, options));
-  router.delete(`/`, authMiddleware, async (req, res) => await AtlasSpriteSheetController.delete(req, res, options));
-  return router;
-};
+class AtlasSpriteSheetRouter {
+  /**
+   * @param {import('../types.js').RouterOptions} options
+   * @returns {import('express').Router}
+   */
+  static router(options) {
+    const router = express.Router();
+    router.post(
+      `/generate/:id`,
+      options.authMiddleware,
+      async (req, res) => await AtlasSpriteSheetController.generate(req, res, options),
+    );
+    router.delete(
+      `/object-layer/:id`,
+      options.authMiddleware,
+      async (req, res) => await AtlasSpriteSheetController.deleteByObjectLayerId(req, res, options),
+    );
+    router.post(`/:id`, options.authMiddleware, async (req, res) => await AtlasSpriteSheetController.post(req, res, options));
+    router.post(`/`, options.authMiddleware, async (req, res) => await AtlasSpriteSheetController.post(req, res, options));
+    router.get(`/blob/:itemKey`, async (req, res) => await AtlasSpriteSheetController.blob(req, res, options));
+    // Metadata endpoints: returns itemKey, atlasWidth, atlasHeight, cellPixelDim, frames (no fileId).
+    // Client fetches /metadata/:itemKey once, caches it, then fetches /blob/:itemKey for the PNG.
+    router.get(`/metadata/:itemKey`, async (req, res) => await AtlasSpriteSheetController.getMetadata(req, res, options));
+    router.get(`/metadata`, async (req, res) => await AtlasSpriteSheetController.getMetadata(req, res, options));
+    router.get(
+      `/:id`,
+      // options.authMiddleware,
+      async (req, res) => await AtlasSpriteSheetController.get(req, res, options),
+    );
+    router.get(`/`, async (req, res) => await AtlasSpriteSheetController.get(req, res, options));
+    router.put(`/:id`, options.authMiddleware, async (req, res) => await AtlasSpriteSheetController.put(req, res, options));
+    router.put(`/`, options.authMiddleware, async (req, res) => await AtlasSpriteSheetController.put(req, res, options));
+    router.delete(`/:id`, options.authMiddleware, async (req, res) => await AtlasSpriteSheetController.delete(req, res, options));
+    router.delete(`/`, options.authMiddleware, async (req, res) => await AtlasSpriteSheetController.delete(req, res, options));
+    return router;
+  }
+}
 
-const ApiRouter = AtlasSpriteSheetRouter;
+const ApiRouter = (options) => AtlasSpriteSheetRouter.router(options);
 
 export { ApiRouter, AtlasSpriteSheetRouter };

package/src/api/atlas-sprite-sheet/atlas-sprite-sheet.service.js

@@ -1,4 +1,4 @@
-import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+import { DataBaseProviderService } from '../../db/DataBaseProvider.js';
 import { loggerFactory } from '../../server/logger.js';
 import { DataQuery } from '../../server/data-query.js';
 import { AtlasSpriteSheetGenerator } from '../../server/atlas-sprite-sheet-generator.js';
@@ -55,9 +55,9 @@ class AtlasSpriteSheetService {
   static blob = async (req, res, options) => {
     /** @type {import('./atlas-sprite-sheet.model.js').AtlasSpriteSheetModel} */
     const AtlasSpriteSheet =
-      DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.AtlasSpriteSheet;
+      DataBaseProviderService.getModel("AtlasSpriteSheet", options);
     /** @type {import('../file/file.model.js').FileModel} */
-    const File = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.File;
+    const File = DataBaseProviderService.getModel("File", options);
 
     const itemKey = req.params.itemKey;
     const atlasDoc = await AtlasSpriteSheet.findOne({ 'metadata.itemKey': itemKey }).lean();
@@ -70,12 +70,12 @@ class AtlasSpriteSheetService {
   };
   static generate = async (req, res, options, generateOptions = {}) => {
     /** @type {import('../object-layer/object-layer.model.js').ObjectLayerModel} */
-    const ObjectLayer = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.ObjectLayer;
+    const ObjectLayer = DataBaseProviderService.getModel("ObjectLayer", options);
     /** @type {import('../file/file.model.js').FileModel} */
-    const File = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.File;
+    const File = DataBaseProviderService.getModel("File", options);
     /** @type {import('./atlas-sprite-sheet.model.js').AtlasSpriteSheetModel} */
     const AtlasSpriteSheet =
-      DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.AtlasSpriteSheet;
+      DataBaseProviderService.getModel("AtlasSpriteSheet", options);
 
     let objectLayer = req.objectLayer;
 
@@ -195,12 +195,12 @@ class AtlasSpriteSheetService {
   };
   static deleteByObjectLayerId = async (req, res, options) => {
     /** @type {import('../object-layer/object-layer.model.js').ObjectLayerModel} */
-    const ObjectLayer = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.ObjectLayer;
+    const ObjectLayer = DataBaseProviderService.getModel("ObjectLayer", options);
     /** @type {import('../file/file.model.js').FileModel} */
-    const File = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.File;
+    const File = DataBaseProviderService.getModel("File", options);
     /** @type {import('./atlas-sprite-sheet.model.js').AtlasSpriteSheetModel} */
     const AtlasSpriteSheet =
-      DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.AtlasSpriteSheet;
+      DataBaseProviderService.getModel("AtlasSpriteSheet", options);
 
     const objectLayer = await ObjectLayer.findById(req.params.id);
     if (!objectLayer) {
@@ -255,13 +255,13 @@ class AtlasSpriteSheetService {
   static post = async (req, res, options) => {
     /** @type {import('./atlas-sprite-sheet.model.js').AtlasSpriteSheetModel} */
     const AtlasSpriteSheet =
-      DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.AtlasSpriteSheet;
+      DataBaseProviderService.getModel("AtlasSpriteSheet", options);
     return await new AtlasSpriteSheet(req.body).save();
   };
   static get = async (req, res, options) => {
     /** @type {import('./atlas-sprite-sheet.model.js').AtlasSpriteSheetModel} */
     const AtlasSpriteSheet =
-      DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.AtlasSpriteSheet;
+      DataBaseProviderService.getModel("AtlasSpriteSheet", options);
     if (req.params.id)
       return await AtlasSpriteSheet.findById(req.params.id)
         .select(AtlasSpriteSheetDto.select.get())
@@ -287,10 +287,10 @@ class AtlasSpriteSheetService {
   // Client fetches this once per itemKey, caches it, then fetches the PNG blob.
   static getMetadata = async (req, res, options) => {
     /** @type {import('../object-layer/object-layer.model.js').ObjectLayerModel} */
-    const ObjectLayer = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.ObjectLayer;
+    const ObjectLayer = DataBaseProviderService.getModel("ObjectLayer", options);
     /** @type {import('./atlas-sprite-sheet.model.js').AtlasSpriteSheetModel} */
     const AtlasSpriteSheet =
-      DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.AtlasSpriteSheet;
+      DataBaseProviderService.getModel("AtlasSpriteSheet", options);
 
     if (req.params.itemKey) {
       const doc = await AtlasSpriteSheet.findOne({ 'metadata.itemKey': req.params.itemKey })
@@ -329,15 +329,15 @@ class AtlasSpriteSheetService {
   static put = async (req, res, options) => {
     /** @type {import('./atlas-sprite-sheet.model.js').AtlasSpriteSheetModel} */
     const AtlasSpriteSheet =
-      DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.AtlasSpriteSheet;
+      DataBaseProviderService.getModel("AtlasSpriteSheet", options);
     return await AtlasSpriteSheet.findByIdAndUpdate(req.params.id, req.body);
   };
   static delete = async (req, res, options) => {
     /** @type {import('./atlas-sprite-sheet.model.js').AtlasSpriteSheetModel} */
     const AtlasSpriteSheet =
-      DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.AtlasSpriteSheet;
+      DataBaseProviderService.getModel("AtlasSpriteSheet", options);
     /** @type {import('../file/file.model.js').FileModel} */
-    const File = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.File;
+    const File = DataBaseProviderService.getModel("File", options);
 
     if (req.params.id) {
       const atlasDoc = await AtlasSpriteSheet.findById(req.params.id);

package/src/api/core/core.router.js

@@ -5,20 +5,25 @@ import express from 'express';
 
 const logger = loggerFactory(import.meta);
 
-const CoreRouter = (options) => {
-  const router = express.Router();
-  const authMiddleware = options.authMiddleware;
-  router.post(`/:id`, authMiddleware, adminGuard, async (req, res) => await CoreController.post(req, res, options));
-  router.post(`/`, authMiddleware, adminGuard, async (req, res) => await CoreController.post(req, res, options));
-  router.get(`/:id`, authMiddleware, adminGuard, async (req, res) => await CoreController.get(req, res, options));
-  router.get(`/`, authMiddleware, adminGuard, async (req, res) => await CoreController.get(req, res, options));
-  router.put(`/:id`, authMiddleware, adminGuard, async (req, res) => await CoreController.put(req, res, options));
-  router.put(`/`, authMiddleware, adminGuard, async (req, res) => await CoreController.put(req, res, options));
-  router.delete(`/:id`, authMiddleware, adminGuard, async (req, res) => await CoreController.delete(req, res, options));
-  router.delete(`/`, authMiddleware, adminGuard, async (req, res) => await CoreController.delete(req, res, options));
-  return router;
-};
+class CoreRouter {
+  /**
+   * @param {import('../types.js').RouterOptions} options
+   * @returns {import('express').Router}
+   */
+  static router(options) {
+    const router = express.Router();
+    router.post(`/:id`, options.authMiddleware, adminGuard, async (req, res) => await CoreController.post(req, res, options));
+    router.post(`/`, options.authMiddleware, adminGuard, async (req, res) => await CoreController.post(req, res, options));
+    router.get(`/:id`, options.authMiddleware, adminGuard, async (req, res) => await CoreController.get(req, res, options));
+    router.get(`/`, options.authMiddleware, adminGuard, async (req, res) => await CoreController.get(req, res, options));
+    router.put(`/:id`, options.authMiddleware, adminGuard, async (req, res) => await CoreController.put(req, res, options));
+    router.put(`/`, options.authMiddleware, adminGuard, async (req, res) => await CoreController.put(req, res, options));
+    router.delete(`/:id`, options.authMiddleware, adminGuard, async (req, res) => await CoreController.delete(req, res, options));
+    router.delete(`/`, options.authMiddleware, adminGuard, async (req, res) => await CoreController.delete(req, res, options));
+    return router;
+  }
+}
 
-const ApiRouter = CoreRouter;
+const ApiRouter = (options) => CoreRouter.router(options);
 
 export { ApiRouter, CoreRouter };

package/src/api/core/core.service.js

@@ -1,4 +1,4 @@
-import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+import { DataBaseProviderService } from '../../db/DataBaseProvider.js';
 import { loggerFactory } from '../../server/logger.js';
 import { shellExec } from '../../server/process.js';
 
@@ -7,22 +7,22 @@ const logger = loggerFactory(import.meta);
 class CoreService {
   static post = async (req, res, options) => {
     /** @type {import('./core.model.js').CoreModel} */
-    const Core = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Core;
+    const Core = DataBaseProviderService.getModel("Core", options);
     return await new Core(req.body).save();
   };
   static get = async (req, res, options) => {
     /** @type {import('./core.model.js').CoreModel} */
-    const Core = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Core;
+    const Core = DataBaseProviderService.getModel("Core", options);
     return await Core.findById(req.params.id);
   };
   static put = async (req, res, options) => {
     /** @type {import('./core.model.js').CoreModel} */
-    const Core = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Core;
+    const Core = DataBaseProviderService.getModel("Core", options);
     return await Core.findByIdAndUpdate(req.params.id, req.body);
   };
   static delete = async (req, res, options) => {
     /** @type {import('./core.model.js').CoreModel} */
-    const Core = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Core;
+    const Core = DataBaseProviderService.getModel("Core", options);
     return await Core.findByIdAndDelete(req.params.id);
   };
 }

package/src/api/crypto/crypto.router.js

@@ -1,20 +1,26 @@
 import { loggerFactory } from '../../server/logger.js';
 import { CryptoController } from './crypto.controller.js';
 import express from 'express';
+
 const logger = loggerFactory(import.meta);
 
-const CryptoRouter = (options) => {
-  const router = express.Router();
-  const authMiddleware = options.authMiddleware;
-  router.post(`/:id`, async (req, res) => await CryptoController.post(req, res, options));
-  router.post(`/`, authMiddleware, async (req, res) => await CryptoController.post(req, res, options));
-  router.get(`/:id`, async (req, res) => await CryptoController.get(req, res, options));
-  router.get(`/`, async (req, res) => await CryptoController.get(req, res, options));
-  router.delete(`/:id`, async (req, res) => await CryptoController.delete(req, res, options));
-  router.delete(`/`, async (req, res) => await CryptoController.delete(req, res, options));
-  return router;
-};
+class CryptoRouter {
+  /**
+   * @param {import('../types.js').RouterOptions} options
+   * @returns {import('express').Router}
+   */
+  static router(options) {
+    const router = express.Router();
+    router.post(`/:id`, async (req, res) => await CryptoController.post(req, res, options));
+    router.post(`/`, options.authMiddleware, async (req, res) => await CryptoController.post(req, res, options));
+    router.get(`/:id`, async (req, res) => await CryptoController.get(req, res, options));
+    router.get(`/`, async (req, res) => await CryptoController.get(req, res, options));
+    router.delete(`/:id`, async (req, res) => await CryptoController.delete(req, res, options));
+    router.delete(`/`, async (req, res) => await CryptoController.delete(req, res, options));
+    return router;
+  }
+}
 
-const ApiRouter = CryptoRouter;
+const ApiRouter = (options) => CryptoRouter.router(options);
 
 export { ApiRouter, CryptoRouter };

package/src/api/crypto/crypto.service.js

@@ -1,14 +1,14 @@
 import { loggerFactory } from '../../server/logger.js';
 import crypto from 'crypto';
-import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+import { DataBaseProviderService } from '../../db/DataBaseProvider.js';
 const logger = loggerFactory(import.meta);
 
 class CryptoService {
   static post = async (req, res, options) => {
     /** @type {import('./crypto.model.js').CryptoModel} */
-    const Crypto = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Crypto;
+    const Crypto = DataBaseProviderService.getModel("Crypto", options);
     /** @type {import('../user/user.model.js').UserModel} */
-    const User = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.User;
+    const User = DataBaseProviderService.getModel("User", options);
 
     switch (req.params.id) {
       case 'verify': {

package/src/api/cyberia-action/cyberia-action.model.js

@@ -1,5 +1,5 @@
 import { Schema, model } from 'mongoose';
-import { CYBERIA_ACTION_TYPES } from '../../client/components/cyberia-portal/CommonCyberiaPortal.js';
+import { CYBERIA_ACTION_TYPES } from '../../client/components/cyberia/SharedDefaultsCyberia.js';
 
 // https://mongoosejs.com/docs/2.7.x/docs/schematypes.html
 

package/src/api/cyberia-action/cyberia-action.router.js

@@ -4,24 +4,28 @@ import express from 'express';
 
 const logger = loggerFactory(import.meta);
 
-const CyberiaActionRouter = (options) => {
-  const router = express.Router();
-  const authMiddleware = options.authMiddleware;
-  router.post(`/:id`, async (req, res) => await CyberiaActionController.post(req, res, options));
-  router.post(`/`, async (req, res) => await CyberiaActionController.post(req, res, options));
-  router.get(
-    `/:id`,
-    // authMiddleware,
-    async (req, res) => await CyberiaActionController.get(req, res, options),
-  );
-  router.get(`/`, async (req, res) => await CyberiaActionController.get(req, res, options));
-  router.put(`/:id`, async (req, res) => await CyberiaActionController.put(req, res, options));
-  router.put(`/`, async (req, res) => await CyberiaActionController.put(req, res, options));
-  router.delete(`/:id`, async (req, res) => await CyberiaActionController.delete(req, res, options));
-  router.delete(`/`, async (req, res) => await CyberiaActionController.delete(req, res, options));
-  return router;
-};
+class CyberiaActionRouter {
+  /**
+   * @param {import('../types.js').RouterOptions} options
+   * @returns {import('express').Router}
+   */
+  static router(options) {
+    const router = express.Router();
+    router.post(`/:id`, async (req, res) => await CyberiaActionController.post(req, res, options));
+    router.post(`/`, async (req, res) => await CyberiaActionController.post(req, res, options));
+    router.get(`/:id`,
+      // options.authMiddleware,
+      async (req, res) => await CyberiaActionController.get(req, res, options),
+    );
+    router.get(`/`, async (req, res) => await CyberiaActionController.get(req, res, options));
+    router.put(`/:id`, async (req, res) => await CyberiaActionController.put(req, res, options));
+    router.put(`/`, async (req, res) => await CyberiaActionController.put(req, res, options));
+    router.delete(`/:id`, async (req, res) => await CyberiaActionController.delete(req, res, options));
+    router.delete(`/`, async (req, res) => await CyberiaActionController.delete(req, res, options));
+    return router;
+  }
+}
 
-const ApiRouter = CyberiaActionRouter;
+const ApiRouter = (options) => CyberiaActionRouter.router(options);
 
 export { ApiRouter, CyberiaActionRouter };

package/src/api/cyberia-action/cyberia-action.service.js

@@ -1,4 +1,4 @@
-import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+import { DataBaseProviderService } from '../../db/DataBaseProvider.js';
 import { loggerFactory } from '../../server/logger.js';
 import { DataQuery } from '../../server/data-query.js';
 
@@ -7,12 +7,12 @@ const logger = loggerFactory(import.meta);
 class CyberiaActionService {
   static post = async (req, res, options) => {
     /** @type {import('./cyberia-action.model.js').CyberiaActionModel} */
-    const CyberiaAction = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaAction;
+    const CyberiaAction = DataBaseProviderService.getModel("CyberiaAction", options);
     return await new CyberiaAction(req.body).save();
   };
   static get = async (req, res, options) => {
     /** @type {import('./cyberia-action.model.js').CyberiaActionModel} */
-    const CyberiaAction = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaAction;
+    const CyberiaAction = DataBaseProviderService.getModel("CyberiaAction", options);
     if (req.params.id) return await CyberiaAction.findById(req.params.id);
 
     // Parse query parameters using DataQuery helper
@@ -28,12 +28,12 @@ class CyberiaActionService {
   };
   static put = async (req, res, options) => {
     /** @type {import('./cyberia-action.model.js').CyberiaActionModel} */
-    const CyberiaAction = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaAction;
+    const CyberiaAction = DataBaseProviderService.getModel("CyberiaAction", options);
     return await CyberiaAction.findByIdAndUpdate(req.params.id, req.body);
   };
   static delete = async (req, res, options) => {
     /** @type {import('./cyberia-action.model.js').CyberiaActionModel} */
-    const CyberiaAction = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaAction;
+    const CyberiaAction = DataBaseProviderService.getModel("CyberiaAction", options);
     if (req.params.id) return await CyberiaAction.findByIdAndDelete(req.params.id);
     else return await CyberiaAction.deleteMany();
   };

package/src/api/cyberia-client-hints/cyberia-client-hints.controller.js

@@ -0,0 +1,74 @@
+import { loggerFactory } from '../../server/logger.js';
+import { CyberiaClientHintsService } from './cyberia-client-hints.service.js';
+
+const logger = loggerFactory(import.meta);
+
+class CyberiaClientHintsController {
+  static post = async (req, res, options) => {
+    try {
+      const result = await CyberiaClientHintsService.post(req, res, options);
+      return res.status(200).json({
+        status: 'success',
+        data: result,
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  };
+  static get = async (req, res, options) => {
+    try {
+      const { page, limit } = req.query;
+      const result = await CyberiaClientHintsService.get(
+        { ...req, query: { ...req.query, page: parseInt(page), limit: parseInt(limit) } },
+        res,
+        options,
+      );
+      return res.status(200).json({
+        status: 'success',
+        data: result,
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  };
+  static put = async (req, res, options) => {
+    try {
+      const result = await CyberiaClientHintsService.put(req, res, options);
+      return res.status(200).json({
+        status: 'success',
+        data: result,
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  };
+  static delete = async (req, res, options) => {
+    try {
+      const result = await CyberiaClientHintsService.delete(req, res, options);
+      return res.status(200).json({
+        status: 'success',
+        data: result,
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  };
+}
+
+export { CyberiaClientHintsController };