strapi-plugin-comments 2.0.6 → 2.0.7

package/__mocks__/initSetup.js

@@ -1,14 +1,32 @@
-const { get, set } = require('lodash');
+const { get, set, isEmpty } = require('lodash');
 
-module.exports = (config = {}, toStore = false) => {
-  const mock = {
-    db: toStore ? {
-      plugin: {
-        comments: {
-          config: { ...config },
-        },
+module.exports = (config = {}, toStore = false, database = {}) => {
+  const dbConfig = toStore ? {
+    plugin: {
+      comments: {
+        config: { ...config },
       },
-    }: {},
+    },
+  }: {};
+
+  let mock = {
+    db: {
+      query: (uid) => {
+        const [handler, rest] = uid.split('::');
+        const [collection] = rest.split('.');
+        const values = get(mock.db, `${handler}.${collection}.records`, []);
+        return {
+          findOne: async () => new Promise(resolve => resolve(values[0])),
+          findMany: async () => new Promise(resolve => resolve(values)),
+          findWithCount: async () => new Promise(resolve => resolve([values, values.length])),
+          count: async () => new Promise(resolve => resolve(values.length)),
+          create: async (value) => new Promise(resolve => resolve(value)), 
+          update: async (value) => new Promise(resolve => resolve(value)), 
+          delete: async (value) => new Promise(resolve => resolve(value)),
+        };
+      },
+      ...dbConfig,
+    },
     getRef: function() {
       return this;
     },
@@ -78,5 +96,13 @@ module.exports = (config = {}, toStore = false) => {
       }
     }
   };
+
+  if (!isEmpty(database)) {
+    Object.keys(database).forEach((uid) => {
+      const [handler, collection] = uid.split('::');
+      set(mock.db, `${handler}.${collection}.records`, database[uid]);
+    });
+  }
+
   return mock;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strapi-plugin-comments",
-  "version": "2.0.6",
+  "version": "2.0.7",
   "description": "Strapi - Comments plugin",
   "strapi": {
     "name": "comments",

package/server/services/__tests__/common.test.js

@@ -5,9 +5,9 @@ const { getPluginService } = require('../../utils/functions');
 jest.mock
 
 
-const setup = function(config) {
+const setup = function(config, toStore, database) {
   Object.defineProperty(global, 'strapi', {
-    value: require('../../../__mocks__/initSetup')(config),
+    value: require('../../../__mocks__/initSetup')(config, toStore, database),
     writable: true,
   });
 }
@@ -242,5 +242,134 @@ describe('Test Comments service functions utils', () => {
         }
       });
     });
+
+    describe('Merge related entity', () => {
+      beforeEach(() => setup({ enabledCollections: [uid] }));
+      const collection = 'api::collection.test';
+      const related = `${collection}:1`;
+      const comment = {
+        id: 1,
+        content: 'ABC',
+        threadOf: null,
+        related,
+        authorId: 1,
+        authorName: 'Joe Doe',
+        authorEmail: 'joe@example.com'
+      };
+      const relatedEntity = { id: 1, title: 'Test', uid: collection};
+
+      
+      test('Should merge related entity', async () => {
+        const result = await getPluginService('common').mergeRelatedEntityTo(comment, [relatedEntity]);
+        expect(result).toHaveProperty('id', 1);
+        expect(result).not.toHaveProperty('related', related);
+        expect(result).toHaveProperty(['related', 'title'], relatedEntity.title);
+      });
+    });
+
+    describe('Client API', () => {
+      const collection = 'api::collection.test';
+      const related = `${collection}:1`;
+      const db = [{
+        id: 1,
+        content: 'ABC',
+        threadOf: null,
+        related,
+        authorId: 1,
+        authorName: 'Joe Doe',
+        authorEmail: 'joe@example.com'
+      }, {
+        id: 2,
+        content: 'DEF',
+        threadOf: 1,
+        related,
+        authorId: 1,
+        authorName: 'Joe Doe',
+        authorEmail: 'joe@example.com',
+        blockedThread: true,
+      }, {
+        id: 3,
+        content: 'GHJ',
+        threadOf: null,
+        related,
+        authorId: 1,
+        authorName: 'Joe Doe',
+        authorEmail: 'joe@example.com'
+      }, {
+        id: 4,
+        content: 'IKL',
+        threadOf: 2,
+        related,
+        authorId: 1,
+        authorName: 'Joe Doe',
+        authorEmail: 'joe@example.com',
+      }];
+      const relatedEntity = { id: 1, title: 'Test', uid: collection};
+
+      beforeEach(() => setup({ enabledCollections: [collection] }, true, {
+        'plugins::comments': db,
+        'api::collection': [relatedEntity],
+      }));
+
+      describe('findAllFlat', () => {
+        test('Should return proper structure', async () => {
+          const result = await getPluginService('common').findAllFlat({ query: { related }}, relatedEntity);
+          expect(result).toHaveProperty('data');
+          expect(result).not.toHaveProperty('meta');
+          expect(result.data.length).toBe(4);
+          expect(result).toHaveProperty(['data', 0, 'content'], db[0].content);
+          expect(result).toHaveProperty(['data', 3, 'content'], db[3].content);
+        });
+  
+        test('Should return structure with pagination', async () => {
+          const result = await getPluginService('common').findAllFlat({ query: { related }, pagination: { page: 1, pageSize: 5 }}, relatedEntity);
+          expect(result).toHaveProperty('data');
+          expect(result).toHaveProperty('meta');
+          expect(result.data.length).toBe(4);
+          expect(result).toHaveProperty(['data', 0, 'content'], db[0].content);
+          expect(result).toHaveProperty(['data', 3, 'content'], db[3].content);
+          expect(result).toHaveProperty(['meta', 'pagination', 'page'], 1);
+          expect(result).toHaveProperty(['meta', 'pagination', 'pageSize'], 5);
+        });
+      });
+
+      describe('findAllInHierarchy', () => {
+        test('Should return nested structure starting for root', async () => {
+          const result = await getPluginService('common').findAllInHierarchy({ query: { related }}, relatedEntity);
+          expect(result).not.toHaveProperty('data');
+          expect(result).not.toHaveProperty('meta');
+          expect(result.length).toBe(2);
+          expect(result).toHaveProperty([0, 'content'], db[0].content);
+          expect(result).toHaveProperty([0, 'children']);
+          expect(result[0].children.length).toBe(1);
+          expect(result).toHaveProperty([0, 'children', 0, 'content'], 'DEF');
+          expect(result).toHaveProperty([0, 'children', 0, 'children']);
+          expect(result[0].children[0].children.length).toBe(1);
+          expect(result).toHaveProperty([0, 'children', 0, 'children', 0, 'content'], 'IKL');
+          expect(result).toHaveProperty([1, 'content'], db[2].content);
+        });
+
+        test('Should return nested structure starting for comment id: 1', async () => {
+          const result = await getPluginService('common').findAllInHierarchy({ query: { related }, startingFromId: 1}, relatedEntity);
+          expect(result).not.toHaveProperty('data');
+          expect(result).not.toHaveProperty('meta');
+          expect(result.length).toBe(1);
+          expect(result).toHaveProperty([0, 'content'], db[1].content);
+          expect(result).toHaveProperty([0, 'children']);
+          expect(result[0].children.length).toBe(1);
+          expect(result).toHaveProperty([0, 'children', 0, 'content'], 'IKL');
+        });
+
+        test('Should return nested structure starting for comment id: 1 without blocked comments', async () => {
+          const result = await getPluginService('common').findAllInHierarchy({ query: { related }, startingFromId: 1, dropBlockedThreads: true}, relatedEntity);
+          expect(result).not.toHaveProperty('data');
+          expect(result).not.toHaveProperty('meta');
+          expect(result.length).toBe(1);
+          expect(result).toHaveProperty([0, 'content'], db[1].content);
+          expect(result).toHaveProperty([0, 'children']);
+          expect(result[0].children.length).toBe(0);
+        });
+      });
+    });
   });
 });

package/server/services/common.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const BadWordsFilter = require('bad-words');
-const { isArray, isNumber, isObject, isNil, isString, first, parseInt, set, get } = require('lodash');
+const { isArray, isNumber, isObject, isNil, isString, isEmpty, first, parseInt, set, get } = require('lodash');
 const { REGEX, CONFIG_PARAMS } = require('../utils/constants');
 const PluginError = require('./../utils/error');
 const {
@@ -143,6 +143,8 @@ module.exports = ({ strapi }) => ({
         }));
 
         const relatedEntities = relatedEntity !== null ? [relatedEntity] : await this.findRelatedEntitiesFor([...entries]);
+        const hasRelatedEntitiesToMap = relatedEntities.filter(_ => _).length > 0;
+
         const result = entries
             .map(_ => {
                 const threadedItem = entriesWithThreads.find(item => item.id === _.id);
@@ -154,16 +156,12 @@ module.exports = ({ strapi }) => ({
                 });
             });
 
-        if (relatedEntities.filter(_ => _).length > 0) {
-            return {
-                data: result.map(_ => this.mergeRelatedEntityTo(_, relatedEntities)),
-                meta,
-            };     
-        }
         return {
-            data: result,
-            meta,
-        };    
+            data: hasRelatedEntitiesToMap ?
+                result.map(_ => this.mergeRelatedEntityTo(_, relatedEntities)) :
+                result,
+            ...(isEmpty(meta) ? {} : { meta }),
+        };   
     },
 
     // Find comments and create relations tree structure
@@ -174,8 +172,8 @@ module.exports = ({ strapi }) => ({
         startingFromId = null,
         dropBlockedThreads = false,
     }, relatedEntity) {
-        const entities = await this.findAllFlat({ query, populate, sort }, relatedEntity)?.data;
-        return buildNestedStructure(entities, startingFromId, 'threadOf', dropBlockedThreads, false);
+        const entities = await this.findAllFlat({ query, populate, sort }, relatedEntity);
+        return buildNestedStructure(entities?.data, startingFromId, 'threadOf', dropBlockedThreads, false);
     },
 
     // Find single comment