cyberia 2.99.8 → 3.0.2

package/scripts/rocky-setup.sh

@@ -103,16 +103,4 @@ echo "[+] Cleanup: remove unnecessary packages and old metadata"
 dnf autoremove -y
 dnf clean all
 
-cat <<EOF
-
-Installation complete.
-- To allow SSH access (if this is a VM or server), open port 22 in firewalld:
-  sudo firewall-cmd --add-service=ssh --permanent && sudo firewall-cmd --reload
-- If you installed Development Tools, you will have gcc, make, etc.
-
-Examples:
-  sudo ./scripts/rocky-setup.sh --install-dev
-  INSTALL_DEV=1 sudo ./scripts/rocky-setup.sh
-
-Customize PACKAGES=(...) inside this script according to your needs (docker, podman, kube, mssql-tools, etc.).
-EOF
+echo "[+] Setup complete! Rocky Linux is now configured with the recommended base packages."

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 };

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

@@ -0,0 +1,193 @@
+import { DataBaseProvider } 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 { 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.
+ *
+ * @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.
+ * @returns {Promise<import('mongoose').Document>}
+ */
+const createPinRecord = async ({ cid, userId, 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 },
+    { upsert: true, new: true, setDefaultsOnInsert: true },
+  );
+
+  logger.info(`IPFS pin record upserted – CID: ${cid}, userId: ${userId}`);
+  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.
+ *
+ * @param {string} cid     – IPFS Content Identifier to clean up.
+ * @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)
+  try {
+    await IpfsClient.unpinCid(cid);
+  } catch (err) {
+    logger.warn(`Best-effort IPFS unpin failed for CID ${cid}: ${err.message}`);
+  }
+};
+
+const IpfsService = {
+  /** Expose helpers so other modules can import them directly. */
+  createPinRecord,
+  removePinRecordsAndUnpin,
+
+  // ──────────────────────────────────────────────
+  //  Standard CRUD
+  // ──────────────────────────────────────────────
+
+  post: async (req, res, options) => {
+    /** @type {import('./ipfs.model.js').IpfsModel} */
+    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} */
+    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());
+    }
+
+    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.countDocuments(query),
+    ]);
+
+    const totalPages = Math.ceil(total / limit);
+    return { data, total, page, totalPages };
+  },
+
+  put: async (req, res, options) => {
+    /** @type {import('./ipfs.model.js').IpfsModel} */
+    const Ipfs = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Ipfs;
+    return await Ipfs.findByIdAndUpdate(req.params.id, req.body, { new: true });
+  },
+
+  delete: async (req, res, options) => {
+    /** @type {import('./ipfs.model.js').IpfsModel} */
+    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) {
+            await IpfsClient.unpinCid(record.cid);
+          }
+        } 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)
+  // ──────────────────────────────────────────────
+
+  /**
+   * POST /ipfs/pin  – add content to IPFS, pin it, and create a DB record.
+   * Body: { data: <string|object>, userId? }
+   */
+  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) => {
+    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 };
+  },
+};
+
+export { IpfsService, createPinRecord, removePinRecordsAndUnpin };