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

package/server/services/common.js

@@ -1,14 +1,14 @@
 'use strict';
 
-const { isArray, isEmpty, uniq, get, first } = require('lodash');
+const { isArray, isNumber, isObject, first, parseInt } = require('lodash');
 // const { sanitizeEntity } = require('strapi-utils');
 const PluginError = require('./../utils/error');
 const {
-    extractMeta,
     getModelUid,
     getRelatedGroups,
     buildNestedStructure,
-    filterOurResolvedReports
+    filterOurResolvedReports,
+    buildAuthorModel,
 } = require('./utils/functions');
 
 /**
@@ -16,62 +16,17 @@ const {
  */
 
 module.exports = ({ strapi }) => ({
-    getAssociationModel(ormModel, related) {
-        const relatedAssociation = ormModel.associations.find(_ => _.alias === 'related');
-        if (relatedAssociation) {
-            return relatedAssociation.related.find(rel => rel.collectionName === related);
-        }
-        return null;
-    },
-
-    getMorphModel() {
-        const ormModel = strapi.query(getModelUid('comment'));
-        return ormModel.model.morph;
-    },
-
-    isMongoDB(){
-        return strapi.query(getModelUid('comment'))?.model?.orm === 'mongoose';
-    },
-
-    getMorphData(query) {
-        return this
-          .getMorphModel()
-          .query(function () {
-              this.where(query);
-          })
-          .fetchAll()
-          .then((entities) => entities.map(entity => entity.toJSON()));
-    },
-
-    checkEntityRelation(uid, entityId) {
-        const result = parsedRelation.some(ref => {
-            const model = strapi.query(ref);
-            return model && model.associations.length &&
-              model.associations.some(_ => _.plugin === 'comments' && _.collection === 'comment');
-        });
-        if (!result) {
-            throw new PluginError(400, 'Comment not have relation to this type content type.');
-        }
-    },
 
-    getConfig(prop) {
+    getConfig(prop, defaultValue) {
         let queryProp = prop;
         if (prop && isArray(prop)) {
             queryProp = prop.join('.');
         }
-        return strapi.config.get(`plugin.comments${ queryProp ? '.' + queryProp : ''}`);
+        return strapi.config.get(`plugin.comments${ queryProp ? '.' + queryProp : ''}`) || defaultValue;
     },
 
     // Find comments in the flat structure
-    async findAllFlat({ query, populate = {} }, isAdmin = false, relatedEntity = null) {
-        const criteria = { 
-            ...query,
-            $or: [{ removed: { $null: true } }, { removed: false }],
-        }
-
-        if (isAdmin){
-            delete criteria.$or;
-        }
+    async findAllFlat({ query = {}, populate = {} }, relatedEntity = null) {
 
         const defaultPopulate = {
             authorUser: true,
@@ -80,7 +35,7 @@ module.exports = ({ strapi }) => ({
         const entries = await strapi.db.query(getModelUid('comment'))
         .findMany({
             where: {
-                ...criteria,
+                ...query,
             },
             populate: {
                 ...defaultPopulate,
@@ -122,9 +77,8 @@ module.exports = ({ strapi }) => ({
         populate = {},
         startingFromId = null,
         dropBlockedThreads = false,
-        isAdmin = false,
     }, relatedEntity) {
-        const entities = await this.findAllFlat({ query, populate }, isAdmin, relatedEntity);
+        const entities = await this.findAllFlat({ query, populate }, relatedEntity);
         return buildNestedStructure(entities, startingFromId, 'threadOf', dropBlockedThreads, false);
     },
 
@@ -135,24 +89,38 @@ module.exports = ({ strapi }) => ({
                 where: criteria
             }, ['related', 'reports']);
         if (!entity){
-            throw strapi.errors.notFound();
+            throw new PluginError(404, 'Not found');
         }
         return filterOurResolvedReports(this.sanitizeCommentEntity(entity));
     },
 
     // Find all related entiries
     async findRelatedEntitiesFor(entities = []) {
-        return Promise.all(uniq(entities.map(_ => _.related)).map(async _ => {
-            const [relatedUid, relatedStringId] = getRelatedGroups(_);
-            const relatedId = parseInt(relatedStringId, 10);
-            const relatedEntity = await strapi.db.query(relatedUid).findOne({ 
-                where: { id: relatedId }
-            });
-            return {
-                ...relatedEntity,
-                uid: relatedUid,
-            };
-        }))
+        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
@@ -187,7 +155,10 @@ module.exports = ({ strapi }) => ({
     },
 
     sanitizeCommentEntity: (entity) => ({
-        ...entity,
+        ...buildAuthorModel({
+            ...entity,
+            threadOf: isObject(entity.threadOf) ? buildAuthorModel(entity.threadOf) : entity.threadOf,
+        }),
 	}),
 
     // sanitizeCommentEntity: (entity) => ({

package/server/services/graphql.js

@@ -0,0 +1,190 @@
+'use strict';
+
+const { has, propEq, isNil, isDate, isObject } = require('lodash/fp');
+const { inputObjectType } = require('nexus');
+
+const virtualScalarAttributes = ['id'];
+
+module.exports = ({ strapi }) => {
+  const { service: getService } = strapi.plugin('graphql');
+
+  const rootLevelOperators = () => {
+    const { operators } = strapi.plugin('graphql').service('builders').filters;
+
+    return [operators.and, operators.or, operators.not];
+  };
+
+  const buildContentTypeFilters = contentType => {
+    const utils = strapi.plugin('graphql').service('utils');
+    const extension = strapi.plugin('graphql').service('extension');
+
+    const { getFiltersInputTypeName, getScalarFilterInputTypeName } = utils.naming;
+    const { isStrapiScalar, isRelation } = utils.attributes;
+
+    const { attributes } = contentType;
+
+    const filtersTypeName = getFiltersInputTypeName(contentType);
+
+    return inputObjectType({
+      name: filtersTypeName,
+
+      definition(t) {
+        const validAttributes = Object.entries(attributes).filter(([attributeName]) =>
+          extension
+            .shadowCRUD(contentType.uid)
+            .field(attributeName)
+            .hasFiltersEnabeld()
+        );
+
+        const isIDFilterEnabled = extension
+          .shadowCRUD(contentType.uid)
+          .field('id')
+          .hasFiltersEnabeld();
+        // Add an ID filter to the collection types
+        if (contentType.kind === 'collectionType' && isIDFilterEnabled) {
+          t.field('id', { type: getScalarFilterInputTypeName('ID') });
+        }
+
+        // Add every defined attribute
+        for (const [attributeName, attribute] of validAttributes) {
+          // Handle scalars
+          if (isStrapiScalar(attribute)) {
+            addScalarAttribute(t, attributeName, attribute);
+          }
+
+          // Handle relations
+          else if (isRelation(attribute)) {
+            addRelationalAttribute(t, attributeName, attribute);
+          }
+        }
+
+        // Conditional clauses
+        for (const operator of rootLevelOperators()) {
+          operator.add(t, filtersTypeName);
+        }
+      },
+    });
+  };
+
+  const addScalarAttribute = (builder, attributeName, attribute) => {
+    const { naming, mappers } = strapi.plugin('graphql').service('utils');
+
+    const gqlType = mappers.strapiScalarToGraphQLScalar(attribute.type);
+
+    builder.field(attributeName, { type: naming.getScalarFilterInputTypeName(gqlType) });
+  };
+
+  const addRelationalAttribute = (builder, attributeName, attribute) => {
+    const utils = strapi.plugin('graphql').service('utils');
+    const extension = strapi.plugin('graphql').service('extension');
+    const { getFiltersInputTypeName } = utils.naming;
+    const { isMorphRelation } = utils.attributes;
+
+    const model = strapi.getModel(attribute.target);
+
+    // If there is no model corresponding to the attribute configuration
+    // or if the attribute is a polymorphic relation, then ignore it
+    if (!model || isMorphRelation(attribute)) return;
+
+    // If the target model is disabled, then ignore it too
+    if (extension.shadowCRUD(model.uid).isDisabled()) return;
+
+    builder.field(attributeName, { type: getFiltersInputTypeName(model) });
+  };
+
+  const recursivelyReplaceScalarOperators = data => {
+    const { operators } = getService('builders').filters;
+
+    if (Array.isArray(data)) {
+      return data.map(recursivelyReplaceScalarOperators);
+    }
+
+    // Note: We need to make an exception for date since GraphQL
+    // automatically cast date strings to date instances in args
+    if (isDate(data) || !isObject(data)) {
+      return data;
+    }
+
+    const result = {};
+
+    for (const [key, value] of Object.entries(data)) {
+      const isOperator = !!operators[key];
+
+      const newKey = isOperator ? operators[key].strapiOperator : key;
+
+      result[newKey] = recursivelyReplaceScalarOperators(value);
+    }
+
+    return result;
+  };
+
+  const graphQLFiltersToStrapiQuery = (filters, contentType = {}) => {
+    const { isStrapiScalar, isMedia, isRelation } = getService('utils').attributes;
+    const { operators } = getService('builders').filters;
+
+    const ROOT_LEVEL_OPERATORS = [operators.and, operators.or, operators.not];
+
+    // Handle unwanted scenario where there is no filters defined
+    if (isNil(filters)) {
+      return {};
+    }
+
+    // If filters is a collection, then apply the transformation to every item of the list
+    if (Array.isArray(filters)) {
+      return filters.map(filtersItem =>
+        graphQLFiltersToStrapiQuery(filtersItem, contentType)
+      );
+    }
+
+    const resultMap = {};
+    const { attributes } = contentType;
+
+    const isAttribute = attributeName => {
+      return virtualScalarAttributes.includes(attributeName) || has(attributeName, attributes);
+    };
+
+    for (const [key, value] of Object.entries(filters)) {
+      // If the key is an attribute, update the value
+      if (isAttribute(key)) {
+        const attribute = attributes[key];
+
+        // If it's a scalar attribute
+        if (virtualScalarAttributes.includes(key) || isStrapiScalar(attribute)) {
+          // Replace (recursively) every GraphQL scalar operator with the associated Strapi operator
+          resultMap[key] = recursivelyReplaceScalarOperators(value);
+        }
+
+        // If it's a deep filter on a relation
+        else if (isRelation(attribute) || isMedia(attribute)) {
+          // Fetch the model from the relation
+          const relModel = strapi.getModel(attribute.target);
+
+          // Recursively apply the mapping to the value using the fetched model,
+          // and update the value within `resultMap`
+          resultMap[key] = graphQLFiltersToStrapiQuery(value, relModel);
+        }
+      }
+
+      // Handle the case where the key is not an attribute (operator, ...)
+      else {
+        const rootLevelOperator = ROOT_LEVEL_OPERATORS.find(propEq('fieldName', key));
+
+        // If it's a root level operator (AND, NOT, OR, ...)
+        if (rootLevelOperator) {
+          const { strapiOperator } = rootLevelOperator;
+
+          // Transform the current value recursively and add it to the resultMap
+          // object using the strapiOperator equivalent of the GraphQL key
+          resultMap[strapiOperator] = graphQLFiltersToStrapiQuery(value, contentType);
+        }
+      }
+    }
+
+    return resultMap;
+  };
+
+  return {
+    buildContentTypeFilters,
+    graphQLFiltersToStrapiQuery,
+  };
+};

package/server/services/index.js

@@ -3,9 +3,11 @@
 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/functions.js

@@ -6,7 +6,7 @@ const { first, get, isObject, isNil } = require('lodash');
 const buildNestedStructure = (
   entities,
   id = null,
-  field = 'parent',
+  field = 'threadOf',
   dropBlockedThreads = false,
   blockNestedThreads = false,
 ) =>
@@ -33,28 +33,21 @@ const buildNestedStructure = (
 
 module.exports = {
     isEqualEntity: (existing, data, user) => {
-        const { authorUser, authorId } = existing;
-        console.log('data', data);
-        console.log(existing);
+        const { authorUser, 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 (authorUser) {
             const existingUserId = authorUser?.id || authorUser;
             const receivedUserId = user?.id || author;
             return existingUserId === receivedUserId;
         }
-        return authorId === author?.id;
-    },
-
-    extractMeta: plugins => {
-        const { comments: plugin } = plugins;
-        const { comments: service } = plugin.services;
-        const { comment: model} = plugin.models;
-        return {
-            model,
-            service,
-            plugin,
-            pluginName: plugin.package.strapi.name.toLowerCase()
-        };
+        return existingAuthor.id === author?.id;
     },
 
     getRelatedGroups: related => related.split(REGEX.relatedUid).filter(s => s && s.length > 0),
@@ -97,6 +90,20 @@ module.exports = {
         return builtInContextEnabled ? !isNil(user.id) : true;
     },
 
+    buildAuthorModel: (item) => {
+        const { authorUser, authorId, authorName, authorEmail, authorAvatar, ...rest } = item;
+        const author = authorUser || {
+            id: authorId,
+            name: authorName,
+            email: authorEmail,
+            avatar: authorAvatar,
+        };
+        return {
+            ...rest,
+            author,
+        };
+    },
+
     resolveUserContextError: user => {
         if (user) {
             throw new PluginError(401, 'Not authenticated');

package/server/utils/constants.js

@@ -5,9 +5,9 @@ const APPROVAL_STATUS = {
 };
 
 const REGEX = {
-  uid: new RegExp(/^(?<type>[a-z]+)\:{2}(?<api>[a-z]+)\.{1}(?<contentType>[a-z]+)$/gmi),
-  relatedUid: new RegExp(/^(?<uid>[a-z]+\:{2}[a-z]+\.[a-z]+)\:{1}(?<id>[0-9]+)$/gmi),
-  email: new RegExp(/\S+@\S+\.\S+/),
+  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+/,
 };
 
 module.exports = {

package/strapi-server.js

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

package/admin/src/components/EntityDetails/index.js

@@ -1,53 +0,0 @@
-/**
- *
- * Entity Details
- *
- */
-
-import React from 'react';
-import PropTypes from 'prop-types';
-import { isNil } from 'lodash';
-import { Box } from '@strapi/design-system/Box';
-import { Divider } from '@strapi/design-system/Divider';
-import { Flex } from '@strapi/design-system/Flex';
-import { Stack } from '@strapi/design-system/Stack';
-import { Typography } from '@strapi/design-system/Typography';
-import { getMessage } from '../../utils';
-
-const EntityDetails = ({ data = {}, schema = {} }) => {
-    const { attributes = {} } = schema;
-    const keys = Object.keys(attributes);
-    
-    if (keys.length === 0) {
-        return null;
-    }
-
-    const itemKeys = keys.filter(_ => (attributes[_].type === 'string') && !isNil(data[_]));
-
-    return (<Box padding={4}>
-        <Typography variant="sigma" textColor="neutral600" id="entity-details">
-            { getMessage('page.details.panel.entity', 'Details') }
-        </Typography>
-        <Box paddingTop={2} paddingBottom={6}>
-            <Divider />
-        </Box>
-        <Stack size={itemKeys.length}>
-            {  itemKeys.map(_ => 
-            (<Flex justifyContent="space-between">
-                <Typography fontWeight="bold">
-                    { _ }
-                </Typography>
-                <Typography>{ data[_] }</Typography>
-            </Flex>))
-            }
-        </Stack>
-    </Box>);
-};
-
-EntityDetails.propTypes = {
-    data: PropTypes.object.isRequired,
-    schema: PropTypes.object.isRequired,
-};
-
-export default EntityDetails;
-