strapi-plugin-comments 2.0.0-beta.5 → 2.0.0-rc.2

package/server/services/client.js

@@ -1,15 +1,14 @@
 'use strict';
 
-const config = require('./../config');
+const config = require('../config');
 const { getPluginService } = require('./../utils/functions');
-const { isNil, isEmpty } = require('lodash');
+const { isNil, isEmpty, isNumber, parseInt } = require('lodash');
 const PluginError = require('./../utils/error');
 const {
     isEqualEntity,
     getModelUid,
     getRelatedGroups,
     checkBadWords,
-    isValidUserContext,
     resolveUserContextError,
 } = require('./utils/functions');
 const { APPROVAL_STATUS, REGEX } = require('./../utils/constants')
@@ -34,7 +33,8 @@ module.exports = ({ strapi }) => ({
         }
 
         const [ uid, relatedStringId ] = getRelatedGroups(relation);
-        const relatedId = parseInt(relatedStringId, 10);
+        const parsedRelatedId = parseInt(relatedStringId);
+        const relatedId = isNumber(parsedRelatedId) ? parsedRelatedId : relatedStringId;
 
         const relatedEntity = await strapi.db.query(uid).findOne(relatedId);
         if (!relatedEntity) {
@@ -44,11 +44,11 @@ module.exports = ({ strapi }) => ({
         const isApprovalFlowEnabled = this.getCommonService().getConfig('approvalFlow', []).includes(uid) ||
             relatedEntity.requireCommentsApproval;
 
-        const linkToThread = !isNil(threadOf) ? !!await this.getCommonService().findOne({
+        const linkToThread = !isNil(threadOf) ? await this.getCommonService().findOne({
             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,15 +59,11 @@ module.exports = ({ strapi }) => ({
         }
 
         if (checkBadWords(content) && singleRelationFulfilled) {
-            const { author, authorUser, ...rest } = data;
+            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)) {
@@ -82,8 +78,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 && 
@@ -97,32 +93,35 @@ module.exports = ({ strapi }) => ({
                     ...authorData,
                     related: relation,
                     approvalStatus: isApprovalFlowEnabled ? APPROVAL_STATUS.PENDING : null,
-                }
+                },
+                populate: {
+                    authorUser: true,
+                },
+            });
+            return this.getCommonService().sanitizeCommentEntity({
+                ...entity,
+                threadOf: !isNil(threadOf) ? linkToThread : null,
             });
-            return this.getCommonService().sanitizeCommentEntity(entity);
         }
         throw new PluginError(400, 'No content received');
     },
 
     // Update a comment
-    async update(id, relation, data, user) {
-        const { content, related } = data;
+    async update(id, relation, data, user = undefined) {
+        const { content } = data;
 
-        const singleRelationFulfilled = related && REGEX.relatedUid.test(related)
-
-        if (relation !== related) {
-            throw new PluginError(400, `Insonsistent relation uid`);
-        }
+        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,
+            related: relation,
         });
-        const validContext = isValidUserContext(user);
+
+        const validContext = this.getCommonService().isValidUserContext(user);
 
         if (!validContext) {
             throw resolveUserContextError(user);
@@ -133,23 +132,24 @@ module.exports = ({ strapi }) => ({
                 const entity = await strapi.db.query(getModelUid('comment')).update({
                     where: { id },
                     data: { content },
+                    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 existingEntity = await this.getCommonService().findOne({
+		const reportAgainstEntity = await this.getCommonService().findOne({
             id, 
             related: relation,
         });
-		if (existingEntity) {
+		if (reportAgainstEntity) {
             const entity = await strapi.db.query(getModelUid('comment-report')).create({
                 data: {
                     ...payload,
@@ -158,39 +158,62 @@ module.exports = ({ strapi }) => ({
                 }
             });
 			if (entity) {
+                const response = {
+                    ...entity,
+                    related: reportAgainstEntity,
+                };
                 try {
                     await this.sendAbuseReportEmail(entity.reason, entity.content); // Could also add some info about relation
+                    return response
                 } catch (err) {
-                    return entity;
+                    return response;
                 }
             } else {
                 throw new PluginError(500, 'Report cannot be created');
             }
-            return 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 that comment exist or you've authenticated your request properly.`);
     },
 
-    async markAsRemoved(relationId, commentId, authorId){
-        const entity = await this.getCommonService().findOne({
-          id: commentId,
-          related: relationId,
-          $or: [{ authorUser: authorId }, { authorId }],
-        });
-        if (!entity){
-            throw new PluginError(404, 'Entity not exist');
+    async markAsRemoved(id, relation, authorId, user = undefined){
+        if (!this.getCommonService().isValidUserContext(user)) {
+            throw resolveUserContextError(user);
+        }
+
+        const author = user?.id || authorId;
+
+        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.`);
         }
 
-        return strapi.db.query(getModelUid('comment'))
+        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'))
           .update({
               where: { 
-                  id: commentId, 
-                  related: relationId
+                  id, 
+                  related: relation
                 },
-                data: { removed: true }
+                data: { removed: true },
+                populate: { threadOf: true, authorUser: true },
           })
-          .then(({ id }) => this.markAsRemovedNested(id, true))
-          .then(() => ({ id: commentId }));
+        await this.markAsRemovedNested(id, true);
+
+        return this.getCommonService().sanitizeCommentEntity(removedEntity);
     },
 
 	async sendAbuseReportEmail(reason, content) {
@@ -229,7 +252,7 @@ module.exports = ({ strapi }) => ({
 		}
 	},
 
-    markAsRemovedNested(id, status){
+    async markAsRemovedNested(id, status){
         return this.getCommonService().modifiedNestedNestedComments(id, 'removed', status);
     },
 });

package/server/services/common.js

@@ -1,13 +1,14 @@
 'use strict';
 
-const { isArray, uniq, first } = require('lodash');
+const { isArray, isNumber, isObject, isNil, first, parseInt } = require('lodash');
 // const { sanitizeEntity } = require('strapi-utils');
 const PluginError = require('./../utils/error');
 const {
     getModelUid,
     getRelatedGroups,
     buildNestedStructure,
-    filterOurResolvedReports
+    filterOurResolvedReports,
+    buildAuthorModel,
 } = require('./utils/functions');
 
 /**
@@ -85,8 +86,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');
         }
@@ -97,9 +102,11 @@ module.exports = ({ strapi }) => ({
     async findRelatedEntitiesFor(entities = []) {
         const data = entities.reduce((acc, cur) => {
                 const [relatedUid, relatedStringId] = getRelatedGroups(cur.related);
+                const parsedRelatedId = parseInt(relatedStringId);
+                const relatedId = isNumber(parsedRelatedId) ? parsedRelatedId : relatedStringId;
                 return {
                     ...acc,
-                    [relatedUid]: [...(acc[relatedUid] || []), parseInt(relatedStringId, 10)]
+                    [relatedUid]: [...(acc[relatedUid] || []), relatedId]
                 };
             },
             {}
@@ -151,12 +158,16 @@ module.exports = ({ strapi }) => ({
         }
     },
 
-    sanitizeCommentEntity: (entity) => ({
-        ...entity,
-	}),
+    sanitizeCommentEntity(entity) {
+        return {
+            ...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 }),
-	// }),
+    isValidUserContext(user) {
+        return user ? !isNil(user?.id) : true;
+    },
 });

package/server/services/graphql.js

@@ -0,0 +1,190 @@
+'use strict';
+
+const { has, propEq, isNil, isDate, isObject } = require('lodash/fp');
+const { inputObjectType } = require('nexus');
+
+const virtualScalarAttributes = ['id'];
+
+module.exports = ({ strapi }) => {
+  const { service: getService } = strapi.plugin('graphql');
+
+  const rootLevelOperators = () => {
+    const { operators } = strapi.plugin('graphql').service('builders').filters;
+
+    return [operators.and, operators.or, operators.not];
+  };
+
+  const buildContentTypeFilters = contentType => {
+    const utils = strapi.plugin('graphql').service('utils');
+    const extension = strapi.plugin('graphql').service('extension');
+
+    const { getFiltersInputTypeName, getScalarFilterInputTypeName } = utils.naming;
+    const { isStrapiScalar, isRelation } = utils.attributes;
+
+    const { attributes } = contentType;
+
+    const filtersTypeName = getFiltersInputTypeName(contentType);
+
+    return inputObjectType({
+      name: filtersTypeName,
+
+      definition(t) {
+        const validAttributes = Object.entries(attributes).filter(([attributeName]) =>
+          extension
+            .shadowCRUD(contentType.uid)
+            .field(attributeName)
+            .hasFiltersEnabeld()
+        );
+
+        const isIDFilterEnabled = extension
+          .shadowCRUD(contentType.uid)
+          .field('id')
+          .hasFiltersEnabeld();
+        // Add an ID filter to the collection types
+        if (contentType.kind === 'collectionType' && isIDFilterEnabled) {
+          t.field('id', { type: getScalarFilterInputTypeName('ID') });
+        }
+
+        // Add every defined attribute
+        for (const [attributeName, attribute] of validAttributes) {
+          // Handle scalars
+          if (isStrapiScalar(attribute)) {
+            addScalarAttribute(t, attributeName, attribute);
+          }
+
+          // Handle relations
+          else if (isRelation(attribute)) {
+            addRelationalAttribute(t, attributeName, attribute);
+          }
+        }
+
+        // Conditional clauses
+        for (const operator of rootLevelOperators()) {
+          operator.add(t, filtersTypeName);
+        }
+      },
+    });
+  };
+
+  const addScalarAttribute = (builder, attributeName, attribute) => {
+    const { naming, mappers } = strapi.plugin('graphql').service('utils');
+
+    const gqlType = mappers.strapiScalarToGraphQLScalar(attribute.type);
+
+    builder.field(attributeName, { type: naming.getScalarFilterInputTypeName(gqlType) });
+  };
+
+  const addRelationalAttribute = (builder, attributeName, attribute) => {
+    const utils = strapi.plugin('graphql').service('utils');
+    const extension = strapi.plugin('graphql').service('extension');
+    const { getFiltersInputTypeName } = utils.naming;
+    const { isMorphRelation } = utils.attributes;
+
+    const model = strapi.getModel(attribute.target);
+
+    // If there is no model corresponding to the attribute configuration
+    // or if the attribute is a polymorphic relation, then ignore it
+    if (!model || isMorphRelation(attribute)) return;
+
+    // If the target model is disabled, then ignore it too
+    if (extension.shadowCRUD(model.uid).isDisabled()) return;
+
+    builder.field(attributeName, { type: getFiltersInputTypeName(model) });
+  };
+
+  const recursivelyReplaceScalarOperators = data => {
+    const { operators } = getService('builders').filters;
+
+    if (Array.isArray(data)) {
+      return data.map(recursivelyReplaceScalarOperators);
+    }
+
+    // Note: We need to make an exception for date since GraphQL
+    // automatically cast date strings to date instances in args
+    if (isDate(data) || !isObject(data)) {
+      return data;
+    }
+
+    const result = {};
+
+    for (const [key, value] of Object.entries(data)) {
+      const isOperator = !!operators[key];
+
+      const newKey = isOperator ? operators[key].strapiOperator : key;
+
+      result[newKey] = recursivelyReplaceScalarOperators(value);
+    }
+
+    return result;
+  };
+
+  const graphQLFiltersToStrapiQuery = (filters, contentType = {}) => {
+    const { isStrapiScalar, isMedia, isRelation } = getService('utils').attributes;
+    const { operators } = getService('builders').filters;
+
+    const ROOT_LEVEL_OPERATORS = [operators.and, operators.or, operators.not];
+
+    // Handle unwanted scenario where there is no filters defined
+    if (isNil(filters)) {
+      return {};
+    }
+
+    // If filters is a collection, then apply the transformation to every item of the list
+    if (Array.isArray(filters)) {
+      return filters.map(filtersItem =>
+        graphQLFiltersToStrapiQuery(filtersItem, contentType)
+      );
+    }
+
+    const resultMap = {};
+    const { attributes } = contentType;
+
+    const isAttribute = attributeName => {
+      return virtualScalarAttributes.includes(attributeName) || has(attributeName, attributes);
+    };
+
+    for (const [key, value] of Object.entries(filters)) {
+      // If the key is an attribute, update the value
+      if (isAttribute(key)) {
+        const attribute = attributes[key];
+
+        // If it's a scalar attribute
+        if (virtualScalarAttributes.includes(key) || isStrapiScalar(attribute)) {
+          // Replace (recursively) every GraphQL scalar operator with the associated Strapi operator
+          resultMap[key] = recursivelyReplaceScalarOperators(value);
+        }
+
+        // If it's a deep filter on a relation
+        else if (isRelation(attribute) || isMedia(attribute)) {
+          // Fetch the model from the relation
+          const relModel = strapi.getModel(attribute.target);
+
+          // Recursively apply the mapping to the value using the fetched model,
+          // and update the value within `resultMap`
+          resultMap[key] = graphQLFiltersToStrapiQuery(value, relModel);
+        }
+      }
+
+      // Handle the case where the key is not an attribute (operator, ...)
+      else {
+        const rootLevelOperator = ROOT_LEVEL_OPERATORS.find(propEq('fieldName', key));
+
+        // If it's a root level operator (AND, NOT, OR, ...)
+        if (rootLevelOperator) {
+          const { strapiOperator } = rootLevelOperator;
+
+          // Transform the current value recursively and add it to the resultMap
+          // object using the strapiOperator equivalent of the GraphQL key
+          resultMap[strapiOperator] = graphQLFiltersToStrapiQuery(value, contentType);
+        }
+      }
+    }
+
+    return resultMap;
+  };
+
+  return {
+    buildContentTypeFilters,
+    graphQLFiltersToStrapiQuery,
+  };
+};

package/server/services/index.js

@@ -3,9 +3,11 @@
 const adminServices = require('./admin');
 const clientServices = require('./client');
 const commonServices = require('./common');
+const graphQLService = require('./graphql');
 
 module.exports = {
   admin: adminServices,
   client: clientServices,
   common: commonServices,
+  gql: graphQLService,
 };

package/server/services/utils/functions.js

@@ -1,12 +1,12 @@
 const BadWordsFilter = require('bad-words');
 const PluginError = require('./../../utils/error');
 const { REGEX } = require('./../../utils/constants')
-const { first, get, isObject, isNil } = require('lodash');
+const { first, get, isObject, isEmpty } = require('lodash');
 
 const buildNestedStructure = (
   entities,
   id = null,
-  field = 'parent',
+  field = 'threadOf',
   dropBlockedThreads = false,
   blockNestedThreads = false,
 ) =>
@@ -33,7 +33,7 @@ const buildNestedStructure = (
 
 module.exports = {
     isEqualEntity: (existing, data, user) => {
-        const { authorUser, authorId } = existing;
+        const { author: existingAuthor } = existing;
         const { author } = data;
 
         // Disallow approval status change by Client
@@ -42,12 +42,12 @@ module.exports = {
         }
 
         // Make sure that author is exact the same
-        if (authorUser) {
-            const existingUserId = authorUser?.id || authorUser;
-            const receivedUserId = user?.id || author;
-            return existingUserId === receivedUserId;
+        if (user) {
+            const existingUserId = existingAuthor?.id || existingAuthor;
+            const receivedUserId = user?.id || author?.id;
+            return receivedUserId && (existingUserId === receivedUserId);
         }
-        return authorId === author?.id;
+        return existingAuthor.id === author?.id;
     },
 
     getRelatedGroups: related => related.split(REGEX.relatedUid).filter(s => s && s.length > 0),
@@ -85,9 +85,28 @@ module.exports = {
 
     buildNestedStructure,
 
-    isValidUserContext: (user = {}) => {
-		const builtInContextEnabled = get(strapi.config, 'plugins.comments.enableUsers', false);
-        return builtInContextEnabled ? !isNil(user.id) : true;
+    buildAuthorModel: (item) => {
+        const { authorUser, authorId, authorName, authorEmail, authorAvatar, ...rest } = item;
+        let author = {};
+        if (authorUser) {
+            author = {
+                id: authorUser.id,
+                name: authorUser.username,
+                email: authorUser.email,
+                avatar: authorUser.avatar,
+            };
+        } else if(authorId) {
+            author = {
+                id: authorId,
+                name: authorName,
+                email: authorEmail,
+                avatar: authorAvatar,
+            };
+        }
+        return {
+            ...rest,
+            author: isEmpty(author) ? undefined : author,
+        };
     },
 
     resolveUserContextError: user => {

package/strapi-server.js

@@ -1,9 +1,42 @@
 'use strict';
 
+const { isArray, isEmpty, isString } = require('lodash');
+
 const server = require('./server');
 const contentTypes = require('./content-types');
+const { REGEX } = require('./server/utils/constants');
 
 module.exports = () => ({
     ...server,
     contentTypes,
+    config: {
+      ...server.config,
+      default: ({ env }) => ({
+        ...server.config.default,
+      }),
+      validator: (config) => { 
+        // Check moderatorRoles values
+        const moderatorRolesValid = config.moderatorRoles
+          .filter(_ => !isString(_)).length === 0;
+        if (!moderatorRolesValid) {
+          throw new Error(`'moderatorRoles' must roles keys`);
+        }
+
+        // Check approvalFlow values
+        const approvalFlowValid = config.approvalFlow
+          .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)
+          .filter(_ => _ !== '*')
+          .filter(_ => !(REGEX.uid.test(_) && isArray(config.entryLabel[_]) && !isEmpty(config.entryLabel[_]))).length === 0;
+
+        if (!entryLabelKeysValid) {
+          throw new Error(`'entryLabel' must contain records in the format like 'api::<collection name>.<content type name>': ['Field1', 'field_2']`);
+        }
+      },
+    },
   });