cyberia 3.1.3 → 3.2.9

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

@@ -3,191 +3,129 @@ import { loggerFactory } from '../../server/logger.js';
 import { DataQuery } from '../../server/data-query.js';
 import { IpfsClient } from '../../server/ipfs-client.js';
 import { IpfsDto } from './ipfs.model.js';
-
 const logger = loggerFactory(import.meta);
-
 /**
- * Create (or upsert) an IPFS pin record for a given user + CID pair.
- * This is a helper consumed by other services (ObjectLayer, AtlasSpriteSheet, …)
- * so they don't need to know about the Ipfs model directly.
+ * Upsert a CID registry entry.
+ * Called by asset services (ObjectLayer, AtlasSpriteSheet) after a successful
+ * IPFS pin so the registry always reflects what is actually pinned.
  *
- * @param {object}  opts
- * @param {string}  opts.cid      – IPFS Content Identifier.
- * @param {string}  opts.userId   – Mongoose ObjectId string of the owning user.
- * @param {object}  opts.options  – Router options ({ host, path }) for DB lookup.
+ * @param {object} opts
+ * @param {string} opts.cid          - IPFS Content Identifier.
+ * @param {string} opts.resourceType - Asset category ('object-layer-data' | 'atlas-sprite-sheet' | 'atlas-metadata').
+ * @param {string} [opts.mfsPath]    - MFS path used when adding the content.
+ * @param {object} opts.options      - Router options ({ host, path }) for DB lookup.
  * @returns {Promise<import('mongoose').Document>}
  */
-const createPinRecord = async ({ cid, userId, options }) => {
+const createPinRecord = async ({ cid, resourceType, mfsPath = '', options }) => {
   const Ipfs = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Ipfs;
-
-  // Upsert: if a record for this user + CID already exists, just touch it.
   const record = await Ipfs.findOneAndUpdate(
-    { cid, userId },
-    { cid, userId },
+    { cid, resourceType },
+    { cid, resourceType, mfsPath },
     { upsert: true, returnDocument: 'after', setDefaultsOnInsert: true },
   );
-
-  logger.info(`IPFS pin record upserted – CID: ${cid}, userId: ${userId}`);
+  logger.info(`IPFS registry upserted – CID: ${cid}, type: ${resourceType}, mfsPath: ${mfsPath}`);
   return record;
 };
-
 /**
- * Remove all DB pin records for a CID, then best-effort unpin from IPFS node/cluster.
- * Always deletes the DB records first so that even if the IPFS node is unreachable
- * the database stays clean.
+ * Remove all DB registry entries for a CID, then best-effort unpin from the IPFS node.
+ * Always deletes DB records first so the registry stays clean even if the node is down.
  *
- * @param {string} cid     – IPFS Content Identifier to clean up.
- * @param {object} options – Router options ({ host, path }) for DB lookup.
+ * @param {string} cid     - IPFS Content Identifier to remove.
+ * @param {object} options - Router options ({ host, path }) for DB lookup.
  * @returns {Promise<void>}
  */
 const removePinRecordsAndUnpin = async (cid, options) => {
   const Ipfs = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Ipfs;
-
-  // 1. Remove all DB pin records for this CID first
   await Ipfs.deleteMany({ cid });
-  logger.info(`Removed all IPFS pin records for CID: ${cid}`);
-
-  // 2. Best-effort unpin from IPFS node/cluster (ignore "not pinned" errors)
+  logger.info(`Removed IPFS registry entries for CID: ${cid}`);
   try {
     await IpfsClient.unpinCid(cid);
   } catch (err) {
     logger.warn(`Best-effort IPFS unpin failed for CID ${cid}: ${err.message}`);
   }
 };
-
-const IpfsService = {
+class IpfsService {
   /** Expose helpers so other modules can import them directly. */
-  createPinRecord,
-  removePinRecordsAndUnpin,
-
+  static createPinRecord = createPinRecord;
+  static removePinRecordsAndUnpin = removePinRecordsAndUnpin;
   // ──────────────────────────────────────────────
   //  Standard CRUD
   // ──────────────────────────────────────────────
-
-  post: async (req, res, options) => {
-    /** @type {import('./ipfs.model.js').IpfsModel} */
+  static post = async (req, res, options) => {
     const Ipfs = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Ipfs;
-
-    // Accept { cid, userId? } in body.
-    // If userId is omitted, fall back to the authenticated user.
-    const body = { ...req.body };
-    if (!body.userId && req.auth && req.auth.user) {
-      body.userId = req.auth.user._id;
-    }
-    // Strip pinType if sent by legacy clients
-    delete body.pinType;
-
-    return await new Ipfs(body).save();
-  },
-
-  get: async (req, res, options) => {
-    /** @type {import('./ipfs.model.js').IpfsModel} */
+    return await new Ipfs(req.body).save();
+  };
+  static get = async (req, res, options) => {
     const Ipfs = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Ipfs;
-
     if (req.params.id) {
-      return await Ipfs.findById(req.params.id).select(IpfsDto.select.get()).populate(IpfsDto.populate.user());
+      return await Ipfs.findById(req.params.id).select(IpfsDto.select.get());
     }
-
     const { query, sort, skip, limit, page } = DataQuery.parse(req.query);
-
     const [data, total] = await Promise.all([
-      Ipfs.find(query)
-        .select(IpfsDto.select.get())
-        .sort(sort)
-        .limit(limit)
-        .skip(skip)
-        .populate(IpfsDto.populate.user()),
+      Ipfs.find(query).select(IpfsDto.select.get()).sort(sort).limit(limit).skip(skip),
       Ipfs.countDocuments(query),
     ]);
-
     const totalPages = Math.ceil(total / limit);
     return { data, total, page, totalPages };
-  },
-
-  put: async (req, res, options) => {
-    /** @type {import('./ipfs.model.js').IpfsModel} */
+  };
+  static put = async (req, res, options) => {
     const Ipfs = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Ipfs;
     return await Ipfs.findByIdAndUpdate(req.params.id, req.body, { returnDocument: 'after' });
-  },
-
-  delete: async (req, res, options) => {
-    /** @type {import('./ipfs.model.js').IpfsModel} */
+  };
+  static delete = async (req, res, options) => {
     const Ipfs = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Ipfs;
-
     if (req.params.id) {
       const record = await Ipfs.findById(req.params.id);
       if (record) {
-        // Remove DB record first, then best-effort unpin
         await Ipfs.findByIdAndDelete(req.params.id);
-        try {
-          // Only unpin from IPFS if no other records reference this CID
-          const remaining = await Ipfs.countDocuments({ cid: record.cid });
-          if (remaining === 0) {
+        // Only unpin from the node when no other registry entries reference this CID.
+        const remaining = await Ipfs.countDocuments({ cid: record.cid });
+        if (remaining === 0) {
+          try {
             await IpfsClient.unpinCid(record.cid);
+          } catch (err) {
+            logger.warn(`Failed to unpin CID ${record.cid}: ${err.message}`);
           }
-        } catch (err) {
-          logger.warn(`Failed to unpin CID ${record.cid} from IPFS node: ${err.message}`);
         }
         return record;
       }
       return null;
     }
-
     return await Ipfs.deleteMany();
-  },
-
+  };
   // ──────────────────────────────────────────────
-  //  Pin / Unpin helpers (called via controller)
+  //  Health / audit
   // ──────────────────────────────────────────────
-
   /**
-   * POST /ipfs/pin  – add content to IPFS, pin it, and create a DB record.
-   * Body: { data: <string|object>, userId? }
+   * GET /ipfs/verify
+   *
+   * Iterates every CID in the registry and checks whether it is actually pinned
+   * on the connected IPFS node. Returns a summary suitable for admin dashboards
+   * and automated alerting.
+   *
+   * Response shape:
+   *   { total, pinned, unpinned, errors, entries: [{ cid, resourceType, mfsPath, pinned, error? }] }
    */
-  pin: async (req, res, options) => {
-    const userId = req.body.userId || (req.auth && req.auth.user ? req.auth.user._id : undefined);
-    if (!userId) throw new Error('userId is required to create a pin record');
-
-    const content = typeof req.body.data === 'string' ? req.body.data : JSON.stringify(req.body.data);
-    const result = await IpfsClient.addToIpfs(Buffer.from(content, 'utf-8'), req.body.filename || 'data');
-
-    if (!result) throw new Error('IPFS node is unreachable – content was not pinned');
-
-    const record = await createPinRecord({
-      cid: result.cid,
-      userId,
-      options,
-    });
-
-    return { cid: result.cid, size: result.size, record };
-  },
-
-  /**
-   * DELETE /ipfs/pin/:cid  – unpin a CID and remove the DB record for the current user.
-   */
-  unpin: async (req, res, options) => {
+  static verify = async (req, res, options) => {
     const Ipfs = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Ipfs;
-    const userId = req.auth && req.auth.user ? req.auth.user._id : undefined;
-    const cid = req.params.cid || req.params.id;
-
-    const record = await Ipfs.findOne({ cid, ...(userId ? { userId } : {}) });
-    if (!record) throw new Error(`No pin record found for CID ${cid}`);
-
-    // Remove DB record first
-    await Ipfs.findByIdAndDelete(record._id);
-
-    // Only unpin from the IPFS node when nobody else has a record for this CID
-    const remaining = await Ipfs.countDocuments({ cid });
-    if (remaining === 0) {
-      try {
-        await IpfsClient.unpinCid(cid);
-      } catch (err) {
-        logger.warn(`Best-effort IPFS unpin failed for CID ${cid}: ${err.message}`);
-      }
-    }
-
-    return { success: true, cid };
-  },
-};
-
+    const records = await Ipfs.find({}).select(IpfsDto.select.get()).lean();
+    let pinned = 0;
+    let unpinned = 0;
+    let errors = 0;
+    const entries = await Promise.all(
+      records.map(async (r) => {
+        try {
+          const isPinned = await IpfsClient.isCidPinned(r.cid);
+          if (isPinned) pinned++;
+          else unpinned++;
+          return { cid: r.cid, resourceType: r.resourceType, mfsPath: r.mfsPath, pinned: isPinned };
+        } catch (err) {
+          errors++;
+          return { cid: r.cid, resourceType: r.resourceType, mfsPath: r.mfsPath, pinned: false, error: err.message };
+        }
+      }),
+    );
+    return { total: records.length, pinned, unpinned, errors, entries };
+  };
+}
 export { IpfsService, createPinRecord, removePinRecordsAndUnpin };

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

@@ -3,8 +3,8 @@ import { ObjectLayerService } from './object-layer.service.js';
 
 const logger = loggerFactory(import.meta);
 
-const ObjectLayerController = {
-  post: async (req, res, options) => {
+class ObjectLayerController {
+  static post = async (req, res, options) => {
     try {
       const result = await ObjectLayerService.post(req, res, options);
       return res.status(200).json({
@@ -18,8 +18,8 @@ const ObjectLayerController = {
         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);
@@ -37,8 +37,8 @@ const ObjectLayerController = {
         message: error.message,
       });
     }
-  },
-  generateWebp: async (req, res, options) => {
+  };
+  static generateWebp = async (req, res, options) => {
     try {
       const result = await ObjectLayerService.generateWebp(req, res, options);
       if (req && req.headers && req.headers.origin) {
@@ -59,8 +59,8 @@ const ObjectLayerController = {
         message: error.message,
       });
     }
-  },
-  put: async (req, res, options) => {
+  };
+  static put = async (req, res, options) => {
     try {
       const result = await ObjectLayerService.put(req, res, options);
       return res.status(200).json({
@@ -74,8 +74,8 @@ const ObjectLayerController = {
         message: error.message,
       });
     }
-  },
-  delete: async (req, res, options) => {
+  };
+  static delete = async (req, res, options) => {
     try {
       const result = await ObjectLayerService.delete(req, res, options);
       return res.status(200).json({
@@ -89,7 +89,7 @@ const ObjectLayerController = {
         message: error.message,
       });
     }
-  },
-};
+  };
+}
 
 export { ObjectLayerController };

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

@@ -3,9 +3,7 @@
  * @module src/api/object-layer/object-layer.model.js
  * @namespace CyberiaObjectLayerModel
  */
-
 import { Schema, model } from 'mongoose';
-
 /**
  * @typedef {Object} Stats
  * @property {number} effect - The effect attribute value
@@ -27,7 +25,6 @@ const StatsSchema = new Schema(
   },
   { _id: false },
 );
-
 /**
  * @typedef {Object} Item
  * @property {string} id - Unique identifier for the item
@@ -45,7 +42,6 @@ const ItemSchema = new Schema(
   },
   { _id: false },
 );
-
 /**
  * @typedef {Object} Ledger
  * Blockchain protocol metadata linking the visual object-layer prefab to its economic reality.
@@ -68,7 +64,6 @@ const LedgerSchema = new Schema(
   },
   { _id: false },
 );
-
 /**
  * @typedef {Object} Render
  * IPFS content identifiers for the consolidated atlas sprite sheet.
@@ -83,7 +78,6 @@ const RenderSchema = new Schema(
   },
   { _id: false },
 );
-
 /**
  * @typedef {Object} ObjectLayer
  * @property {Object} data - Object layer data
@@ -138,11 +132,9 @@ const ObjectLayerSchema = new Schema(
     toObject: { virtuals: true },
   },
 );
-
 // Index for faster querying
 ObjectLayerSchema.index({ 'data.item.id': 1 });
 ObjectLayerSchema.index({ 'data.item.type': 1 });
-
 // Add text index for searchable fields
 ObjectLayerSchema.index(
   {
@@ -158,7 +150,6 @@ ObjectLayerSchema.index(
     },
   },
 );
-
 // Pre-save hook to ensure data consistency
 ObjectLayerSchema.pre('save', function () {
   // Ensure all required fields are present
@@ -167,14 +158,11 @@ ObjectLayerSchema.pre('save', function () {
   }
   // cid (object layer data JSON) and data.render.cid (atlas PNG) are optional – default to ''
 });
-
 // Create and export the model
 const ObjectLayerModel = model('ObjectLayer', ObjectLayerSchema);
-
 const ProviderSchema = ObjectLayerSchema;
-
-const ObjectLayerDto = {
-  select: {
+class ObjectLayerDto {
+  static select = {
     get: () => {
       return {
         _id: 1,
@@ -207,7 +195,6 @@ const ObjectLayerDto = {
         objectLayerRenderFramesId: 1,
       };
     },
-  },
-};
-
+  };
+}
 export { ObjectLayerSchema, ObjectLayerModel, ProviderSchema, ObjectLayerDto };

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

@@ -334,6 +334,36 @@ const ObjectLayerRouter = (options) => {
     */
     return await ObjectLayerController.get(req, res, options);
   });
+  router.get(`/search-item-ids`, async (req, res) => {
+    /*
+      #swagger.auto = false
+      #swagger.tags = ['object-layer']
+      #swagger.summary = 'Search object layer item IDs'
+      #swagger.description = 'Returns partial matches of data.item.id for type-ahead autocomplete'
+      #swagger.path = '/object-layer/search-item-ids'
+      #swagger.method = 'get'
+      #swagger.produces = ['application/json']
+
+      #swagger.parameters['q'] = {
+          in: 'query',
+          description: 'Partial item ID to search for',
+          required: false,
+          type: 'string'
+      }
+
+      #swagger.responses[200] = {
+        description: 'Item IDs matching the query',
+        content: {
+            'application/json': {
+                schema: {
+                  $ref: '#/components/schemas/objectLayerResponse'
+                }
+            }
+        }
+      }
+    */
+    return await ObjectLayerController.get(req, res, options);
+  });
   router.get(`/frame-counts/:id`, async (req, res) => {
     /*
       #swagger.auto = false