cyberia 3.2.9 → 3.2.12

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

@@ -5,59 +5,64 @@ import express from 'express';
 
 const logger = loggerFactory(import.meta);
 
-const CyberiaInstanceRouter = (options) => {
-  const router = express.Router();
-  const authMiddleware = options.authMiddleware;
-  // ── Custom actions (must come before generic /:id routes) ──────────────
-  router.get(`/fallback-world`, async (req, res) => await CyberiaInstanceController.fallbackWorld(req, res, options));
-  router.get(
-    `/:id/portal-connect`,
-    authMiddleware,
-    userGuard,
-    async (req, res) => await CyberiaInstanceController.portalConnect(req, res, options),
-  );
+class CyberiaInstanceRouter {
+  /**
+   * @param {import('../types.js').RouterOptions} options
+   * @returns {import('express').Router}
+   */
+  static router(options) {
+    const router = express.Router();
+    // ── Custom actions (must come before generic /:id routes) ──────────────
+    router.get(`/fallback-world`, async (req, res) => await CyberiaInstanceController.fallbackWorld(req, res, options));
+    router.get(
+      `/:id/portal-connect`,
+      options.authMiddleware,
+      userGuard,
+      async (req, res) => await CyberiaInstanceController.portalConnect(req, res, options),
+    );
 
-  router.post(
-    `/:id`,
-    authMiddleware,
-    userGuard,
-    async (req, res) => await CyberiaInstanceController.post(req, res, options),
-  );
-  router.post(
-    `/`,
-    authMiddleware,
-    userGuard,
-    async (req, res) => await CyberiaInstanceController.post(req, res, options),
-  );
-  router.get(`/:id`, async (req, res) => await CyberiaInstanceController.get(req, res, options));
-  router.get(`/`, async (req, res) => await CyberiaInstanceController.get(req, res, options));
-  router.put(
-    `/:id`,
-    authMiddleware,
-    userGuard,
-    async (req, res) => await CyberiaInstanceController.put(req, res, options),
-  );
-  router.put(
-    `/`,
-    authMiddleware,
-    userGuard,
-    async (req, res) => await CyberiaInstanceController.put(req, res, options),
-  );
-  router.delete(
-    `/:id`,
-    authMiddleware,
-    userGuard,
-    async (req, res) => await CyberiaInstanceController.delete(req, res, options),
-  );
-  router.delete(
-    `/`,
-    authMiddleware,
-    adminGuard,
-    async (req, res) => await CyberiaInstanceController.delete(req, res, options),
-  );
-  return router;
-};
+    router.post(
+      `/:id`,
+      options.authMiddleware,
+      userGuard,
+      async (req, res) => await CyberiaInstanceController.post(req, res, options),
+    );
+    router.post(
+      `/`,
+      options.authMiddleware,
+      userGuard,
+      async (req, res) => await CyberiaInstanceController.post(req, res, options),
+    );
+    router.get(`/:id`, async (req, res) => await CyberiaInstanceController.get(req, res, options));
+    router.get(`/`, async (req, res) => await CyberiaInstanceController.get(req, res, options));
+    router.put(
+      `/:id`,
+      options.authMiddleware,
+      userGuard,
+      async (req, res) => await CyberiaInstanceController.put(req, res, options),
+    );
+    router.put(
+      `/`,
+      options.authMiddleware,
+      userGuard,
+      async (req, res) => await CyberiaInstanceController.put(req, res, options),
+    );
+    router.delete(
+      `/:id`,
+      options.authMiddleware,
+      userGuard,
+      async (req, res) => await CyberiaInstanceController.delete(req, res, options),
+    );
+    router.delete(
+      `/`,
+      options.authMiddleware,
+      adminGuard,
+      async (req, res) => await CyberiaInstanceController.delete(req, res, options),
+    );
+    return router;
+  }
+}
 
-const ApiRouter = CyberiaInstanceRouter;
+const ApiRouter = (options) => CyberiaInstanceRouter.router(options);
 
 export { ApiRouter, CyberiaInstanceRouter };

package/src/api/cyberia-instance/cyberia-instance.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 { connectPortals } from './cyberia-portal-connector.js';
@@ -9,9 +9,9 @@ const logger = loggerFactory(import.meta);
 class CyberiaInstanceService {
   static post = async (req, res, options) => {
     /** @type {import('./cyberia-instance.model.js').CyberiaInstanceModel} */
-    const CyberiaInstance = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaInstance;
+    const CyberiaInstance = DataBaseProviderService.getModel("CyberiaInstance", options);
     const CyberiaInstanceConf =
-      DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaInstanceConf;
+      DataBaseProviderService.getModel("CyberiaInstanceConf", options);
     if (req.auth && req.auth.user) req.body.creator = req.auth.user._id;
     const instance = await new CyberiaInstance(req.body).save();
 
@@ -37,7 +37,7 @@ class CyberiaInstanceService {
   };
   static get = async (req, res, options) => {
     /** @type {import('./cyberia-instance.model.js').CyberiaInstanceModel} */
-    const CyberiaInstance = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaInstance;
+    const CyberiaInstance = DataBaseProviderService.getModel("CyberiaInstance", options);
     const populateCreator = { path: 'creator', model: 'User', select: '_id username' };
     if (req.params.id) return await CyberiaInstance.findById(req.params.id).populate(populateCreator);
 
@@ -54,13 +54,13 @@ class CyberiaInstanceService {
   };
   static put = async (req, res, options) => {
     /** @type {import('./cyberia-instance.model.js').CyberiaInstanceModel} */
-    const CyberiaInstance = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaInstance;
+    const CyberiaInstance = DataBaseProviderService.getModel("CyberiaInstance", options);
     const instance = await CyberiaInstance.findById(req.params.id);
     if (!instance) throw new Error('instance not found');
     if (req.auth.user.role !== 'admin' && String(instance.creator) !== String(req.auth.user._id))
       throw new Error('insufficient permission');
     if (req.body.thumbnail && instance.thumbnail && String(req.body.thumbnail) !== String(instance.thumbnail)) {
-      const File = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.File;
+      const File = DataBaseProviderService.getModel("File", options);
       await File.findByIdAndDelete(instance.thumbnail);
     }
     return await CyberiaInstance.findByIdAndUpdate(req.params.id, req.body, { returnDocument: 'after' });
@@ -80,8 +80,8 @@ class CyberiaInstanceService {
    *   ?persist=true  — save generated portals to DB
    */
   static portalConnect = async (req, res, options) => {
-    const CyberiaInstance = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaInstance;
-    const CyberiaMap = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaMap;
+    const CyberiaInstance = DataBaseProviderService.getModel("CyberiaInstance", options);
+    const CyberiaMap = DataBaseProviderService.getModel("CyberiaMap", options);
 
     const instance = await CyberiaInstance.findById(req.params.id).lean();
     if (!instance) throw new Error('instance not found');
@@ -116,14 +116,14 @@ class CyberiaInstanceService {
 
   static delete = async (req, res, options) => {
     /** @type {import('./cyberia-instance.model.js').CyberiaInstanceModel} */
-    const CyberiaInstance = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaInstance;
+    const CyberiaInstance = DataBaseProviderService.getModel("CyberiaInstance", options);
     if (req.params.id) {
       const instance = await CyberiaInstance.findById(req.params.id);
       if (!instance) throw new Error('instance not found');
       if (req.auth.user.role !== 'admin' && String(instance.creator) !== String(req.auth.user._id))
         throw new Error('insufficient permission');
       if (instance.thumbnail) {
-        const File = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.File;
+        const File = DataBaseProviderService.getModel("File", options);
         await File.findByIdAndDelete(instance.thumbnail);
       }
       return await CyberiaInstance.findByIdAndDelete(req.params.id);

package/src/api/cyberia-instance/cyberia-world-generator.js

@@ -19,9 +19,9 @@
 import {
   ENTITY_TYPE_DEFAULTS,
   RESOURCE_ENTITY_TYPE_DEFAULTS,
-} from '../cyberia-instance-conf/cyberia-instance-conf.defaults.js';
-
-import { DefaultCyberiaItems, ITEM_TYPES } from '../../client/components/cyberia-portal/CommonCyberiaPortal.js';
+  DefaultCyberiaItems,
+  ITEM_TYPES,
+} from '../cyberia-server-defaults/cyberia-server-defaults.js';
 
 import { PORTAL_MODES, PORTAL_MODE_COLOR_KEY, EXTRA_PORTAL_MODES } from './cyberia-portal-connector.js';
 

package/src/api/cyberia-instance-conf/cyberia-instance-conf.model.js

@@ -1,16 +1,5 @@
 import { Schema, model } from 'mongoose';
-import { CYBERIA_INSTANCE_CONF_DEFAULTS as D } from './cyberia-instance-conf.defaults.js';
-
-const ColorEntrySchema = new Schema(
-  {
-    key: { type: String, required: true },
-    r: { type: Number, default: 0 },
-    g: { type: Number, default: 0 },
-    b: { type: Number, default: 0 },
-    a: { type: Number, default: 255 },
-  },
-  { _id: false },
-);
+import { CYBERIA_INSTANCE_CONF_DEFAULTS as D } from '../cyberia-server-defaults/cyberia-server-defaults.js';
 
 // ObjectLayer inventory slot: itemId + whether it starts active + initial quantity.
 // Used by EntityDefaultSchema.defaultObjectLayers.
@@ -23,6 +12,9 @@ const ObjectLayerSlotSchema = new Schema(
   { _id: false },
 );
 
+// Per-entity-type simulation defaults. ONLY authoritative item-id wiring
+// lives here — presentation (palette, colour keys) is the client's
+// responsibility and travels through the CyberiaClientHints REST contract.
 const EntityDefaultSchema = new Schema(
   {
     // Entity category string (matches entity_type_str / bot Behavior in game engine)
@@ -30,13 +22,10 @@ const EntityDefaultSchema = new Schema(
     // Default ObjectLayer item IDs when the entity is alive and carries no assigned items.
     liveItemIds: { type: [String], default: [] },
     // Default ObjectLayer item IDs for the dead / ghost / respawning state.
-    // Empty array = use liveItemIds solid fill color.
     deadItemIds: { type: [String], default: [] },
     // Resource-only inventory items granted on extraction/depletion.
     // These are not auto-activated on the entity itself.
     dropItemIds: { type: [String], default: [] },
-    // Palette key for solid-color fallback when no OL items are assigned.
-    colorKey: { type: String, default: '' },
     // Full default ObjectLayer inventory for this entity type.
     // Each entry specifies itemId, whether it starts active, and its initial quantity.
     // The coin slot must always have active:false — coins are non-activable.
@@ -55,26 +44,14 @@ const SkillConfigEntrySchema = new Schema(
 );
 
 // ── StatusIconEntrySchema ────────────────────────────────────────────────────
-// Maps a u8 status ID to an overhead icon and a border colour used by the
-// interaction bubble / interact overlay on the C/WASM client.
-// See STATUS_ICONS in cyberia-instance-conf.defaults.js.
-const StatusIconBorderColorSchema = new Schema(
-  {
-    r: { type: Number, default: 100 },
-    g: { type: Number, default: 100 },
-    b: { type: Number, default: 100 },
-    a: { type: Number, default: 200 },
-  },
-  { _id: false },
-);
-
+// Numeric Entity Status Indicator (ESI) IDs. The Go server stamps one of
+// these u8 IDs on every entity in the AOI binary wire format. Visual
+// resolution (icon stem, border colour, bounce) is the C client's job and
+// arrives through the /api/cyberia-client-hints REST contract — NOT here.
 const StatusIconEntrySchema = new Schema(
   {
     id: { type: Number, required: true },
     name: { type: String, default: '' },
-    iconId: { type: String, default: null },
-    bounce: { type: Boolean, default: false },
-    borderColor: { type: StatusIconBorderColorSchema },
     description: { type: String, default: '' },
   },
   { _id: false },
@@ -82,7 +59,7 @@ const StatusIconEntrySchema = new Schema(
 
 // ── EconomyRulesSchema ───────────────────────────────────────────────────────
 // Mirrors the EconomyRules proto message and the economyRules sub-document in
-// cyberia-instance-conf.defaults.js.  All fields default from those canonical
+// cyberia-server-defaults.js.  All fields default from those canonical
 // values so a freshly created document is immediately playable.
 // See OFF_CHAIN_ECONOMY.md for the full Fountain & Sink architecture.
 const EconomyRulesSchema = new Schema(
@@ -105,7 +82,7 @@ const EconomyRulesSchema = new Schema(
 // ── EquipmentRulesSchema ─────────────────────────────────────────────────────
 // Governs which ObjectLayer item types can be simultaneously active on a
 // character entity and enforces the one-active-per-type constraint.
-// See EQUIPMENT_RULES_DEFAULTS in cyberia-instance-conf.defaults.js.
+// See EQUIPMENT_RULES_DEFAULTS in cyberia-server-defaults.js.
 const EquipmentRulesSchema = new Schema(
   {
     // Item types that players are allowed to activate (equip).
@@ -147,20 +124,9 @@ const CyberiaInstanceConfSchema = new Schema(
     // Back-reference to the owning instance (indexed for fast lookup by code).
     instanceCode: { type: String, required: true, unique: true, trim: true },
 
-    // ── Rendering / camera ──────────────────────────────────────────
-    cellSize: { type: Number, default: D.cellSize },
-    fps: { type: Number, default: D.fps },
-    interpolationMs: { type: Number, default: D.interpolationMs },
-    defaultObjWidth: { type: Number, default: D.defaultObjWidth },
-    defaultObjHeight: { type: Number, default: D.defaultObjHeight },
-    cameraSmoothing: { type: Number, default: D.cameraSmoothing },
-    cameraZoom: { type: Number, default: D.cameraZoom },
-    defaultWidthScreenFactor: { type: Number, default: D.defaultWidthScreenFactor },
-    defaultHeightScreenFactor: { type: Number, default: D.defaultHeightScreenFactor },
-    devUi: { type: Boolean, default: D.devUi },
-    // Empty array by default — colours must be configured per-instance.
-    // toInstanceConfig() fills in CYBERIA_INSTANCE_CONF_DEFAULTS.colors when the array is empty.
-    colors: { type: [ColorEntrySchema], default: [] },
+    // ── Tick model (authoritative simulation cadence) ─────────────────
+    tickRate: { type: Number, default: D.tickRate },
+    snapshotRate: { type: Number, default: D.snapshotRate },
 
     // ── World / AOI ─────────────────────────────────────────────────
     aoiRadius: { type: Number, default: D.aoiRadius },
@@ -205,7 +171,7 @@ const CyberiaInstanceConfSchema = new Schema(
 
     // ── Entity Status Indicators ────────────────────────────────────
     // Overhead icon mapping + per-status border colour.
-    // See STATUS_ICONS in cyberia-instance-conf.defaults.js.
+    // See STATUS_ICONS in cyberia-server-defaults.js.
     statusIcons: { type: [StatusIconEntrySchema], default: D.statusIcons },
 
     // ── Skill system ─────────────────────────────────────────────────

package/src/api/cyberia-instance-conf/cyberia-instance-conf.router.js

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

package/src/api/cyberia-instance-conf/cyberia-instance-conf.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';
 
@@ -8,13 +8,13 @@ class CyberiaInstanceConfService {
   static post = async (req, res, options) => {
     /** @type {import('./cyberia-instance-conf.model.js').CyberiaInstanceConfModel} */
     const CyberiaInstanceConf =
-      DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaInstanceConf;
+      DataBaseProviderService.getModel("CyberiaInstanceConf", options);
     return await new CyberiaInstanceConf(req.body).save();
   };
   static get = async (req, res, options) => {
     /** @type {import('./cyberia-instance-conf.model.js').CyberiaInstanceConfModel} */
     const CyberiaInstanceConf =
-      DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaInstanceConf;
+      DataBaseProviderService.getModel("CyberiaInstanceConf", options);
     if (req.params.id) return await CyberiaInstanceConf.findById(req.params.id);
 
     // Parse query parameters using DataQuery helper
@@ -31,13 +31,13 @@ class CyberiaInstanceConfService {
   static put = async (req, res, options) => {
     /** @type {import('./cyberia-instance-conf.model.js').CyberiaInstanceConfModel} */
     const CyberiaInstanceConf =
-      DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaInstanceConf;
+      DataBaseProviderService.getModel("CyberiaInstanceConf", options);
     return await CyberiaInstanceConf.findByIdAndUpdate(req.params.id, req.body);
   };
   static delete = async (req, res, options) => {
     /** @type {import('./cyberia-instance-conf.model.js').CyberiaInstanceConfModel} */
     const CyberiaInstanceConf =
-      DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaInstanceConf;
+      DataBaseProviderService.getModel("CyberiaInstanceConf", options);
     if (req.params.id) return await CyberiaInstanceConf.findByIdAndDelete(req.params.id);
     else return await CyberiaInstanceConf.deleteMany();
   };

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

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

package/src/api/cyberia-map/cyberia-map.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,13 +7,13 @@ const logger = loggerFactory(import.meta);
 class CyberiaMapService {
   static post = async (req, res, options) => {
     /** @type {import('./cyberia-map.model.js').CyberiaMapModel} */
-    const CyberiaMap = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaMap;
+    const CyberiaMap = DataBaseProviderService.getModel("CyberiaMap", options);
     if (req.auth && req.auth.user) req.body.creator = req.auth.user._id;
     return await new CyberiaMap(req.body).save();
   };
   static get = async (req, res, options) => {
     /** @type {import('./cyberia-map.model.js').CyberiaMapModel} */
-    const CyberiaMap = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaMap;
+    const CyberiaMap = DataBaseProviderService.getModel("CyberiaMap", options);
     const populateCreator = { path: 'creator', model: 'User', select: '_id username' };
 
     // GET /search-codes?q=<partial> - Fast partial match search on code
@@ -43,27 +43,27 @@ class CyberiaMapService {
   };
   static put = async (req, res, options) => {
     /** @type {import('./cyberia-map.model.js').CyberiaMapModel} */
-    const CyberiaMap = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaMap;
+    const CyberiaMap = DataBaseProviderService.getModel("CyberiaMap", options);
     const map = await CyberiaMap.findById(req.params.id);
     if (!map) throw new Error('map not found');
     if (req.auth.user.role !== 'admin' && String(map.creator) !== String(req.auth.user._id))
       throw new Error('insufficient permission');
     if (req.body.thumbnail && map.thumbnail && String(req.body.thumbnail) !== String(map.thumbnail)) {
-      const File = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.File;
+      const File = DataBaseProviderService.getModel("File", options);
       await File.findByIdAndDelete(map.thumbnail);
     }
     return await CyberiaMap.findByIdAndUpdate(req.params.id, req.body, { returnDocument: 'after' });
   };
   static delete = async (req, res, options) => {
     /** @type {import('./cyberia-map.model.js').CyberiaMapModel} */
-    const CyberiaMap = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaMap;
+    const CyberiaMap = DataBaseProviderService.getModel("CyberiaMap", options);
     if (req.params.id) {
       const map = await CyberiaMap.findById(req.params.id);
       if (!map) throw new Error('map not found');
       if (req.auth.user.role !== 'admin' && String(map.creator) !== String(req.auth.user._id))
         throw new Error('insufficient permission');
       if (map.thumbnail) {
-        const File = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.File;
+        const File = DataBaseProviderService.getModel("File", options);
         await File.findByIdAndDelete(map.thumbnail);
       }
       return await CyberiaMap.findByIdAndDelete(req.params.id);

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

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

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

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

package/src/api/cyberia-quest/cyberia-quest.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 CyberiaQuestService {
   static post = async (req, res, options) => {
     /** @type {import('./cyberia-quest.model.js').CyberiaQuestModel} */
-    const CyberiaQuest = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaQuest;
+    const CyberiaQuest = DataBaseProviderService.getModel("CyberiaQuest", options);
     return await new CyberiaQuest(req.body).save();
   };
   static get = async (req, res, options) => {
     /** @type {import('./cyberia-quest.model.js').CyberiaQuestModel} */
-    const CyberiaQuest = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaQuest;
+    const CyberiaQuest = DataBaseProviderService.getModel("CyberiaQuest", options);
     if (req.params.id) return await CyberiaQuest.findById(req.params.id);
 
     // Parse query parameters using DataQuery helper
@@ -28,12 +28,12 @@ class CyberiaQuestService {
   };
   static put = async (req, res, options) => {
     /** @type {import('./cyberia-quest.model.js').CyberiaQuestModel} */
-    const CyberiaQuest = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaQuest;
+    const CyberiaQuest = DataBaseProviderService.getModel("CyberiaQuest", options);
     return await CyberiaQuest.findByIdAndUpdate(req.params.id, req.body);
   };
   static delete = async (req, res, options) => {
     /** @type {import('./cyberia-quest.model.js').CyberiaQuestModel} */
-    const CyberiaQuest = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaQuest;
+    const CyberiaQuest = DataBaseProviderService.getModel("CyberiaQuest", options);
     if (req.params.id) return await CyberiaQuest.findByIdAndDelete(req.params.id);
     else return await CyberiaQuest.deleteMany();
   };