strapi-plugin-comments 2.0.2 → 2.0.6

package/server/controllers/admin.js

@@ -10,6 +10,48 @@ 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 settingsRestart(ctx) {
+    try {
+      await this.getService().restart();
+      return ctx.send({ status: 200 });
+    } catch (e) {
+      throwError(ctx, e);
+    }
+  },
+
   async findAll(ctx) {
     return this.getService()
       .findAll(ctx.query);
@@ -101,14 +143,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

@@ -13,9 +13,15 @@ module.exports = {
   async findAllFlat(ctx) {
     const { params = {}, query, sort, pagination } = ctx;
     const { relation } = parseParams(params);
+
+    const { sort: querySort, pagination: queryPagination, ...filterQuery } = query || {};
+
+
+console.log(filterQuery);
+
     try {
       return this.getService('common')
-        .findAllFlat(flatInput(relation, query, sort, pagination));
+        .findAllFlat(flatInput(relation, filterQuery, sort || querySort, pagination || queryPagination));
     } catch (e) {
       throwError(ctx, e);
     }
@@ -24,10 +30,13 @@ module.exports = {
   async findAllInHierarchy(ctx) {
     const { params = {}, query, sort } = ctx;
     const { relation } = parseParams(params);
+
+    const { sort: querySort, ...filterQuery } = query || {};
+
     try {
       return await this.getService('common')
         .findAllInHierarchy({
-          ...flatInput(relation, query, sort),
+          ...flatInput(relation, filterQuery, sort || querySort),
           dropBlockedThreads: true,
         });
     } catch (e) {

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

@@ -0,0 +1,94 @@
+const { flatInput } = require('../parsers');
+
+jest.mock
+
+describe('Test Comments controller parsers utils', () => {
+  
+  describe('Flat Input properties', () => {
+    const relation = 'api::test.relation';
+    const filters = {
+      content: {
+        '$eq': 'Test'
+      }
+    };
+    const sort = {
+      createdAt: 'desc'
+    };
+    const pagination = {
+      page: 3,
+      pageSize: 5,
+    };
+
+    test('Should contain default property \'populate\'', () => {
+      expect(flatInput()).toHaveProperty(['populate', 'threadOf', 'populate', 'authorUser'], true);
+    });
+
+    test('Should assign relation to \'query\'', () => {
+      expect(flatInput(relation)).toHaveProperty(['query', 'related'], relation);
+    });
+
+    test('Should assign filters to \'query\'', () => {
+      const result = flatInput(relation, filters);
+      expect(result).toHaveProperty(['query', 'content', '$eq'], filters.content['$eq']);
+    });
+
+    test('Should assign not allow to overwrite \'removed\' in $or operator', () => {
+      const overwrittenOrOperator = {
+        $or: [{ removed: true }, { removed: false }, { removed: null }]
+      };
+      const result = flatInput(relation, overwrittenOrOperator);
+      expect(result).toHaveProperty(['query', '$or', 0, 'removed', '$null'], true);
+      expect(result).toHaveProperty(['query', '$or', 1, 'removed'], false);
+    });
+
+    test('Should assign sort', () => {
+      const result = flatInput(relation, filters, sort);
+      expect(result).toHaveProperty(['sort', 'createdAt'], sort.createdAt);
+    });
+
+    test('Should assign pagination', () => {
+      const result = flatInput(relation, filters, sort, pagination);
+      expect(result).toHaveProperty(['pagination', 'page'], pagination.page);
+      expect(result).toHaveProperty(['pagination', 'pageSize'], pagination.pageSize);
+    });
+
+    test('Should build complex output', () => {
+      const day = 24 * 60 * 60 * 1000;
+      const now = Date.now().toString();
+      const oneDayBefore = new Date(Date.now().valueOf() - day).toString();
+      const complexFilters = {
+        '$or': [{
+          createdAt: {
+            '$lte':  oneDayBefore
+          }
+        }, {
+          createdAt: {
+            '$eq':  now
+          }
+        }],
+        content: {
+          '$contains': 'Test'
+        }
+      };
+
+      const complexSort = [{
+        createdAt: 'desc'
+      }, {
+        title: 'asc'
+      }];
+
+      const result = flatInput(relation, complexFilters, complexSort, pagination);
+
+      expect(result).toHaveProperty(['query', 'related'], relation);
+      expect(result).toHaveProperty(['query', '$or', 0, 'createdAt', '$lte'], oneDayBefore);
+      expect(result).toHaveProperty(['query', '$or', 1, 'createdAt', '$eq'], now);
+      expect(result).toHaveProperty(['query', '$or', 2, 'removed', '$null'], true);
+      expect(result).toHaveProperty(['query', '$or', 3, 'removed'], false);
+      expect(result).toHaveProperty(['query', 'content', '$contains'], complexFilters.content['$contains']);
+      expect(result).toHaveProperty(['sort', 0, 'createdAt'], complexSort[0].createdAt);
+      expect(result).toHaveProperty(['sort', 1, 'title'], complexSort[1].title);
+      expect(result).toHaveProperty(['pagination', 'page'], pagination.page);
+      expect(result).toHaveProperty(['pagination', 'pageSize'], pagination.pageSize);
+    });
+  });
+});

package/server/controllers/utils/parsers.js

@@ -2,20 +2,22 @@
 
 module.exports = {
     flatInput(relation, query, sort, pagination) {
-        return {
-            query: {
-              ...query,
-              $or: [{ removed: { $null: true } }, { removed: false }],
-              related: relation,
+      const filters = query?.filters || query;
+      const orOperator = (filters?.$or || []).filter(_ => !Object.keys(_).includes('removed'));
+      return {
+          query: {
+            ...filters,
+            $or: [...orOperator, { removed: { $null: true } }, { removed: false }],
+            related: relation,
+          },
+          populate: {
+            threadOf: {
+              populate: { authorUser: true },
             },
-            populate: {
-              threadOf: {
-                populate: { authorUser: true },
-              },
-            },
-            pagination,
-            sort,
-          };
+          },
+          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

@@ -10,7 +10,7 @@ module.exports = ({ strapi, nexus }) => {
 	const { args } = getService('internals');
 
 	return {
-		type: nonNull(list('CommentSingle')),
+		type: 'ResponseFindAll',
 		args: {
 			relation: nonNull(stringArg()),
 			filters: getPluginService('gql').buildContentTypeFilters(contentType),

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/index.js

@@ -11,6 +11,9 @@ const typesFactories = [
 	require('./report'),
 	require('./report-reason'),
 	require('./create-report'),
+	require('./response-pagination'),
+	require('./response-meta'),
+	require('./response-find-all'),
 ];
 
 module.exports = context => typesFactories.map(factory => factory(context));

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/graphql/types/response-find-all.js

@@ -0,0 +1,7 @@
+module.exports = ({ nexus }) => nexus.objectType({
+  name: "ResponseFindAll",
+  definition(t) {
+    t.list.field("data", { type: 'CommentSingle' })
+    t.field("meta", { type: 'ResponseMeta' })
+  }
+})

package/server/graphql/types/response-meta.js

@@ -0,0 +1,6 @@
+module.exports = ({ nexus }) => nexus.objectType({
+  name: "ResponseMeta",
+  definition(t) {
+    t.field("pagination", { type: 'ResponsePagination' })
+  }
+})

package/server/graphql/types/response-pagination.js

@@ -0,0 +1,11 @@
+module.exports = ({ nexus }) => nexus.objectType({
+  name: "ResponsePagination",
+  definition(t) {
+    t.int('page')
+    t.int('pageSize')
+    t.int('pageCount')
+    t.int('total')
+    t.int('start')
+    t.int('limit')
+  }
+})

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,36 @@ 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: [],
+    },
+  },
+  {
+    method: 'GET',
+    path: '/settings/restart',
+    handler: 'admin.settingsRestart',
+    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,17 +21,68 @@ 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();
+
+        await pluginStore.delete({key: 'config'})
+    
+        return this.config();
+      },
+
+    async restart() {
+        setImmediate(() => strapi.reload());
     },
 
     // Find all comments