strapi-plugin-comments 2.0.2 → 2.0.6

package/server/services/client.js

@@ -10,7 +10,7 @@ const {
     getRelatedGroups,
     resolveUserContextError,
 } = require('./utils/functions');
-const { APPROVAL_STATUS, REGEX } = require('./../utils/constants')
+const { APPROVAL_STATUS, REGEX, CONFIG_PARAMS } = require('./../utils/constants')
 
 /**
  * Comments Plugin - Client services
@@ -31,16 +31,15 @@ module.exports = ({ strapi }) => ({
             throw new PluginError(400, `Field "related" got incorrect format, use format like "api::<collection name>.<content type name>:<entity id>"`);
         }
 
-        const [ uid, relatedStringId ] = getRelatedGroups(relation);
-        const parsedRelatedId = parseInt(relatedStringId);
-        const relatedId = isNumber(parsedRelatedId) ? parsedRelatedId : relatedStringId;
+        const [ uid, relatedId ] = await this.getCommonService().parseRelationString(relation);
 
         const relatedEntity = await strapi.db.query(uid).findOne(relatedId);
         if (!relatedEntity) {
             throw new PluginError(400, `Relation for field "related" does not exist. Check your payload please.`);
         }
 
-        const isApprovalFlowEnabled = this.getCommonService().getConfig('approvalFlow', []).includes(uid) ||
+        const approvalFlow = await this.getCommonService().getConfig(CONFIG_PARAMS.APPROVAL_FLOW, []);
+        const isApprovalFlowEnabled = approvalFlow.includes(uid) ||
             relatedEntity.requireCommentsApproval;
 
         const linkToThread = !isNil(threadOf) ? await this.getCommonService().findOne({
@@ -57,7 +56,7 @@ module.exports = ({ strapi }) => ({
             throw resolveUserContextError(user);
         }
 
-        if (this.getCommonService().checkBadWords(content) && singleRelationFulfilled) {
+        if (await this.getCommonService().checkBadWords(content) && singleRelationFulfilled) {
             const { author = {}, ...rest } = data;
             let authorData = {};
             if (validContext && user) {
@@ -115,6 +114,8 @@ module.exports = ({ strapi }) => ({
             throw new PluginError(400, `Request property "relation" got incorrect format, use format like "api::<collection name>.<content type name>:<entity id>"`);
         }
 
+        await this.getCommonService().parseRelationString(relation);
+
         const existingEntity = await this.getCommonService().findOne({
             id,
             related: relation,
@@ -127,7 +128,7 @@ module.exports = ({ strapi }) => ({
         }
 
         if (isEqualEntity(existingEntity, data, user) && content) {
-            if (this.getCommonService().checkBadWords(content)) {
+            if (await this.getCommonService().checkBadWords(content)) {
                 const entity = await strapi.db.query(getModelUid('comment')).update({
                     where: { id },
                     data: { content },
@@ -144,6 +145,9 @@ module.exports = ({ strapi }) => ({
         if (!this.getCommonService().isValidUserContext(user)) {
             throw resolveUserContextError(user);
         }
+
+        await this.getCommonService().parseRelationString(relation);
+
 		const reportAgainstEntity = await this.getCommonService().findOne({
             id, 
             related: relation,
@@ -185,6 +189,8 @@ module.exports = ({ strapi }) => ({
             throw new PluginError(403, `You're not allowed to take an action on that entity. Make sure that you've provided proper "authorId" or authenticated your request properly.`);
         }
 
+        await this.getCommonService().parseRelationString(relation);
+
         let entity;
         try {
             const byAuthor = user?.id ? {
@@ -216,7 +222,7 @@ module.exports = ({ strapi }) => ({
     },
 
 	async sendAbuseReportEmail(reason, content) {
-		const rolesToBeNotified = this.getCommonService().getConfig('moderatorRoles') || ['strapi-super-admin'];
+		const rolesToBeNotified = await this.getCommonService().getConfig(CONFIG_PARAMS.MODERATOR_ROLES) || ['strapi-super-admin'];
 
         const adminUserModel = strapi.db.query('admin::user');
 		const emails = await adminUserModel.findMany({

package/server/services/common.js

@@ -1,8 +1,8 @@
 'use strict';
 
 const BadWordsFilter = require('bad-words');
-const { isArray, isNumber, isObject, isNil, isString, first, parseInt, set } = require('lodash');
-const { REGEX } = require('../utils/constants');
+const { isArray, isNumber, isObject, isNil, isString, first, parseInt, set, get } = require('lodash');
+const { REGEX, CONFIG_PARAMS } = require('../utils/constants');
 const PluginError = require('./../utils/error');
 const {
     getModelUid,
@@ -10,6 +10,7 @@ const {
     buildNestedStructure,
     filterOurResolvedReports,
     buildAuthorModel,
+    buildConfigQueryProp,
 } = require('./utils/functions');
 
 /**
@@ -18,11 +19,26 @@ const {
 
 module.exports = ({ strapi }) => ({
 
-    getConfig(prop, defaultValue) {
-        let queryProp = prop;
-        if (prop && isArray(prop)) {
-            queryProp = prop.join('.');
+    async getConfig(prop, defaultValue, useLocal = false) {
+        const queryProp = buildConfigQueryProp(prop);
+        const pluginStore = await this.getPluginStore();
+        const config = await pluginStore.get({ key: 'config' });
+
+        let result;
+        if (config && !useLocal) {
+            result = queryProp ? get(config, queryProp, defaultValue) : config;
+        } else {
+            result = this.getLocalConfig(queryProp, defaultValue);
         }
+        return isNil(result) ? defaultValue : result;
+    },
+
+    async getPluginStore() {
+        return strapi.store({ type: 'plugin', name: 'comments' });
+    },
+
+    getLocalConfig(prop, defaultValue) {
+        const queryProp = buildConfigQueryProp(prop);
         const result = strapi.config.get(`plugin.comments${ queryProp ? '.' + queryProp : ''}`);
         return isNil(result) ? defaultValue : result;
     },
@@ -52,12 +68,35 @@ module.exports = ({ strapi }) => ({
             };
         }
 
+        let meta = {};
         if (pagination && isObject(pagination)) {
-            const { page = 1, pageSize = 10 } = pagination;
+            const parsedPagination = Object.keys(pagination).reduce((prev, curr) => ({
+                ...prev,
+                [curr]: parseInt(pagination[curr]),
+            }), {});
+            const { page, pageSize = 10, limit, start = 0 } = parsedPagination
+            const paginationByPage = !isNil(page);
+
             queryExtension = {
                 ...queryExtension,
-                offset: (page - 1) * pageSize,
-                limit: pageSize,
+                offset: paginationByPage ? (page - 1) * pageSize : start,
+                limit: paginationByPage ? pageSize : limit,
+            };
+
+            const metaPagination = paginationByPage ? {
+                pagination: {
+                    page,
+                    pageSize,
+                },
+            } : {
+                pagination: {
+                    start,
+                    limit,
+                },
+            };
+
+            meta = {
+                ...metaPagination,
             };
         }
         
@@ -73,6 +112,26 @@ module.exports = ({ strapi }) => ({
             ...queryExtension,
         });
 
+        if (pagination?.withCount && (pagination.withCount === 'true' || pagination.withCount === true)) {
+            const total = await strapi.db.query(getModelUid('comment'))
+                .count({
+                    where: {
+                        ...query,
+                    }
+                });
+            const pageCount = Math.floor(total / meta.pagination.pageSize);
+            meta = {
+                ...meta,
+                pagination: {
+                    ...meta.pagination,
+                    pageCount: !isNil(meta.pagination.page) ? 
+                        total % meta.pagination.pageSize === 0 ? pageCount : pageCount + 1 : 
+                        undefined,
+                    total,
+                },
+            };
+        }
+
         const entriesWithThreads = await Promise.all(entries.map(async _ => {
             const [nestedEntries, count] = await strapi.db.query(getModelUid('comment'))
                 .findWithCount({ 
@@ -96,9 +155,15 @@ module.exports = ({ strapi }) => ({
             });
 
         if (relatedEntities.filter(_ => _).length > 0) {
-            return result.map(_ => this.mergeRelatedEntityTo(_, relatedEntities));
+            return {
+                data: result.map(_ => this.mergeRelatedEntityTo(_, relatedEntities)),
+                meta,
+            };     
         }
-        return result;    
+        return {
+            data: result,
+            meta,
+        };    
     },
 
     // Find comments and create relations tree structure
@@ -109,7 +174,7 @@ module.exports = ({ strapi }) => ({
         startingFromId = null,
         dropBlockedThreads = false,
     }, relatedEntity) {
-        const entities = await this.findAllFlat({ query, populate, sort }, relatedEntity);
+        const entities = await this.findAllFlat({ query, populate, sort }, relatedEntity)?.data;
         return buildNestedStructure(entities, startingFromId, 'threadOf', dropBlockedThreads, false);
     },
 
@@ -124,7 +189,7 @@ module.exports = ({ strapi }) => ({
                 },
             });
         if (!entity){
-            throw new PluginError(404, 'Not found');
+            throw new PluginError(404, 'Comment does not exist. Check your payload please.');
         }
         return filterOurResolvedReports(this.sanitizeCommentEntity(entity));
     },
@@ -202,8 +267,20 @@ module.exports = ({ strapi }) => ({
         return user ? !isNil(user?.id) : true;
     },
 
-    checkBadWords(content) {
-        const config = this.getConfig('badWords', true);
+    async parseRelationString(relation) {
+        const [ uid, relatedStringId ] = getRelatedGroups(relation);
+        const parsedRelatedId = parseInt(relatedStringId);
+        const relatedId = isNumber(parsedRelatedId) ? parsedRelatedId : relatedStringId;
+
+        const enabledCollections = await this.getConfig(CONFIG_PARAMS.ENABLED_COLLECTIONS, []);
+        if (!enabledCollections.includes(uid)) {
+            throw new PluginError(403, `Action not allowed for collection '${uid}'. Use one of: ${ enabledCollections.join(', ') }`);
+        }
+        return [ uid, relatedId];
+    },
+
+    async checkBadWords(content) {
+        const config = await this.getConfig(CONFIG_PARAMS.BAD_WORDS, true);
         if (config) {
             const filter = new BadWordsFilter(isObject(config) ? config : undefined);
             if (content && filter.isProfane(content)) {

package/server/services/utils/__tests__/functions.test.js

@@ -1,5 +1,5 @@
 const PluginError = require('../../../utils/error');
-const { resolveUserContextError, getModelUid } = require('../functions');
+const { resolveUserContextError, getModelUid, buildConfigQueryProp } = require('../functions');
 
 beforeEach(() => {
   Object.defineProperty(global, 'strapi', {
@@ -39,4 +39,15 @@ describe('Test service functions utils', () => {
       }
     });
   });
+
+  describe('Building config query props', () => {
+    test('Should return prop as is', () => {
+      expect(buildConfigQueryProp('my.sample.prop')).toBe('my.sample.prop');
+    });
+
+    test('Should build query prop with \'.\'', () => {
+      expect(buildConfigQueryProp(['my', 'sample', 'prop'])).toBe('my.sample.prop');
+    });
+  });
+  
 });

package/server/services/utils/functions.js

@@ -1,6 +1,6 @@
 const PluginError = require('./../../utils/error');
 const { REGEX } = require('./../../utils/constants')
-const { first, isObject, isEmpty } = require('lodash');
+const { first, isObject, isArray, isEmpty } = require('lodash');
 
 const buildNestedStructure = (
   entities,
@@ -93,6 +93,14 @@ module.exports = {
         };
     },
 
+    buildConfigQueryProp(prop) {
+        let queryProp = prop;
+        if (prop && isArray(prop)) {
+            queryProp = prop.join('.');
+        }
+        return queryProp;
+    },
+
     resolveUserContextError: user => {
         if (user) {
             throw new PluginError(401, 'Not authenticated');

package/server/utils/constants.js

@@ -1,3 +1,11 @@
+const CONFIG_PARAMS = {
+  ENABLED_COLLECTIONS: 'enabledCollections',
+  APPROVAL_FLOW: 'approvalFlow',
+  ENTRY_LABEL: 'entryLabel',
+  MODERATOR_ROLES: 'moderatorRoles',
+  BAD_WORDS: 'badWords',
+};
+
 const APPROVAL_STATUS = {
   PENDING: "PENDING",
   APPROVED: "APPROVED",
@@ -12,6 +20,7 @@ const REGEX = {
 };
 
 module.exports = {
+  CONFIG_PARAMS,
   APPROVAL_STATUS,
   REGEX,
 };

package/strapi-server.js

@@ -4,7 +4,7 @@ const { isArray, isEmpty, isString } = require('lodash');
 
 const server = require('./server');
 const contentTypes = require('./content-types');
-const { REGEX } = require('./server/utils/constants');
+const { REGEX, CONFIG_PARAMS } = require('./server/utils/constants');
 
 module.exports = () => ({
     ...server,
@@ -15,24 +15,31 @@ module.exports = () => ({
         ...server.config.default,
       }),
       validator: (config) => { 
+        // Check enabledCollections values
+        const enabledCollectionsValid = config[CONFIG_PARAMS.ENABLED_COLLECTIONS]
+          .filter(_ => !REGEX.uid.test(_)).length === 0;
+        if (!enabledCollectionsValid) {
+          throw new Error(`'enabledCollections' must contain Content Types identifiers in the format like 'api::<collection name>.<content type name>'`);
+        }
+
         // Check moderatorRoles values
-        const moderatorRolesValid = config.moderatorRoles
+        const moderatorRolesValid = config[CONFIG_PARAMS.MODERATOR_ROLES]
           .filter(_ => !isString(_)).length === 0;
         if (!moderatorRolesValid) {
           throw new Error(`'moderatorRoles' must roles keys`);
         }
 
         // Check approvalFlow values
-        const approvalFlowValid = config.approvalFlow
+        const approvalFlowValid = config[CONFIG_PARAMS.APPROVAL_FLOW]
           .filter(_ => !REGEX.uid.test(_)).length === 0;
         if (!approvalFlowValid) {
           throw new Error(`'approvalFlow' must contain Content Types identifiers in the format like 'api::<collection name>.<content type name>'`);
         }
 
         // Check entryLabel keys and values
-        const entryLabelKeysValid = Object.keys(config.entryLabel)
+        const entryLabelKeysValid = Object.keys(config[CONFIG_PARAMS.ENTRY_LABEL])
           .filter(_ => _ !== '*')
-          .filter(_ => !(REGEX.uid.test(_) && isArray(config.entryLabel[_]) && !isEmpty(config.entryLabel[_]))).length === 0;
+          .filter(_ => !(REGEX.uid.test(_) && isArray(config[CONFIG_PARAMS.ENTRY_LABEL][_]) && !isEmpty(config[CONFIG_PARAMS.ENTRY_LABEL][_]))).length === 0;
 
         if (!entryLabelKeysValid) {
           throw new Error(`'entryLabel' must contain records in the format like 'api::<collection name>.<content type name>': ['Field1', 'field_2']`);