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

package/server/graphql/mutations/index.js

@@ -0,0 +1,21 @@
+'use strict'
+
+module.exports = (context) => {
+	const mutations = {
+		createComment: require('./createComment'),
+		updateComment: require('./updateComment'),
+		removeComment: require('./removeComment'),
+		createAbuseReport: require('./createAbuseReport'),
+	};
+
+  return context.nexus.extendType({
+    type: 'Mutation',
+		definition(t) {
+			for (const [name, configFactory] of Object.entries(mutations)) {
+				const config = configFactory(context);
+
+				t.field(name, config);
+			}
+    },
+  });
+};

package/server/graphql/mutations/removeComment.js

@@ -0,0 +1,20 @@
+'use strict'
+
+const { getPluginService } = require('../../utils/functions');
+
+module.exports = ({ nexus }) => {
+	const { nonNull } = nexus;
+
+	return {
+		type: nonNull('CommentSingle'),
+		args: {
+			input: nonNull('RemoveComment'),
+		},
+		async resolve(obj, args) {
+			const { input } = args;
+			const { id, relation, author } = input;
+			return await getPluginService('client')
+				.markAsRemoved(id, relation, author?.id);
+		},
+	};
+}

package/server/graphql/mutations/updateComment.js

@@ -0,0 +1,20 @@
+'use strict'
+
+const { getPluginService } = require('../../utils/functions');
+
+module.exports = ({ nexus }) => {
+	const { nonNull } = nexus;
+
+	return {
+		type: nonNull('CommentSingle'),
+		args: {
+			input: nonNull('UpdateComment'),
+		},
+		async resolve(obj, args) {
+			const { input } = args;
+			const { id, relation, ...body } = input;
+			return await getPluginService('client')
+				.update(id, relation, body);
+		},
+	};
+}

package/server/graphql/queries/findAllFlat.js

@@ -0,0 +1,29 @@
+'use strict'
+
+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 { service: getService } = strapi.plugin('graphql');
+	const { args } = getService('internals');
+
+	return {
+		type: nonNull(list('CommentSingle')),
+		args: {
+			relation: nonNull(stringArg()),
+			filters: getPluginService('gql').buildContentTypeFilters(contentType),
+			pagination: args.PaginationArg,
+			sort: args.SortArg,
+		},
+		async resolve(obj, args) {
+			const { relation, filters } = args;
+			return await getPluginService('common')
+				.findAllFlat(flatInput(
+					relation, 
+					getPluginService('gql').graphQLFiltersToStrapiQuery(filters, contentType)
+				), undefined);
+		},
+	};
+}

package/server/graphql/queries/findAllInHierarchy.js

@@ -0,0 +1,31 @@
+'use strict'
+
+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 { service: getService } = strapi.plugin('graphql');
+	const { args } = getService('internals');
+
+	return {
+		type: nonNull(list('CommentNested')),
+		args: {
+			relation: nonNull(stringArg()),
+			// filters: filtersArg,
+			sort: args.SortArg,
+		},
+		async resolve(obj, args) {
+			const { relation, filters } = args;
+			return await getPluginService('common')
+				.findAllInHierarchy({
+					...flatInput(
+						relation, 
+						getPluginService('gql').graphQLFiltersToStrapiQuery(filters, contentType)
+					),
+					dropBlockedThreads: true,
+				});
+		},
+	};
+}

package/server/graphql/queries/index.js

@@ -0,0 +1,19 @@
+'use strict'
+
+module.exports = (context) => {
+	const queries = {
+		findAllFlat: require('./findAllFlat'),
+		findAllInHierarchy: require('./findAllInHierarchy'),
+	};
+
+  return context.nexus.extendType({
+    type: 'Query',
+		definition(t) {
+			for (const [name, configFactory] of Object.entries(queries)) {
+				const config = configFactory(context);
+
+				t.field(name, config);
+			}
+    },
+  });
+};

package/server/graphql/resolvers-config.js

@@ -0,0 +1,10 @@
+'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 },
+});

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

@@ -0,0 +1,9 @@
+module.exports = ({ nexus }) => nexus.objectType({
+  name: "CommentAuthorUser",
+  definition(t) {
+    t.id("id")
+    t.nonNull.string("firstName")
+    t.string("lastName")
+    t.string("email")
+  }
+})

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

@@ -0,0 +1,9 @@
+module.exports = ({ nexus }) => nexus.objectType({
+  name: "CommentAuthor",
+  definition(t) {
+    t.id("id")
+    t.nonNull.string("name")
+    t.string("email")
+    t.string("avatar")
+  }
+})

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

@@ -0,0 +1,16 @@
+module.exports = ({ nexus }) => nexus.objectType({
+  name: "CommentNested",
+  definition(t) {
+    t.id("id")
+    t.nonNull.string("content")
+    t.boolean("blocked")
+    t.boolean("blockedThread")
+    t.string("approvalStatus")
+    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

@@ -0,0 +1,16 @@
+module.exports = ({ nexus }) => nexus.objectType({
+  name: "CommentSingle",
+  definition(t) {
+    t.id("id")
+    t.nonNull.string("content")
+    t.boolean("blocked")
+    t.boolean("blockedThread")
+    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

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

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

@@ -0,0 +1,9 @@
+module.exports = ({ nexus }) => nexus.inputObjectType({
+  name: "CreateComment",
+  definition(t) {
+    t.nonNull.string("content")
+    t.nonNull.string("relation")
+    t.id("threadOf")
+    t.field("author", { type: 'CreateCommentAuthor' })
+  }
+})

package/server/graphql/types/create-report.js

@@ -0,0 +1,9 @@
+module.exports = ({ nexus }) => nexus.inputObjectType({
+  name: "CreateReport",
+  definition(t) {
+    t.id("commentId")
+    t.nonNull.string("relation")
+    t.nonNull.string("content")
+    t.field("reason", { type: 'ReportReason' })
+  }
+})

package/server/graphql/types/id.js

@@ -0,0 +1,24 @@
+const { isNumber, parseInt } = require('lodash');
+const { Kind } = require('graphql');
+
+module.exports = ({ nexus }) => nexus.scalarType({
+  name: "Id",
+  asNexusMethod: 'id',
+  description: 'Id as string or int',
+  parseValue(value) {
+    const parsedValue = parseInt(value);
+    if (isNumber(parsedValue)) {
+      return parsedValue;
+    }
+    return value;
+  },
+  serialize(value) {
+    return value;
+  },
+  parseLiteral(ast) {
+    if ([Kind.INT, Kind.STRING].includes(ast.kind)) {
+      return ast.value;
+    }
+    return null
+  },
+})

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

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

package/server/graphql/types/index.js

@@ -0,0 +1,17 @@
+const typesFactories = [
+	require('./id'),
+	require('./comment'),
+	require('./comment-nested'),
+	require('./comment-author'),
+	require('./comment-author-user'),
+	require('./create-comment'),
+	require('./create-comment-author'),
+	require('./update-comment'),
+	require('./remove-comment'),
+	require('./identify-comment-author'),
+	require('./report'),
+	require('./report-reason'),
+	require('./create-report'),
+];
+
+module.exports = context => typesFactories.map(factory => factory(context));

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

@@ -0,0 +1,8 @@
+module.exports = ({ nexus }) => nexus.inputObjectType({
+  name: "RemoveComment",
+  definition(t) {
+    t.id("id")
+    t.nonNull.string("relation")
+    t.field("author", { type: 'IdentifyCommentAuthor' })
+  }
+})

package/server/graphql/types/report-reason.js

@@ -0,0 +1,10 @@
+const { getPluginService } = require("../../utils/functions");
+
+
+module.exports = ({ nexus }) => nexus.enumType({
+  name: "ReportReason",
+  description: 'Reason of abuse report',
+  members: {
+    ...getPluginService('common').getConfig('reportReasons', {})
+  },
+})

package/server/graphql/types/report.js

@@ -0,0 +1,11 @@
+module.exports = ({ nexus }) => nexus.objectType({
+  name: "Report",
+  definition(t) {
+    t.id("id")
+    t.nonNull.string("content")
+    t.field("reason", { type: 'ReportReason' })
+    t.field("related", { type: 'CommentSingle' })
+    t.string("createdAt")
+    t.string("updatedAt")
+  }
+})

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

@@ -0,0 +1,9 @@
+module.exports = ({ nexus }) => nexus.inputObjectType({
+  name: "UpdateComment",
+  definition(t) {
+    t.id("id")
+    t.nonNull.string("content")
+    t.nonNull.string("relation")
+    t.field("author", { type: 'IdentifyCommentAuthor' })
+  }
+})

package/server/register.js

@@ -1,5 +1,7 @@
 'use strict';
 
 module.exports = ({ strapi }) => {
-  // registeration phase
+  if (strapi.plugin('graphql')) {
+    require('./graphql')({ strapi });
+  }
 };

package/server/services/admin.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const { getPluginService, parseParams } = require('./../utils/functions');
-const { isEmpty, isNil } = require('lodash');
+const { isEmpty, isNil, isNumber, parseInt } = require('lodash');
 const PluginError = require('./../utils/error');
 const {
     getModelUid,
@@ -137,7 +137,8 @@ const { APPROVAL_STATUS, REGEX } = require('./../utils/constants')
         }
 
         const [relatedUid, relatedStringId] = getRelatedGroups(entity.related);
-        const relatedId = parseInt(relatedStringId, 10);
+        const parsedRelatedId = parseInt(relatedStringId);
+        const relatedId = isNumber(parsedRelatedId) ? parsedRelatedId : relatedStringId;
         const relatedEntity = await strapi.db.query(relatedUid).findOne({ 
             where: { id: relatedId }
         }).then(_ => ({
@@ -164,15 +165,14 @@ const { APPROVAL_STATUS, REGEX } = require('./../utils/constants')
                 startingFromId: levelThreadId,
                 isAdmin: true
             }, false);
-
-        const selectedEntity = this.getCommonService().sanitizeCommentEntity(entity);
+        const selectedEntity = this.getCommonService().sanitizeCommentEntity({
+            ...entity,
+            threadOf: entity.threadOf || null,
+        });
         
         return {
             entity: relatedEntity,
-            selected: {
-                ...selectedEntity,
-                threadOf: selectedEntity.threadOf ? selectedEntity.threadOf : null,
-            },
+            selected: selectedEntity,
             level: entitiesOnSameLevel,
         };
     },

package/server/services/client.js

@@ -2,7 +2,7 @@
 
 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,
@@ -34,7 +34,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,7 +45,7 @@ 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;
@@ -99,20 +100,19 @@ module.exports = ({ strapi }) => ({
                     approvalStatus: isApprovalFlowEnabled ? APPROVAL_STATUS.PENDING : null,
                 }
             });
-            return this.getCommonService().sanitizeCommentEntity(entity);
+            return this.getCommonService().sanitizeCommentEntity({
+                ...entity,
+                threadOf: !isNil(threadOf) ? linkToThread : null,
+            });
         }
         throw new PluginError(400, 'No content received');
     },
 
     // Update a comment
     async update(id, relation, data, user) {
-        const { content, related } = data;
-
-        const singleRelationFulfilled = related && REGEX.relatedUid.test(related)
+        const { content } = data;
 
-        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>"`);
@@ -120,7 +120,7 @@ module.exports = ({ strapi }) => ({
 
         const existingEntity = await this.getCommonService().findOne({
             id,
-            related,
+            related: relation,
         });
         const validContext = isValidUserContext(user);
 
@@ -133,6 +133,7 @@ module.exports = ({ strapi }) => ({
                 const entity = await strapi.db.query(getModelUid('comment')).update({
                     where: { id },
                     data: { content },
+                    populate: { threadOf: true },
                 });
                 return this.getCommonService().sanitizeCommentEntity(entity);
             }
@@ -145,11 +146,11 @@ module.exports = ({ strapi }) => ({
         if (!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 +159,46 @@ 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');
     },
 
-    async markAsRemoved(relationId, commentId, authorId){
+    async markAsRemoved(id, relation, authorId){
         const entity = await this.getCommonService().findOne({
-          id: commentId,
-          related: relationId,
-          $or: [{ authorUser: authorId }, { authorId }],
+            id,
+            related: relation,
+            $or: [{ authorUser: authorId }, { authorId }],
         });
-        if (!entity){
+
+        if (!entity) {
             throw new PluginError(404, 'Entity not exist');
         }
 
-        return strapi.db.query(getModelUid('comment'))
+        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 },
           })
-          .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 +237,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, first, parseInt } = require('lodash');
 // const { sanitizeEntity } = require('strapi-utils');
 const PluginError = require('./../utils/error');
 const {
     getModelUid,
     getRelatedGroups,
     buildNestedStructure,
-    filterOurResolvedReports
+    filterOurResolvedReports,
+    buildAuthorModel,
 } = require('./utils/functions');
 
 /**
@@ -97,9 +98,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]
                 };
             },
             {}
@@ -152,7 +155,10 @@ module.exports = ({ strapi }) => ({
     },
 
     sanitizeCommentEntity: (entity) => ({
-        ...entity,
+        ...buildAuthorModel({
+            ...entity,
+            threadOf: isObject(entity.threadOf) ? buildAuthorModel(entity.threadOf) : entity.threadOf,
+        }),
 	}),
 
     // sanitizeCommentEntity: (entity) => ({