strapi-plugin-comments 2.0.6 → 2.0.9

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/admin/src/pages/Settings/index.js

@@ -1,7 +1,7 @@
 import React, { useRef, useMemo, useState } from 'react';
 import { useQuery } from 'react-query';
 import { Formik } from 'formik';
-import { capitalize, first, orderBy, isEmpty, isEqual } from 'lodash';
+import { capitalize, first, orderBy, isEmpty, isEqual, isNil } from 'lodash';
 import {
 	CheckPermissions,
 	LoadingIndicatorPage,
@@ -109,7 +109,7 @@ const Settings = () => {
 		.filter(_ => _) || [];
 	const entryLabel = configData?.entryLabel || {};
 	const approvalFlow = configData?.approvalFlow || [];
-	const badWords = configData?.badWords || undefined;
+	const badWords = isNil(configData?.badWords) ? true : configData?.badWords;
 	const isGQLPluginEnabled = configData?.isGQLPluginEnabled;
 	const gqlAuthEnabled = configData?.gql?.auth || undefined;
 	const moderatorRoles = configData?.moderatorRoles

package/package.json

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

package/server/controllers/client.js

@@ -16,9 +16,6 @@ module.exports = {
 
     const { sort: querySort, pagination: queryPagination, ...filterQuery } = query || {};
 
-
-console.log(filterQuery);
-
     try {
       return this.getService('common')
         .findAllFlat(flatInput(relation, filterQuery, sort || querySort, pagination || queryPagination));

package/server/graphql/queries/findAllFlat.js

@@ -1,11 +1,12 @@
 'use strict'
 
+const { isEmpty } = require('lodash');
 const contentType = require('../../../content-types/comment');
 const { flatInput } = require('../../controllers/utils/parsers');
 const { getPluginService } = require('../../utils/functions');
 
 module.exports = ({ strapi, nexus }) => {
-	const { nonNull, list, stringArg } = nexus;
+	const { nonNull, stringArg } = nexus;
 	const { service: getService } = strapi.plugin('graphql');
 	const { args } = getService('internals');
 
@@ -24,7 +25,10 @@ module.exports = ({ strapi, nexus }) => {
 					relation, 
 					getPluginService('gql').graphQLFiltersToStrapiQuery(filters, contentType),
 					sort,
-					pagination
+					pagination ? {
+						...pagination,
+						withCount: !isEmpty(pagination),
+					} : undefined
 				), undefined);
 		},
 	};

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,158 @@ 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, { id: 2, title: 'Test 2', uid: collection }],
+      }));
+
+      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', 0, 'author']);
+          expect(result).toHaveProperty(['data', 0, 'author', 'id'], db[0].authorId);
+          expect(result).toHaveProperty(['data', 0, 'author', 'name'], db[0].authorName);
+          expect(result).toHaveProperty(['data', 0, 'author', 'email'], db[0].authorEmail);
+          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);
+        });
+      });
+
+      describe('findOne', () => {
+        test('Should return proper structure', async () => {
+          const result = await getPluginService('common').findOne({ related });
+          expect(result).toHaveProperty('id', db[0].id);
+          expect(result).toHaveProperty('content', db[0].content);
+          expect(result).toHaveProperty(['author', 'id'], db[0].authorId);
+          expect(result).toHaveProperty(['author', 'name'], db[0].authorName);
+          expect(result).toHaveProperty(['author', 'email'], db[0].authorEmail);
+        });
+      });
+
+      describe('findRelatedEntitiesFor', () => {
+        test('Should return proper structure', async () => {
+          const result = await getPluginService('common').findRelatedEntitiesFor(db);
+          expect(result).toHaveProperty([0, 'id'], relatedEntity.id);
+          expect(result).toHaveProperty([0, 'title'], relatedEntity.title);
+          expect(result).toHaveProperty([0, 'uid'], relatedEntity.uid);
+        });
+      });
+    });
   });
 });

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 {
@@ -74,8 +74,8 @@ module.exports = ({ strapi }) => ({
                 ...prev,
                 [curr]: parseInt(pagination[curr]),
             }), {});
-            const { page, pageSize = 10, limit, start = 0 } = parsedPagination
-            const paginationByPage = !isNil(page);
+            const { page = 1, pageSize = 10, start = 0, limit = 10 } = parsedPagination;
+            const paginationByPage = !isNil(parsedPagination?.page) || !isNil(parsedPagination?.pageSize);
 
             queryExtension = {
                 ...queryExtension,
@@ -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