cyberia 3.0.1 → 3.0.2

package/manifests/cronjobs/dd-cron/dd-cron-backup.yaml

@@ -23,7 +23,7 @@ spec:
         spec:
           containers:
             - name: dd-cron-backup
-              image: underpost/underpost-engine:v3.0.1
+              image: underpost/underpost-engine:v3.0.2
               command:
                 - /bin/sh
                 - -c

package/manifests/cronjobs/dd-cron/dd-cron-dns.yaml

@@ -23,7 +23,7 @@ spec:
         spec:
           containers:
             - name: dd-cron-dns
-              image: underpost/underpost-engine:v3.0.1
+              image: underpost/underpost-engine:v3.0.2
               command:
                 - /bin/sh
                 - -c

package/manifests/deployment/dd-default-development/deployment.yaml

@@ -17,7 +17,7 @@ spec:
     spec:
       containers:
         - name: dd-default-development-blue
-          image: localhost/rockylinux9-underpost:v3.0.1
+          image: localhost/rockylinux9-underpost:v3.0.2
           #          resources:
           #            requests:
           #              memory: "124Ki"
@@ -100,7 +100,7 @@ spec:
     spec:
       containers:
         - name: dd-default-development-green
-          image: localhost/rockylinux9-underpost:v3.0.1
+          image: localhost/rockylinux9-underpost:v3.0.2
           #          resources:
           #            requests:
           #              memory: "124Ki"

package/manifests/deployment/dd-test-development/deployment.yaml

@@ -18,7 +18,7 @@ spec:
     spec:
       containers:
         - name: dd-test-development-blue
-          image: localhost/rockylinux9-underpost:v3.0.1
+          image: localhost/rockylinux9-underpost:v3.0.2
 
           command:
             - /bin/sh
@@ -103,7 +103,7 @@ spec:
     spec:
       containers:
         - name: dd-test-development-green
-          image: localhost/rockylinux9-underpost:v3.0.1
+          image: localhost/rockylinux9-underpost:v3.0.2
 
           command:
             - /bin/sh

package/manifests/ipfs/configmap.yaml

@@ -16,6 +16,13 @@ data:
       ipfs-cluster-service init
     fi
 
+    # Bind cluster APIs to 0.0.0.0 so they are reachable from other pods.
+    # By default ipfs-cluster listens on 127.0.0.1 for REST (9094),
+    # Proxy (9095) and Pinning Service (9097).
+    sed -i 's|/ip4/127\.0\.0\.1/tcp/9094|/ip4/0.0.0.0/tcp/9094|g' /data/ipfs-cluster/service.json
+    sed -i 's|/ip4/127\.0\.0\.1/tcp/9095|/ip4/0.0.0.0/tcp/9095|g' /data/ipfs-cluster/service.json
+    sed -i 's|/ip4/127\.0\.0\.1/tcp/9097|/ip4/0.0.0.0/tcp/9097|g' /data/ipfs-cluster/service.json
+
     PEER_HOSTNAME=$(cat /proc/sys/kernel/hostname)
 
     if echo "${PEER_HOSTNAME}" | grep -q "^ipfs-cluster-0"; then

package/package.json

@@ -2,7 +2,7 @@
     "type": "module",
     "main": "src/index.js",
     "name": "cyberia",
-    "version": "3.0.1",
+    "version": "3.0.2",
     "description": "Cyberia Engine - Object Layer and Assets Management Microservice",
     "scripts": {
         "start": "env-cmd -f .env.production node --max-old-space-size=8192 src/server",
@@ -76,20 +76,24 @@
         "http-proxy-middleware": "^2.0.6",
         "ignore-walk": "^8.0.0",
         "iovalkey": "^0.2.1",
+        "jimp": "^1.6.0",
         "json-colorizer": "^2.2.2",
         "jsonwebtoken": "^9.0.2",
         "mariadb": "^3.2.2",
         "marked": "^12.0.2",
-        "mocha": "^11.3.0",
+        "maxrects-packer": "^2.7.3",
+        "mocha": "^7.2.0",
         "mongoose": "^8.9.5",
         "morgan": "^1.10.0",
         "nodemailer": "^7.0.9",
         "nodemon": "^3.0.1",
         "peer": "^1.0.2",
         "peerjs": "^1.5.2",
+        "pngjs": "^7.0.0",
         "prom-client": "^15.1.2",
         "read": "^2.1.0",
         "rrule": "^2.8.1",
+        "sharp": "^0.32.5",
         "shelljs": "^0.10.0",
         "sitemap": "^7.1.1",
         "socket.io": "^4.8.0",
@@ -100,11 +104,7 @@
         "uglify-js": "^3.17.4",
         "validator": "^13.11.0",
         "vanilla-jsoneditor": "^2.3.2",
-        "winston": "^3.11.0",
-        "maxrects-packer": "^2.7.3",
-        "pngjs": "^7.0.0",
-        "jimp": "^1.6.0",
-        "sharp": "^0.32.5"
+        "winston": "^3.11.0"
     },
     "publishConfig": {
         "provenance": true,
@@ -115,4 +115,4 @@
         "minimatch": "^10.2.2",
         "glob": "^11.0.0"
     }
-}
+}

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

@@ -51,6 +51,8 @@ const AtlasSpriteSheetController = {
   },
   get: async (req, res, options) => {
     try {
+      res.setHeader('Access-Control-Allow-Origin', '*');
+      res.setHeader('Cross-Origin-Resource-Policy', 'cross-origin');
       const { page, limit } = req.query;
       const result = await AtlasSpriteSheetService.get(
         { ...req, query: { ...req.query, page: parseInt(page), limit: parseInt(limit) } },

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

@@ -75,6 +75,7 @@ const DirectionFramesSchema = new Schema(
 /**
  * @typedef {Object} AtlasSpriteSheet
  * @property {Types.ObjectId} fileId - Reference to File document (consolidated PNG)
+ * @property {string} [cid] - IPFS Content Identifier for the atlas PNG
  * @property {Object} metadata - Atlas sprite sheet metadata
  * @property {string} metadata.itemKey - Item identifier key for texture reference
  * @property {number} metadata.atlasWidth - Total atlas width in pixels
@@ -92,6 +93,11 @@ const AtlasSpriteSheetSchema = new Schema(
       ref: 'File',
       required: true,
     },
+    cid: {
+      type: String,
+      default: '',
+      trim: true,
+    },
     metadata: {
       itemKey: { type: String, required: true, trim: true },
       atlasWidth: { type: Number, required: true, min: 1 },
@@ -129,6 +135,7 @@ const AtlasSpriteSheetDto = {
       return {
         _id: 1,
         fileId: 1,
+        cid: 1,
         metadata: 1,
         createdAt: 1,
         updatedAt: 1,

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

@@ -4,6 +4,8 @@ import { DataQuery } from '../../server/data-query.js';
 import { AtlasSpriteSheetGenerator } from '../../server/atlas-sprite-sheet-generator.js';
 import { FileFactory } from '../file/file.service.js';
 import { AtlasSpriteSheetDto } from './atlas-sprite-sheet.model.js';
+import { IpfsClient } from '../../server/ipfs-client.js';
+import { createPinRecord, removePinRecordsAndUnpin } from '../ipfs/ipfs.service.js';
 
 const logger = loggerFactory(import.meta);
 
@@ -39,6 +41,27 @@ const AtlasSpriteSheetService = {
 
     const fileDoc = await new File(FileFactory.create(buffer, `${itemKey}.png`)).save();
 
+    // Add atlas PNG to IPFS and obtain its CID
+    let atlasCid = '';
+    try {
+      const ipfsResult = await IpfsClient.addBufferToIpfs(
+        buffer,
+        `${itemKey}_atlas_sprite_sheet.png`,
+        `/object-layer/${itemKey}/${itemKey}_atlas_sprite_sheet.png`,
+      );
+      if (ipfsResult) {
+        atlasCid = ipfsResult.cid;
+        // Create pin record for the authenticated user (when available)
+        const userId = req.auth && req.auth.user ? req.auth.user._id : undefined;
+        if (userId) {
+          await createPinRecord({ cid: atlasCid, userId, options });
+        }
+        logger.info(`Atlas sprite sheet pinned to IPFS – CID: ${atlasCid}`);
+      }
+    } catch (ipfsError) {
+      logger.warn('Failed to add atlas sprite sheet to IPFS:', ipfsError.message);
+    }
+
     let atlasDoc = await AtlasSpriteSheet.findOne({ 'metadata.itemKey': itemKey });
 
     if (atlasDoc) {
@@ -47,16 +70,20 @@ const AtlasSpriteSheetService = {
         await File.findByIdAndDelete(atlasDoc.fileId);
       }
       atlasDoc.fileId = fileDoc._id;
+      atlasDoc.cid = atlasCid;
       atlasDoc.metadata = metadata;
       await atlasDoc.save();
     } else {
       atlasDoc = await new AtlasSpriteSheet({
         fileId: fileDoc._id,
+        cid: atlasCid,
         metadata,
       }).save();
     }
 
     objectLayer.atlasSpriteSheetId = atlasDoc._id;
+    objectLayer.data.atlasSpriteSheetCid = atlasCid;
+    objectLayer.markModified('data.atlasSpriteSheetCid');
     await objectLayer.save();
 
     return atlasDoc;
@@ -78,12 +105,30 @@ const AtlasSpriteSheetService = {
     if (objectLayer.atlasSpriteSheetId) {
       const atlasDoc = await AtlasSpriteSheet.findById(objectLayer.atlasSpriteSheetId);
       if (atlasDoc) {
+        // Remove pin records and unpin atlas CID from IPFS
+        const atlasCid = atlasDoc.cid || objectLayer.data.atlasSpriteSheetCid;
+        if (atlasCid) {
+          try {
+            await removePinRecordsAndUnpin(atlasCid, options);
+            // Remove the MFS entry for the atlas sprite sheet PNG
+            const itemId = objectLayer.data.item.id;
+            await IpfsClient.removeMfsPath(`/object-layer/${itemId}/${itemId}_atlas_sprite_sheet.png`);
+            logger.info(`Cleaned up IPFS atlas CID ${atlasCid} for ObjectLayer ${objectLayer._id}`);
+          } catch (ipfsErr) {
+            logger.warn(`Failed to clean up IPFS atlas CID ${atlasCid}: ${ipfsErr.message}`);
+          }
+        }
+
+        // Delete the atlas File document from MongoDB
         if (atlasDoc.fileId) {
           await File.findByIdAndDelete(atlasDoc.fileId);
         }
+        // Delete the AtlasSpriteSheet document itself
         await AtlasSpriteSheet.findByIdAndDelete(atlasDoc._id);
       }
       objectLayer.atlasSpriteSheetId = undefined;
+      objectLayer.data.atlasSpriteSheetCid = '';
+      objectLayer.markModified('data.atlasSpriteSheetCid');
       await objectLayer.save();
     }
 
@@ -130,8 +175,54 @@ const AtlasSpriteSheetService = {
     /** @type {import('./atlas-sprite-sheet.model.js').AtlasSpriteSheetModel} */
     const AtlasSpriteSheet =
       DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.AtlasSpriteSheet;
-    if (req.params.id) return await AtlasSpriteSheet.findByIdAndDelete(req.params.id);
-    else return await AtlasSpriteSheet.deleteMany();
+    /** @type {import('../file/file.model.js').FileModel} */
+    const File = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.File;
+
+    if (req.params.id) {
+      const atlasDoc = await AtlasSpriteSheet.findById(req.params.id);
+      if (!atlasDoc) return null;
+
+      // Remove pin records and unpin atlas CID from IPFS
+      if (atlasDoc.cid) {
+        try {
+          await removePinRecordsAndUnpin(atlasDoc.cid, options);
+          if (atlasDoc.metadata?.itemKey) {
+            const itemKey = atlasDoc.metadata.itemKey;
+            await IpfsClient.removeMfsPath(`/object-layer/${itemKey}/${itemKey}_atlas_sprite_sheet.png`);
+          }
+          logger.info(`Cleaned up IPFS atlas CID ${atlasDoc.cid} for AtlasSpriteSheet ${atlasDoc._id}`);
+        } catch (ipfsErr) {
+          logger.warn(`Failed to clean up IPFS atlas CID ${atlasDoc.cid}: ${ipfsErr.message}`);
+        }
+      }
+
+      // Delete the referenced File document (the atlas PNG blob)
+      if (atlasDoc.fileId) {
+        await File.findByIdAndDelete(atlasDoc.fileId);
+      }
+
+      return await AtlasSpriteSheet.findByIdAndDelete(req.params.id);
+    } else {
+      // Bulk delete: iterate each atlas to clean up File, IPFS pins, and pin records
+      const allAtlases = await AtlasSpriteSheet.find({});
+      for (const atlasDoc of allAtlases) {
+        try {
+          if (atlasDoc.cid) {
+            await removePinRecordsAndUnpin(atlasDoc.cid, options);
+            if (atlasDoc.metadata?.itemKey) {
+              const itemKey = atlasDoc.metadata.itemKey;
+              await IpfsClient.removeMfsPath(`/object-layer/${itemKey}/${itemKey}_atlas_sprite_sheet.png`);
+            }
+          }
+          if (atlasDoc.fileId) {
+            await File.findByIdAndDelete(atlasDoc.fileId);
+          }
+        } catch (err) {
+          logger.error(`Failed to clean up AtlasSpriteSheet ${atlasDoc._id} during bulk delete: ${err.message}`);
+        }
+      }
+      return await AtlasSpriteSheet.deleteMany();
+    }
   },
 };
 

package/src/api/file/file.controller.js

@@ -19,22 +19,12 @@ const FileController = {
   },
   get: async (req, res, options) => {
     try {
+      res.setHeader('Access-Control-Allow-Origin', '*');
+      res.setHeader('Cross-Origin-Resource-Policy', 'cross-origin');
       const result = await FileService.get(req, res, options);
       if (result instanceof Buffer) {
-        if (
-          process.env.NODE_ENV === 'development' ||
-          req.hostname === options.host ||
-          (options.origins && options.origins.find((o) => o.match(req.hostname)))
-        ) {
-          res.set('Cross-Origin-Resource-Policy', 'cross-origin');
-          return res.status(200).end(result);
-        }
-        return res.status(403).json({
-          status: 'error',
-          message: 'Forbidden',
-        });
+        return res.status(200).end(result);
       }
-
       return res.status(200).json({
         status: 'success',
         data: result,

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

@@ -5,27 +5,6 @@
       "logo": true
     }
   },
-  {
-    "api": "cyberia-biome",
-    "model": {
-      "fileId": true,
-      "topLevelColorFileId": true
-    }
-  },
-  {
-    "api": "cyberia-tile",
-    "model": {
-      "fileId": true
-    }
-  },
-  {
-    "api": "cyberia-world",
-    "model": {
-      "adjacentFace": {
-        "fileId": true
-      }
-    }
-  },
   {
     "api": "document",
     "model": {

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

@@ -0,0 +1,104 @@
+import { loggerFactory } from '../../server/logger.js';
+import { IpfsService } from './ipfs.service.js';
+
+const logger = loggerFactory(import.meta);
+
+const IpfsController = {
+  post: async (req, res, options) => {
+    try {
+      const result = await IpfsService.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 IpfsService.get(
+        { ...req, query: { ...req.query, page: parseInt(page), limit: parseInt(limit) } },
+        res,
+        options,
+      );
+      return res.status(200).json({
+        status: 'success',
+        data: result,
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  },
+  put: async (req, res, options) => {
+    try {
+      const result = await IpfsService.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 IpfsService.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,
+      });
+    }
+  },
+  pin: async (req, res, options) => {
+    try {
+      const result = await IpfsService.pin(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,
+      });
+    }
+  },
+};
+
+export { IpfsController };

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

@@ -0,0 +1,71 @@
+/**
+ * Mongoose model for IPFS API – a general-purpose pin record that relates
+ * a user to a CID.
+ *
+ * @module src/api/ipfs/ipfs.model.js
+ * @namespace IpfsModel
+ */
+
+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: {
+      type: String,
+      required: true,
+      trim: true,
+    },
+    userId: {
+      type: Schema.Types.ObjectId,
+      ref: 'User',
+      required: true,
+    },
+  },
+  {
+    timestamps: true,
+  },
+);
+
+// Compound index: one pin record per user + CID pair.
+IpfsSchema.index({ cid: 1, userId: 1 }, { unique: true });
+
+// Fast look-ups by user.
+IpfsSchema.index({ userId: 1 });
+
+// Fast look-ups by CID.
+IpfsSchema.index({ cid: 1 });
+
+const IpfsModel = model('Ipfs', IpfsSchema);
+
+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',
+    }),
+  },
+};
+
+export { IpfsSchema, IpfsModel, ProviderSchema, IpfsDto };

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

@@ -0,0 +1,31 @@
+import { adminGuard } from '../../server/auth.js';
+import { loggerFactory } from '../../server/logger.js';
+import { IpfsController } from './ipfs.controller.js';
+import express from 'express';
+
+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));
+  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;
+};
+
+const ApiRouter = IpfsRouter;
+
+export { ApiRouter, IpfsRouter };