strapi-plugin-comments 2.0.0-beta.2 → 2.0.0-beta.6

package/admin/src/utils/index.js

@@ -1,6 +1,8 @@
 export { default as axiosInstance } from './axiosInstance';
-export { default as getApiURL } from './getApiURL';
+export { default as getApiURL } from './getApiUrl';
 export { default as getUrl } from './getUrl';
 export { default as getMessage } from './getMessage';
 export { default as handleAPIError } from './handleAPIError';
-export { default as getRelatedGroups } from './getRelatedGroups';
+export { default as getRelatedGroups } from './getRelatedGroups';
+export { default as resolveCommentStatus } from './resolveCommentStatus';
+export { default as resolveCommentStatusColor } from './resolveCommentStatusColor';

package/admin/src/utils/renderEntryTitle.js

@@ -0,0 +1,14 @@
+import { first } from 'lodash';
+
+const renderEntryTitle = (entry, config = {}) => {
+    const { entryLabel } = config;
+    const rule = entry.uid in entryLabel ? entryLabel[entry.uid] : entryLabel['*'];
+    return first(
+      Object.keys(entry)
+        .filter(_ => (rule === _) || rule.includes(_))
+        .map(_ => entry[_])
+        .filter(_ => _)
+    );
+  };
+
+export default renderEntryTitle;

package/admin/src/utils/resolveCommentStatus.js

@@ -0,0 +1,30 @@
+import { isNil } from 'lodash';
+import { COMMENT_STATUS } from './constants';
+
+const resolveCommentStatus = ({ removed, blocked, blockedThread, approvalStatus, reviewFlowEnabled }) => {
+    const gotApprovalFlow = !isNil(approvalStatus);
+
+    if (reviewFlowEnabled) {
+        return COMMENT_STATUS.TO_REVIEW;
+    }
+
+    if (removed) {
+        return COMMENT_STATUS.REMOVED;
+    } 
+    
+    if (blocked || blockedThread) {
+        return COMMENT_STATUS.BLOCKED;
+    } 
+    
+    if (gotApprovalFlow) {
+        const status = approvalStatus.toUpperCase();
+        if (Object.keys(COMMENT_STATUS).includes(status)) {
+            return status;
+        }
+        return COMMENT_STATUS.UNKNOWN;
+    }
+
+    return COMMENT_STATUS.OPEN;
+}
+
+export default resolveCommentStatus;

package/admin/src/utils/resolveCommentStatusColor.js

@@ -0,0 +1,22 @@
+import { isNil } from 'lodash';
+import { COMMENT_STATUS } from './constants';
+
+const resolveCommentStatusColor = (status) => {
+    if (Object.keys(COMMENT_STATUS).includes(status)) {
+        switch (status) {
+            case COMMENT_STATUS.REMOVED:
+                return 'secondary';
+            case COMMENT_STATUS.TO_REVIEW:
+            case COMMENT_STATUS.REJECTED:
+                return 'warning';
+            case COMMENT_STATUS.BLOCKED:
+                return 'danger';
+            case COMMENT_STATUS.OPEN:
+            case COMMENT_STATUS.APPROVED:
+                return 'success';
+        };
+    }
+    return 'secondary';
+}
+
+export default resolveCommentStatusColor;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strapi-plugin-comments",
-  "version": "2.0.0-beta.2",
+  "version": "2.0.0-beta.6",
   "description": "Strapi - Comments plugin",
   "strapi": {
     "name": "comments",
@@ -15,6 +15,7 @@
     "url": "https://github.com/VirtusLab-Open-Source/strapi-plugin-comments"
   },
   "dependencies": {
+    "@strapi/utils": "^4.0.5",
     "bad-words": "^3.0.4"
   },
   "devDependencies": {
@@ -23,6 +24,9 @@
     "jest-cli": "^26.0.1",
     "jest-styled-components": "^7.0.2"
   },
+  "peerDependencies": {
+    "@strapi/strapi": "4.x"
+  },
   "author": {
     "name": "VirtusLab // Mateusz Ziarko",
     "email": "mziarko@virtuslab.com",
@@ -41,8 +45,8 @@
     }
   ],
   "engines": {
-    "node": ">=12.x. <=16.x.x",
-    "npm": ">=6.0.0"
+    "node": ">=14.x.x <=17.x.x",
+    "npm": ">=7.x.x"
   },
   "keywords": ["strapi", "plugin", "comments"],
   "license": "MIT"

package/permissions.js

@@ -0,0 +1,19 @@
+'use strict';
+
+module.exports = {
+    render: function(uid) {
+        return `plugin::comments.${uid}`;
+    },
+    comments: {
+        read: 'read',
+        moderate: 'moderate',
+    },
+    reports: {
+        read: 'reports.read',
+        action: 'reports.action',
+    },
+    settings: {
+        read: 'settings.read',
+        change: 'settings.change',
+    },
+};

package/server/bootstrap.js

@@ -1,5 +1,41 @@
 'use strict';
 
-module.exports = ({ strapi }) => {
-  // bootstrap phase
+const permissions = require('./../permissions');
+
+module.exports = async ({ strapi }) => {
+  // Check if the plugin users-permissions is installed because the navigation needs it
+  if (Object.keys(strapi.plugins).indexOf("users-permissions") === -1) {
+    throw new Error(
+      "In order to make the comments plugin work the users-permissions plugin is required",
+    );
+  }
+  // Add permissions
+  const actions = [
+    {
+      section: "plugins",
+      displayName: "Comments: Read",
+      uid: permissions.comments.read,
+      pluginName: "comments",
+    },
+    {
+      section: "plugins",
+      displayName: "Comments: Moderate",
+      uid: permissions.comments.moderate,
+      pluginName: "comments",
+    },
+    {
+      section: "plugins",
+      displayName: "Reports: Read",
+      uid: permissions.reports.read,
+      pluginName: "comments",
+    },
+    {
+      section: "plugins",
+      displayName: "Reports: Moderate",
+      uid: permissions.reports.action,
+      pluginName: "comments",
+    },
+  ];
+
+  await strapi.admin.services.permission.actionProvider.registerMany(actions);
 };

package/server/config/index.js

@@ -2,9 +2,10 @@
 
 module.exports = {
   default: {
+    moderatorRoles: [],
+    approvalFlow: [],
     entryLabel: {
       '*': ['Title', 'title', 'Name', 'name', 'Subject', 'subject']
-    }
-  },
-  validator() {},
+    },
+  }
 };

package/server/controllers/admin.js

@@ -16,11 +16,11 @@ module.exports = {
   },
 
   async findOne(ctx) {
-    const { params = {} } = ctx;
+    const { params = {}, query } = ctx;
     const { id } = parseParams(params);
     try {
       return await this.getService()
-        .findOneAndThread(id);
+        .findOneAndThread(id, query);
     } catch (e) {
       throwError(ctx, e);
     }
@@ -101,7 +101,7 @@ module.exports = {
     }
   },
 
-  async config() {
+  async config(ctx) {
     try {
       return await this.getService().config();
     } catch (e) {

package/server/controllers/client.js

@@ -16,8 +16,14 @@ module.exports = {
     try {
       return this.getService('common')
         .findAllFlat({
-          ...query,
-          related: relation,
+          query: {
+            ...query,
+            $or: [{ removed: { $null: true } }, { removed: false }],
+            related: relation,
+          },
+          populate: {
+            threadOf: true,
+          },
         });
     } catch (e) {
       throwError(ctx, e);
@@ -34,6 +40,9 @@ module.exports = {
             ...query,
             related: relation,
           },
+          populate: {
+            threadOf: true,
+          },
           dropBlockedThreads: true,
         });
     } catch (e) {

package/server/services/admin.js

@@ -1,14 +1,12 @@
 'use strict';
 
 const { getPluginService, parseParams } = require('./../utils/functions');
-const { getAssociationModel } = require('./common');
-const { first, isEmpty, isNil, uniq, get } = require('lodash');
+const { isEmpty, isNil } = require('lodash');
 const PluginError = require('./../utils/error');
 const {
     getModelUid,
     getRelatedGroups,
     filterOurResolvedReports,
-    convertContentTypeNameToSlug
 } = require('./utils/functions');
 const { APPROVAL_STATUS, REGEX } = require('./../utils/constants')
 
@@ -25,8 +23,14 @@ const { APPROVAL_STATUS, REGEX } = require('./../utils/constants')
     // Config
     async config() {
         const entryLabel = this.getCommonService().getConfig('entryLabel');
+        const approvalFlow = this.getCommonService().getConfig('approvalFlow');
         return {
             entryLabel,
+            approvalFlow,
+            regex: Object.keys(REGEX).reduce((prev, curr) => ({
+                ...prev,
+                [curr]: REGEX[curr].toString(),
+            }), {}),
         };
     },
 
@@ -34,10 +38,18 @@ const { APPROVAL_STATUS, REGEX } = require('./../utils/constants')
     async findAll({ related, entity, ...query }) {
         const { _q, orderBy, pageSize = 10, page = 1, filters, ...rest } = parseParams(query);
 
+        const defaultWhere = {
+            $or: [
+                { removed: false },
+                { removed: null },
+            ],
+        };
+
         let params = {
             where: !isEmpty(filters) ? {
+                ...defaultWhere,
                 ...filters,
-            } : undefined,
+            } : { ...defaultWhere },
             offset: (page - 1)*pageSize, 
             limit: pageSize,
             orderBy: orderBy || [{ createdAt: 'desc' }],
@@ -55,7 +67,18 @@ const { APPROVAL_STATUS, REGEX } = require('./../utils/constants')
         }
     
         const entities = await strapi.db.query(getModelUid('comment'))
-            .findMany(params, ['authorUser', 'reports']);
+            .findMany({
+                ...params, 
+                populate: {
+                    authorUser: true,
+                    threadOf: true,
+                    reports: {
+                        where: { 
+                            resolved: false
+                        },
+                    },
+                },
+            });
         const total = await strapi.db.query(getModelUid('comment'))
             .count({
                 where: params.where,
@@ -65,24 +88,48 @@ const { APPROVAL_STATUS, REGEX } = require('./../utils/constants')
             .map(_ => filterOurResolvedReports(this.getCommonService().sanitizeCommentEntity(_)))
             .map(_ => this.getCommonService().mergeRelatedEntityTo(_, relatedEntities));
 
+        const pageCount = Math.floor(total / pageSize);
         return {
             result,
             pagination: {
                 page: page,
                 pageSize: pageSize,
-                pageCount: Math.floor(total / pageSize) + 1,
+                pageCount: total % pageSize === 0 ? pageCount : pageCount + 1,
                 total,
             },
         };
     },
 
     // Find single comment
-    async findOneAndThread(id) {
+    async findOneAndThread(id, { removed, ...query }) {
+        const defaultWhere = !removed ? {
+            $or: [
+                { removed: false },
+                { removed: null },
+            ],
+        } : {};
+        
+        const reportsPopulation = {
+            reports: {
+                where: { 
+                    resolved: false,
+                },
+            }
+        };
+
         const entity = await strapi.db.query(getModelUid('comment')).findOne({ 
             where: {
-                id
+                id,
+            },
+            populate: {
+                authorUser: true,
+                threadOf: {
+                    populate: { 
+                        ...reportsPopulation
+                    },
+                },
+                ...reportsPopulation,
             },
-            populate: ['threadOf', 'threadOf.reports', 'authorUser', 'reports'] 
         });
 
         if (!entity){
@@ -106,22 +153,27 @@ const { APPROVAL_STATUS, REGEX } = require('./../utils/constants')
         const entitiesOnSameLevel = await this.getCommonService()
             .findAllInHierarchy({
                 query: {
+                    ...defaultWhere,
+                    ...query,
                     threadOf: levelThreadId,
                     related: entity.related,
                 },
+                populate: {
+                    ...reportsPopulation,
+                },
                 startingFromId: levelThreadId,
                 isAdmin: true
             }, false);
 
-        const selectedEntity = filterOurResolvedReports(this.getCommonService().sanitizeCommentEntity(entity));
+        const selectedEntity = this.getCommonService().sanitizeCommentEntity(entity);
         
         return {
             entity: relatedEntity,
             selected: {
                 ...selectedEntity,
-                threadOf: selectedEntity.threadOf ? filterOurResolvedReports(selectedEntity.threadOf) : null,
+                threadOf: selectedEntity.threadOf ? selectedEntity.threadOf : null,
             },
-            level: entitiesOnSameLevel.map(_ => filterOurResolvedReports(_))
+            level: entitiesOnSameLevel,
         };
     },
 
@@ -138,9 +190,13 @@ const { APPROVAL_STATUS, REGEX } = require('./../utils/constants')
     // Block / Unblock a comment thread
     async blockCommentThread(id, forceStatus) {
         const existingEntity = await this.getCommonService().findOne({ id });
+        const status = !isNil(forceStatus) ? forceStatus : !existingEntity.blockedThread;
         const changedEntity = await strapi.db.query(getModelUid('comment')).update({ 
             where: { id },
-            data: { blockedThread: !isNil(forceStatus) ? forceStatus : !existingEntity.blockedThread }
+            data: { 
+                blocked: status,
+                blockedThread: status,
+            },
         });
         await this.blockNestedThreads(id, changedEntity.blockedThread);
 

package/server/services/client.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const config = require('./../config');
+const config = require('../config');
 const { getPluginService } = require('./../utils/functions');
 const { isNil, isEmpty } = require('lodash');
 const PluginError = require('./../utils/error');
@@ -26,18 +26,14 @@ module.exports = ({ strapi }) => ({
 
     // Create a comment
     async create(relation, data, user = undefined) {
-        const { content, threadOf, related } = data;
-        const singleRelationFulfilled = related && REGEX.relatedUid.test(related);
-
-        if (relation !== related) {
-            throw new PluginError(400, `Insonsistent relation uid`);
-        }
-
+        const { content, threadOf } = data;
+        const singleRelationFulfilled = relation && REGEX.relatedUid.test(relation);
+        
         if(!singleRelationFulfilled) {
             throw new PluginError(400, `Field "related" got incorrect format, use format like "api::<collection name>.<content type name>:<entity id>"`);
         }
 
-        const [ uid, relatedStringId ] = getRelatedGroups(related);
+        const [ uid, relatedStringId ] = getRelatedGroups(relation);
         const relatedId = parseInt(relatedStringId, 10);
 
         const relatedEntity = await strapi.db.query(uid).findOne(relatedId);
@@ -45,9 +41,12 @@ module.exports = ({ strapi }) => ({
             throw new PluginError(400, `Relation for field "related" does not exist. Check your payload please.`);
         }
 
+        const isApprovalFlowEnabled = this.getCommonService().getConfig('approvalFlow', []).includes(uid) ||
+            relatedEntity.requireCommentsApproval;
+
         const linkToThread = !isNil(threadOf) ? !!await this.getCommonService().findOne({
             id: threadOf,
-            related,
+            related: relation,
         }) : true;
         const validContext = isValidUserContext(user);
 
@@ -87,7 +86,8 @@ module.exports = ({ strapi }) => ({
                 throw new PluginError(400, 'Object: "author" is invalid. Check your payload');
             }
 
-            if (relatedEntity.requireCommentsApproval && data.approvalStatus !== APPROVAL_STATUS.PENDING) {
+            if (isApprovalFlowEnabled && 
+                (!isNil(data.approvalStatus) && (data.approvalStatus !== APPROVAL_STATUS.PENDING))) {
                 throw new PluginError(400, 'Invalid approval status');
             }
 
@@ -95,7 +95,8 @@ module.exports = ({ strapi }) => ({
                 data: {
                     ...rest,
                     ...authorData,
-                    related,
+                    related: relation,
+                    approvalStatus: isApprovalFlowEnabled ? APPROVAL_STATUS.PENDING : null,
                 }
             });
             return this.getCommonService().sanitizeCommentEntity(entity);
@@ -160,7 +161,7 @@ module.exports = ({ strapi }) => ({
                 try {
                     await this.sendAbuseReportEmail(entity.reason, entity.content); // Could also add some info about relation
                 } catch (err) {
-                    throw err;
+                    return entity;
                 }
             } else {
                 throw new PluginError(500, 'Report cannot be created');
@@ -177,10 +178,17 @@ module.exports = ({ strapi }) => ({
           $or: [{ authorUser: authorId }, { authorId }],
         });
         if (!entity){
-            throw strapi.errors.notFound('Entity not exist');
+            throw new PluginError(404, 'Entity not exist');
         }
+
         return strapi.db.query(getModelUid('comment'))
-          .update({ id: commentId, relatedSlug: relationId }, { removed: true })
+          .update({
+              where: { 
+                  id: commentId, 
+                  related: relationId
+                },
+                data: { removed: true }
+          })
           .then(({ id }) => this.markAsRemovedNested(id, true))
           .then(() => ({ id: commentId }));
     },

package/server/services/common.js

@@ -1,10 +1,9 @@
 'use strict';
 
-const { isArray, isEmpty, uniq, get, first } = require('lodash');
+const { isArray, uniq, first } = require('lodash');
 // const { sanitizeEntity } = require('strapi-utils');
 const PluginError = require('./../utils/error');
 const {
-    extractMeta,
     getModelUid,
     getRelatedGroups,
     buildNestedStructure,
@@ -16,71 +15,31 @@ const {
  */
 
 module.exports = ({ strapi }) => ({
-    getAssociationModel(ormModel, related) {
-        const relatedAssociation = ormModel.associations.find(_ => _.alias === 'related');
-        if (relatedAssociation) {
-            return relatedAssociation.related.find(rel => rel.collectionName === related);
-        }
-        return null;
-    },
-
-    getMorphModel() {
-        const ormModel = strapi.query(getModelUid('comment'));
-        return ormModel.model.morph;
-    },
-
-    isMongoDB(){
-        return strapi.query(getModelUid('comment'))?.model?.orm === 'mongoose';
-    },
-
-    getMorphData(query) {
-        return this
-          .getMorphModel()
-          .query(function () {
-              this.where(query);
-          })
-          .fetchAll()
-          .then((entities) => entities.map(entity => entity.toJSON()));
-    },
-
-    checkEntityRelation(uid, entityId) {
-        const result = parsedRelation.some(ref => {
-            const model = strapi.query(ref);
-            return model && model.associations.length &&
-              model.associations.some(_ => _.plugin === 'comments' && _.collection === 'comment');
-        });
-        if (!result) {
-            throw new PluginError(400, 'Comment not have relation to this type content type.');
-        }
-    },
 
-    getConfig(prop) {
+    getConfig(prop, defaultValue) {
         let queryProp = prop;
         if (prop && isArray(prop)) {
             queryProp = prop.join('.');
         }
-        return strapi.config.get(`plugin.comments${ queryProp ? '.' + queryProp : ''}`);
+        return strapi.config.get(`plugin.comments${ queryProp ? '.' + queryProp : ''}`) || defaultValue;
     },
 
     // Find comments in the flat structure
-    async findAllFlat(query, isAdmin = false, relatedEntity = null) {
-        const criteria = { 
-            ...query,
-            $or: [{ removed: { $null: true } }, { removed: false }],
-        }
-
-        if (isAdmin){
-            delete criteria.$or;
-        }
+    async findAllFlat({ query = {}, populate = {} }, relatedEntity = null) {
 
-        const populate = { authorUser: true, reports: true };
+        const defaultPopulate = {
+            authorUser: true,
+        };
 
         const entries = await strapi.db.query(getModelUid('comment'))
         .findMany({
             where: {
-                ...criteria,
+                ...query,
+            },
+            populate: {
+                ...defaultPopulate,
+                ...populate,
             },
-            populate,
         });
 
         const entriesWithThreads = await Promise.all(entries.map(async _ => {
@@ -97,12 +56,12 @@ module.exports = ({ strapi }) => ({
         const result = entries
             .map(_ => {
                 const threadedItem = entriesWithThreads.find(item => item.id === _.id);
-                return filterOurResolvedReports(this.sanitizeCommentEntity({
+                return this.sanitizeCommentEntity({
                     ..._,
                     threadOf: query.threadOf || _.threadOf || null,
                     gotThread: (threadedItem?.itemsInTread || 0) > 0,
                     threadFirstItemId: threadedItem?.firstThreadItemId,
-                }))
+                });
             });
 
         if (relatedEntities.filter(_ => _).length > 0) {
@@ -114,11 +73,11 @@ module.exports = ({ strapi }) => ({
     // Find comments and create relations tree structure
     async findAllInHierarchy ({
         query,
+        populate = {},
         startingFromId = null,
         dropBlockedThreads = false,
-        isAdmin = false,
     }, relatedEntity) {
-        const entities = await this.findAllFlat(query, isAdmin, relatedEntity);
+        const entities = await this.findAllFlat({ query, populate }, relatedEntity);
         return buildNestedStructure(entities, startingFromId, 'threadOf', dropBlockedThreads, false);
     },
 
@@ -129,24 +88,36 @@ module.exports = ({ strapi }) => ({
                 where: criteria
             }, ['related', 'reports']);
         if (!entity){
-            throw strapi.errors.notFound();
+            throw new PluginError(404, 'Not found');
         }
         return filterOurResolvedReports(this.sanitizeCommentEntity(entity));
     },
 
     // Find all related entiries
     async findRelatedEntitiesFor(entities = []) {
-        return Promise.all(uniq(entities.map(_ => _.related)).map(async _ => {
-            const [relatedUid, relatedStringId] = getRelatedGroups(_);
-            const relatedId = parseInt(relatedStringId, 10);
-            const relatedEntity = await strapi.db.query(relatedUid).findOne({ 
-                where: { id: relatedId }
-            });
-            return {
-                ...relatedEntity,
-                uid: relatedUid,
-            };
-        }))
+        const data = entities.reduce((acc, cur) => {
+                const [relatedUid, relatedStringId] = getRelatedGroups(cur.related);
+                return {
+                    ...acc,
+                    [relatedUid]: [...(acc[relatedUid] || []), parseInt(relatedStringId, 10)]
+                };
+            },
+            {}
+        );
+        return Promise.all(
+            Object.entries(data)
+            .map(async ([relatedUid, relatedStringIds]) => 
+                strapi.db.query(relatedUid).findMany({ 
+                    where: { id: Array.from(new Set(relatedStringIds)) } 
+                }).then(relatedEntities => relatedEntities.map(_ => 
+                    ({
+                        ..._,
+                        uid: relatedUid,
+                    })
+                ))
+            )
+        )
+        .then(result => result.flat(2));
     },
 
     // Merge related entity with comment