strapi-plugin-comments 2.0.2 → 2.0.3

package/admin/src/utils/index.js

@@ -7,4 +7,5 @@ export { default as getRelatedGroups } from './getRelatedGroups';
 export { default as renderEntryTitle } from './renderEntryTitle';
 export { default as renderInitials } from './renderInitials';
 export { default as resolveCommentStatus } from './resolveCommentStatus';
-export { default as resolveCommentStatusColor } from './resolveCommentStatusColor';
+export { default as resolveCommentStatusColor } from './resolveCommentStatusColor';
+export { default as parseRegExp } from './parseRegExp';

package/admin/src/utils/parseRegExp.js

@@ -0,0 +1,10 @@
+
+const parseRegExp = (regexpString) => {
+    const [value, flags] = regexpString.split('/').filter(_ => _.length > 0);
+    return {
+        value,
+        flags,
+    };
+}
+
+export default parseRegExp;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strapi-plugin-comments",
-  "version": "2.0.2",
+  "version": "2.0.3",
   "description": "Strapi - Comments plugin",
   "strapi": {
     "name": "comments",
@@ -9,6 +9,7 @@
     "kind": "plugin"
   },
   "scripts": {
+    "prepare": "husky install",
     "publish": "npm publish --tag latest",
     "test:unit": "jest --verbose --coverage"
   },
@@ -26,14 +27,16 @@
     "jest": "^26.0.1",
     "jest-cli": "^26.0.1",
     "jest-styled-components": "^7.0.2",
-    "koa": "2.13.3"
+    "koa": "2.13.3",
+    "husky": "7.0.4",
+    "prettier": "2.5.1"
   },
   "peerDependencies": {
     "@strapi/strapi": "4.x"
   },
   "author": {
-    "name": "VirtusLab // Mateusz Ziarko",
-    "email": "mziarko@virtuslab.com",
+    "name": "VirtusLab",
+    "email": "strapi@virtuslab.com",
     "url": "https://virtuslab.com"
   },
   "maintainers": [

package/server/bootstrap.js

@@ -1,8 +1,20 @@
 'use strict';
 
+const { isEmpty } = require('lodash');
 const permissions = require('./../permissions');
+const { getPluginService } = require('./utils/functions');
 
 module.exports = async ({ strapi }) => {
+
+  // Provide GQL support
+  if (strapi.plugin('graphql')) {
+    const config = await getPluginService('common').getConfig();
+    const { enabledCollections } = config;
+    if (!isEmpty(enabledCollections)) {
+      await require('./graphql')({ strapi, config });
+    }
+  }
+
   // 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(
@@ -35,6 +47,18 @@ module.exports = async ({ strapi }) => {
       uid: permissions.reports.action,
       pluginName: "comments",
     },
+    {
+      section: "plugins",
+      displayName: "Settings: Read",
+      uid: permissions.settings.read,
+      pluginName: "comments",
+    },
+    {
+      section: "plugins",
+      displayName: "Settings: Change",
+      uid: permissions.settings.change,
+      pluginName: "comments",
+    },
   ];
 
   await strapi.admin.services.permission.actionProvider.registerMany(actions);

package/server/config/index.js

@@ -2,6 +2,7 @@
 
 module.exports = {
   default: {
+    enabledCollections: [],
     moderatorRoles: [],
     approvalFlow: [],
     entryLabel: {

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/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/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/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

@@ -1,3 +1,4 @@
+const { CONFIG_PARAMS } = require('../../utils/constants');
 const PluginError = require('../../utils/error');
 const { getPluginService } = require('../../utils/functions');
 
@@ -16,18 +17,48 @@ afterEach(() => {
 })
 
 describe('Test Comments service functions utils', () => {
+  describe('Get plugin store', () => {
+    beforeEach(() => setup());
 
-  describe('Get plugin config', () => {
-    beforeEach(() => setup({
-      test: 'sample',
-    }));
+    test('Should return store', async () => {
+      const pluginStore = await getPluginService('common').getPluginStore();
+      expect(pluginStore).toHaveProperty('get');
+      expect(pluginStore).toHaveProperty('set');
+      expect(pluginStore).toHaveProperty('delete');
+    });
+  });
 
-    test('Should return config value', () => {
-      expect(getPluginService('common').getConfig('test')).toEqual('sample');
+  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');
+      });
     });
 
-    test('Should return default config prop value if not set', () => {
-      expect(getPluginService('common').getConfig('another', 'defaultValue')).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');
+      });
     });
   });
 
@@ -131,12 +162,12 @@ describe('Test Comments service functions utils', () => {
 
     const text = 'Lorem ipsum dolor sit fuck amet';
 
-    test('Should find bad words usage and throw error PluginError', () => {
+    test('Should find bad words usage and throw error PluginError', async () => {
       expect.assertions(7);
       try {
-        getPluginService('common').checkBadWords(text);
+        await getPluginService('common').checkBadWords(text);
       } catch (e) {
-        expect(getPluginService('common').getConfig('badWords')).toEqual(undefined);
+        expect(await getPluginService('common').getConfig('badWords')).toEqual(undefined);
         expect(e).toBeInstanceOf(PluginError);
         expect(e).toHaveProperty('status', 400);
         expect(e).toHaveProperty('name', 'Strapi:Plugin:Comments');
@@ -157,9 +188,59 @@ describe('Test Comments service functions utils', () => {
 
     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);
+    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

@@ -10,7 +10,7 @@ const {
     getRelatedGroups,
     resolveUserContextError,
 } = require('./utils/functions');
-const { APPROVAL_STATUS, REGEX } = require('./../utils/constants')
+const { APPROVAL_STATUS, REGEX, CONFIG_PARAMS } = require('./../utils/constants')
 
 /**
  * Comments Plugin - Client services
@@ -31,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({
@@ -57,7 +55,7 @@ module.exports = ({ strapi }) => ({
             throw resolveUserContextError(user);
         }
 
-        if (this.getCommonService().checkBadWords(content) && singleRelationFulfilled) {
+        if (await this.getCommonService().checkBadWords(content) && singleRelationFulfilled) {
             const { author = {}, ...rest } = data;
             let authorData = {};
             if (validContext && user) {
@@ -115,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,
@@ -127,7 +127,7 @@ module.exports = ({ strapi }) => ({
         }
 
         if (isEqualEntity(existingEntity, data, user) && content) {
-            if (this.getCommonService().checkBadWords(content)) {
+            if (await this.getCommonService().checkBadWords(content)) {
                 const entity = await strapi.db.query(getModelUid('comment')).update({
                     where: { id },
                     data: { content },
@@ -144,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,
@@ -185,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 ? {
@@ -216,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({

package/server/services/common.js

@@ -1,8 +1,8 @@
 'use strict';
 
 const BadWordsFilter = require('bad-words');
-const { isArray, isNumber, isObject, isNil, isString, first, parseInt, set } = require('lodash');
-const { REGEX } = require('../utils/constants');
+const { isArray, isNumber, isObject, isNil, isString, first, parseInt, set, get } = require('lodash');
+const { REGEX, CONFIG_PARAMS } = require('../utils/constants');
 const PluginError = require('./../utils/error');
 const {
     getModelUid,
@@ -10,6 +10,7 @@ const {
     buildNestedStructure,
     filterOurResolvedReports,
     buildAuthorModel,
+    buildConfigQueryProp,
 } = require('./utils/functions');
 
 /**
@@ -18,11 +19,26 @@ const {
 
 module.exports = ({ strapi }) => ({
 
-    getConfig(prop, defaultValue) {
-        let queryProp = prop;
-        if (prop && isArray(prop)) {
-            queryProp = prop.join('.');
+    async getConfig(prop, defaultValue, useLocal = false) {
+        const queryProp = buildConfigQueryProp(prop);
+        const pluginStore = await this.getPluginStore();
+        const config = await pluginStore.get({ key: 'config' });
+
+        let result;
+        if (config && !useLocal) {
+            result = queryProp ? get(config, queryProp) : config;;
+        } else {
+            result = this.getLocalConfig(queryProp, defaultValue);
         }
+        return isNil(result) ? defaultValue : result;
+    },
+
+    async getPluginStore() {
+        return strapi.store({ type: 'plugin', name: 'comments' });
+    },
+
+    getLocalConfig(prop, defaultValue) {
+        const queryProp = buildConfigQueryProp(prop);
         const result = strapi.config.get(`plugin.comments${ queryProp ? '.' + queryProp : ''}`);
         return isNil(result) ? defaultValue : result;
     },
@@ -124,7 +140,7 @@ module.exports = ({ strapi }) => ({
                 },
             });
         if (!entity){
-            throw new PluginError(404, 'Not found');
+            throw new PluginError(404, 'Comment does not exist. Check your payload please.');
         }
         return filterOurResolvedReports(this.sanitizeCommentEntity(entity));
     },
@@ -202,8 +218,20 @@ module.exports = ({ strapi }) => ({
         return user ? !isNil(user?.id) : true;
     },
 
-    checkBadWords(content) {
-        const config = this.getConfig('badWords', true);
+    async parseRelationString(relation) {
+        const [ uid, relatedStringId ] = getRelatedGroups(relation);
+        const parsedRelatedId = parseInt(relatedStringId);
+        const relatedId = isNumber(parsedRelatedId) ? parsedRelatedId : relatedStringId;
+
+        const enabledCollections = await this.getConfig(CONFIG_PARAMS.ENABLED_COLLECTIONS, []);
+        if (!enabledCollections.includes(uid)) {
+            throw new PluginError(403, `Action not allowed for collection '${uid}'. Use one of: ${ enabledCollections.join(', ') }`);
+        }
+        return [ uid, relatedId];
+    },
+
+    async checkBadWords(content) {
+        const config = await this.getConfig(CONFIG_PARAMS.BAD_WORDS, true);
         if (config) {
             const filter = new BadWordsFilter(isObject(config) ? config : undefined);
             if (content && filter.isProfane(content)) {

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

@@ -1,5 +1,5 @@
 const PluginError = require('../../../utils/error');
-const { resolveUserContextError, getModelUid } = require('../functions');
+const { resolveUserContextError, getModelUid, buildConfigQueryProp } = require('../functions');
 
 beforeEach(() => {
   Object.defineProperty(global, 'strapi', {
@@ -39,4 +39,15 @@ describe('Test service functions utils', () => {
       }
     });
   });
+
+  describe('Building config query props', () => {
+    test('Should return prop as is', () => {
+      expect(buildConfigQueryProp('my.sample.prop')).toBe('my.sample.prop');
+    });
+
+    test('Should build query prop with \'.\'', () => {
+      expect(buildConfigQueryProp(['my', 'sample', 'prop'])).toBe('my.sample.prop');
+    });
+  });
+  
 });