strapi-plugin-comments 2.0.0-rc.2 → 2.0.3

package/server/controllers/admin.js

@@ -10,6 +10,39 @@ module.exports = {
     return getPluginService(name);
   },
 
+  async config(ctx) {
+    try {
+      return await this.getService().config();
+    } catch (e) {
+      throwError(ctx, e);
+    }
+  },
+
+  async settingsConfig(ctx) {
+    try {
+      return this.getService().config(true);
+    } catch (e) {
+      throwError(ctx, e);
+    }
+  },
+
+  async settingsUpdateConfig(ctx) {
+    try {
+      const { request: { body } } = ctx;
+      return this.getService().updateConfig(body);
+    } catch (e) {
+      throwError(ctx, e);
+    }
+  },
+
+  async settingsRestoreConfig(ctx) {
+    try {
+      return this.getService().restoreConfig();
+    } catch (e) {
+      throwError(ctx, e);
+    }
+  },
+
   async findAll(ctx) {
     return this.getService()
       .findAll(ctx.query);
@@ -101,14 +134,6 @@ module.exports = {
     }
   },
 
-  async config(ctx) {
-    try {
-      return await this.getService().config();
-    } catch (e) {
-      throwError(ctx, e);
-    }
-  },
-
   getContentsTypes() {
     return Object.entries(strapi.contentTypes)
       .filter(([, contentType]) => (

package/server/controllers/client.js

@@ -11,23 +11,23 @@ module.exports = {
   },
 
   async findAllFlat(ctx) {
-    const { params = {}, query } = ctx;
+    const { params = {}, query, sort, pagination } = ctx;
     const { relation } = parseParams(params);
     try {
       return this.getService('common')
-        .findAllFlat(flatInput(relation, query));
+        .findAllFlat(flatInput(relation, query, sort, pagination));
     } catch (e) {
       throwError(ctx, e);
     }
   },
 
   async findAllInHierarchy(ctx) {
-    const { params = {}, query } = ctx;
+    const { params = {}, query, sort } = ctx;
     const { relation } = parseParams(params);
     try {
       return await this.getService('common')
         .findAllInHierarchy({
-          ...flatInput(relation, query),
+          ...flatInput(relation, query, sort),
           dropBlockedThreads: true,
         });
     } catch (e) {

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

@@ -1,6 +1,6 @@
-const PluginError = require('../../../services/utils/error');
+const PluginError = require('../../../utils/error');
 const ctx = require('koa/lib/context');
-const { parseParams, throwError } = require('../functions');
+const { throwError } = require('../functions');
 
 jest.mock
 

package/server/controllers/utils/parsers.js

@@ -1,7 +1,7 @@
 'use strict'
 
 module.exports = {
-    flatInput(relation, query) {
+    flatInput(relation, query, sort, pagination) {
         return {
             query: {
               ...query,
@@ -13,6 +13,8 @@ module.exports = {
                 populate: { authorUser: true },
               },
             },
+            pagination,
+            sort,
           };
     },
   

package/server/graphql/index.js

@@ -6,17 +6,16 @@ const getMutations = require('./mutations');
 const getResolversConfig = require('./resolvers-config');
 const { getModelUid } = require('../services/utils/functions');
 
-module.exports = () => {
+module.exports = async ({ strapi, config}) => {
 	const extensionService = strapi.plugin('graphql').service('extension');
-
 	extensionService.shadowCRUD(getModelUid('comment')).disable();
 	extensionService.shadowCRUD(getModelUid('comment-report')).disable();
-
-	extensionService.use(({ nexus }) => {
-		const types = getTypes({ strapi, nexus });
-		const queries = getQueries({ strapi, nexus });
-		const mutations = getMutations({ strapi, nexus });
-		const resolversConfig = getResolversConfig({ strapi });
+	
+	extensionService.use(({ strapi, nexus }) => {
+		const types = getTypes({ strapi, nexus, config });
+		const queries = getQueries({ strapi, nexus, config });
+		const mutations = getMutations({ strapi, nexus, config });
+		const resolversConfig = getResolversConfig({ strapi, config });
 
 		return {
 			types: [types, queries, mutations],

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,9 +1,7 @@
 'use strict'
 
-const { getPluginService } = require("../utils/functions");
-
-module.exports = () => {
-	const auth = getPluginService('common').getConfig('gql.auth', false);
+module.exports = ({ config }) => {
+	const { gql: { auth = false } = {}} = config;
 	return {
 		'Query.findAllFlat': { auth },
 		'Query.findAllInHierarchy': { auth },

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

@@ -6,6 +6,7 @@ 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("author", { type: 'CommentAuthor' })

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

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

package/server/register.js

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

package/server/routes/admin.js

@@ -89,4 +89,28 @@ module.exports = [
       policies: [],
     },
   },
+  {
+    method: 'GET',
+    path: '/settings/config',
+    handler: 'admin.settingsConfig',
+    config: {
+      policies: [],
+    },
+  },
+  {
+    method: 'PUT',
+    path: '/settings/config',
+    handler: 'admin.settingsUpdateConfig',
+    config: {
+      policies: [],
+    },
+  },
+  {
+    method: 'DELETE',
+    path: '/settings/config',
+    handler: 'admin.settingsRestoreConfig',
+    config: {
+      policies: [],
+    },
+  },
 ];

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

@@ -0,0 +1,246 @@
+const { CONFIG_PARAMS } = require('../../utils/constants');
+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 store', () => {
+    beforeEach(() => setup());
+
+    test('Should return store', async () => {
+      const pluginStore = await getPluginService('common').getPluginStore();
+      expect(pluginStore).toHaveProperty('get');
+      expect(pluginStore).toHaveProperty('set');
+      expect(pluginStore).toHaveProperty('delete');
+    });
+  });
+
+  describe('Get plugin config', () => {
+    describe('Local config', () => {
+      beforeEach(() => setup({
+        test: 'sample',
+      }));
+  
+      test('Should return config value', async () => {
+        const result = await getPluginService('common').getConfig('test');
+        expect(result).toEqual('sample');
+      });
+  
+      test('Should return default config prop value if not set', async () => {
+        const result = await getPluginService('common').getConfig('another', 'defaultValue');
+        expect(result).toEqual('defaultValue');
+      });
+    });
+
+    describe('Store config', () => {
+      beforeEach(() => setup({
+        test: 'sample',
+      }, true));
+  
+      test('Should return config value', async () => {
+        const result = await getPluginService('common').getConfig('test');
+        expect(result).toEqual('sample');
+      });
+  
+      test('Should return default config prop value if not set', async () => {
+        const result = await getPluginService('common').getConfig('another', 'defaultValue');
+        expect(result).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', async () => {
+      expect.assertions(7);
+      try {
+        await getPluginService('common').checkBadWords(text);
+      } catch (e) {
+        expect(await 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', async () => {
+      expect(await getPluginService('common').getConfig('badWords')).toEqual(false);
+      expect(await getPluginService('common').checkBadWords(text)).toEqual(text);
+    });
+  });
+
+  describe('Parse relation string (store config)', () => {
+    const [uid, id] = ['api::my-collection.my-content-type', '1'];
+    const validCollection = `${uid}:${id}`;
+
+    const [wrongUid, wrongId] = ['api::wrong.type', '2'];
+    const testCollection = `${wrongUid}:${wrongId}`;
+
+    describe('Store config', () => {
+      beforeEach(() => setup({ enabledCollections: [uid] }, true));
+
+      test('Should pass', async () => {
+        expect(await getPluginService('common').parseRelationString(validCollection));
+        expect(await getPluginService('common').getConfig(CONFIG_PARAMS.ENABLED_COLLECTIONS)).toContain(uid);
+      });
+  
+      test('Should fail with 403', async () => {
+  
+        try {
+          await getPluginService('common').parseRelationString(testCollection);
+        } catch(e) {
+          expect(await getPluginService('common').getConfig(CONFIG_PARAMS.ENABLED_COLLECTIONS)).toContain(uid);
+          expect(await getPluginService('common').getConfig(CONFIG_PARAMS.ENABLED_COLLECTIONS)).not.toContain(wrongUid);
+          expect(e).toBeInstanceOf(PluginError);
+          expect(e).toHaveProperty('status', 403);
+        }
+      });
+    });
+
+    describe('Local config', () => {
+      beforeEach(() => setup({ enabledCollections: [uid] }));
+
+      test('Should pass', async () => {
+        expect(await getPluginService('common').parseRelationString(validCollection));
+        expect(await getPluginService('common').getConfig(CONFIG_PARAMS.ENABLED_COLLECTIONS)).toContain(uid);
+      });
+  
+      test('Should fail with 403', async () => {
+  
+        try {
+          await getPluginService('common').parseRelationString(testCollection);
+        } catch(e) {
+          expect(await getPluginService('common').getConfig(CONFIG_PARAMS.ENABLED_COLLECTIONS)).toContain(uid);
+          expect(await getPluginService('common').getConfig(CONFIG_PARAMS.ENABLED_COLLECTIONS)).not.toContain(wrongUid);
+          expect(e).toBeInstanceOf(PluginError);
+          expect(e).toHaveProperty('status', 403);
+        }
+      });
+    });
+  });
+});

package/server/services/admin.js

@@ -21,19 +21,73 @@ 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,
+    async config(viaSettingsPage = false) {
+        const pluginStore = await this.getCommonService().getPluginStore();
+        const config = await pluginStore.get({ key: 'config' });
+        const additionalConfiguration = {
             regex: Object.keys(REGEX).reduce((prev, curr) => ({
                 ...prev,
                 [curr]: REGEX[curr].toString(),
             }), {}),
         };
+
+        const isGQLPluginEnabled = !isNil(strapi.plugin('graphql'));
+
+        if (config) {
+            return {
+                ...config,
+                ...additionalConfiguration,
+                isGQLPluginEnabled: viaSettingsPage ? isGQLPluginEnabled : undefined,
+            };
+        }
+
+        const entryLabel = this.getCommonService().getLocalConfig('entryLabel');
+        const approvalFlow = this.getCommonService().getLocalConfig('approvalFlow');
+        const reportReasons = this.getCommonService().getLocalConfig('reportReasons');
+        const result = {
+            entryLabel,
+            approvalFlow,
+            reportReasons,
+            ...additionalConfiguration,
+        };
+
+        if (viaSettingsPage) {
+            const enabledCollections = this.getCommonService().getLocalConfig('enabledCollections');
+            const moderatorRoles = this.getCommonService().getLocalConfig('moderatorRoles');
+            return {
+                ...result,
+                enabledCollections,
+                moderatorRoles,
+                isGQLPluginEnabled,
+            };
+        }
+
+        return result;
     },
 
+    async updateConfig(body) {
+        const pluginStore = await this.getCommonService().getPluginStore();
+    
+        await pluginStore.set({ key: 'config', value: body });
+    
+        return this.config();
+      },
+    
+      async restoreConfig() {
+        const pluginStore = await this.getCommonService().getPluginStore();
+        const defaultConfig = this.getCommonService().getLocalConfig();
+    
+        await pluginStore.delete({key: 'config'})
+        await pluginStore.set({
+            key: 'config',
+            value: {
+                ...defaultConfig,
+            }
+        });
+    
+        return this.config();
+      },
+
     // Find all comments
     async findAll({ related, entity, ...query }) {
         const { _q, orderBy, pageSize = 10, page = 1, filters, ...rest } = parseParams(query);

package/server/services/client.js

@@ -8,10 +8,9 @@ const {
     isEqualEntity,
     getModelUid,
     getRelatedGroups,
-    checkBadWords,
     resolveUserContextError,
 } = require('./utils/functions');
-const { APPROVAL_STATUS, REGEX } = require('./../utils/constants')
+const { APPROVAL_STATUS, REGEX, CONFIG_PARAMS } = require('./../utils/constants')
 
 /**
  * Comments Plugin - Client services
@@ -32,16 +31,14 @@ 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 isApprovalFlowEnabled = await this.getCommonService().getConfig(CONFIG_PARAMS.APPROVAL_FLOW, []).includes(uid) ||
             relatedEntity.requireCommentsApproval;
 
         const linkToThread = !isNil(threadOf) ? await this.getCommonService().findOne({
@@ -58,7 +55,7 @@ module.exports = ({ strapi }) => ({
             throw resolveUserContextError(user);
         }
 
-        if (checkBadWords(content) && singleRelationFulfilled) {
+        if (await this.getCommonService().checkBadWords(content) && singleRelationFulfilled) {
             const { author = {}, ...rest } = data;
             let authorData = {};
             if (validContext && user) {
@@ -116,6 +113,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,
@@ -128,7 +127,7 @@ module.exports = ({ strapi }) => ({
         }
 
         if (isEqualEntity(existingEntity, data, user) && content) {
-            if (checkBadWords(content)) {
+            if (await this.getCommonService().checkBadWords(content)) {
                 const entity = await strapi.db.query(getModelUid('comment')).update({
                     where: { id },
                     data: { content },
@@ -145,6 +144,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,
@@ -186,6 +188,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 ? {
@@ -217,7 +221,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({