strapi-plugin-comments 2.0.0-rc.1 → 2.0.2

package/server/graphql/mutations/updateComment.js

@@ -10,11 +10,16 @@ module.exports = ({ nexus }) => {
 		args: {
 			input: nonNull('UpdateComment'),
 		},
-		async resolve(obj, args) {
+		async resolve(obj, args, ctx) {
 			const { input } = args;
+			const { state: { user } = {} } = ctx;
 			const { id, relation, ...body } = input;
-			return await getPluginService('client')
-				.update(id, relation, body);
+			try {
+				return await getPluginService('client')
+					.update(id, relation, body, user);
+			} catch(e) {
+				throw new Error(e);
+			}
 		},
 	};
 }

package/server/graphql/queries/findAllFlat.js

@@ -18,11 +18,13 @@ module.exports = ({ strapi, nexus }) => {
 			sort: args.SortArg,
 		},
 		async resolve(obj, args) {
-			const { relation, filters } = args;
+			const { relation, filters, sort, pagination } = args;
 			return await getPluginService('common')
 				.findAllFlat(flatInput(
 					relation, 
-					getPluginService('gql').graphQLFiltersToStrapiQuery(filters, contentType)
+					getPluginService('gql').graphQLFiltersToStrapiQuery(filters, contentType),
+					sort,
+					pagination
 				), undefined);
 		},
 	};

package/server/graphql/queries/findAllInHierarchy.js

@@ -13,16 +13,16 @@ module.exports = ({ strapi, nexus }) => {
 		type: nonNull(list('CommentNested')),
 		args: {
 			relation: nonNull(stringArg()),
-			// filters: filtersArg,
 			sort: args.SortArg,
 		},
 		async resolve(obj, args) {
-			const { relation, filters } = args;
+			const { relation, filters, sort } = args;
 			return await getPluginService('common')
 				.findAllInHierarchy({
 					...flatInput(
 						relation, 
-						getPluginService('gql').graphQLFiltersToStrapiQuery(filters, contentType)
+						getPluginService('gql').graphQLFiltersToStrapiQuery(filters, contentType),
+						sort
 					),
 					dropBlockedThreads: true,
 				});

package/server/graphql/resolvers-config.js

@@ -1,10 +1,15 @@
 'use strict'
 
-module.exports = ({ }) => ({
-	'Query.findAllFlat': { auth: false },
-	'Query.findAllInHierarchy': { auth: false },
-	'Mutation.createComment': { auth: false },
-	'Mutation.updateComment': { auth: false },
-	'Mutation.removeComment': { auth: false },
-	'Mutation.createAbuseReport': { auth: false },
-});
+const { getPluginService } = require("../utils/functions");
+
+module.exports = () => {
+	const auth = getPluginService('common').getConfig('gql.auth', false);
+	return {
+		'Query.findAllFlat': { auth },
+		'Query.findAllInHierarchy': { auth },
+		'Mutation.createComment': { auth },
+		'Mutation.updateComment': { auth },
+		'Mutation.removeComment': { auth },
+		'Mutation.createAbuseReport': { auth },
+	};
+};

package/server/graphql/types/comment-nested.js

@@ -6,9 +6,9 @@ module.exports = ({ nexus }) => nexus.objectType({
     t.boolean("blocked")
     t.boolean("blockedThread")
     t.string("approvalStatus")
+    t.boolean("removed")
     t.field("threadOf", { type: 'CommentSingle' })
     t.list.field("children", { type: 'CommentNested' })
-    t.field("authorUser", { type: 'CommentAuthorUser' })
     t.field("author", { type: 'CommentAuthor' })
     t.string("createdAt")
     t.string("updatedAt")

package/server/graphql/types/comment.js

@@ -8,7 +8,6 @@ module.exports = ({ nexus }) => nexus.objectType({
     t.boolean("removed")
     t.string("approvalStatus")
     t.field("threadOf", { type: 'CommentSingle' })
-    t.field("authorUser", { type: 'CommentAuthorUser' })
     t.field("author", { type: 'CommentAuthor' })
     t.string("createdAt")
     t.string("updatedAt")

package/server/graphql/types/create-comment-author.js

@@ -1,7 +1,7 @@
 module.exports = ({ nexus }) => nexus.inputObjectType({
   name: "CreateCommentAuthor",
   definition(t) {
-    t.nonNull.string("id")
+    t.nonNull.id("id")
     t.nonNull.string("name")
     t.string("email")
     t.string("avatar")

package/server/graphql/types/identify-comment-author.js

@@ -1,6 +1,6 @@
 module.exports = ({ nexus }) => nexus.inputObjectType({
   name: "IdentifyCommentAuthor",
   definition(t) {
-    t.nonNull.string("id")
+    t.nonNull.id("id")
   }
 })

package/server/graphql/types/index.js

@@ -3,7 +3,6 @@ const typesFactories = [
 	require('./comment'),
 	require('./comment-nested'),
 	require('./comment-author'),
-	require('./comment-author-user'),
 	require('./create-comment'),
 	require('./create-comment-author'),
 	require('./update-comment'),

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

@@ -0,0 +1,165 @@
+const PluginError = require('../../utils/error');
+const { getPluginService } = require('../../utils/functions');
+
+jest.mock
+
+
+const setup = function(config) {
+  Object.defineProperty(global, 'strapi', {
+    value: require('../../../__mocks__/initSetup')(config),
+    writable: true,
+  });
+}
+
+afterEach(() => {
+  Object.defineProperty(global, 'strapi', {});
+})
+
+describe('Test Comments service functions utils', () => {
+
+  describe('Get plugin config', () => {
+    beforeEach(() => setup({
+      test: 'sample',
+    }));
+
+    test('Should return config value', () => {
+      expect(getPluginService('common').getConfig('test')).toEqual('sample');
+    });
+
+    test('Should return default config prop value if not set', () => {
+      expect(getPluginService('common').getConfig('another', 'defaultValue')).toEqual('defaultValue');
+    });
+  });
+
+  describe('Validate user context', () => {
+    beforeEach(() => setup());
+
+    test('Should context be valid', () => {
+      expect(getPluginService('common').isValidUserContext({ id: 1 })).toEqual(true);
+    });
+
+    test('Should context be invalid', () => {
+      expect(getPluginService('common').isValidUserContext({ })).toEqual(false);
+    });
+
+    test('Should use fallback', () => {
+      expect(getPluginService('common').isValidUserContext()).toEqual(true);
+    });
+  });
+
+  describe('Sanitize comments entity', () => {
+    beforeEach(() => setup());
+
+    const sample = {
+      id: 1,
+      content: 'Test text',
+      blocked: false,
+      removed: true,
+    };
+
+    const authorSample = {
+      id: 1,
+      username: 'Joe Doe',
+      email: 'test@example.com',
+      password: 'xxx',
+    };
+
+    const authorGenericSample = {
+      authorId: 1,
+      authorName: 'Joe Doe',
+      authorEmail: 'test@example.com',
+    };
+
+    const outputAuthorSample = {
+      id: 1,
+      name: 'Joe Doe',
+      email: 'test@example.com',
+    };
+
+    test('Should return exact the same value', () => {
+      const input = { ...sample };
+      const output = getPluginService('common').sanitizeCommentEntity(input);
+      expect(output).toHaveProperty('id', input.id);
+      expect(output).toHaveProperty('content', input.content);
+      expect(output).toHaveProperty('blocked', input.blocked);
+      expect(output).toHaveProperty('removed', input.removed);
+    });
+
+    test('Should return entity with \'author\' property for generic author', () => {
+      const input = {
+        ...sample,
+        ...authorGenericSample,
+      };
+      const output = getPluginService('common').sanitizeCommentEntity(input);
+
+      expect(output).toHaveProperty('author');
+      expect(output).toHaveProperty('author.id', input.authorId);
+      expect(output).toHaveProperty('author.id', outputAuthorSample.id);
+      expect(output).toHaveProperty('author.name', input.authorName);
+      expect(output).toHaveProperty('author.name', outputAuthorSample.name);
+      expect(output).toHaveProperty('author.email', input.authorEmail);
+      expect(output).toHaveProperty('author.email', outputAuthorSample.email);
+
+      expect(output).not.toHaveProperty('authorId');
+      expect(output).not.toHaveProperty('authorName');
+      expect(output).not.toHaveProperty('authorEmail');
+    });
+
+    test('Should return entity with \'author\' property for Strapi author', () => {
+      const input = {
+        ...sample,
+        authorUser: authorSample,
+      };
+      const output = getPluginService('common').sanitizeCommentEntity(input);
+
+      expect(output).toHaveProperty('author');
+      expect(output).toHaveProperty('author.id', input.authorUser.id);
+      expect(output).toHaveProperty('author.id', outputAuthorSample.id);
+      expect(output).toHaveProperty('author.name', input.authorUser.username);
+      expect(output).toHaveProperty('author.name', outputAuthorSample.name);
+      expect(output).toHaveProperty('author.email', input.authorUser.email);
+      expect(output).toHaveProperty('author.email', outputAuthorSample.email);
+
+      expect(output).not.toHaveProperty('authorUser');
+
+      expect(output).not.toHaveProperty('author.password');
+    });
+  });
+
+  describe('Bad Words filtering', () => {
+    beforeEach(() => setup());
+
+    const text = 'Lorem ipsum dolor sit fuck amet';
+
+    test('Should find bad words usage and throw error PluginError', () => {
+      expect.assertions(7);
+      try {
+        getPluginService('common').checkBadWords(text);
+      } catch (e) {
+        expect(getPluginService('common').getConfig('badWords')).toEqual(undefined);
+        expect(e).toBeInstanceOf(PluginError);
+        expect(e).toHaveProperty('status', 400);
+        expect(e).toHaveProperty('name', 'Strapi:Plugin:Comments');
+        expect(e).toHaveProperty('message', 'Bad language used! Please polite your comment...');
+        expect(e).toHaveProperty('payload');
+        expect(e.payload).toEqual(expect.objectContaining({
+          content: {
+            original: text,
+            filtered: text.replace('fuck', '****'),
+          }
+        }));
+      }
+    });
+  });
+
+  describe('Bad Words filtering', () => {
+    beforeEach(() => setup({ badWords: false }));
+
+    const text = 'Lorem ipsum dolor sit fuck amet';
+
+    test('Should skip bad words filtering because of configuration change', () => {
+      expect(getPluginService('common').getConfig('badWords')).toEqual(false);
+      expect(getPluginService('common').checkBadWords(text)).toEqual(text);
+    });
+  });
+});

package/server/services/admin.js

@@ -117,19 +117,24 @@ const { APPROVAL_STATUS, REGEX } = require('./../utils/constants')
             }
         };
 
-        const entity = await strapi.db.query(getModelUid('comment')).findOne({ 
-            where: {
-                id,
-            },
+        const defaultPopulate = {
             populate: {
                 authorUser: true,
                 threadOf: {
                     populate: { 
+                        authorUser: true,
                         ...reportsPopulation
                     },
                 },
                 ...reportsPopulation,
             },
+        }
+
+        const entity = await strapi.db.query(getModelUid('comment')).findOne({ 
+            where: {
+                id,
+            },
+            ...defaultPopulate,
         });
 
         if (!entity){
@@ -159,9 +164,7 @@ const { APPROVAL_STATUS, REGEX } = require('./../utils/constants')
                     threadOf: levelThreadId,
                     related: entity.related,
                 },
-                populate: {
-                    ...reportsPopulation,
-                },
+                ...defaultPopulate,
                 startingFromId: levelThreadId,
                 isAdmin: true
             }, false);

package/server/services/client.js

@@ -8,8 +8,6 @@ const {
     isEqualEntity,
     getModelUid,
     getRelatedGroups,
-    checkBadWords,
-    isValidUserContext,
     resolveUserContextError,
 } = require('./utils/functions');
 const { APPROVAL_STATUS, REGEX } = require('./../utils/constants')
@@ -49,7 +47,7 @@ module.exports = ({ strapi }) => ({
             id: threadOf,
             related: relation,
         }) : true;
-        const validContext = isValidUserContext(user);
+        const validContext = this.getCommonService().isValidUserContext(user);
 
         if (!linkToThread) {
             throw new PluginError(400, 'Thread does not exist');
@@ -59,16 +57,12 @@ module.exports = ({ strapi }) => ({
             throw resolveUserContextError(user);
         }
 
-        if (checkBadWords(content) && singleRelationFulfilled) {
-            const { author, authorUser, ...rest } = data;
+        if (this.getCommonService().checkBadWords(content) && singleRelationFulfilled) {
+            const { author = {}, ...rest } = data;
             let authorData = {};
             if (validContext && user) {
                 authorData = {
-                    authorUser: user?.id || authorUser,
-                };
-            } else if (authorUser) {
-                authorData = {
-                    authorUser,
+                    authorUser: user?.id,
                 };
             } else {
                 if (author.email && !REGEX.email.test(author.email)) {
@@ -83,8 +77,8 @@ module.exports = ({ strapi }) => ({
                 };
             }
             
-            if (!isEmpty(authorData) && !authorData.authorId) {
-                throw new PluginError(400, 'Object: "author" is invalid. Check your payload');
+            if (!isEmpty(authorData) && !(authorData.authorId || authorData.authorUser)) {
+                throw new PluginError(400, `Not able to recognise author of a comment. Make sure you've provided "author" property in a payload or authenticated your request properly.`);
             }
 
             if (isApprovalFlowEnabled && 
@@ -98,7 +92,10 @@ module.exports = ({ strapi }) => ({
                     ...authorData,
                     related: relation,
                     approvalStatus: isApprovalFlowEnabled ? APPROVAL_STATUS.PENDING : null,
-                }
+                },
+                populate: {
+                    authorUser: true,
+                },
             });
             return this.getCommonService().sanitizeCommentEntity({
                 ...entity,
@@ -109,41 +106,42 @@ module.exports = ({ strapi }) => ({
     },
 
     // Update a comment
-    async update(id, relation, data, user) {
+    async update(id, relation, data, user = undefined) {
         const { content } = 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>"`);
+            throw new PluginError(400, `Request property "relation" got incorrect format, use format like "api::<collection name>.<content type name>:<entity id>"`);
         }
 
         const existingEntity = await this.getCommonService().findOne({
             id,
             related: relation,
         });
-        const validContext = isValidUserContext(user);
+
+        const validContext = this.getCommonService().isValidUserContext(user);
 
         if (!validContext) {
             throw resolveUserContextError(user);
         }
 
         if (isEqualEntity(existingEntity, data, user) && content) {
-            if (checkBadWords(content)) {
+            if (this.getCommonService().checkBadWords(content)) {
                 const entity = await strapi.db.query(getModelUid('comment')).update({
                     where: { id },
                     data: { content },
-                    populate: { threadOf: true },
+                    populate: { threadOf: true, authorUser: true },
                 });
                 return this.getCommonService().sanitizeCommentEntity(entity);
             }
         }
-        throw new PluginError(409, 'Action on that entity is not allowed');
+        throw new PluginError(403, `You're not allowed to take an action on that entity. Make sure you've provided "author" property in a payload or authenticated your request properly.`);
     },
 
     // Report abuse in comment
-	async reportAbuse(id, relation, payload, user) {
-        if (!isValidUserContext(user)) {
+	async reportAbuse(id, relation, payload, user = undefined) {
+        if (!this.getCommonService().isValidUserContext(user)) {
             throw resolveUserContextError(user);
         }
 		const reportAgainstEntity = await this.getCommonService().findOne({
@@ -173,18 +171,34 @@ module.exports = ({ strapi }) => ({
                 throw new PluginError(500, 'Report cannot be created');
             }
         }
-        throw new PluginError(409, 'Action on that entity is not allowed');
+        throw new PluginError(403, `You're not allowed to take an action on that entity. Make sure that comment exist or you've authenticated your request properly.`);
     },
 
-    async markAsRemoved(id, relation, authorId){
-        const entity = await this.getCommonService().findOne({
-            id,
-            related: relation,
-            $or: [{ authorUser: authorId }, { authorId }],
-        });
+    async markAsRemoved(id, relation, authorId, user = undefined){
+        if (!this.getCommonService().isValidUserContext(user)) {
+            throw resolveUserContextError(user);
+        }
+
+        const author = user?.id || authorId;
 
-        if (!entity) {
-            throw new PluginError(404, 'Entity not exist');
+        if (!author) {
+            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.`);
+        }
+
+        let entity;
+        try {
+            const byAuthor = user?.id ? {
+                authorUser: author
+            } : {
+                authorId: author
+            }
+            entity = await this.getCommonService().findOne({
+                id,
+                related: relation,
+                ...byAuthor,
+            });
+        } catch(e) {
+            throw new PluginError(404, `Entity does not exist or you're not allowed to take an action on it`);
         }
 
         const removedEntity = await strapi.db.query(getModelUid('comment'))
@@ -194,7 +208,7 @@ module.exports = ({ strapi }) => ({
                   related: relation
                 },
                 data: { removed: true },
-                populate: { threadOf: true },
+                populate: { threadOf: true, authorUser: true },
           })
         await this.markAsRemovedNested(id, true);
 

package/server/services/common.js

@@ -1,7 +1,8 @@
 'use strict';
 
-const { isArray, isNumber, isObject, first, parseInt } = require('lodash');
-// const { sanitizeEntity } = require('strapi-utils');
+const BadWordsFilter = require('bad-words');
+const { isArray, isNumber, isObject, isNil, isString, first, parseInt, set } = require('lodash');
+const { REGEX } = require('../utils/constants');
 const PluginError = require('./../utils/error');
 const {
     getModelUid,
@@ -22,16 +23,44 @@ module.exports = ({ strapi }) => ({
         if (prop && isArray(prop)) {
             queryProp = prop.join('.');
         }
-        return strapi.config.get(`plugin.comments${ queryProp ? '.' + queryProp : ''}`) || defaultValue;
+        const result = strapi.config.get(`plugin.comments${ queryProp ? '.' + queryProp : ''}`);
+        return isNil(result) ? defaultValue : result;
     },
 
     // Find comments in the flat structure
-    async findAllFlat({ query = {}, populate = {} }, relatedEntity = null) {
+    async findAllFlat({ 
+        query = {}, 
+        populate = {}, 
+        sort, 
+        pagination }, relatedEntity = null) {
 
         const defaultPopulate = {
             authorUser: true,
         };
 
+        let queryExtension = {};
+
+        if (sort && (isString(sort) || isArray(sort))) {
+            queryExtension = {
+                ...queryExtension,
+                orderBy: (isString(sort) ? [sort] : sort)
+                .map(_ => REGEX.sorting.test(_) ? _ : `${_}:asc`)
+                .reduce((prev, curr) => {
+                    const [type = 'asc', ...parts] = curr.split(':').reverse();
+                    return { ...set(prev, parts.reverse().join('.'), type) };
+                }, {})
+            };
+        }
+
+        if (pagination && isObject(pagination)) {
+            const { page = 1, pageSize = 10 } = pagination;
+            queryExtension = {
+                ...queryExtension,
+                offset: (page - 1) * pageSize,
+                limit: pageSize,
+            };
+        }
+        
         const entries = await strapi.db.query(getModelUid('comment'))
         .findMany({
             where: {
@@ -41,6 +70,7 @@ module.exports = ({ strapi }) => ({
                 ...defaultPopulate,
                 ...populate,
             },
+            ...queryExtension,
         });
 
         const entriesWithThreads = await Promise.all(entries.map(async _ => {
@@ -75,10 +105,11 @@ module.exports = ({ strapi }) => ({
     async findAllInHierarchy ({
         query,
         populate = {},
+        sort,
         startingFromId = null,
         dropBlockedThreads = false,
     }, relatedEntity) {
-        const entities = await this.findAllFlat({ query, populate }, relatedEntity);
+        const entities = await this.findAllFlat({ query, populate, sort }, relatedEntity);
         return buildNestedStructure(entities, startingFromId, 'threadOf', dropBlockedThreads, false);
     },
 
@@ -86,8 +117,12 @@ module.exports = ({ strapi }) => ({
     async findOne(criteria) {
         const entity = await strapi.db.query(getModelUid('comment'))
             .findOne({
-                where: criteria
-            }, ['related', 'reports']);
+                where: criteria,
+                populate: {
+                    reports: true,
+                    authorUser: true,
+                },
+            });
         if (!entity){
             throw new PluginError(404, 'Not found');
         }
@@ -111,7 +146,7 @@ module.exports = ({ strapi }) => ({
             Object.entries(data)
             .map(async ([relatedUid, relatedStringIds]) => 
                 strapi.db.query(relatedUid).findMany({ 
-                    where: { id: Array.from(new Set(relatedStringIds)) } 
+                    where: { id: Array.from(new Set(relatedStringIds)) },
                 }).then(relatedEntities => relatedEntities.map(_ => 
                     ({
                         ..._,
@@ -154,15 +189,32 @@ module.exports = ({ strapi }) => ({
         }
     },
 
-    sanitizeCommentEntity: (entity) => ({
-        ...buildAuthorModel({
-            ...entity,
-            threadOf: isObject(entity.threadOf) ? buildAuthorModel(entity.threadOf) : entity.threadOf,
-        }),
-	}),
-
-    // sanitizeCommentEntity: (entity) => ({
-    //     ...entity,
-    //     authorUser: sanitizeEntity(entity.authorUser, { model: strapi.plugins['users-permissions'].models.user }),
-	// }),
+    sanitizeCommentEntity(entity) {
+        return {
+            ...buildAuthorModel({
+                ...entity,
+                threadOf: isObject(entity.threadOf) ? buildAuthorModel(entity.threadOf) : entity.threadOf,
+            }),
+        };
+    },
+
+    isValidUserContext(user) {
+        return user ? !isNil(user?.id) : true;
+    },
+
+    checkBadWords(content) {
+        const config = this.getConfig('badWords', true);
+        if (config) {
+            const filter = new BadWordsFilter(isObject(config) ? config : undefined);
+            if (content && filter.isProfane(content)) {
+                throw new PluginError(400, 'Bad language used! Please polite your comment...', {
+                    content: {
+                        original: content,
+                        filtered: content && filter.clean(content),
+                    },
+                });
+            }
+        }
+        return content;
+    },
 });