cyberia 3.2.9 → 3.2.12

package/src/api/document/document.router.js

@@ -1,31 +1,36 @@
 import { loggerFactory } from '../../server/logger.js';
 import { DocumentController } from './document.controller.js';
 import express from 'express';
-import fs from 'fs-extra';
+
 const logger = loggerFactory(import.meta);
 
-const DocumentRouter = (options) => {
-  const router = express.Router();
-  const authMiddleware = options.authMiddleware;
-  router.post(`/:id`, authMiddleware, async (req, res) => await DocumentController.post(req, res, options));
-  router.post(`/`, authMiddleware, async (req, res) => await DocumentController.post(req, res, options));
-  router.get(`/public/high`, async (req, res) => await DocumentController.get(req, res, options));
-  router.get(`/public`, async (req, res) => await DocumentController.get(req, res, options));
-  router.get(`/:id`, authMiddleware, async (req, res) => await DocumentController.get(req, res, options));
-  router.get(`/`, authMiddleware, async (req, res) => await DocumentController.get(req, res, options));
-  router.put(`/:id`, authMiddleware, async (req, res) => await DocumentController.put(req, res, options));
-  router.put(`/`, authMiddleware, async (req, res) => await DocumentController.put(req, res, options));
-  router.patch(`/:id/copy-share-link`, async (req, res) => await DocumentController.patch(req, res, options));
-  router.patch(
-    `/:id/toggle-public`,
-    authMiddleware,
-    async (req, res) => await DocumentController.patch(req, res, options),
-  );
-  router.delete(`/:id`, authMiddleware, async (req, res) => await DocumentController.delete(req, res, options));
-  router.delete(`/`, authMiddleware, async (req, res) => await DocumentController.delete(req, res, options));
-  return router;
-};
+class DocumentRouter {
+  /**
+   * @param {import('../types.js').RouterOptions} options
+   * @returns {import('express').Router}
+   */
+  static router(options) {
+    const router = express.Router();
+    router.post(`/:id`, options.authMiddleware, async (req, res) => await DocumentController.post(req, res, options));
+    router.post(`/`, options.authMiddleware, async (req, res) => await DocumentController.post(req, res, options));
+    router.get(`/public/high`, async (req, res) => await DocumentController.get(req, res, options));
+    router.get(`/public`, async (req, res) => await DocumentController.get(req, res, options));
+    router.get(`/:id`, options.authMiddleware, async (req, res) => await DocumentController.get(req, res, options));
+    router.get(`/`, options.authMiddleware, async (req, res) => await DocumentController.get(req, res, options));
+    router.put(`/:id`, options.authMiddleware, async (req, res) => await DocumentController.put(req, res, options));
+    router.put(`/`, options.authMiddleware, async (req, res) => await DocumentController.put(req, res, options));
+    router.patch(`/:id/copy-share-link`, async (req, res) => await DocumentController.patch(req, res, options));
+    router.patch(
+      `/:id/toggle-public`,
+      options.authMiddleware,
+      async (req, res) => await DocumentController.patch(req, res, options),
+    );
+    router.delete(`/:id`, options.authMiddleware, async (req, res) => await DocumentController.delete(req, res, options));
+    router.delete(`/`, options.authMiddleware, async (req, res) => await DocumentController.delete(req, res, options));
+    return router;
+  }
+}
 
-const ApiRouter = DocumentRouter;
+const ApiRouter = (options) => DocumentRouter.router(options);
 
 export { ApiRouter, DocumentRouter };

package/src/api/document/document.service.js

@@ -1,5 +1,14 @@
+/**
+ * Document service module for handling document CRUD operations.
+ * Provides REST API handlers for document management with security-aware
+ * public/private document access control, search, and file cleanup integration.
+ *
+ * @module src/api/document/document.service.js
+ * @namespace DocumentService
+ */
+
 import { loggerFactory } from '../../server/logger.js';
-import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+import { DataBaseProviderService } from '../../db/DataBaseProvider.js';
 import { DocumentDto } from './document.model.js';
 import { uniqueArray } from '../../client/components/core/CommonJs.js';
 import { getBearerToken, verifyJWT } from '../../server/auth.js';
@@ -8,10 +17,26 @@ import { FileCleanup } from '../file/file.service.js';
 
 const logger = loggerFactory(import.meta);
 
-const DocumentService = {
-  post: async (req, res, options) => {
+/**
+ * Document Service for handling REST API document operations.
+ * Implements a security model for public/private document access control
+ * with support for high-query typeahead search, tag filtering, and pagination.
+ * @namespace DocumentService
+ */
+class DocumentService {
+  /**
+   * POST - Create a new document.
+   * @async
+   * @function post
+   * @memberof DocumentService
+   * @param {Object} req - Express request object.
+   * @param {Object} res - Express response object.
+   * @param {Object} options - Request options containing host and path.
+   * @returns {Promise<Object>} Created document object.
+   */
+  static post = async (req, res, options) => {
     /** @type {import('./document.model.js').DocumentModel} */
-    const Document = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Document;
+    const Document = DataBaseProviderService.getModel("Document", options);
 
     switch (req.params.id) {
       default:
@@ -25,14 +50,28 @@ const DocumentService = {
 
         return await new Document(req.body).save();
     }
-  },
-  get: async (req, res, options) => {
+  };
+
+  /**
+   * GET - Retrieve documents.
+   * Supports public high-query search, public tag-filtered listing,
+   * and authenticated user document retrieval with pagination.
+   * @async
+   * @function get
+   * @memberof DocumentService
+   * @param {Object} req - Express request object.
+   * @param {Object} res - Express response object.
+   * @param {Object} options - Request options containing host and path.
+   * @returns {Promise<Object>} Document data with optional pagination metadata.
+   * @throws {Error} If search query is invalid or document not found.
+   */
+  static get = async (req, res, options) => {
     /** @type {import('./document.model.js').DocumentModel} */
-    const Document = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Document;
+    const Document = DataBaseProviderService.getModel("Document", options);
     /** @type {import('../user/user.model.js').UserModel} */
-    const User = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.User;
+    const User = DataBaseProviderService.getModel("User", options);
     /** @type {import('../file/file.model.js').FileModel} */
-    const File = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.File;
+    const File = DataBaseProviderService.getModel("File", options);
 
     // High-query endpoint for typeahead search
     //
@@ -436,12 +475,24 @@ const DocumentService = {
         };
       }
     }
-  },
-  delete: async (req, res, options) => {
+  };
+
+  /**
+   * DELETE - Remove a document and its associated files.
+   * @async
+   * @function delete
+   * @memberof DocumentService
+   * @param {Object} req - Express request object.
+   * @param {Object} res - Express response object.
+   * @param {Object} options - Request options containing host and path.
+   * @returns {Promise<Object>} Deleted document object.
+   * @throws {Error} If document not found or user not authorized.
+   */
+  static delete = async (req, res, options) => {
     /** @type {import('./document.model.js').DocumentModel} */
-    const Document = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Document;
+    const Document = DataBaseProviderService.getModel("Document", options);
     /** @type {import('../file/file.model.js').FileModel} */
-    const File = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.File;
+    const File = DataBaseProviderService.getModel("File", options);
 
     switch (req.params.id) {
       default: {
@@ -460,12 +511,25 @@ const DocumentService = {
         return await Document.findByIdAndDelete(req.params.id);
       }
     }
-  },
-  put: async (req, res, options) => {
+  };
+
+  /**
+   * PUT - Update a document.
+   * Cleans up replaced files and handles tag-based isPublic extraction.
+   * @async
+   * @function put
+   * @memberof DocumentService
+   * @param {Object} req - Express request object.
+   * @param {Object} res - Express response object.
+   * @param {Object} options - Request options containing host and path.
+   * @returns {Promise<Object>} Updated document object.
+   * @throws {Error} If document not found.
+   */
+  static put = async (req, res, options) => {
     /** @type {import('./document.model.js').DocumentModel} */
-    const Document = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Document;
+    const Document = DataBaseProviderService.getModel("Document", options);
     /** @type {import('../file/file.model.js').FileModel} */
-    const File = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.File;
+    const File = DataBaseProviderService.getModel("File", options);
 
     switch (req.params.id) {
       default: {
@@ -500,10 +564,23 @@ const DocumentService = {
         return await Document.findByIdAndUpdate(req.params.id, req.body, { returnDocument: 'after' });
       }
     }
-  },
-  patch: async (req, res, options) => {
+  };
+
+  /**
+   * PATCH - Partially update a document.
+   * Supports toggle-public and copy-share-link operations.
+   * @async
+   * @function patch
+   * @memberof DocumentService
+   * @param {Object} req - Express request object.
+   * @param {Object} res - Express response object.
+   * @param {Object} options - Request options containing host and path.
+   * @returns {Promise<Object>} Updated document or result object.
+   * @throws {Error} If document not found or invalid patch endpoint.
+   */
+  static patch = async (req, res, options) => {
     /** @type {import('./document.model.js').DocumentModel} */
-    const Document = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Document;
+    const Document = DataBaseProviderService.getModel("Document", options);
 
     if (req.path.includes('/toggle-public')) {
       const document = await Document.findById(req.params.id);
@@ -550,7 +627,7 @@ const DocumentService = {
     }
 
     throw new Error('Invalid patch endpoint');
-  },
-};
+  };
+}
 
-export { DocumentService };
+export { DocumentService };

package/src/api/file/file.router.js

@@ -2,21 +2,27 @@ import { adminGuard } from '../../server/auth.js';
 import { loggerFactory } from '../../server/logger.js';
 import { FileController } from './file.controller.js';
 import express from 'express';
+
 const logger = loggerFactory(import.meta);
 
-const FileRouter = (options) => {
-  const router = express.Router();
-  const authMiddleware = options.authMiddleware;
-  router.post(`/:id`, authMiddleware, async (req, res) => await FileController.post(req, res, options));
-  router.post(`/`, authMiddleware, async (req, res) => await FileController.post(req, res, options));
-  router.get(`/blob/:id`, async (req, res) => await FileController.get(req, res, options));
-  router.get(`/:id`, async (req, res) => await FileController.get(req, res, options));
-  router.get(`/`, async (req, res) => await FileController.get(req, res, options));
-  router.delete(`/:id`, authMiddleware, adminGuard, async (req, res) => await FileController.delete(req, res, options));
-  router.delete(`/`, authMiddleware, adminGuard, async (req, res) => await FileController.delete(req, res, options));
-  return router;
-};
+class FileRouter {
+  /**
+   * @param {import('../types.js').RouterOptions} options
+   * @returns {import('express').Router}
+   */
+  static router(options) {
+    const router = express.Router();
+    router.post(`/:id`, options.authMiddleware, async (req, res) => await FileController.post(req, res, options));
+    router.post(`/`, options.authMiddleware, async (req, res) => await FileController.post(req, res, options));
+    router.get(`/blob/:id`, async (req, res) => await FileController.get(req, res, options));
+    router.get(`/:id`, async (req, res) => await FileController.get(req, res, options));
+    router.get(`/`, async (req, res) => await FileController.get(req, res, options));
+    router.delete(`/:id`, options.authMiddleware, adminGuard, async (req, res) => await FileController.delete(req, res, options));
+    router.delete(`/`, options.authMiddleware, adminGuard, async (req, res) => await FileController.delete(req, res, options));
+    return router;
+  }
+}
 
-const ApiRouter = FileRouter;
+const ApiRouter = (options) => FileRouter.router(options);
 
 export { ApiRouter, FileRouter };

package/src/api/file/file.service.js

@@ -6,7 +6,7 @@
  * @namespace FileServiceServer
  */
 
-import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+import { DataBaseProviderService } from '../../db/DataBaseProvider.js';
 import { getBearerToken, jwtVerify } from '../../server/auth.js';
 import { loggerFactory } from '../../server/logger.js';
 import crypto from 'crypto';
@@ -266,7 +266,9 @@ class FileCleanup {
       const newFileId = newData[field];
 
       // If field has old file and new data changes or removes it
-      if (oldFileId && newFileId !== undefined && String(oldFileId) !== String(newFileId)) {
+      // newFileId === null means client explicitly wants to remove the file
+      // newFileId === undefined means field was not included in request (no change)
+      if (oldFileId && newFileId !== undefined && (newFileId === null || String(oldFileId) !== String(newFileId))) {
         try {
           const file = await File.findOne({ _id: oldFileId });
           if (file) {
@@ -345,7 +347,7 @@ class FileService {
     }
 
     /** @type {import('./file.model.js').FileModel} */
-    const File = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.File;
+    const File = DataBaseProviderService.getModel("File", options);
 
     const uploadedFiles = await FileFactory.upload(req, File);
     return FileServiceDto.toMetadataArray(uploadedFiles);
@@ -367,11 +369,11 @@ class FileService {
    */
   static get = async (req, res, options) => {
     /** @type {import('./file.model.js').FileModel} */
-    const File = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.File;
+    const File = DataBaseProviderService.getModel("File", options);
     /** @type {import('../document/document.model.js').DocumentModel} */
-    const Document = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Document;
+    const Document = DataBaseProviderService.getModel("Document", options);
     /** @type {import('../user/user.model.js').User} */
-    const User = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.User;
+    const User = DataBaseProviderService.getModel("User", options);
 
     const isFileAuthorized = async (fileId) => {
       try {
@@ -482,7 +484,7 @@ class FileService {
    */
   static delete = async (req, res, options) => {
     /** @type {import('./file.model.js').FileModel} */
-    const File = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.File;
+    const File = DataBaseProviderService.getModel("File", options);
 
     const result = await File.findByIdAndDelete(req.params.id);
 

package/src/api/instance/instance.router.js

@@ -5,30 +5,35 @@ import express from 'express';
 
 const logger = loggerFactory(import.meta);
 
-const InstanceRouter = (options) => {
-  const router = express.Router();
-  const authMiddleware = options.authMiddleware;
-  router.post(`/:id`, authMiddleware, adminGuard, async (req, res) => await InstanceController.post(req, res, options));
-  router.post(`/`, authMiddleware, adminGuard, async (req, res) => await InstanceController.post(req, res, options));
-  router.get(`/:id`, authMiddleware, adminGuard, async (req, res) => await InstanceController.get(req, res, options));
-  router.get(`/`, authMiddleware, async (req, res) => await InstanceController.get(req, res, options));
-  router.put(`/:id`, authMiddleware, adminGuard, async (req, res) => await InstanceController.put(req, res, options));
-  router.put(`/`, authMiddleware, adminGuard, async (req, res) => await InstanceController.put(req, res, options));
-  router.delete(
-    `/:id`,
-    authMiddleware,
-    adminGuard,
-    async (req, res) => await InstanceController.delete(req, res, options),
-  );
-  router.delete(
-    `/`,
-    authMiddleware,
-    adminGuard,
-    async (req, res) => await InstanceController.delete(req, res, options),
-  );
-  return router;
-};
+class InstanceRouter {
+  /**
+   * @param {import('../types.js').RouterOptions} options
+   * @returns {import('express').Router}
+   */
+  static router(options) {
+    const router = express.Router();
+    router.post(`/:id`, options.authMiddleware, adminGuard, async (req, res) => await InstanceController.post(req, res, options));
+    router.post(`/`, options.authMiddleware, adminGuard, async (req, res) => await InstanceController.post(req, res, options));
+    router.get(`/:id`, options.authMiddleware, adminGuard, async (req, res) => await InstanceController.get(req, res, options));
+    router.get(`/`, options.authMiddleware, async (req, res) => await InstanceController.get(req, res, options));
+    router.put(`/:id`, options.authMiddleware, adminGuard, async (req, res) => await InstanceController.put(req, res, options));
+    router.put(`/`, options.authMiddleware, adminGuard, async (req, res) => await InstanceController.put(req, res, options));
+    router.delete(
+      `/:id`,
+      options.authMiddleware,
+      adminGuard,
+      async (req, res) => await InstanceController.delete(req, res, options),
+    );
+    router.delete(
+      `/`,
+      options.authMiddleware,
+      adminGuard,
+      async (req, res) => await InstanceController.delete(req, res, options),
+    );
+    return router;
+  }
+}
 
-const ApiRouter = InstanceRouter;
+const ApiRouter = (options) => InstanceRouter.router(options);
 
 export { ApiRouter, InstanceRouter };

package/src/api/instance/instance.service.js

@@ -1,4 +1,4 @@
-import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+import { DataBaseProviderService } from '../../db/DataBaseProvider.js';
 import { loggerFactory } from '../../server/logger.js';
 import { DataQuery } from '../../server/data-query.js';
 import { InstanceDto } from './instance.model.js';
@@ -8,15 +8,15 @@ const logger = loggerFactory(import.meta);
 class InstanceService {
   static post = async (req, res, options) => {
     /** @type {import('./instance.model.js').InstanceModel} */
-    const Instance = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Instance;
+    const Instance = DataBaseProviderService.getModel("Instance", options);
     return await new Instance(req.body).save();
   };
   static get = async (req, res, options) => {
     /** @type {import('./instance.model.js').InstanceModel} */
-    const Instance = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Instance;
+    const Instance = DataBaseProviderService.getModel("Instance", options);
 
     /** @type {import('../user/user.model.js').UserModel} */
-    const User = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.User;
+    const User = DataBaseProviderService.getModel("User", options);
 
     const user = await User.findOne({
       _id: req.auth.user._id,
@@ -61,12 +61,12 @@ class InstanceService {
   };
   static put = async (req, res, options) => {
     /** @type {import('./instance.model.js').InstanceModel} */
-    const Instance = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Instance;
+    const Instance = DataBaseProviderService.getModel("Instance", options);
     return await Instance.findByIdAndUpdate(req.params.id, req.body);
   };
   static delete = async (req, res, options) => {
     /** @type {import('./instance.model.js').InstanceModel} */
-    const Instance = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Instance;
+    const Instance = DataBaseProviderService.getModel("Instance", options);
     if (req.params.id) return await Instance.findByIdAndDelete(req.params.id);
     else return await Instance.deleteMany();
   };

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

@@ -5,22 +5,27 @@ import express from 'express';
 
 const logger = loggerFactory(import.meta);
 
-const IpfsRouter = (options) => {
-  const router = express.Router();
-  const authMiddleware = options.authMiddleware;
-  // 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;
-};
+class IpfsRouter {
+  /**
+   * @param {import('../types.js').RouterOptions} options
+   * @returns {import('express').Router}
+   */
+  static router(options) {
+    const router = express.Router();
+    // Health / audit — must come before /:id to avoid matching conflicts.
+    router.get(`/verify`, options.authMiddleware, adminGuard, async (req, res) => await IpfsController.verify(req, res, options));
+    router.post(`/:id`, options.authMiddleware, adminGuard, async (req, res) => await IpfsController.post(req, res, options));
+    router.post(`/`, options.authMiddleware, adminGuard, async (req, res) => await IpfsController.post(req, res, options));
+    router.get(`/:id`, options.authMiddleware, adminGuard, async (req, res) => await IpfsController.get(req, res, options));
+    router.get(`/`, options.authMiddleware, adminGuard, async (req, res) => await IpfsController.get(req, res, options));
+    router.put(`/:id`, options.authMiddleware, adminGuard, async (req, res) => await IpfsController.put(req, res, options));
+    router.put(`/`, options.authMiddleware, adminGuard, async (req, res) => await IpfsController.put(req, res, options));
+    router.delete(`/:id`, options.authMiddleware, adminGuard, async (req, res) => await IpfsController.delete(req, res, options));
+    router.delete(`/`, options.authMiddleware, adminGuard, async (req, res) => await IpfsController.delete(req, res, options));
+    return router;
+  }
+}
 
-const ApiRouter = IpfsRouter;
+const ApiRouter = (options) => IpfsRouter.router(options);
 
 export { ApiRouter, IpfsRouter };

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

@@ -1,4 +1,4 @@
-import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+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';
@@ -17,7 +17,7 @@ const logger = loggerFactory(import.meta);
  * @returns {Promise<import('mongoose').Document>}
  */
 const createPinRecord = async ({ cid, resourceType, mfsPath = '', options }) => {
-  const Ipfs = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Ipfs;
+  const Ipfs = DataBaseProviderService.getModel("Ipfs", options);
   const record = await Ipfs.findOneAndUpdate(
     { cid, resourceType },
     { cid, resourceType, mfsPath },
@@ -35,7 +35,7 @@ const createPinRecord = async ({ cid, resourceType, mfsPath = '', options }) =>
  * @returns {Promise<void>}
  */
 const removePinRecordsAndUnpin = async (cid, options) => {
-  const Ipfs = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Ipfs;
+  const Ipfs = DataBaseProviderService.getModel("Ipfs", options);
   await Ipfs.deleteMany({ cid });
   logger.info(`Removed IPFS registry entries for CID: ${cid}`);
   try {
@@ -52,11 +52,11 @@ class IpfsService {
   //  Standard CRUD
   // ──────────────────────────────────────────────
   static post = async (req, res, options) => {
-    const Ipfs = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Ipfs;
+    const Ipfs = DataBaseProviderService.getModel("Ipfs", options);
     return await new Ipfs(req.body).save();
   };
   static get = async (req, res, options) => {
-    const Ipfs = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Ipfs;
+    const Ipfs = DataBaseProviderService.getModel("Ipfs", options);
     if (req.params.id) {
       return await Ipfs.findById(req.params.id).select(IpfsDto.select.get());
     }
@@ -69,11 +69,11 @@ class IpfsService {
     return { data, total, page, totalPages };
   };
   static put = async (req, res, options) => {
-    const Ipfs = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Ipfs;
+    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 = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Ipfs;
+    const Ipfs = DataBaseProviderService.getModel("Ipfs", options);
     if (req.params.id) {
       const record = await Ipfs.findById(req.params.id);
       if (record) {
@@ -107,7 +107,7 @@ class IpfsService {
    *   { total, pinned, unpinned, errors, entries: [{ cid, resourceType, mfsPath, pinned, error? }] }
    */
   static verify = async (req, res, options) => {
-    const Ipfs = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Ipfs;
+    const Ipfs = DataBaseProviderService.getModel("Ipfs", options);
     const records = await Ipfs.find({}).select(IpfsDto.select.get()).lean();
     let pinned = 0;
     let unpinned = 0;