cyberia 3.2.5 → 3.2.12

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

@@ -3,8 +3,8 @@ import { AtlasSpriteSheetService } from './atlas-sprite-sheet.service.js';
 
 const logger = loggerFactory(import.meta);
 
-const AtlasSpriteSheetController = {
-  blob: async (req, res, options) => {
+class AtlasSpriteSheetController {
+  static blob = async (req, res, options) => {
     try {
       if (req && req.headers && req.headers.origin) {
         res.set('Access-Control-Allow-Origin', req.headers.origin);
@@ -23,8 +23,8 @@ const AtlasSpriteSheetController = {
         message: error.message,
       });
     }
-  },
-  generate: async (req, res, options) => {
+  };
+  static generate = async (req, res, options) => {
     try {
       const result = await AtlasSpriteSheetService.generate(req, res, options);
       return res.status(200).json({
@@ -38,8 +38,8 @@ const AtlasSpriteSheetController = {
         message: error.message,
       });
     }
-  },
-  deleteByObjectLayerId: async (req, res, options) => {
+  };
+  static deleteByObjectLayerId = async (req, res, options) => {
     try {
       const result = await AtlasSpriteSheetService.deleteByObjectLayerId(req, res, options);
       return res.status(200).json({
@@ -53,8 +53,8 @@ const AtlasSpriteSheetController = {
         message: error.message,
       });
     }
-  },
-  post: async (req, res, options) => {
+  };
+  static post = async (req, res, options) => {
     try {
       const result = await AtlasSpriteSheetService.post(req, res, options);
       return res.status(200).json({
@@ -68,8 +68,8 @@ const AtlasSpriteSheetController = {
         message: error.message,
       });
     }
-  },
-  get: async (req, res, options) => {
+  };
+  static get = async (req, res, options) => {
     try {
       if (req && req.headers && req.headers.origin) {
         res.set('Access-Control-Allow-Origin', req.headers.origin);
@@ -92,8 +92,8 @@ const AtlasSpriteSheetController = {
         message: error.message,
       });
     }
-  },
-  put: async (req, res, options) => {
+  };
+  static put = async (req, res, options) => {
     try {
       const result = await AtlasSpriteSheetService.put(req, res, options);
       return res.status(200).json({
@@ -107,8 +107,8 @@ const AtlasSpriteSheetController = {
         message: error.message,
       });
     }
-  },
-  delete: async (req, res, options) => {
+  };
+  static delete = async (req, res, options) => {
     try {
       const result = await AtlasSpriteSheetService.delete(req, res, options);
       return res.status(200).json({
@@ -122,8 +122,8 @@ const AtlasSpriteSheetController = {
         message: error.message,
       });
     }
-  },
-  getMetadata: async (req, res, options) => {
+  };
+  static getMetadata = async (req, res, options) => {
     try {
       if (req && req.headers && req.headers.origin) {
         res.set('Access-Control-Allow-Origin', req.headers.origin);
@@ -146,7 +146,7 @@ const AtlasSpriteSheetController = {
         message: error.message,
       });
     }
-  },
-};
+  };
+}
 
 export { AtlasSpriteSheetController };

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

@@ -3,9 +3,7 @@
  * @module src/api/atlas-sprite-sheet/atlas-sprite-sheet.model.js
  * @namespace CyberiaAtlasSpriteSheetModel
  */
-
 import { Schema, model, Types } from 'mongoose';
-
 /**
  * @typedef {Object} FrameMetadata
  * @property {number} x - X position in the atlas
@@ -25,7 +23,6 @@ const FrameMetadataSchema = new Schema(
   },
   { _id: false },
 );
-
 /**
  * @typedef {Object} DirectionFrames
  * @property {FrameMetadata[]} up_idle - Up idle animation frames
@@ -71,7 +68,6 @@ const DirectionFramesSchema = new Schema(
   },
   { _id: false },
 );
-
 /**
  * @typedef {Object} AtlasSpriteSheet
  * @property {Types.ObjectId} fileId - Reference to File document (consolidated PNG)
@@ -81,6 +77,7 @@ const DirectionFramesSchema = new Schema(
  * @property {number} metadata.atlasWidth - Total atlas width in pixels
  * @property {number} metadata.atlasHeight - Total atlas height in pixels
  * @property {number} metadata.cellPixelDim - Pixel dimension of each cell
+ * @property {number} metadata.frame_duration - Duration of each frame in milliseconds
  * @property {DirectionFrames} metadata.frames - Frame positions in atlas by direction
  * @property {Date} createdAt - When the document was created
  * @property {Date} updatedAt - When the document was last updated
@@ -103,6 +100,7 @@ const AtlasSpriteSheetSchema = new Schema(
       atlasWidth: { type: Number, required: true, min: 1 },
       atlasHeight: { type: Number, required: true, min: 1 },
       cellPixelDim: { type: Number, required: true, min: 1, default: 20 },
+      frame_duration: { type: Number, min: 0, default: 100 },
       frames: { type: DirectionFramesSchema, required: true },
     },
   },
@@ -112,24 +110,19 @@ const AtlasSpriteSheetSchema = new Schema(
     toObject: { virtuals: true },
   },
 );
-
 // Indexes for efficient querying
 AtlasSpriteSheetSchema.index({ 'metadata.itemKey': 1 }, { unique: true });
 AtlasSpriteSheetSchema.index({ fileId: 1 });
-
 // Pre-save validation
 AtlasSpriteSheetSchema.pre('save', function () {
   if (!this.fileId || !this.metadata) {
     throw new Error('AtlasSpriteSheet missing required fields: fileId or metadata');
   }
 });
-
 const AtlasSpriteSheetModel = model('AtlasSpriteSheet', AtlasSpriteSheetSchema);
-
 const ProviderSchema = AtlasSpriteSheetSchema;
-
-const AtlasSpriteSheetDto = {
-  select: {
+class AtlasSpriteSheetDto {
+  static select = {
     get: () => {
       return {
         _id: 1,
@@ -151,12 +144,12 @@ const AtlasSpriteSheetDto = {
         'metadata.atlasWidth': 1,
         'metadata.atlasHeight': 1,
         'metadata.cellPixelDim': 1,
+        'metadata.frame_duration': 1,
         'metadata.frames': 1,
         createdAt: 1,
         updatedAt: 1,
       };
     },
-  },
-};
-
+  };
+}
 export { AtlasSpriteSheetSchema, AtlasSpriteSheetModel, ProviderSchema, AtlasSpriteSheetDto };

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';
@@ -8,14 +8,56 @@ import { IpfsClient } from '../../server/ipfs-client.js';
 import { createPinRecord, removePinRecordsAndUnpin } from '../ipfs/ipfs.service.js';
 
 const logger = loggerFactory(import.meta);
-
-const AtlasSpriteSheetService = {
-  blob: async (req, res, options) => {
+const DEFAULT_ATLAS_FRAME_DURATION = 100;
+
+function parseAtlasFrameDuration(value) {
+  const frameDuration = Number(value);
+  return Number.isFinite(frameDuration) ? frameDuration : null;
+}
+
+async function resolveAtlasFrameDuration(ObjectLayer, itemKey) {
+  if (!itemKey) return DEFAULT_ATLAS_FRAME_DURATION;
+
+  const objectLayer = await ObjectLayer.findOne({ 'data.item.id': itemKey })
+    .select({ _id: 1, objectLayerRenderFramesId: 1 })
+    .populate('objectLayerRenderFramesId', { _id: 1, frame_duration: 1 })
+    .lean();
+
+  return (
+    parseAtlasFrameDuration(objectLayer?.objectLayerRenderFramesId?.frame_duration) || DEFAULT_ATLAS_FRAME_DURATION
+  );
+}
+
+async function withResolvedAtlasFrameDuration(doc, ObjectLayer) {
+  if (!doc?.metadata) return doc;
+
+  const frameDuration = parseAtlasFrameDuration(doc.metadata.frame_duration);
+  if (frameDuration !== null) {
+    return {
+      ...doc,
+      metadata: {
+        ...doc.metadata,
+        frame_duration: frameDuration,
+      },
+    };
+  }
+
+  return {
+    ...doc,
+    metadata: {
+      ...doc.metadata,
+      frame_duration: await resolveAtlasFrameDuration(ObjectLayer, doc.metadata.itemKey),
+    },
+  };
+}
+
+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();
@@ -25,15 +67,15 @@ const AtlasSpriteSheetService = {
     if (!fileDoc || !fileDoc.data) throw new Error(`File not found for atlas itemKey: ${itemKey}`);
 
     return { buffer: Buffer.from(fileDoc.data), mimetype: fileDoc.mimetype || 'image/png', name: fileDoc.name };
-  },
-  generate: async (req, res, options, generateOptions = {}) => {
+  };
+  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;
 
@@ -150,15 +192,15 @@ const AtlasSpriteSheetService = {
     await objectLayer.save();
 
     return atlasDoc;
-  },
-  deleteByObjectLayerId: async (req, res, options) => {
+  };
+  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) {
@@ -209,17 +251,17 @@ const AtlasSpriteSheetService = {
     }
 
     return { success: true };
-  },
-  post: async (req, res, options) => {
+  };
+  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();
-  },
-  get: async (req, res, options) => {
+  };
+  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())
@@ -240,20 +282,22 @@ const AtlasSpriteSheetService = {
 
     const totalPages = Math.ceil(total / limit);
     return { data, total, page, totalPages };
-  },
+  };
   // Returns atlas metadata (layout + frames) for the client.
   // Client fetches this once per itemKey, caches it, then fetches the PNG blob.
-  getMetadata: async (req, res, options) => {
+  static getMetadata = async (req, res, options) => {
+    /** @type {import('../object-layer/object-layer.model.js').ObjectLayerModel} */
+    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 })
         .select(AtlasSpriteSheetDto.select.getMetadataOnly())
         .lean();
       if (!doc) throw new Error(`Atlas not found for itemKey: ${req.params.itemKey}`);
-      return doc;
+      return await withResolvedAtlasFrameDuration(doc, ObjectLayer);
     }
 
     const { query, sort, skip, limit, page } = DataQuery.parse(req.query);
@@ -269,20 +313,31 @@ const AtlasSpriteSheetService = {
     ]);
 
     const totalPages = Math.ceil(total / limit);
-    return { data, total, page, totalPages };
-  },
-  put: async (req, res, options) => {
+    return {
+      data: data.map((doc) => ({
+        ...doc,
+        metadata: {
+          ...doc.metadata,
+          frame_duration: parseAtlasFrameDuration(doc?.metadata?.frame_duration) || DEFAULT_ATLAS_FRAME_DURATION,
+        },
+      })),
+      total,
+      page,
+      totalPages,
+    };
+  };
+  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);
-  },
-  delete: async (req, res, options) => {
+  };
+  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);
@@ -329,7 +384,7 @@ const AtlasSpriteSheetService = {
       }
       return await AtlasSpriteSheet.deleteMany();
     }
-  },
-};
+  };
+}
 
 export { AtlasSpriteSheetService };

package/src/api/core/core.controller.js

@@ -3,8 +3,8 @@ import { CoreService } from './core.service.js';
 
 const logger = loggerFactory(import.meta);
 
-const CoreController = {
-  post: async (req, res, options) => {
+class CoreController {
+  static post = async (req, res, options) => {
     try {
       const result = await CoreService.post(req, res, options);
       return res.status(200).json({
@@ -18,8 +18,8 @@ const CoreController = {
         message: error.message,
       });
     }
-  },
-  get: async (req, res, options) => {
+  };
+  static get = async (req, res, options) => {
     try {
       const result = await CoreService.put(req, res, options);
       return res.status(200).json({
@@ -33,8 +33,8 @@ const CoreController = {
         message: error.message,
       });
     }
-  },
-  put: async (req, res, options) => {
+  };
+  static put = async (req, res, options) => {
     try {
       const result = await CoreService.get(req, res, options);
       return res.status(200).json({
@@ -48,8 +48,8 @@ const CoreController = {
         message: error.message,
       });
     }
-  },
-  delete: async (req, res, options) => {
+  };
+  static delete = async (req, res, options) => {
     try {
       const result = await CoreService.delete(req, res, options);
       return res.status(200).json({
@@ -63,7 +63,7 @@ const CoreController = {
         message: error.message,
       });
     }
-  },
-};
+  };
+}
 
 export { CoreController };

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,30 +1,30 @@
-import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+import { DataBaseProviderService } from '../../db/DataBaseProvider.js';
 import { loggerFactory } from '../../server/logger.js';
 import { shellExec } from '../../server/process.js';
 
 const logger = loggerFactory(import.meta);
 
-const CoreService = {
-  post: async (req, res, options) => {
+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();
-  },
-  get: async (req, res, options) => {
+  };
+  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);
-  },
-  put: async (req, res, options) => {
+  };
+  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);
-  },
-  delete: async (req, res, options) => {
+  };
+  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);
-  },
-};
+  };
+}
 
 export { CoreService };

package/src/api/crypto/crypto.controller.js

@@ -2,8 +2,8 @@ import { loggerFactory } from '../../server/logger.js';
 import { CryptoService } from './crypto.service.js';
 const logger = loggerFactory(import.meta);
 
-const CryptoController = {
-  post: async (req, res, options) => {
+class CryptoController {
+  static post = async (req, res, options) => {
     try {
       return res.status(200).json({
         status: 'success',
@@ -16,8 +16,8 @@ const CryptoController = {
         message: error.message,
       });
     }
-  },
-  get: async (req, res, options) => {
+  };
+  static get = async (req, res, options) => {
     try {
       return res.status(200).json({
         status: 'success',
@@ -30,8 +30,8 @@ const CryptoController = {
         message: error.message,
       });
     }
-  },
-  delete: async (req, res, options) => {
+  };
+  static delete = async (req, res, options) => {
     try {
       const result = await CryptoService.delete(req, res, options);
       return res.status(200).json({
@@ -45,7 +45,7 @@ const CryptoController = {
         message: error.message,
       });
     }
-  },
-};
+  };
+}
 
 export { CryptoController };