strapi-plugin-comments 2.0.11 → 2.1.1

package/server/services/common.js

@@ -1,295 +0,0 @@
-'use strict';
-
-const BadWordsFilter = require('bad-words');
-const { isArray, isNumber, isObject, isNil, isString, isEmpty, first, parseInt, set, get } = require('lodash');
-const { REGEX, CONFIG_PARAMS } = require('../utils/constants');
-const PluginError = require('./../utils/error');
-const {
-    getModelUid,
-    getRelatedGroups,
-    buildNestedStructure,
-    filterOurResolvedReports,
-    buildAuthorModel,
-    buildConfigQueryProp,
-} = require('./utils/functions');
-
-/**
- * Comments Plugin - common services
- */
-
-module.exports = ({ strapi }) => ({
-
-    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, defaultValue) : 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;
-    },
-
-    // Find comments in the flat structure
-    async findAllFlat({ 
-        query = {}, 
-        populate = {}, 
-        sort, 
-        pagination }, relatedEntity = null) {
-
-        const defaultPopulate = {
-            authorUser: true,
-        };
-
-        let queryExtension = {};
-
-        if (sort && (isString(sort) || isArray(sort))) {
-            queryExtension = {
-                ...queryExtension,
-                orderBy: (isString(sort) ? [sort] : sort)
-                .map(_ => REGEX.sorting.test(_) ? _ : `${_}:asc`)
-                .reduce((prev, curr) => {
-                    const [type = 'asc', ...parts] = curr.split(':').reverse();
-                    return { ...set(prev, parts.reverse().join('.'), type) };
-                }, {})
-            };
-        }
-
-        let meta = {};
-        if (pagination && isObject(pagination)) {
-            const parsedPagination = Object.keys(pagination).reduce((prev, curr) => ({
-                ...prev,
-                [curr]: parseInt(pagination[curr]),
-            }), {});
-            const { page = 1, pageSize = 10, start = 0, limit = 10 } = parsedPagination;
-            const paginationByPage = !isNil(parsedPagination?.page) || !isNil(parsedPagination?.pageSize);
-
-            queryExtension = {
-                ...queryExtension,
-                offset: paginationByPage ? (page - 1) * pageSize : start,
-                limit: paginationByPage ? pageSize : limit,
-            };
-
-            const metaPagination = paginationByPage ? {
-                pagination: {
-                    page,
-                    pageSize,
-                },
-            } : {
-                pagination: {
-                    start,
-                    limit,
-                },
-            };
-
-            meta = {
-                ...metaPagination,
-            };
-        }
-        
-        const entries = await strapi.db.query(getModelUid('comment'))
-        .findMany({
-            where: {
-                ...query,
-            },
-            populate: {
-                ...defaultPopulate,
-                ...populate,
-            },
-            ...queryExtension,
-        });
-
-        if (pagination?.withCount && (pagination.withCount === 'true' || pagination.withCount === true)) {
-            const total = await strapi.db.query(getModelUid('comment'))
-                .count({
-                    where: {
-                        ...query,
-                    }
-                });
-            const pageCount = Math.floor(total / meta.pagination.pageSize);
-            meta = {
-                ...meta,
-                pagination: {
-                    ...meta.pagination,
-                    pageCount: !isNil(meta.pagination.page) ? 
-                        total % meta.pagination.pageSize === 0 ? pageCount : pageCount + 1 : 
-                        undefined,
-                    total,
-                },
-            };
-        }
-
-        const entriesWithThreads = await Promise.all(entries.map(async _ => {
-            const [nestedEntries, count] = await strapi.db.query(getModelUid('comment'))
-                .findWithCount({ 
-                    where: {
-                        threadOf: _.id
-                    }
-                 })
-            return { id: _.id, itemsInTread: count, firstThreadItemId: first(nestedEntries)?.id }
-        }));
-
-        const relatedEntities = relatedEntity !== null ? [relatedEntity] : await this.findRelatedEntitiesFor([...entries]);
-        const hasRelatedEntitiesToMap = relatedEntities.filter(_ => _).length > 0;
-
-        const result = entries
-            .map(_ => {
-                const threadedItem = entriesWithThreads.find(item => item.id === _.id);
-                return this.sanitizeCommentEntity({
-                    ..._,
-                    threadOf: query.threadOf || _.threadOf || null,
-                    gotThread: (threadedItem?.itemsInTread || 0) > 0,
-                    threadFirstItemId: threadedItem?.firstThreadItemId,
-                });
-            });
-
-        return {
-            data: hasRelatedEntitiesToMap ?
-                result.map(_ => this.mergeRelatedEntityTo(_, relatedEntities)) :
-                result,
-            ...(isEmpty(meta) ? {} : { meta }),
-        };   
-    },
-
-    // Find comments and create relations tree structure
-    async findAllInHierarchy ({
-        query,
-        populate = {},
-        sort,
-        startingFromId = null,
-        dropBlockedThreads = false,
-    }, relatedEntity) {
-        const entities = await this.findAllFlat({ query, populate, sort }, relatedEntity);
-        return buildNestedStructure(entities?.data, startingFromId, 'threadOf', dropBlockedThreads, false);
-    },
-
-    // Find single comment
-    async findOne(criteria) {
-        const entity = await strapi.db.query(getModelUid('comment'))
-            .findOne({
-                where: criteria,
-                populate: {
-                    reports: true,
-                    authorUser: true,
-                },
-            });
-        if (!entity){
-            throw new PluginError(404, 'Comment does not exist. Check your payload please.');
-        }
-        return filterOurResolvedReports(this.sanitizeCommentEntity(entity));
-    },
-
-    // Find all related entiries
-    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] || []), relatedId]
-                };
-            },
-            {}
-        );
-        return Promise.all(
-            Object.entries(data)
-            .map(async ([relatedUid, relatedStringIds]) => 
-                strapi.db.query(relatedUid).findMany({ 
-                    where: { id: Array.from(new Set(relatedStringIds)) },
-                }).then(relatedEntities => relatedEntities.map(_ => 
-                    ({
-                        ..._,
-                        uid: relatedUid,
-                    })
-                ))
-            )
-        )
-        .then(result => result.flat(2));
-    },
-
-    // Merge related entity with comment
-    mergeRelatedEntityTo(entity, relatedEntities = []) {
-        return {
-            ...entity,
-            related: relatedEntities.find(relatedEntity => entity.related === `${relatedEntity.uid}:${relatedEntity.id}`)
-        };
-    },
-
-    async modifiedNestedNestedComments(id, fieldName, value) {
-        try {
-            const entitiesToChange = await strapi.bd.query(getModelUid('comment'))
-                .findMany({
-                    where: { threadOf: id }
-                });
-            const changedEntities = await strapi.bd.query(getModelUid('comment'))
-                .updateMany({
-                    where: { id: entitiesToChange.map(_ => _.id) },
-                    data: { [fieldName]: value }
-                });
-            if ((entitiesToChange.length === changedEntities.length) && (changedEntities.length > 0)) {
-                const nestedTransactions = await Promise.all(
-                  changedEntities.map(item => this.modifiedNestedNestedComments(item.id, fieldName, value))
-                );
-                return nestedTransactions.length === changedEntities.length;
-            }
-            return true;
-        } catch (e) {
-            return false;
-        }
-    },
-
-    sanitizeCommentEntity(entity) {
-        return {
-            ...buildAuthorModel({
-                ...entity,
-                threadOf: isObject(entity.threadOf) ? buildAuthorModel(entity.threadOf) : entity.threadOf,
-            }),
-        };
-    },
-
-    isValidUserContext(user) {
-        return user ? !isNil(user?.id) : 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)) {
-                throw new PluginError(400, 'Bad language used! Please polite your comment...', {
-                    content: {
-                        original: content,
-                        filtered: content && filter.clean(content),
-                    },
-                });
-            }
-        }
-        return content;
-    },
-});

package/server/services/index.js

@@ -1,13 +0,0 @@
-'use strict';
-
-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/__tests__/functions.test.js

@@ -1,53 +0,0 @@
-const PluginError = require('../../../utils/error');
-const { resolveUserContextError, getModelUid, buildConfigQueryProp } = require('../functions');
-
-beforeEach(() => {
-  Object.defineProperty(global, 'strapi', {
-    value: require('../../../../__mocks__/initSetup')(),
-    writable: true,
-  });
-})
-
-describe('Test service functions utils', () => {
-
-  describe('Getting models uid\'s ', () => {
-    test('Should get comments uid', () => {
-      expect(getModelUid('comment')).toBe('plugins::comments.comment');
-    });
-
-    test('Should get report uid', () => {
-      expect(getModelUid('comment-report')).toBe('plugins::comments.comment-report');
-    });
-  });
-
-  describe('Resolve user context error', () => {
-    test('Should throw 401', () => {
-      try {
-        resolveUserContextError({ id: 1 });
-      } catch (e) {
-        expect(e).toBeInstanceOf(PluginError);
-        expect(e).toHaveProperty('status', 401);
-      }
-    });
-
-    test('Should throw 403', () => {
-      try {
-        resolveUserContextError();
-      } catch (e) {
-        expect(e).toBeInstanceOf(PluginError);
-        expect(e).toHaveProperty('status', 403);
-      }
-    });
-  });
-
-  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');
-    });
-  });
-  
-});

package/server/services/utils/functions.js

@@ -1,112 +0,0 @@
-const PluginError = require('./../../utils/error');
-const { REGEX } = require('./../../utils/constants')
-const { first, isObject, isArray, isEmpty } = require('lodash');
-
-const buildNestedStructure = (
-  entities,
-  id = null,
-  field = 'threadOf',
-  dropBlockedThreads = false,
-  blockNestedThreads = false,
-) =>
-  entities
-    .filter(entity => {
-        // mongo by default not return `null` for empty data
-        if (entity[field] === null && id === null) {
-            return true;
-        }
-        let data = entity[field];
-        if (data && typeof id === 'string') {
-            data = data.toString();
-        }
-        return (data && data === id) || (isObject(entity[field]) && (entity[field].id === id));
-    })
-    .map(entity => ({
-        ...entity,
-        [field]: undefined,
-        related: undefined,
-        blockedThread: blockNestedThreads || entity.blockedThread,
-        children: entity.blockedThread && dropBlockedThreads ? [] : buildNestedStructure(entities, entity.id, field,
-        dropBlockedThreads, entity.blockedThread),
-    }));
-
-module.exports = {
-    isEqualEntity: (existing, data, user) => {
-        const { author: existingAuthor } = existing;
-        const { author } = data;
-
-        // Disallow approval status change by Client
-        if (data.approvalStatus && (existing.approvalStatus !== data.approvalStatus)) {
-            return false;
-        }
-
-        // Make sure that author is exact the same
-        if (user) {
-            const existingUserId = existingAuthor?.id || existingAuthor;
-            const receivedUserId = user?.id || author?.id;
-            return receivedUserId && (existingUserId === receivedUserId);
-        }
-        return existingAuthor.id === author?.id;
-    },
-
-    getRelatedGroups: related => related.split(REGEX.relatedUid).filter(s => s && s.length > 0),
-
-    getModelUid: name => {
-        return strapi
-            .plugin('comments')
-            .contentTypes[name]?.uid;
-    },
-
-    filterOurResolvedReports: item => (item ? {
-        ...item,
-        reports: (item.reports || []).filter(report => !report.resolved),
-    } : item),
-
-    convertContentTypeNameToSlug: str => {
-        const plainConversion = str.replace(/[A-Z]/g, letter => `-${letter.toLowerCase()}`);
-        return first(plainConversion) === '-' ? plainConversion.slice(1, plainConversion.length) : plainConversion;
-    },
-
-    buildNestedStructure,
-
-    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,
-        };
-    },
-
-    buildConfigQueryProp(prop) {
-        let queryProp = prop;
-        if (prop && isArray(prop)) {
-            queryProp = prop.join('.');
-        }
-        return queryProp;
-    },
-
-    resolveUserContextError: user => {
-        if (user) {
-            throw new PluginError(401, 'Not authenticated');
-        } else {
-            throw new PluginError(403, 'Not authorized');
-        }
-    },
-};
-

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

@@ -1,17 +0,0 @@
-const { getPluginService } = require('../functions');
-
-beforeEach(() => {
-  Object.defineProperty(global, 'strapi', {
-    value: require('../../../__mocks__/initSetup')(),
-    writable: true,
-  });
-})
-
-describe('Test plugin functions utils', () => {
-
-  describe('Get plugin service', () => {
-    test('Should get common service', () => {
-      expect(getPluginService('common')).toHaveProperty('findAllFlat');
-    });
-  });
-});

package/server/utils/constants.js

@@ -1,26 +0,0 @@
-const CONFIG_PARAMS = {
-  ENABLED_COLLECTIONS: 'enabledCollections',
-  APPROVAL_FLOW: 'approvalFlow',
-  ENTRY_LABEL: 'entryLabel',
-  MODERATOR_ROLES: 'moderatorRoles',
-  BAD_WORDS: 'badWords',
-};
-
-const APPROVAL_STATUS = {
-  PENDING: "PENDING",
-  APPROVED: "APPROVED",
-  REJECTED: "REJECTED",
-};
-
-const REGEX = {
-  uid: /^(?<type>[a-z0-9-]+)\:{2}(?<api>[a-z0-9-]+)\.{1}(?<contentType>[a-z0-9-]+)$/i,
-  relatedUid: /^(?<uid>[a-z0-9-]+\:{2}[a-z0-9-]+\.[a-z0-9-]+)\:{1}(?<id>[a-z0-9-]+)$/i,
-  email: /\S+@\S+\.\S+/,
-  sorting: /^(?<path>[a-z0-9-_\:\.]+)\:+(asc|desc)$/i
-};
-
-module.exports = {
-  CONFIG_PARAMS,
-  APPROVAL_STATUS,
-  REGEX,
-};

package/server/utils/error.js

@@ -1,24 +0,0 @@
-module.exports = class PluginError extends Error {
-    constructor(status, message, payload = undefined) { 
-        super();
-        this.name = 'Strapi:Plugin:Comments'; 
-        this.status = status || 500;
-        this.message = message || 'Internal error'; 
-        this.payload = payload;
-     }
-
-     toString(e = this) {
-        return `${e.name} - ${e.message}`;
-     }
-
-     toJSON() {
-        if (this.payload) {
-           return {
-               name: this.name,
-               message: this.message,
-               ...(this.payload || {}),
-           };
-       }
-       return this;
-    }
-}; 

package/server/utils/functions.js

@@ -1,19 +0,0 @@
-'use strict'
-
-module.exports = {
-    getPluginService(name) {
-        return strapi
-          .plugin('comments')
-          .service(name);
-      },
-
-    parseParams: params => 
-        Object.keys(params).reduce((prev, curr) => {
-            const value = params[curr];
-            const parsedValue = Number(value);
-            return {
-                ...prev,
-                [curr]: isNaN(parsedValue) ? value : parsedValue
-            };
-        }, {}),
-};

package/strapi-admin.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./admin/src').default;

package/strapi-server.js

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