cyberia 3.1.3 → 3.2.5

package/src/api/cyberia-instance-conf/cyberia-instance-conf.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 CyberiaInstanceConfService = {
+  post: async (req, res, options) => {
+    /** @type {import('./cyberia-instance-conf.model.js').CyberiaInstanceConfModel} */
+    const CyberiaInstanceConf = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaInstanceConf;
+    return await new CyberiaInstanceConf(req.body).save();
+  },
+  get: async (req, res, options) => {
+    /** @type {import('./cyberia-instance-conf.model.js').CyberiaInstanceConfModel} */
+    const CyberiaInstanceConf = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaInstanceConf;
+    if (req.params.id) return await CyberiaInstanceConf.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([
+      CyberiaInstanceConf.find(query).sort(sort).limit(limit).skip(skip),
+      CyberiaInstanceConf.countDocuments(query),
+    ]);
+
+    const totalPages = Math.ceil(total / limit);
+    return { data, total, page, totalPages };
+  },
+  put: async (req, res, options) => {
+    /** @type {import('./cyberia-instance-conf.model.js').CyberiaInstanceConfModel} */
+    const CyberiaInstanceConf = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaInstanceConf;
+    return await CyberiaInstanceConf.findByIdAndUpdate(req.params.id, req.body);
+  },
+  delete: async (req, res, options) => {
+    /** @type {import('./cyberia-instance-conf.model.js').CyberiaInstanceConfModel} */
+    const CyberiaInstanceConf = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaInstanceConf;
+    if (req.params.id) return await CyberiaInstanceConf.findByIdAndDelete(req.params.id);
+    else return await CyberiaInstanceConf.deleteMany();
+  },
+};
+
+export { CyberiaInstanceConfService };

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

@@ -0,0 +1,79 @@
+import { loggerFactory } from '../../server/logger.js';
+import { CyberiaMapService } from './cyberia-map.service.js';
+
+const logger = loggerFactory(import.meta);
+
+const CyberiaMapController = {
+  post: async (req, res, options) => {
+    try {
+      const result = await CyberiaMapService.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 CyberiaMapService.get(
+        {
+          ...req,
+          path: req.path,
+          params: req.params,
+          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 CyberiaMapService.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 CyberiaMapService.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 { CyberiaMapController };

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

@@ -0,0 +1,30 @@
+import { Schema, model, Types } from 'mongoose';
+import { CyberiaEntitySchema } from '../cyberia-entity/cyberia-entity.model.js';
+
+// https://mongoosejs.com/docs/2.7.x/docs/schematypes.html
+
+const CyberiaMapSchema = new Schema(
+  {
+    code: { type: String, default: '', unique: true },
+    name: { type: String, default: '' },
+    description: { type: String, default: '' },
+    entities: { type: [CyberiaEntitySchema], default: [] },
+    tags: { type: [String], default: [] },
+    creator: { type: Schema.Types.ObjectId, ref: 'User' },
+    status: { type: String, default: 'unlisted' },
+    thumbnail: { type: Schema.Types.ObjectId, ref: 'File' },
+    gridX: { type: Number, default: 16 },
+    gridY: { type: Number, default: 16 },
+    cellWidth: { type: Number, default: 32 },
+    cellHeight: { type: Number, default: 32 },
+  },
+  {
+    timestamps: true,
+  },
+);
+
+const CyberiaMapModel = model('CyberiaMap', CyberiaMapSchema);
+
+const ProviderSchema = CyberiaMapSchema;
+
+export { CyberiaMapSchema, CyberiaMapModel, ProviderSchema };

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

@@ -0,0 +1,40 @@
+import { loggerFactory } from '../../server/logger.js';
+import { CyberiaMapController } from './cyberia-map.controller.js';
+import { userGuard, adminGuard } from '../../server/auth.js';
+import express from 'express';
+
+const logger = loggerFactory(import.meta);
+
+const CyberiaMapRouter = (options) => {
+  const router = express.Router();
+  const authMiddleware = options.authMiddleware;
+  router.post(
+    `/:id`,
+    authMiddleware,
+    userGuard,
+    async (req, res) => await CyberiaMapController.post(req, res, options),
+  );
+  router.post(`/`, authMiddleware, userGuard, async (req, res) => await CyberiaMapController.post(req, res, options));
+  router.get(`/search-codes`, async (req, res) => await CyberiaMapController.get(req, res, options));
+  router.get(`/:id`, async (req, res) => await CyberiaMapController.get(req, res, options));
+  router.get(`/`, async (req, res) => await CyberiaMapController.get(req, res, options));
+  router.put(`/:id`, authMiddleware, userGuard, async (req, res) => await CyberiaMapController.put(req, res, options));
+  router.put(`/`, authMiddleware, userGuard, async (req, res) => await CyberiaMapController.put(req, res, options));
+  router.delete(
+    `/:id`,
+    authMiddleware,
+    userGuard,
+    async (req, res) => await CyberiaMapController.delete(req, res, options),
+  );
+  router.delete(
+    `/`,
+    authMiddleware,
+    adminGuard,
+    async (req, res) => await CyberiaMapController.delete(req, res, options),
+  );
+  return router;
+};
+
+const ApiRouter = CyberiaMapRouter;
+
+export { ApiRouter, CyberiaMapRouter };

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

@@ -0,0 +1,74 @@
+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 CyberiaMapService = {
+  post: async (req, res, options) => {
+    /** @type {import('./cyberia-map.model.js').CyberiaMapModel} */
+    const CyberiaMap = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaMap;
+    if (req.auth && req.auth.user) req.body.creator = req.auth.user._id;
+    return await new CyberiaMap(req.body).save();
+  },
+  get: async (req, res, options) => {
+    /** @type {import('./cyberia-map.model.js').CyberiaMapModel} */
+    const CyberiaMap = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaMap;
+    const populateCreator = { path: 'creator', model: 'User', select: '_id username' };
+
+    // GET /search-codes?q=<partial> - Fast partial match search on code
+    if (req.path?.startsWith('/search-codes')) {
+      const q = (req.query.q || '').trim();
+      if (!q) return { codes: [] };
+      const escaped = q.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+      const results = await CyberiaMap.find({ code: { $regex: escaped, $options: 'i' } }, { code: 1, _id: 0 })
+        .limit(20)
+        .lean();
+      const codes = [...new Set(results.map((r) => r.code).filter(Boolean))];
+      return { codes };
+    }
+
+    if (req.params.id) return await CyberiaMap.findById(req.params.id).populate(populateCreator);
+
+    // Parse query parameters using DataQuery helper
+    const { query, sort, skip, limit, page } = DataQuery.parse(req.query);
+
+    const [data, total] = await Promise.all([
+      CyberiaMap.find(query).sort(sort).limit(limit).skip(skip).populate(populateCreator),
+      CyberiaMap.countDocuments(query),
+    ]);
+
+    const totalPages = Math.ceil(total / limit);
+    return { data, total, page, totalPages };
+  },
+  put: async (req, res, options) => {
+    /** @type {import('./cyberia-map.model.js').CyberiaMapModel} */
+    const CyberiaMap = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaMap;
+    const map = await CyberiaMap.findById(req.params.id);
+    if (!map) throw new Error('map not found');
+    if (req.auth.user.role !== 'admin' && String(map.creator) !== String(req.auth.user._id))
+      throw new Error('insufficient permission');
+    if (req.body.thumbnail && map.thumbnail && String(req.body.thumbnail) !== String(map.thumbnail)) {
+      const File = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.File;
+      await File.findByIdAndDelete(map.thumbnail);
+    }
+    return await CyberiaMap.findByIdAndUpdate(req.params.id, req.body, { returnDocument: 'after' });
+  },
+  delete: async (req, res, options) => {
+    /** @type {import('./cyberia-map.model.js').CyberiaMapModel} */
+    const CyberiaMap = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaMap;
+    if (req.params.id) {
+      const map = await CyberiaMap.findById(req.params.id);
+      if (!map) throw new Error('map not found');
+      if (req.auth.user.role !== 'admin' && String(map.creator) !== String(req.auth.user._id))
+        throw new Error('insufficient permission');
+      if (map.thumbnail) {
+        const File = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.File;
+        await File.findByIdAndDelete(map.thumbnail);
+      }
+      return await CyberiaMap.findByIdAndDelete(req.params.id);
+    } else return await CyberiaMap.deleteMany();
+  },
+};
+
+export { CyberiaMapService };

package/src/api/file/file.ref.json

@@ -1,10 +1,28 @@
 [
+  {
+    "api": "atlas-sprite-sheet",
+    "model": {
+      "fileId": true
+    }
+  },
   {
     "api": "company",
     "model": {
       "logo": true
     }
   },
+  {
+    "api": "cyberia-instance",
+    "model": {
+      "thumbnail": true
+    }
+  },
+  {
+    "api": "cyberia-map",
+    "model": {
+      "thumbnail": true
+    }
+  },
   {
     "api": "document",
     "model": {

package/src/api/ipfs/ipfs.controller.js

@@ -69,34 +69,13 @@ const IpfsController = {
       });
     }
   },
-  pin: async (req, res, options) => {
+  verify: async (req, res, options) => {
     try {
-      const result = await IpfsService.pin(req, res, options);
-      return res.status(200).json({
-        status: 'success',
-        data: result,
-      });
+      const result = await IpfsService.verify(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,
-      });
-    }
-  },
-  unpin: async (req, res, options) => {
-    try {
-      const result = await IpfsService.unpin(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,
-      });
+      return res.status(400).json({ status: 'error', message: error.message });
     }
   },
 };

package/src/api/ipfs/ipfs.model.js

@@ -1,6 +1,22 @@
 /**
- * Mongoose model for IPFS API – a general-purpose pin record that relates
- * a user to a CID.
+ * Mongoose model for the IPFS CID Registry.
+ *
+ * Purpose: tracks every CID that the Engine has pinned to IPFS so that:
+ *   1. Deletions can cleanly unpin the right CID from the IPFS node/cluster.
+ *   2. Admins can run a health-check that verifies every DB-registered CID is
+ *      still actually pinned (GET /ipfs/verify).
+ *   3. Garbage-collection jobs can discover orphaned CIDs (pinned on the node
+ *      but not referenced by any DB document).
+ *
+ * Fields:
+ *   cid          - IPFS Content Identifier (CIDv0 or CIDv1).
+ *   resourceType - What kind of asset this CID belongs to:
+ *                    'object-layer-data'  - JSON payload of an ObjectLayer document.
+ *                    'atlas-sprite-sheet' - PNG sprite-sheet of an ObjectLayer.
+ *                    'atlas-metadata'     - JSON metadata of an AtlasSpriteSheet.
+ *   mfsPath      - MFS (Mutable File System) path used when the CID was added,
+ *                  e.g. /object-layer/sword/sword_data.json.
+ *                  Enables targeted removal via files/rm without knowing the CID.
  *
  * @module src/api/ipfs/ipfs.model.js
  * @namespace IpfsModel
@@ -8,14 +24,6 @@
 
 import { Schema, model } from 'mongoose';
 
-/**
- * @typedef {Object} Ipfs
- * @property {string}         cid       – IPFS Content Identifier (CIDv0 or CIDv1).
- * @property {Types.ObjectId} userId    – Reference to the User who owns / requested the pin.
- * @property {Date}           createdAt – Auto-managed by Mongoose.
- * @property {Date}           updatedAt – Auto-managed by Mongoose.
- * @memberof IpfsModel
- */
 const IpfsSchema = new Schema(
   {
     cid: {
@@ -23,10 +31,19 @@ const IpfsSchema = new Schema(
       required: true,
       trim: true,
     },
-    userId: {
-      type: Schema.Types.ObjectId,
-      ref: 'User',
+    // Asset category - determines which service owns this CID.
+    resourceType: {
+      type: String,
       required: true,
+      trim: true,
+      enum: ['object-layer-data', 'atlas-sprite-sheet', 'atlas-metadata'],
+    },
+    // MFS path used when the content was added to IPFS.
+    // Empty string when the content was added without an MFS copy.
+    mfsPath: {
+      type: String,
+      default: '',
+      trim: true,
     },
   },
   {
@@ -34,14 +51,14 @@ const IpfsSchema = new Schema(
   },
 );
 
-// Compound index: one pin record per user + CID pair.
-IpfsSchema.index({ cid: 1, userId: 1 }, { unique: true });
+// One DB record per (CID, resourceType) pair.
+IpfsSchema.index({ cid: 1, resourceType: 1 }, { unique: true });
 
-// Fast look-ups by user.
-IpfsSchema.index({ userId: 1 });
+// Fast look-ups for health-check and garbage-collection by type.
+IpfsSchema.index({ resourceType: 1 });
 
-// Fast look-ups by CID.
-IpfsSchema.index({ cid: 1 });
+// Fast look-ups for targeted MFS cleanup.
+IpfsSchema.index({ mfsPath: 1 });
 
 const IpfsModel = model('Ipfs', IpfsSchema);
 
@@ -49,21 +66,13 @@ const ProviderSchema = IpfsSchema;
 
 const IpfsDto = {
   select: {
-    get: () => {
-      return {
-        _id: 1,
-        cid: 1,
-        userId: 1,
-        createdAt: 1,
-        updatedAt: 1,
-      };
-    },
-  },
-  populate: {
-    user: () => ({
-      path: 'userId',
-      model: 'User',
-      select: '_id username email role',
+    get: () => ({
+      _id: 1,
+      cid: 1,
+      resourceType: 1,
+      mfsPath: 1,
+      createdAt: 1,
+      updatedAt: 1,
     }),
   },
 };

package/src/api/ipfs/ipfs.router.js

@@ -8,19 +8,14 @@ const logger = loggerFactory(import.meta);
 const IpfsRouter = (options) => {
   const router = express.Router();
   const authMiddleware = options.authMiddleware;
-  router.post(`/pin`, authMiddleware, adminGuard, async (req, res) => await IpfsController.pin(req, res, options));
-  router.delete(
-    `/pin/:cid`,
-    authMiddleware,
-    adminGuard,
-    async (req, res) => await IpfsController.unpin(req, res, options),
-  );
-  router.post(`/:id`, authMiddleware, async (req, res) => await IpfsController.post(req, res, options));
-  router.post(`/`, authMiddleware, async (req, res) => await IpfsController.post(req, res, options));
-  router.get(`/:id`, authMiddleware, async (req, res) => await IpfsController.get(req, res, options));
-  router.get(`/`, authMiddleware, async (req, res) => await IpfsController.get(req, res, options));
-  router.put(`/:id`, authMiddleware, async (req, res) => await IpfsController.put(req, res, options));
-  router.put(`/`, authMiddleware, async (req, res) => await IpfsController.put(req, res, options));
+  // Health / audit — must come before /:id to avoid matching conflicts.
+  router.get(`/verify`, authMiddleware, adminGuard, async (req, res) => await IpfsController.verify(req, res, options));
+  router.post(`/:id`, authMiddleware, adminGuard, async (req, res) => await IpfsController.post(req, res, options));
+  router.post(`/`, authMiddleware, adminGuard, async (req, res) => await IpfsController.post(req, res, options));
+  router.get(`/:id`, authMiddleware, adminGuard, async (req, res) => await IpfsController.get(req, res, options));
+  router.get(`/`, authMiddleware, adminGuard, async (req, res) => await IpfsController.get(req, res, options));
+  router.put(`/:id`, authMiddleware, adminGuard, async (req, res) => await IpfsController.put(req, res, options));
+  router.put(`/`, authMiddleware, adminGuard, async (req, res) => await IpfsController.put(req, res, options));
   router.delete(`/:id`, authMiddleware, adminGuard, async (req, res) => await IpfsController.delete(req, res, options));
   router.delete(`/`, authMiddleware, adminGuard, async (req, res) => await IpfsController.delete(req, res, options));
   return router;