cyberia 3.1.3 → 3.2.9

package/src/api/object-layer/object-layer.service.js

@@ -36,7 +36,7 @@ const logger = loggerFactory(import.meta);
  * @namespace CyberiaObjectLayerService.ObjectLayerService
  * @memberof CyberiaObjectLayerService
  */
-const ObjectLayerService = {
+class ObjectLayerService {
   /**
    * POST handler for creating object layers and uploading frame images.
    *
@@ -59,7 +59,7 @@ const ObjectLayerService = {
    * @returns {Promise<Object>} The created object layer document or frame upload result.
    * @throws {Error} If file validation fails or required parameters are missing.
    */
-  post: async (req, res, options) => {
+  static post = async (req, res, options) => {
     /** @type {import('./object-layer.model.js').ObjectLayerModel} */
 
     if (req.path.startsWith('/frame-image')) {
@@ -182,33 +182,70 @@ const ObjectLayerService = {
       return objectLayer;
     }
 
-    // create object layer from body
+    // create object layer from body – cut-over consistency: stage all CIDs before writing to DB
     const ObjectLayer = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.ObjectLayer;
     const ObjectLayerRenderFrames =
       DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.ObjectLayerRenderFrames;
-    let newObjectLayer = await new ObjectLayer(req.body).save();
 
-    // Generate atlas sprite sheet – this sets data.render.cid and saves
+    const bodyData = { ...req.body };
+    if (!bodyData.data) bodyData.data = {};
+    if (!bodyData.data.render) bodyData.data.render = {};
+    bodyData.data.render.cid = '';
+    bodyData.data.render.metadataCid = '';
+
+    // If has render frames, generate atlas + CIDs BEFORE creating the ObjectLayer
+    if (bodyData.objectLayerRenderFramesId) {
+      const renderFramesDoc = await ObjectLayerRenderFrames.findById(bodyData.objectLayerRenderFramesId);
+      if (renderFramesDoc) {
+        try {
+          const stagingOL = {
+            data: bodyData.data,
+            objectLayerRenderFramesId: renderFramesDoc,
+          };
+          const result = await AtlasSpriteSheetService.generate(
+            { objectLayer: stagingOL, auth: req.auth },
+            res,
+            options,
+            { skipObjectLayerSave: true },
+          );
+          bodyData.data.render.cid = result.atlasCid;
+          bodyData.data.render.metadataCid = result.atlasMetadataCid;
+          bodyData.atlasSpriteSheetId = result.atlasDoc._id;
+        } catch (atlasError) {
+          logger.error('Failed to auto-generate atlas for new ObjectLayer:', atlasError);
+        }
+      }
+    }
+
+    // Compute final SHA-256 with all CIDs
+    bodyData.sha256 = ObjectLayerEngine.computeSha256(bodyData.data);
+
+    // Pin data JSON to IPFS
     try {
-      await AtlasSpriteSheetService.generate({ params: { id: newObjectLayer._id }, auth: req.auth }, res, options);
-    } catch (atlasError) {
-      logger.error('Failed to auto-generate atlas for new ObjectLayer:', atlasError);
+      const itemId = bodyData.data.item.id;
+      const mfsPath = `/object-layer/${itemId}/${itemId}_data.json`;
+      const ipfsResult = await IpfsClient.addJsonToIpfs(bodyData.data, `${itemId}_data.json`, mfsPath);
+      if (ipfsResult) {
+        bodyData.cid = ipfsResult.cid;
+        await createPinRecord({ cid: ipfsResult.cid, resourceType: 'object-layer-data', mfsPath, options });
+      }
+    } catch (ipfsError) {
+      logger.warn('Failed to pin data JSON to IPFS:', ipfsError.message);
     }
 
-    // Re-read so data.render.cid is up-to-date, then recompute SHA-256 & IPFS CID
-    newObjectLayer = await ObjectLayer.findById(newObjectLayer._id).populate('objectLayerRenderFramesId');
-    if (newObjectLayer) {
-      newObjectLayer = await ObjectLayerEngine.computeAndSaveFinalSha256({
-        objectLayer: newObjectLayer,
-        ipfsClient: IpfsClient,
-        createPinRecord,
-        userId: req.auth && req.auth.user ? req.auth.user._id : undefined,
-        options,
-      });
+    // Atomic create/replace – ObjectLayer is fully populated with all CIDs
+    let newObjectLayer;
+    const existingByItemId = await ObjectLayer.findOne({ 'data.item.id': bodyData.data.item.id });
+    if (existingByItemId) {
+      newObjectLayer = await ObjectLayer.findByIdAndUpdate(existingByItemId._id, bodyData, {
+        returnDocument: 'after',
+      }).populate('objectLayerRenderFramesId');
+    } else {
+      newObjectLayer = await (await new ObjectLayer(bodyData).save()).populate('objectLayerRenderFramesId');
     }
 
     return newObjectLayer;
-  },
+  };
 
   /**
    * GET handler for retrieving object layers.
@@ -231,10 +268,26 @@ const ObjectLayerService = {
    * @returns {Promise<Object>} The requested object layer data, list, or frame counts.
    * @throws {Error} If the requested object layer is not found.
    */
-  get: async (req, res, options) => {
+  static get = async (req, res, options) => {
     /** @type {import('./object-layer.model.js').ObjectLayerModel} */
     const ObjectLayer = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.ObjectLayer;
 
+    // GET /search-item-ids?q=<partial> - Fast partial match search on data.item.id
+    if (req.path.startsWith('/search-item-ids')) {
+      const q = (req.query.q || '').trim();
+      if (!q) return { itemIds: [] };
+      // Escape regex special characters for safe partial matching
+      const escaped = q.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+      const results = await ObjectLayer.find(
+        { 'data.item.id': { $regex: escaped, $options: 'i' } },
+        { 'data.item.id': 1, _id: 0 },
+      )
+        .limit(20)
+        .lean();
+      const itemIds = [...new Set(results.map((r) => r.data.item.id))];
+      return { itemIds };
+    }
+
     // GET /frame-counts/:id - Get frame counts for each direction using numeric codes
     if (req.path.startsWith('/frame-counts/')) {
       const objectLayer = await ObjectLayer.findById(req.params.id)
@@ -379,7 +432,7 @@ const ObjectLayerService = {
       ObjectLayer.countDocuments(query), // { userId: req.auth.user._id }
     ]);
     return { data, total, page, totalPages: Math.ceil(total / limit) };
-  },
+  };
 
   /**
    * Generates a WebP animation from PNG frame images for a specific direction of an object layer.
@@ -396,7 +449,7 @@ const ObjectLayerService = {
    * @returns {Promise<Buffer>} The generated WebP animation as a Buffer.
    * @throws {Error} If required parameters are missing, frames directory is not found, or img2webp fails.
    */
-  generateWebp: async (req, res, options) => {
+  static generateWebp = async (req, res, options) => {
     /** @type {import('./object-layer.model.js').ObjectLayerModel} */
     const ObjectLayer = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.ObjectLayer;
 
@@ -507,7 +560,7 @@ const ObjectLayerService = {
 
       throw error;
     }
-  },
+  };
 
   /**
    * PUT handler for updating object layers, their frame images, and metadata.
@@ -531,7 +584,7 @@ const ObjectLayerService = {
    * @returns {Promise<Object>} The updated object layer document or frame upload result.
    * @throws {Error} If file validation fails, object layer is not found, or required parameters are missing.
    */
-  put: async (req, res, options) => {
+  static put = async (req, res, options) => {
     /** @type {import('./object-layer.model.js').ObjectLayerModel} */
     const ObjectLayer = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.ObjectLayer;
 
@@ -667,32 +720,62 @@ const ObjectLayerService = {
       return objectLayer;
     }
 
-    // PUT /:id - Standard update
-    let updatedObjectLayer = await ObjectLayer.findByIdAndUpdate(req.params.id, req.body, { returnDocument: 'after' });
+    // PUT /:id - Standard update with cut-over consistency
+    const existingOL = await ObjectLayer.findById(req.params.id).populate('objectLayerRenderFramesId');
+    if (!existingOL) {
+      throw new Error('ObjectLayer not found');
+    }
+
+    // Apply body updates to staging data in memory
+    const updateData = { ...req.body };
+    const stagingData = updateData.data || existingOL.data.toObject();
+    if (!stagingData.render) stagingData.render = {};
 
-    if (updatedObjectLayer) {
-      // Generate atlas sprite sheet – this sets data.render.cid and saves
+    // Use existing render frames if available
+    const renderFramesData = existingOL.objectLayerRenderFramesId;
+    if (renderFramesData) {
       try {
-        await AtlasSpriteSheetService.generate({ params: { id: req.params.id }, auth: req.auth }, res, options);
+        const stagingOL = {
+          data: stagingData,
+          objectLayerRenderFramesId: renderFramesData,
+        };
+        const result = await AtlasSpriteSheetService.generate(
+          { objectLayer: stagingOL, auth: req.auth },
+          res,
+          options,
+          { skipObjectLayerSave: true },
+        );
+        stagingData.render.cid = result.atlasCid;
+        stagingData.render.metadataCid = result.atlasMetadataCid;
+        updateData.atlasSpriteSheetId = result.atlasDoc._id;
       } catch (atlasError) {
         logger.error('Failed to auto-update atlas for ObjectLayer:', atlasError);
       }
+    }
 
-      // Re-read so data.render.cid is up-to-date, then recompute SHA-256 & IPFS CID
-      updatedObjectLayer = await ObjectLayer.findById(req.params.id).populate('objectLayerRenderFramesId');
-      if (updatedObjectLayer) {
-        updatedObjectLayer = await ObjectLayerEngine.computeAndSaveFinalSha256({
-          objectLayer: updatedObjectLayer,
-          ipfsClient: IpfsClient,
-          createPinRecord,
-          userId: req.auth && req.auth.user ? req.auth.user._id : undefined,
-          options,
-        });
+    updateData.data = stagingData;
+    updateData.sha256 = ObjectLayerEngine.computeSha256(stagingData);
+
+    // Pin data JSON to IPFS
+    try {
+      const itemId = stagingData.item.id;
+      const mfsPath = `/object-layer/${itemId}/${itemId}_data.json`;
+      const ipfsResult = await IpfsClient.addJsonToIpfs(stagingData, `${itemId}_data.json`, mfsPath);
+      if (ipfsResult) {
+        updateData.cid = ipfsResult.cid;
+        await createPinRecord({ cid: ipfsResult.cid, resourceType: 'object-layer-data', mfsPath, options });
       }
+    } catch (ipfsError) {
+      logger.warn('Failed to pin data JSON to IPFS:', ipfsError.message);
     }
 
+    // Atomic update with all CIDs populated
+    let updatedObjectLayer = await ObjectLayer.findByIdAndUpdate(req.params.id, updateData, {
+      returnDocument: 'after',
+    }).populate('objectLayerRenderFramesId');
+
     return updatedObjectLayer;
-  },
+  };
 
   /**
    * DELETE handler for removing object layers and all associated resources.
@@ -718,7 +801,7 @@ const ObjectLayerService = {
    * @returns {Promise<Object>} The deleted object layer document or bulk delete count.
    * @throws {Error} If the object layer is not found.
    */
-  delete: async (req, res, options) => {
+  static delete = async (req, res, options) => {
     /** @type {import('./object-layer.model.js').ObjectLayerModel} */
     const ObjectLayer = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.ObjectLayer;
     const ObjectLayerRenderFrames =
@@ -807,7 +890,7 @@ const ObjectLayerService = {
       }
       return { deletedCount: allObjectLayers.length };
     }
-  },
-};
+  };
+}
 
 export { ObjectLayerService };

package/src/api/object-layer-render-frames/object-layer-render-frames.controller.js

@@ -3,8 +3,8 @@ import { ObjectLayerRenderFramesService } from './object-layer-render-frames.ser
 
 const logger = loggerFactory(import.meta);
 
-const ObjectLayerRenderFramesController = {
-  post: async (req, res, options) => {
+class ObjectLayerRenderFramesController {
+  static post = async (req, res, options) => {
     try {
       const result = await ObjectLayerRenderFramesService.post(req, res, options);
       return res.status(200).json({
@@ -18,8 +18,8 @@ const ObjectLayerRenderFramesController = {
         message: error.message,
       });
     }
-  },
-  get: async (req, res, options) => {
+  };
+  static get = async (req, res, options) => {
     try {
       const { page, limit } = req.query;
       const result = await ObjectLayerRenderFramesService.get(
@@ -38,8 +38,8 @@ const ObjectLayerRenderFramesController = {
         message: error.message,
       });
     }
-  },
-  put: async (req, res, options) => {
+  };
+  static put = async (req, res, options) => {
     try {
       const result = await ObjectLayerRenderFramesService.put(req, res, options);
       return res.status(200).json({
@@ -53,8 +53,8 @@ const ObjectLayerRenderFramesController = {
         message: error.message,
       });
     }
-  },
-  delete: async (req, res, options) => {
+  };
+  static delete = async (req, res, options) => {
     try {
       const result = await ObjectLayerRenderFramesService.delete(req, res, options);
       return res.status(200).json({
@@ -68,7 +68,7 @@ const ObjectLayerRenderFramesController = {
         message: error.message,
       });
     }
-  },
-};
+  };
+}
 
 export { ObjectLayerRenderFramesController };

package/src/api/object-layer-render-frames/object-layer-render-frames.model.js

@@ -3,9 +3,7 @@
  * @module src/api/object-layer-render-frames/object-layer-render-frames.model.js
  * @namespace CyberiaObjectLayerRenderFramesModel
  */
-
 import { Schema, model } from 'mongoose';
-
 /**
  * @typedef {Object} ObjectLayerRenderFramesDirections
  * @property {number[][][]} up_idle - Up idle animation frames
@@ -51,13 +49,11 @@ const ObjectLayerRenderFramesDirectionsSchema = new Schema(
   },
   { _id: false },
 );
-
 /**
  * @typedef {Object} ObjectLayerRenderFrames
  * @property {RenderFrames} frames - Animation frames for different states
  * @property {number[][]} colors - Color palette for rendering
  * @property {number} frame_duration - Duration of each frame in milliseconds
- * @property {boolean} is_stateless - Whether the render is stateless
  * @property {Date} createdAt - When the document was created
  * @property {Date} updatedAt - When the document was last updated
  * @memberof CyberiaObjectLayerRenderFramesModel
@@ -67,7 +63,6 @@ const ObjectLayerRenderFramesSchema = new Schema(
     frames: { type: ObjectLayerRenderFramesDirectionsSchema, required: true },
     colors: { type: [[Number]], required: true },
     frame_duration: { type: Number, required: true, min: 0 },
-    is_stateless: { type: Boolean, default: false },
   },
   {
     timestamps: true,
@@ -75,7 +70,6 @@ const ObjectLayerRenderFramesSchema = new Schema(
     toObject: { virtuals: true },
   },
 );
-
 // Pre-save hook to ensure data consistency
 ObjectLayerRenderFramesSchema.pre('save', function () {
   // Ensure all required fields are present
@@ -83,21 +77,17 @@ ObjectLayerRenderFramesSchema.pre('save', function () {
     throw new Error('Missing required fields: frames, colors, or frame_duration');
   }
 });
-
 // Create and export the model
 const ObjectLayerRenderFramesModel = model('ObjectLayerRenderFrames', ObjectLayerRenderFramesSchema);
-
 const ProviderSchema = ObjectLayerRenderFramesSchema;
-
-const ObjectLayerRenderFramesDto = {
-  select: {
+class ObjectLayerRenderFramesDto {
+  static select = {
     get: () => {
-      return { _id: 1, frame_duration: 1, is_stateless: 1 };
+      return { _id: 1, frame_duration: 1 };
     },
     getFull: () => {
-      return { _id: 1, frames: 1, colors: 1, frame_duration: 1, is_stateless: 1 };
+      return { _id: 1, frames: 1, colors: 1, frame_duration: 1 };
     },
-  },
-};
-
+  };
+}
 export { ObjectLayerRenderFramesSchema, ObjectLayerRenderFramesModel, ProviderSchema, ObjectLayerRenderFramesDto };

package/src/api/object-layer-render-frames/object-layer-render-frames.service.js

@@ -4,15 +4,17 @@ import { DataQuery } from '../../server/data-query.js';
 
 const logger = loggerFactory(import.meta);
 
-const ObjectLayerRenderFramesService = {
-  post: async (req, res, options) => {
+class ObjectLayerRenderFramesService {
+  static post = async (req, res, options) => {
     /** @type {import('./object-layer-render-frames.model.js').ObjectLayerRenderFramesModel} */
-    const ObjectLayerRenderFrames = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.ObjectLayerRenderFrames;
+    const ObjectLayerRenderFrames =
+      DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.ObjectLayerRenderFrames;
     return await new ObjectLayerRenderFrames(req.body).save();
-  },
-  get: async (req, res, options) => {
+  };
+  static get = async (req, res, options) => {
     /** @type {import('./object-layer-render-frames.model.js').ObjectLayerRenderFramesModel} */
-    const ObjectLayerRenderFrames = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.ObjectLayerRenderFrames;
+    const ObjectLayerRenderFrames =
+      DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.ObjectLayerRenderFrames;
     if (req.params.id) return await ObjectLayerRenderFrames.findById(req.params.id);
 
     // Parse query parameters using DataQuery helper
@@ -25,18 +27,20 @@ const ObjectLayerRenderFramesService = {
 
     const totalPages = Math.ceil(total / limit);
     return { data, total, page, totalPages };
-  },
-  put: async (req, res, options) => {
+  };
+  static put = async (req, res, options) => {
     /** @type {import('./object-layer-render-frames.model.js').ObjectLayerRenderFramesModel} */
-    const ObjectLayerRenderFrames = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.ObjectLayerRenderFrames;
+    const ObjectLayerRenderFrames =
+      DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.ObjectLayerRenderFrames;
     return await ObjectLayerRenderFrames.findByIdAndUpdate(req.params.id, req.body);
-  },
-  delete: async (req, res, options) => {
+  };
+  static delete = async (req, res, options) => {
     /** @type {import('./object-layer-render-frames.model.js').ObjectLayerRenderFramesModel} */
-    const ObjectLayerRenderFrames = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.ObjectLayerRenderFrames;
+    const ObjectLayerRenderFrames =
+      DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.ObjectLayerRenderFrames;
     if (req.params.id) return await ObjectLayerRenderFrames.findByIdAndDelete(req.params.id);
     else return await ObjectLayerRenderFrames.deleteMany();
-  },
-};
+  };
+}
 
 export { ObjectLayerRenderFramesService };

package/src/api/test/test.controller.js

@@ -3,8 +3,8 @@ import { TestService } from './test.service.js';
 
 const logger = loggerFactory(import.meta);
 
-const TestController = {
-  post: async (req, res, options) => {
+class TestController {
+  static post = async (req, res, options) => {
     try {
       return res.status(200).json({
         status: 'success',
@@ -17,8 +17,8 @@ const TestController = {
         message: error.message,
       });
     }
-  },
-  get: async (req, res, options) => {
+  };
+  static get = async (req, res, options) => {
     try {
       const result = await TestService.get(req, res, options);
       if (result)
@@ -37,8 +37,8 @@ const TestController = {
         message: error.message,
       });
     }
-  },
-  delete: async (req, res, options) => {
+  };
+  static delete = async (req, res, options) => {
     try {
       const result = await TestService.delete(req, res, options);
 
@@ -53,7 +53,7 @@ const TestController = {
         message: error.message,
       });
     }
-  },
-};
+  };
+}
 
 export { TestController };

package/src/api/test/test.service.js

@@ -5,14 +5,14 @@ import { getYouTubeID, validatePassword } from '../../client/components/core/Com
 
 const logger = loggerFactory(import.meta);
 
-const TestService = {
-  post: async (req, res, options) => {
+class TestService {
+  static post = async (req, res, options) => {
     switch (req.params.id) {
       default:
         break;
     }
-  },
-  get: async (req, res, options) => {
+  };
+  static get = async (req, res, options) => {
     switch (req.params.id) {
       case 'verify-email':
         return validator.isEmail(req.query.email);
@@ -23,13 +23,13 @@ const TestService = {
 
       default:
     }
-  },
-  delete: async (req, res, options) => {
+  };
+  static delete = async (req, res, options) => {
     switch (req.params.id) {
       default:
         break;
     }
-  },
-};
+  };
+}
 
 export { TestService };

package/src/api/user/guest.service.js

@@ -0,0 +1,99 @@
+import mongoose from 'mongoose';
+import { UserDto } from './user.model.js';
+import { ValkeyAPI } from '../../server/valkey.js';
+import { hashPassword, getBearerToken, jwtSign } from '../../server/auth.js';
+
+// ─── TTL ──────────────────────────────────────────────────────────────────────
+
+const _guestTtlMs = () => {
+  const minutes = Number.parseInt(process.env.REFRESH_EXPIRE_MINUTES || '60', 10);
+  return Number.isFinite(minutes) && minutes > 0 ? minutes * 60 * 1000 : 60 * 60 * 1000;
+};
+
+// ─── Domain helpers ───────────────────────────────────────────────────────────
+
+/**
+ * Constructs a new ephemeral guest user object.
+ * This is domain logic specific to the guest lifecycle; it does not belong
+ * in the generic Valkey storage module.
+ *
+ * @param {{ host?: string }} options
+ * @returns {object}
+ */
+const buildGuestUser = (options) => {
+  const now = new Date().toISOString();
+  const _id = new mongoose.Types.ObjectId().toString();
+  const role = 'guest';
+  return {
+    _id: `${role}${_id}`,
+    username: `${role}${_id.slice(-5)}`,
+    email: `${_id}@${options.host || 'localhost'}`,
+    password: hashPassword(process.env.JWT_SECRET),
+    role,
+    emailConfirmed: false,
+    profileImageId: null,
+    publicKey: [],
+    phoneNumbers: [],
+    activeSessions: [],
+    failedLoginAttempts: 0,
+    recoverTimeOut: null,
+    lastLoginDate: null,
+    createdAt: now,
+    updatedAt: now,
+    guestSessionExpiresAt: Date.now() + _guestTtlMs(),
+  };
+};
+
+/**
+ * Projects a user object to the public-safe fields defined by UserDto.select.get().
+ * Keeps this logic next to the guest domain instead of in a generic utility.
+ *
+ * @param {object} user
+ * @returns {object}
+ */
+const _toPublicUser = (user) => {
+  const select = UserDto.select.get();
+  return Object.fromEntries(
+    Object.keys(select)
+      .filter((k) => select[k] === 1 && k in user)
+      .map((k) => [k, user[k]]),
+  );
+};
+
+const _withRefreshedExpiry = (user) => ({ ...user, guestSessionExpiresAt: Date.now() + _guestTtlMs() });
+
+// ─── Service ──────────────────────────────────────────────────────────────────
+
+class GuestService {
+  static async create(req, options) {
+    const user = buildGuestUser(options);
+
+    await ValkeyAPI.set(options, user.email, user, _guestTtlMs());
+
+    return {
+      token: jwtSign(
+        UserDto.auth.payload(user, null, req.ip, req.headers['user-agent'], options.host, options.path),
+        options,
+      ),
+      user: _toPublicUser(user),
+    };
+  }
+
+  static async auth(req, options) {
+    const user = await ValkeyAPI.get(options, req.auth.user.email);
+    if (!user) throw new Error('guest user expired');
+
+    const expiresAt = Number(user.guestSessionExpiresAt || 0);
+    if (expiresAt && expiresAt <= Date.now()) throw new Error('guest user expired');
+
+    const refreshed = _withRefreshedExpiry(user);
+    await ValkeyAPI.set(options, refreshed.email, refreshed, _guestTtlMs());
+
+    return {
+      user: _toPublicUser(refreshed),
+      token: getBearerToken(req),
+    };
+  }
+}
+
+export { GuestService };

package/src/api/user/user.controller.js

@@ -25,11 +25,11 @@ const handleRequest = (serviceMethod) => async (req, res, options) => {
   }
 };
 
-const UserController = {
-  post: handleRequest(UserService.post),
-  get: handleRequest(UserService.get),
-  delete: handleRequest(UserService.delete),
-  put: handleRequest(UserService.put),
-};
+class UserController {
+  static post = handleRequest(UserService.post);
+  static get = handleRequest(UserService.get);
+  static delete = handleRequest(UserService.delete);
+  static put = handleRequest(UserService.put);
+}
 
 export { UserController };