cyberia 3.0.3 → 3.2.5

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

@@ -4,6 +4,26 @@ import { AtlasSpriteSheetService } from './atlas-sprite-sheet.service.js';
 const logger = loggerFactory(import.meta);
 
 const AtlasSpriteSheetController = {
+  blob: async (req, res, options) => {
+    try {
+      if (req && req.headers && req.headers.origin) {
+        res.set('Access-Control-Allow-Origin', req.headers.origin);
+      } else res.setHeader('Access-Control-Allow-Origin', '*');
+      res.setHeader('Cross-Origin-Resource-Policy', 'cross-origin');
+
+      const { buffer, mimetype, name } = await AtlasSpriteSheetService.blob(req, res, options);
+      res.set('Content-Type', mimetype);
+      res.set('Content-Length', buffer.length);
+      res.set('Content-Disposition', `inline; filename="${name}"`);
+      return res.status(200).end(buffer);
+    } catch (error) {
+      logger.error('AtlasSpriteSheetController.blob error:', error);
+      return res.status(404).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  },
   generate: async (req, res, options) => {
     try {
       const result = await AtlasSpriteSheetService.generate(req, res, options);
@@ -51,7 +71,9 @@ const AtlasSpriteSheetController = {
   },
   get: async (req, res, options) => {
     try {
-      res.setHeader('Access-Control-Allow-Origin', '*');
+      if (req && req.headers && req.headers.origin) {
+        res.set('Access-Control-Allow-Origin', req.headers.origin);
+      } else res.setHeader('Access-Control-Allow-Origin', '*');
       res.setHeader('Cross-Origin-Resource-Policy', 'cross-origin');
       const { page, limit } = req.query;
       const result = await AtlasSpriteSheetService.get(
@@ -101,6 +123,30 @@ const AtlasSpriteSheetController = {
       });
     }
   },
+  getMetadata: async (req, res, options) => {
+    try {
+      if (req && req.headers && req.headers.origin) {
+        res.set('Access-Control-Allow-Origin', req.headers.origin);
+      } else res.setHeader('Access-Control-Allow-Origin', '*');
+      res.setHeader('Cross-Origin-Resource-Policy', 'cross-origin');
+      const { page, limit } = req.query;
+      const result = await AtlasSpriteSheetService.getMetadata(
+        { ...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(404).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  },
 };
 
 export { AtlasSpriteSheetController };

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

@@ -118,11 +118,10 @@ AtlasSpriteSheetSchema.index({ 'metadata.itemKey': 1 }, { unique: true });
 AtlasSpriteSheetSchema.index({ fileId: 1 });
 
 // Pre-save validation
-AtlasSpriteSheetSchema.pre('save', function (next) {
+AtlasSpriteSheetSchema.pre('save', function () {
   if (!this.fileId || !this.metadata) {
     throw new Error('AtlasSpriteSheet missing required fields: fileId or metadata');
   }
-  next();
 });
 
 const AtlasSpriteSheetModel = model('AtlasSpriteSheet', AtlasSpriteSheetSchema);
@@ -141,6 +140,22 @@ const AtlasSpriteSheetDto = {
         updatedAt: 1,
       };
     },
+    // Returns all fields the client needs per itemKey:
+    // layout dims + frames for rendering, no fileId.
+    // Client flow: GET /metadata/:itemKey → cache → GET /blob/:itemKey → cache PNG.
+    getMetadataOnly: () => {
+      return {
+        _id: 1,
+        cid: 1,
+        'metadata.itemKey': 1,
+        'metadata.atlasWidth': 1,
+        'metadata.atlasHeight': 1,
+        'metadata.cellPixelDim': 1,
+        'metadata.frames': 1,
+        createdAt: 1,
+        updatedAt: 1,
+      };
+    },
   },
 };
 

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

@@ -19,6 +19,11 @@ const AtlasSpriteSheetRouter = (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,

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

@@ -10,7 +10,23 @@ import { createPinRecord, removePinRecordsAndUnpin } from '../ipfs/ipfs.service.
 const logger = loggerFactory(import.meta);
 
 const AtlasSpriteSheetService = {
-  generate: async (req, res, options) => {
+  blob: async (req, res, options) => {
+    /** @type {import('./atlas-sprite-sheet.model.js').AtlasSpriteSheetModel} */
+    const AtlasSpriteSheet =
+      DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.AtlasSpriteSheet;
+    /** @type {import('../file/file.model.js').FileModel} */
+    const File = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.File;
+
+    const itemKey = req.params.itemKey;
+    const atlasDoc = await AtlasSpriteSheet.findOne({ 'metadata.itemKey': itemKey }).lean();
+    if (!atlasDoc) throw new Error(`Atlas not found for itemKey: ${itemKey}`);
+
+    const fileDoc = await File.findById(atlasDoc.fileId);
+    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 = {}) => {
     /** @type {import('../object-layer/object-layer.model.js').ObjectLayerModel} */
     const ObjectLayer = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.ObjectLayer;
     /** @type {import('../file/file.model.js').FileModel} */
@@ -53,9 +69,6 @@ const AtlasSpriteSheetService = {
       );
       if (ipfsResult) {
         atlasCid = ipfsResult.cid;
-        if (userId) {
-          await createPinRecord({ cid: atlasCid, userId, options });
-        }
         logger.info(`Atlas sprite sheet pinned to IPFS – CID: ${atlasCid}`);
       }
     } catch (ipfsError) {
@@ -71,9 +84,6 @@ const AtlasSpriteSheetService = {
       );
       if (metadataIpfsResult) {
         atlasMetadataCid = metadataIpfsResult.cid;
-        if (userId) {
-          await createPinRecord({ cid: atlasMetadataCid, userId, options });
-        }
         logger.info(`Atlas metadata pinned to IPFS – CID: ${atlasMetadataCid}`);
       }
     } catch (ipfsError) {
@@ -99,6 +109,39 @@ const AtlasSpriteSheetService = {
       }).save();
     }
 
+    // Register CIDs in the IPFS registry now that atlasDoc._id is known.
+    if (atlasCid) {
+      try {
+        await createPinRecord({
+          cid: atlasCid,
+          resourceType: 'atlas-sprite-sheet',
+          mfsPath: `/object-layer/${itemKey}/${itemKey}_atlas_sprite_sheet.png`,
+          options,
+        });
+      } catch (e) {
+        logger.warn('IPFS registry update failed (atlas PNG):', e.message);
+      }
+    }
+    if (atlasMetadataCid) {
+      try {
+        await createPinRecord({
+          cid: atlasMetadataCid,
+          resourceType: 'atlas-metadata',
+          mfsPath: `/object-layer/${itemKey}/${itemKey}_atlas_sprite_sheet_metadata.json`,
+          options,
+        });
+      } catch (e) {
+        logger.warn('IPFS registry update failed (atlas metadata):', e.message);
+      }
+    }
+
+    // When skipObjectLayerSave is set, return CIDs without mutating the OL document.
+    // This enables cut-over consistency: callers stage CIDs in memory and write the
+    // ObjectLayer atomically only after all CIDs are computed.
+    if (generateOptions.skipObjectLayerSave) {
+      return { atlasDoc, atlasCid, atlasMetadataCid };
+    }
+
     objectLayer.atlasSpriteSheetId = atlasDoc._id;
     if (!objectLayer.data.render) objectLayer.data.render = {};
     objectLayer.data.render.cid = atlasCid;
@@ -198,6 +241,36 @@ 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) => {
+    /** @type {import('./atlas-sprite-sheet.model.js').AtlasSpriteSheetModel} */
+    const AtlasSpriteSheet =
+      DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.AtlasSpriteSheet;
+
+    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;
+    }
+
+    const { query, sort, skip, limit, page } = DataQuery.parse(req.query);
+
+    const [data, total] = await Promise.all([
+      AtlasSpriteSheet.find(query)
+        .select(AtlasSpriteSheetDto.select.getMetadataOnly())
+        .sort(sort)
+        .limit(limit)
+        .skip(skip)
+        .lean(),
+      AtlasSpriteSheet.countDocuments(query),
+    ]);
+
+    const totalPages = Math.ceil(total / limit);
+    return { data, total, page, totalPages };
+  },
   put: async (req, res, options) => {
     /** @type {import('./atlas-sprite-sheet.model.js').AtlasSpriteSheetModel} */
     const AtlasSpriteSheet =

package/src/api/cyberia-dialogue/cyberia-dialogue.controller.js

@@ -0,0 +1,93 @@
+import { loggerFactory } from '../../server/logger.js';
+import { CyberiaDialogueService } from './cyberia-dialogue.service.js';
+
+const logger = loggerFactory(import.meta);
+
+const CyberiaDialogueController = {
+  post: async (req, res, options) => {
+    try {
+      const result = await CyberiaDialogueService.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,
+      });
+    }
+  },
+  get: async (req, res, options) => {
+    try {
+      const { page, limit } = req.query;
+      const result = await CyberiaDialogueService.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,
+      });
+    }
+  },
+  put: async (req, res, options) => {
+    try {
+      const result = await CyberiaDialogueService.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,
+      });
+    }
+  },
+  delete: async (req, res, options) => {
+    try {
+      const result = await CyberiaDialogueService.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,
+      });
+    }
+  },
+  getByItemId: async (req, res, options) => {
+    try {
+      if (req && req.headers && req.headers.origin) {
+        res.set('Access-Control-Allow-Origin', req.headers.origin);
+      } else res.setHeader('Access-Control-Allow-Origin', '*');
+      res.setHeader('Cross-Origin-Resource-Policy', 'cross-origin');
+      const result = await CyberiaDialogueService.getByItemId(req, res, options);
+      return res.status(200).json({
+        status: 'success',
+        data: result,
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(404).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  },
+};
+
+export { CyberiaDialogueController };

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

@@ -0,0 +1,36 @@
+import { Schema, model, Types } from 'mongoose';
+
+// https://mongoosejs.com/docs/2.7.x/docs/schematypes.html
+
+/**
+ * CyberiaDialogue — each document is a single dialogue record tied to an
+ * item ID from DefaultCyberiaItems.  One item may have many dialogue records
+ * (ordered by `order`).  The client displays them sequentially when the
+ * player interacts with an entity whose active item layers match `itemId`.
+ *
+ *   itemId  – references an entry in DefaultCyberiaItems (e.g. "lain", "eiri")
+ *   order   – zero-based index governing the display sequence
+ *   speaker – display name shown above the dialogue line
+ *   text    – the dialogue line itself
+ *   mood    – optional emotion hint (neutral / angry / sad / happy / …)
+ */
+const CyberiaDialogueSchema = new Schema(
+  {
+    itemId: { type: String, required: true, index: true },
+    order: { type: Number, default: 0 },
+    speaker: { type: String, default: '' },
+    text: { type: String, required: true },
+    mood: { type: String, default: 'neutral' },
+  },
+  {
+    timestamps: true,
+  },
+);
+
+CyberiaDialogueSchema.index({ itemId: 1, order: 1 });
+
+const CyberiaDialogueModel = model('CyberiaDialogue', CyberiaDialogueSchema);
+
+const ProviderSchema = CyberiaDialogueSchema;
+
+export { CyberiaDialogueSchema, CyberiaDialogueModel, ProviderSchema };

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

@@ -0,0 +1,29 @@
+import { loggerFactory } from '../../server/logger.js';
+import { CyberiaDialogueController } from './cyberia-dialogue.controller.js';
+import express from 'express';
+
+const logger = loggerFactory(import.meta);
+
+const CyberiaDialogueRouter = (options) => {
+  const router = express.Router();
+  const authMiddleware = options.authMiddleware;
+  router.post(`/:id`, async (req, res) => await CyberiaDialogueController.post(req, res, options));
+  router.post(`/`, async (req, res) => await CyberiaDialogueController.post(req, res, options));
+  // Direct lookup by itemId — C client fetches dialogue by item key (same pattern as atlas /metadata/:itemKey)
+  router.get(`/item/:itemId`, async (req, res) => await CyberiaDialogueController.getByItemId(req, res, options));
+  router.get(
+    `/:id`,
+    // authMiddleware,
+    async (req, res) => await CyberiaDialogueController.get(req, res, options),
+  );
+  router.get(`/`, async (req, res) => await CyberiaDialogueController.get(req, res, options));
+  router.put(`/:id`, async (req, res) => await CyberiaDialogueController.put(req, res, options));
+  router.put(`/`, async (req, res) => await CyberiaDialogueController.put(req, res, options));
+  router.delete(`/:id`, async (req, res) => await CyberiaDialogueController.delete(req, res, options));
+  router.delete(`/`, async (req, res) => await CyberiaDialogueController.delete(req, res, options));
+  return router;
+};
+
+const ApiRouter = CyberiaDialogueRouter;
+
+export { ApiRouter, CyberiaDialogueRouter };

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

@@ -0,0 +1,51 @@
+import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+import { loggerFactory } from '../../server/logger.js';
+import { DataQuery } from '../../server/data-query.js';
+
+const logger = loggerFactory(import.meta);
+
+const CyberiaDialogueService = {
+  post: async (req, res, options) => {
+    /** @type {import('./cyberia-dialogue.model.js').CyberiaDialogueModel} */
+    const CyberiaDialogue = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaDialogue;
+    return await new CyberiaDialogue(req.body).save();
+  },
+  get: async (req, res, options) => {
+    /** @type {import('./cyberia-dialogue.model.js').CyberiaDialogueModel} */
+    const CyberiaDialogue = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaDialogue;
+    if (req.params.id) return await CyberiaDialogue.findById(req.params.id);
+
+    // Parse query parameters using DataQuery helper
+    const { query, sort, skip, limit, page } = DataQuery.parse(req.query);
+
+    const [data, total] = await Promise.all([
+      CyberiaDialogue.find(query).sort(sort).limit(limit).skip(skip),
+      CyberiaDialogue.countDocuments(query),
+    ]);
+
+    const totalPages = Math.ceil(total / limit);
+    return { data, total, page, totalPages };
+  },
+  put: async (req, res, options) => {
+    /** @type {import('./cyberia-dialogue.model.js').CyberiaDialogueModel} */
+    const CyberiaDialogue = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaDialogue;
+    return await CyberiaDialogue.findByIdAndUpdate(req.params.id, req.body);
+  },
+  delete: async (req, res, options) => {
+    /** @type {import('./cyberia-dialogue.model.js').CyberiaDialogueModel} */
+    const CyberiaDialogue = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaDialogue;
+    if (req.params.id) return await CyberiaDialogue.findByIdAndDelete(req.params.id);
+    else return await CyberiaDialogue.deleteMany();
+  },
+  getByItemId: async (req, res, options) => {
+    /** @type {import('./cyberia-dialogue.model.js').CyberiaDialogueModel} */
+    const CyberiaDialogue = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaDialogue;
+    const { itemId } = req.params;
+    if (!itemId) throw new Error('itemId parameter is required');
+    const data = await CyberiaDialogue.find({ itemId }).sort({ order: 1 }).lean();
+    if (!data.length) throw new Error(`No dialogue found for itemId: ${itemId}`);
+    return data;
+  },
+};
+
+export { CyberiaDialogueService };

package/src/api/cyberia-entity/cyberia-entity.controller.js

@@ -0,0 +1,74 @@
+import { loggerFactory } from '../../server/logger.js';
+import { CyberiaEntityService } from './cyberia-entity.service.js';
+
+const logger = loggerFactory(import.meta);
+
+const CyberiaEntityController = {
+  post: async (req, res, options) => {
+    try {
+      const result = await CyberiaEntityService.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,
+      });
+    }
+  },
+  get: async (req, res, options) => {
+    try {
+      const { page, limit } = req.query;
+      const result = await CyberiaEntityService.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,
+      });
+    }
+  },
+  put: async (req, res, options) => {
+    try {
+      const result = await CyberiaEntityService.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,
+      });
+    }
+  },
+  delete: async (req, res, options) => {
+    try {
+      const result = await CyberiaEntityService.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 { CyberiaEntityController };

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

@@ -0,0 +1,24 @@
+import { Schema, model, Types } from 'mongoose';
+
+// https://mongoosejs.com/docs/2.7.x/docs/schematypes.html
+
+const CyberiaEntitySchema = new Schema({
+  entityType: { type: String, default: 'floor' },
+  initCellX: { type: Number, default: 0 },
+  initCellY: { type: Number, default: 0 },
+  dimX: { type: Number, default: 1 },
+  dimY: { type: Number, default: 1 },
+  color: { type: String, default: 'rgba(255, 0, 0, 1)' },
+  objectLayerItemIds: { type: [String], default: [] },
+  // Bot-specific fields (ignored for non-bot entities)
+  spawnRadius: { type: Number, default: 0 },
+  aggroRange: { type: Number, default: 0 },
+  maxLife: { type: Number, default: 0 },
+  lifeRegen: { type: Number, default: 0 },
+});
+
+const CyberiaEntityModel = model('CyberiaEntity', CyberiaEntitySchema);
+
+const ProviderSchema = CyberiaEntitySchema;
+
+export { CyberiaEntitySchema, CyberiaEntityModel, ProviderSchema };

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

@@ -0,0 +1,27 @@
+import { loggerFactory } from '../../server/logger.js';
+import { CyberiaEntityController } from './cyberia-entity.controller.js';
+import express from 'express';
+
+const logger = loggerFactory(import.meta);
+
+const CyberiaEntityRouter = (options) => {
+  const router = express.Router();
+  const authMiddleware = options.authMiddleware;
+  router.post(`/:id`, async (req, res) => await CyberiaEntityController.post(req, res, options));
+  router.post(`/`, async (req, res) => await CyberiaEntityController.post(req, res, options));
+  router.get(
+    `/:id`,
+    // authMiddleware,
+    async (req, res) => await CyberiaEntityController.get(req, res, options),
+  );
+  router.get(`/`, async (req, res) => await CyberiaEntityController.get(req, res, options));
+  router.put(`/:id`, async (req, res) => await CyberiaEntityController.put(req, res, options));
+  router.put(`/`, async (req, res) => await CyberiaEntityController.put(req, res, options));
+  router.delete(`/:id`, async (req, res) => await CyberiaEntityController.delete(req, res, options));
+  router.delete(`/`, async (req, res) => await CyberiaEntityController.delete(req, res, options));
+  return router;
+};
+
+const ApiRouter = CyberiaEntityRouter;
+
+export { ApiRouter, CyberiaEntityRouter };

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

@@ -0,0 +1,42 @@
+import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+import { loggerFactory } from '../../server/logger.js';
+import { DataQuery } from '../../server/data-query.js';
+
+const logger = loggerFactory(import.meta);
+
+const CyberiaEntityService = {
+  post: async (req, res, options) => {
+    /** @type {import('./cyberia-entity.model.js').CyberiaEntityModel} */
+    const CyberiaEntity = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaEntity;
+    return await new CyberiaEntity(req.body).save();
+  },
+  get: async (req, res, options) => {
+    /** @type {import('./cyberia-entity.model.js').CyberiaEntityModel} */
+    const CyberiaEntity = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaEntity;
+    if (req.params.id) return await CyberiaEntity.findById(req.params.id);
+
+    // Parse query parameters using DataQuery helper
+    const { query, sort, skip, limit, page } = DataQuery.parse(req.query);
+
+    const [data, total] = await Promise.all([
+      CyberiaEntity.find(query).sort(sort).limit(limit).skip(skip),
+      CyberiaEntity.countDocuments(query),
+    ]);
+
+    const totalPages = Math.ceil(total / limit);
+    return { data, total, page, totalPages };
+  },
+  put: async (req, res, options) => {
+    /** @type {import('./cyberia-entity.model.js').CyberiaEntityModel} */
+    const CyberiaEntity = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaEntity;
+    return await CyberiaEntity.findByIdAndUpdate(req.params.id, req.body);
+  },
+  delete: async (req, res, options) => {
+    /** @type {import('./cyberia-entity.model.js').CyberiaEntityModel} */
+    const CyberiaEntity = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaEntity;
+    if (req.params.id) return await CyberiaEntity.findByIdAndDelete(req.params.id);
+    else return await CyberiaEntity.deleteMany();
+  },
+};
+
+export { CyberiaEntityService };