cyberia 3.2.12 → 3.2.70

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

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

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

@@ -0,0 +1,50 @@
+import { Schema, model } from 'mongoose';
+
+// https://mongoosejs.com/docs/2.7.x/docs/schematypes.html
+
+// Expanded metadata for one logic event a trigger item can fire. Mirrors the
+// `skills[]` entries in DefaultSkillConfig (cyberia-server-defaults.js) and the
+// SkillDefinition consumed by cyberia-server (game/skill.go).
+const SkillDefinitionSchema = new Schema(
+  {
+    // Handler key dispatched by the simulation skill engine (e.g. 'projectile',
+    // 'coin_drop_or_transaction', 'doppelganger').
+    logicEventId: { type: String, required: true, trim: true },
+    name: { type: String, default: '', trim: true },
+    description: { type: String, default: '' },
+    // ObjectLayer item id the skill summons. A leading '$' marks a runtime
+    // placeholder resolved by the server (e.g. '$active_skin').
+    summonedEntityItemId: { type: String, default: '', trim: true },
+  },
+  { _id: false },
+);
+
+/**
+ * Authoritative skill definition for a single trigger item. Owns the full skill
+ * record (logic event keys + expanded metadata) so the simulation receives the
+ * summoned-entity item ids the instance-conf skillConfig schema does not carry.
+ */
+const CyberiaSkillSchema = new Schema(
+  {
+    // ObjectLayer item id whose active layer fires these skills (e.g. 'coin',
+    // 'atlas_pistol_mk2'). One skill document per trigger item. The unique
+    // index is declared via schema.index() below (not `unique: true` here) to
+    // avoid a duplicate-index definition.
+    triggerItemId: { type: String, required: true, trim: true },
+
+    // Compact list of handler keys — the discriminator the dispatcher matches.
+    logicEventIds: { type: [String], default: [] },
+
+    // Expanded per-logic-event metadata (name, description, summoned entity).
+    skills: { type: [SkillDefinitionSchema], default: [] },
+  },
+  { timestamps: true },
+);
+
+CyberiaSkillSchema.index({ triggerItemId: 1 }, { unique: true });
+
+const CyberiaSkillModel = model('CyberiaSkill', CyberiaSkillSchema);
+
+const ProviderSchema = CyberiaSkillSchema;
+
+export { CyberiaSkillSchema, CyberiaSkillModel, ProviderSchema };

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

@@ -0,0 +1,63 @@
+import { loggerFactory } from '../../server/logger.js';
+import { CyberiaSkillController } from './cyberia-skill.controller.js';
+import express from 'express';
+import { moderatorGuard, adminGuard } from '../../server/auth.js';
+
+const logger = loggerFactory(import.meta);
+
+class CyberiaSkillRouter {
+  /**
+   * @param {import('../types.js').RouterOptions} options
+   * @returns {import('express').Router}
+   */
+  static router(options) {
+    const router = express.Router();
+    router.post(
+      `/:id`,
+      options.authMiddleware,
+      moderatorGuard,
+      async (req, res) => await CyberiaSkillController.post(req, res, options),
+    );
+    router.post(
+      `/`,
+      options.authMiddleware,
+      moderatorGuard,
+      async (req, res) => await CyberiaSkillController.post(req, res, options),
+    );
+    router.get(
+      `/:id`,
+      // options.authMiddleware,
+      async (req, res) => await CyberiaSkillController.get(req, res, options),
+    );
+    router.get(`/`, async (req, res) => await CyberiaSkillController.get(req, res, options));
+    router.put(
+      `/:id`,
+      options.authMiddleware,
+      moderatorGuard,
+      async (req, res) => await CyberiaSkillController.put(req, res, options),
+    );
+    router.put(
+      `/`,
+      options.authMiddleware,
+      moderatorGuard,
+      async (req, res) => await CyberiaSkillController.put(req, res, options),
+    );
+    router.delete(
+      `/:id`,
+      options.authMiddleware,
+      moderatorGuard,
+      async (req, res) => await CyberiaSkillController.delete(req, res, options),
+    );
+    router.delete(
+      `/`,
+      options.authMiddleware,
+      adminGuard,
+      async (req, res) => await CyberiaSkillController.delete(req, res, options),
+    );
+    return router;
+  }
+}
+
+const ApiRouter = (options) => CyberiaSkillRouter.router(options);
+
+export { ApiRouter, CyberiaSkillRouter };

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

@@ -0,0 +1,42 @@
+import { DataBaseProviderService } from '../../db/DataBaseProvider.js';
+import { loggerFactory } from '../../server/logger.js';
+import { DataQuery } from '../../server/data-query.js';
+
+const logger = loggerFactory(import.meta);
+
+class CyberiaSkillService {
+  static post = async (req, res, options) => {
+    /** @type {import('./cyberia-skill.model.js').CyberiaSkillModel} */
+    const CyberiaSkill = DataBaseProviderService.getModel("CyberiaSkill", options);
+    return await new CyberiaSkill(req.body).save();
+  };
+  static get = async (req, res, options) => {
+    /** @type {import('./cyberia-skill.model.js').CyberiaSkillModel} */
+    const CyberiaSkill = DataBaseProviderService.getModel("CyberiaSkill", options);
+    if (req.params.id) return await CyberiaSkill.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([
+      CyberiaSkill.find(query).sort(sort).limit(limit).skip(skip),
+      CyberiaSkill.countDocuments(query),
+    ]);
+
+    const totalPages = Math.ceil(total / limit);
+    return { data, total, page, totalPages };
+  };
+  static put = async (req, res, options) => {
+    /** @type {import('./cyberia-skill.model.js').CyberiaSkillModel} */
+    const CyberiaSkill = DataBaseProviderService.getModel("CyberiaSkill", options);
+    return await CyberiaSkill.findByIdAndUpdate(req.params.id, req.body);
+  };
+  static delete = async (req, res, options) => {
+    /** @type {import('./cyberia-skill.model.js').CyberiaSkillModel} */
+    const CyberiaSkill = DataBaseProviderService.getModel("CyberiaSkill", options);
+    if (req.params.id) return await CyberiaSkill.findByIdAndDelete(req.params.id);
+    else return await CyberiaSkill.deleteMany();
+  };
+}
+
+export { CyberiaSkillService };

package/src/api/ipfs/ipfs.service.js

@@ -1,7 +1,7 @@
 import { DataBaseProviderService } from '../../db/DataBaseProvider.js';
 import { loggerFactory } from '../../server/logger.js';
 import { DataQuery } from '../../server/data-query.js';
-import { IpfsClient } from '../../server/ipfs-client.js';
+import { IpfsClient } from '../../projects/cyberia/ipfs-client.js';
 import { IpfsDto } from './ipfs.model.js';
 const logger = loggerFactory(import.meta);
 /**
@@ -17,14 +17,27 @@ const logger = loggerFactory(import.meta);
  * @returns {Promise<import('mongoose').Document>}
  */
 const createPinRecord = async ({ cid, resourceType, mfsPath = '', options }) => {
-  const Ipfs = DataBaseProviderService.getModel("Ipfs", options);
-  const record = await Ipfs.findOneAndUpdate(
-    { cid, resourceType },
-    { cid, resourceType, mfsPath },
-    { upsert: true, returnDocument: 'after', setDefaultsOnInsert: true },
-  );
-  logger.info(`IPFS registry upserted – CID: ${cid}, type: ${resourceType}, mfsPath: ${mfsPath}`);
-  return record;
+  const Ipfs = DataBaseProviderService.getModel('Ipfs', options);
+  try {
+    const record = await Ipfs.findOneAndUpdate(
+      { cid, resourceType },
+      { $set: { mfsPath } },
+      { upsert: true, returnDocument: 'after', setDefaultsOnInsert: true },
+    );
+    logger.info(`IPFS registry upserted – CID: ${cid}, type: ${resourceType}, mfsPath: ${mfsPath}`);
+    return record;
+  } catch (err) {
+    if (err?.code === 11000) {
+      const record = await Ipfs.findOneAndUpdate(
+        { cid, resourceType },
+        { $set: { mfsPath } },
+        { returnDocument: 'after' },
+      );
+      logger.info(`IPFS registry reconciled (duplicate key) – CID: ${cid}, type: ${resourceType}, mfsPath: ${mfsPath}`);
+      return record;
+    }
+    throw err;
+  }
 };
 /**
  * Remove all DB registry entries for a CID, then best-effort unpin from the IPFS node.
@@ -35,7 +48,7 @@ const createPinRecord = async ({ cid, resourceType, mfsPath = '', options }) =>
  * @returns {Promise<void>}
  */
 const removePinRecordsAndUnpin = async (cid, options) => {
-  const Ipfs = DataBaseProviderService.getModel("Ipfs", options);
+  const Ipfs = DataBaseProviderService.getModel('Ipfs', options);
   await Ipfs.deleteMany({ cid });
   logger.info(`Removed IPFS registry entries for CID: ${cid}`);
   try {
@@ -52,11 +65,11 @@ class IpfsService {
   //  Standard CRUD
   // ──────────────────────────────────────────────
   static post = async (req, res, options) => {
-    const Ipfs = DataBaseProviderService.getModel("Ipfs", options);
+    const Ipfs = DataBaseProviderService.getModel('Ipfs', options);
     return await new Ipfs(req.body).save();
   };
   static get = async (req, res, options) => {
-    const Ipfs = DataBaseProviderService.getModel("Ipfs", options);
+    const Ipfs = DataBaseProviderService.getModel('Ipfs', options);
     if (req.params.id) {
       return await Ipfs.findById(req.params.id).select(IpfsDto.select.get());
     }
@@ -69,11 +82,11 @@ class IpfsService {
     return { data, total, page, totalPages };
   };
   static put = async (req, res, options) => {
-    const Ipfs = DataBaseProviderService.getModel("Ipfs", options);
+    const Ipfs = DataBaseProviderService.getModel('Ipfs', options);
     return await Ipfs.findByIdAndUpdate(req.params.id, req.body, { returnDocument: 'after' });
   };
   static delete = async (req, res, options) => {
-    const Ipfs = DataBaseProviderService.getModel("Ipfs", options);
+    const Ipfs = DataBaseProviderService.getModel('Ipfs', options);
     if (req.params.id) {
       const record = await Ipfs.findById(req.params.id);
       if (record) {
@@ -107,7 +120,7 @@ class IpfsService {
    *   { total, pinned, unpinned, errors, entries: [{ cid, resourceType, mfsPath, pinned, error? }] }
    */
   static verify = async (req, res, options) => {
-    const Ipfs = DataBaseProviderService.getModel("Ipfs", options);
+    const Ipfs = DataBaseProviderService.getModel('Ipfs', options);
     const records = await Ipfs.find({}).select(IpfsDto.select.get()).lean();
     let pinned = 0;
     let unpinned = 0;

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

@@ -1,7 +1,7 @@
 import { loggerFactory } from '../../server/logger.js';
 import { ObjectLayerController } from './object-layer.controller.js';
 import express from 'express';
-import { adminGuard } from '../../server/auth.js';
+import { moderatorGuard, adminGuard } from '../../server/auth.js';
 
 const logger = loggerFactory(import.meta);
 
@@ -12,8 +12,12 @@ class ObjectLayerRouter {
    */
   static router(options) {
     const router = express.Router();
-    router.post(`/frame-image/:itemType/:itemId/:directionCode`, async (req, res) => {
-      /*
+    router.post(
+      `/frame-image/:itemType/:itemId/:directionCode`,
+      options.authMiddleware,
+      moderatorGuard,
+      async (req, res) => {
+        /*
           #swagger.auto = false
           #swagger.tags = ['object-layer']
           #swagger.summary = 'Upload frame image'
@@ -65,9 +69,10 @@ class ObjectLayerRouter {
             }
           }
         */
-      return await ObjectLayerController.post(req, res, options);
-    });
-    router.post(`/metadata/:itemType/:itemId`, async (req, res) => {
+        return await ObjectLayerController.post(req, res, options);
+      },
+    );
+    router.post(`/metadata/:itemType/:itemId`, options.authMiddleware, moderatorGuard, async (req, res) => {
       /*
         #swagger.auto = false
         #swagger.tags = ['object-layer']
@@ -117,7 +122,7 @@ class ObjectLayerRouter {
       return await ObjectLayerController.post(req, res, options);
     });
 
-    router.post(`/:id`, options.authMiddleware, async (req, res) => {
+    router.post(`/:id`, options.authMiddleware, moderatorGuard, async (req, res) => {
       /*
         #swagger.auto = false
         #swagger.tags = ['object-layer']
@@ -162,7 +167,7 @@ class ObjectLayerRouter {
       */
       return await ObjectLayerController.post(req, res, options);
     });
-    router.post(`/`, options.authMiddleware, async (req, res) => {
+    router.post(`/`, options.authMiddleware, moderatorGuard, async (req, res) => {
       /*
         #swagger.auto = false
         #swagger.tags = ['object-layer']
@@ -484,8 +489,12 @@ class ObjectLayerRouter {
       */
       return await ObjectLayerController.get(req, res, options);
     });
-    router.put(`/:id/frame-image/:itemType/:itemId/:directionCode`, options.authMiddleware, async (req, res) => {
-      /*
+    router.put(
+      `/:id/frame-image/:itemType/:itemId/:directionCode`,
+      options.authMiddleware,
+      moderatorGuard,
+      async (req, res) => {
+        /*
           #swagger.auto = false
           #swagger.tags = ['object-layer']
           #swagger.summary = 'Update frame image'
@@ -547,9 +556,10 @@ class ObjectLayerRouter {
             }
           }
         */
-      return await ObjectLayerController.put(req, res, options);
-    });
-    router.put(`/:id/metadata/:itemType/:itemId`, options.authMiddleware, async (req, res) => {
+        return await ObjectLayerController.put(req, res, options);
+      },
+    );
+    router.put(`/:id/metadata/:itemType/:itemId`, options.authMiddleware, moderatorGuard, async (req, res) => {
       /*
           #swagger.auto = false
           #swagger.tags = ['object-layer']
@@ -608,7 +618,7 @@ class ObjectLayerRouter {
         */
       return await ObjectLayerController.put(req, res, options);
     });
-    router.put(`/:id`, options.authMiddleware, async (req, res) => {
+    router.put(`/:id`, options.authMiddleware, moderatorGuard, async (req, res) => {
       /*
         #swagger.auto = false
         #swagger.tags = ['object-layer']
@@ -653,7 +663,7 @@ class ObjectLayerRouter {
       */
       return await ObjectLayerController.put(req, res, options);
     });
-    router.put(`/`, options.authMiddleware, async (req, res) => {
+    router.put(`/`, options.authMiddleware, moderatorGuard, async (req, res) => {
       /*
         #swagger.ignore = true
       */

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

@@ -4,7 +4,7 @@
  * including frame image management, metadata processing, and WebP animation generation.
  *
  * Delegates shared object layer creation and update logic to {@link ObjectLayerEngine} in
- * `src/server/object-layer.js` to keep a single source of truth shared with the Cyberia CLI.
+ * `src/projects/cyberia/object-layer.js` to keep a single source of truth shared with the Cyberia CLI.
  *
  * @module src/api/object-layer/object-layer.service.js
  * @namespace CyberiaObjectLayerService
@@ -16,11 +16,11 @@ import { ObjectLayerRenderFramesDto } from '../object-layer-render-frames/object
 import { FileFactory } from '../file/file.service.js';
 import fs from 'fs-extra';
 import { ObjectLayerDto } from './object-layer.model.js';
-import { ObjectLayerEngine } from '../../server/object-layer.js';
+import { ObjectLayerEngine } from '../../projects/cyberia/object-layer.js';
 import { shellExec } from '../../server/process.js';
 import { DataQuery } from '../../server/data-query.js';
 import { AtlasSpriteSheetService } from '../atlas-sprite-sheet/atlas-sprite-sheet.service.js';
-import { IpfsClient } from '../../server/ipfs-client.js';
+import { IpfsClient } from '../../projects/cyberia/ipfs-client.js';
 import { createPinRecord, removePinRecordsAndUnpin } from '../ipfs/ipfs.service.js';
 
 /**
@@ -149,9 +149,8 @@ class ObjectLayerService {
       fs.writeFileSync(`${publicFolder}/metadata.json`, metadataContent);
 
       // Build object layer data from the asset directory
-      const ObjectLayer = DataBaseProviderService.getModel("ObjectLayer", options);
-      const ObjectLayerRenderFrames =
-        DataBaseProviderService.getModel("ObjectLayerRenderFrames", options);
+      const ObjectLayer = DataBaseProviderService.getModel('ObjectLayer', options);
+      const ObjectLayerRenderFrames = DataBaseProviderService.getModel('ObjectLayerRenderFrames', options);
 
       const { objectLayerRenderFramesData, objectLayerData } =
         await ObjectLayerEngine.buildObjectLayerDataFromDirectory({
@@ -183,9 +182,8 @@ class ObjectLayerService {
     }
 
     // create object layer from body – cut-over consistency: stage all CIDs before writing to DB
-    const ObjectLayer = DataBaseProviderService.getModel("ObjectLayer", options);
-    const ObjectLayerRenderFrames =
-      DataBaseProviderService.getModel("ObjectLayerRenderFrames", options);
+    const ObjectLayer = DataBaseProviderService.getModel('ObjectLayer', options);
+    const ObjectLayerRenderFrames = DataBaseProviderService.getModel('ObjectLayerRenderFrames', options);
 
     const bodyData = { ...req.body };
     if (!bodyData.data) bodyData.data = {};
@@ -270,7 +268,7 @@ class ObjectLayerService {
    */
   static get = async (req, res, options) => {
     /** @type {import('./object-layer.model.js').ObjectLayerModel} */
-    const ObjectLayer = DataBaseProviderService.getModel("ObjectLayer", options);
+    const ObjectLayer = DataBaseProviderService.getModel('ObjectLayer', options);
 
     // GET /search-item-ids?q=<partial> - Fast partial match search on data.item.id
     if (req.path.startsWith('/search-item-ids')) {
@@ -359,9 +357,8 @@ class ObjectLayerService {
       // If the atlas or its file is missing, clear the reference so the UI can offer to generate a new atlas.
       if (objectLayer.atlasSpriteSheetId) {
         try {
-          const AtlasSpriteSheet =
-            DataBaseProviderService.getModel("AtlasSpriteSheet", options);
-          const File = DataBaseProviderService.getModel("File", options);
+          const AtlasSpriteSheet = DataBaseProviderService.getModel('AtlasSpriteSheet', options);
+          const File = DataBaseProviderService.getModel('File', options);
 
           const atlasDoc = await AtlasSpriteSheet.findById(objectLayer.atlasSpriteSheetId);
 
@@ -451,7 +448,7 @@ class ObjectLayerService {
    */
   static generateWebp = async (req, res, options) => {
     /** @type {import('./object-layer.model.js').ObjectLayerModel} */
-    const ObjectLayer = DataBaseProviderService.getModel("ObjectLayer", options);
+    const ObjectLayer = DataBaseProviderService.getModel('ObjectLayer', options);
 
     // GET /generate-webp/:itemType/:itemId/:directionCode - Generate webp animation from PNG frames
     const itemType = req.params.itemType;
@@ -589,7 +586,7 @@ class ObjectLayerService {
    */
   static put = async (req, res, options) => {
     /** @type {import('./object-layer.model.js').ObjectLayerModel} */
-    const ObjectLayer = DataBaseProviderService.getModel("ObjectLayer", options);
+    const ObjectLayer = DataBaseProviderService.getModel('ObjectLayer', options);
 
     // PUT /:id/frame-image/:itemType/:itemId/:directionCode - Update frame images for specific direction
     if (req.path.includes('/frame-image/')) {
@@ -688,8 +685,7 @@ class ObjectLayerService {
       fs.writeFileSync(`${folder}/metadata.json`, metadataContent);
       fs.writeFileSync(`${publicFolder}/metadata.json`, metadataContent);
 
-      const ObjectLayerRenderFrames =
-        DataBaseProviderService.getModel("ObjectLayerRenderFrames", options);
+      const ObjectLayerRenderFrames = DataBaseProviderService.getModel('ObjectLayerRenderFrames', options);
 
       // Build object layer data from the asset directory
       const { objectLayerRenderFramesData, objectLayerData } =
@@ -806,9 +802,8 @@ class ObjectLayerService {
    */
   static delete = async (req, res, options) => {
     /** @type {import('./object-layer.model.js').ObjectLayerModel} */
-    const ObjectLayer = DataBaseProviderService.getModel("ObjectLayer", options);
-    const ObjectLayerRenderFrames =
-      DataBaseProviderService.getModel("ObjectLayerRenderFrames", options);
+    const ObjectLayer = DataBaseProviderService.getModel('ObjectLayer', options);
+    const ObjectLayerRenderFrames = DataBaseProviderService.getModel('ObjectLayerRenderFrames', options);
 
     if (req.params.id) {
       // Load the full object layer so we can access all references

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

@@ -1,6 +1,7 @@
 import { loggerFactory } from '../../server/logger.js';
 import { ObjectLayerRenderFramesController } from './object-layer-render-frames.controller.js';
 import express from 'express';
+import { moderatorGuard, adminGuard } from '../../server/auth.js';
 
 const logger = loggerFactory(import.meta);
 
@@ -11,17 +12,48 @@ class ObjectLayerRenderFramesRouter {
    */
   static router(options) {
     const router = express.Router();
-    router.post(`/:id`, async (req, res) => await ObjectLayerRenderFramesController.post(req, res, options));
-    router.post(`/`, async (req, res) => await ObjectLayerRenderFramesController.post(req, res, options));
-    router.get(`/:id`,
+    router.post(
+      `/:id`,
+      options.authMiddleware,
+      moderatorGuard,
+      async (req, res) => await ObjectLayerRenderFramesController.post(req, res, options),
+    );
+    router.post(
+      `/`,
+      options.authMiddleware,
+      moderatorGuard,
+      async (req, res) => await ObjectLayerRenderFramesController.post(req, res, options),
+    );
+    router.get(
+      `/:id`,
       // options.authMiddleware,
       async (req, res) => await ObjectLayerRenderFramesController.get(req, res, options),
     );
     router.get(`/`, async (req, res) => await ObjectLayerRenderFramesController.get(req, res, options));
-    router.put(`/:id`, async (req, res) => await ObjectLayerRenderFramesController.put(req, res, options));
-    router.put(`/`, async (req, res) => await ObjectLayerRenderFramesController.put(req, res, options));
-    router.delete(`/:id`, async (req, res) => await ObjectLayerRenderFramesController.delete(req, res, options));
-    router.delete(`/`, async (req, res) => await ObjectLayerRenderFramesController.delete(req, res, options));
+    router.put(
+      `/:id`,
+      options.authMiddleware,
+      moderatorGuard,
+      async (req, res) => await ObjectLayerRenderFramesController.put(req, res, options),
+    );
+    router.put(
+      `/`,
+      options.authMiddleware,
+      moderatorGuard,
+      async (req, res) => await ObjectLayerRenderFramesController.put(req, res, options),
+    );
+    router.delete(
+      `/:id`,
+      options.authMiddleware,
+      moderatorGuard,
+      async (req, res) => await ObjectLayerRenderFramesController.delete(req, res, options),
+    );
+    router.delete(
+      `/`,
+      options.authMiddleware,
+      adminGuard,
+      async (req, res) => await ObjectLayerRenderFramesController.delete(req, res, options),
+    );
     return router;
   }
 }