cyberia 3.1.3 → 3.2.9

package/scripts/rhel-grpc-setup.sh

@@ -0,0 +1,56 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# ──────────────────────────────────────────────────────────────────
+# rhel-grpc-setup.sh — Install gRPC / Protocol Buffers system
+# packages on RHEL / Rocky Linux / AlmaLinux / Fedora.
+#
+# Installs:
+#   1. protobuf-compiler (protoc) + protobuf-devel
+#   2. grpc / grpc-devel / grpc-plugins (C++ libs + plugin binaries)
+#
+# For Go-specific tooling (protoc-gen-go, protoc-gen-go-grpc,
+# go mod tidy, proto codegen) use:
+#   ./cyberia-server/scripts/grpc-setup.sh
+#
+# Usage:
+#   sudo ./scripts/rhel-grpc-setup.sh
+# ──────────────────────────────────────────────────────────────────
+
+if [[ "${1:-}" == "-h" || "${1:-}" == "--help" ]]; then
+  echo "Usage: sudo $0"
+  echo "Installs protobuf + gRPC system packages via dnf."
+  echo "For Go codegen plugins, run: ./cyberia-server/scripts/grpc-setup.sh"
+  exit 0
+fi
+
+# ── 1. Enable EPEL (needed for protobuf / grpc on RHEL) ──────────
+echo ">>> Enabling EPEL repository..."
+sudo dnf install -y epel-release || true
+sudo dnf install -y dnf-plugins-core || true
+
+# On RHEL proper, enable CRB/PowerTools for devel headers
+if grep -qi 'Red Hat Enterprise' /etc/os-release 2>/dev/null; then
+  sudo dnf config-manager --set-enabled codeready-builder-for-rhel-"$(rpm -E %rhel)"-"$(uname -m)-rpms" 2>/dev/null || true
+elif grep -qi 'Rocky\|AlmaLinux' /etc/os-release 2>/dev/null; then
+  sudo dnf config-manager --set-enabled crb 2>/dev/null || \
+    sudo dnf config-manager --set-enabled powertools 2>/dev/null || true
+fi
+
+# ── 2. Install protobuf compiler + gRPC system packages ──────────
+echo ">>> Installing protobuf-compiler, protobuf-devel, grpc, grpc-devel, grpc-plugins..."
+sudo dnf install -y \
+  protobuf-compiler \
+  protobuf-devel \
+  grpc \
+  grpc-devel \
+  grpc-plugins
+
+# ── 3. Verify protoc ─────────────────────────────────────────────
+if command -v protoc &>/dev/null; then
+  echo ">>> protoc installed: $(protoc --version)"
+else
+  echo "WARNING: protoc not found in PATH after install." >&2
+fi
+
+echo ">>> gRPC system packages setup complete."

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

@@ -3,8 +3,28 @@ import { AtlasSpriteSheetService } from './atlas-sprite-sheet.service.js';
 
 const logger = loggerFactory(import.meta);
 
-const AtlasSpriteSheetController = {
-  generate: 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);
+      } 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,
+      });
+    }
+  };
+  static generate = async (req, res, options) => {
     try {
       const result = await AtlasSpriteSheetService.generate(req, res, options);
       return res.status(200).json({
@@ -18,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({
@@ -33,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({
@@ -48,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);
@@ -72,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({
@@ -87,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({
@@ -102,7 +122,31 @@ const AtlasSpriteSheetController = {
         message: error.message,
       });
     }
-  },
-};
+  };
+  static 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

@@ -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,
@@ -140,7 +133,23 @@ 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.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

@@ -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

@@ -8,9 +8,67 @@ import { IpfsClient } from '../../server/ipfs-client.js';
 import { createPinRecord, removePinRecordsAndUnpin } from '../ipfs/ipfs.service.js';
 
 const logger = loggerFactory(import.meta);
+const DEFAULT_ATLAS_FRAME_DURATION = 100;
 
-const AtlasSpriteSheetService = {
-  generate: async (req, res, options) => {
+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;
+    /** @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 };
+  };
+  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;
     /** @type {import('../file/file.model.js').FileModel} */
@@ -53,9 +111,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 +126,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 +151,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;
@@ -107,8 +192,8 @@ 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;
     /** @type {import('../file/file.model.js').FileModel} */
@@ -166,14 +251,14 @@ 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;
     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;
@@ -197,14 +282,57 @@ const AtlasSpriteSheetService = {
 
     const totalPages = Math.ceil(total / limit);
     return { data, total, page, totalPages };
-  },
-  put: async (req, res, options) => {
+  };
+  // Returns atlas metadata (layout + frames) for the client.
+  // 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;
+    /** @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 await withResolvedAtlasFrameDuration(doc, ObjectLayer);
+    }
+
+    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: 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;
     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;
@@ -256,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.service.js

@@ -4,27 +4,27 @@ 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;
     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;
     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;
     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;
     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 };

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

@@ -3,8 +3,8 @@ import crypto from 'crypto';
 import { DataBaseProvider } from '../../db/DataBaseProvider.js';
 const logger = loggerFactory(import.meta);
 
-const CryptoService = {
-  post: async (req, res, options) => {
+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;
     /** @type {import('../user/user.model.js').UserModel} */
@@ -48,17 +48,17 @@ const CryptoService = {
         return publicKey;
       }
     }
-  },
-  get: async (req, res, options) => {
+  };
+  static get = async (req, res, options) => {
     switch (req.params.id) {
       default:
     }
-  },
-  delete: async (req, res, options) => {
+  };
+  static delete = async (req, res, options) => {
     switch (req.params.id) {
       default:
     }
-  },
-};
+  };
+}
 
 export { CryptoService };