strapi-plugin-comments 2.1.0 → 2.1.1

package/server/services/common.ts

@@ -0,0 +1,503 @@
+import BadWordsFilter from "bad-words";
+import {
+  isArray,
+  isNumber,
+  isObject,
+  isNil,
+  isString,
+  isEmpty,
+  first,
+  parseInt,
+  set,
+  get,
+  uniq,
+} from "lodash";
+import {
+  Id,
+  StrapiContext,
+  StrapiStore,
+  StrapiPagination,
+  StrapiResponseMeta,
+  StrapiPaginatedResponse,
+  StrapiDBQueryArgs,
+  PopulateClause,
+  StrapiUser,
+  OnlyStrings,
+  StringMap,
+} from "strapi-typed";
+import {
+  CommentsPluginConfig,
+  FindAllFlatProps,
+  FindAllInHierarhyProps,
+  IServiceCommon,
+  ToBeFixed,
+  Comment,
+  RelatedEntity,
+  CommentModelKeys,
+  SettingsCommentsPluginConfig,
+} from "../../types";
+import { REGEX, CONFIG_PARAMS } from "../utils/constants";
+import PluginError from "./../utils/error";
+import {
+  getModelUid,
+  getRelatedGroups,
+  buildNestedStructure,
+  filterOurResolvedReports,
+  buildAuthorModel,
+  buildConfigQueryProp,
+} from "./utils/functions";
+
+/**
+ * Comments Plugin - common services
+ */
+
+const PAGE_SIZE = 10;
+
+export = ({ strapi }: StrapiContext): IServiceCommon => ({
+  async getConfig<T>(
+    this: IServiceCommon,
+    prop?: string,
+    defaultValue?: any,
+    useLocal: boolean = false
+  ): Promise<T> {
+    const queryProp: string = buildConfigQueryProp(prop);
+    const pluginStore: StrapiStore = await this.getPluginStore();
+    const config: CommentsPluginConfig = await pluginStore.get({
+      key: "config",
+    });
+
+    let result: T;
+    if (config && !useLocal) {
+      result = queryProp ? get(config, queryProp, defaultValue) : config;
+    } else {
+      result = this.getLocalConfig(queryProp, defaultValue);
+    }
+    return isNil(result) ? defaultValue : result;
+  },
+
+  async getPluginStore(): Promise<StrapiStore> {
+    return strapi.store({ type: "plugin", name: "comments" });
+  },
+
+  getLocalConfig<T>(prop?: string, defaultValue?: any): T {
+    const queryProp: string = buildConfigQueryProp(prop);
+    const result: T = strapi.config.get(
+      `plugin.comments${queryProp ? "." + queryProp : ""}`
+    );
+    return isNil(result) ? defaultValue : result;
+  },
+
+  // Find comments in the flat structure
+  async findAllFlat(
+    this: IServiceCommon,
+    {
+      query = {},
+      populate = {},
+      sort,
+      pagination,
+      fields,
+    }: FindAllFlatProps<Comment>,
+    relatedEntity: RelatedEntity | null = null
+  ): Promise<StrapiPaginatedResponse<Comment>> {
+    const defaultSelect: Array<CommentModelKeys> = ["id", "related"];
+
+    const populateClause: PopulateClause<CommentModelKeys> = {
+      authorUser: true,
+      ...(isObject(populate) ? populate : {}),
+    };
+
+    let queryExtension: StrapiDBQueryArgs<CommentModelKeys> = {};
+
+    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) };
+          }, {}),
+      };
+    }
+
+    if (!isNil(fields)) {
+      queryExtension = {
+        ...queryExtension,
+        select: isArray(fields) ? uniq([...fields, ...defaultSelect]) : fields,
+      };
+    }
+
+    let meta: StrapiResponseMeta = {} as StrapiResponseMeta;
+    if (pagination && isObject(pagination)) {
+      const parsedpagination: StrapiPagination = Object.keys(pagination).reduce(
+        (prev: StrapiPagination, curr: string) => ({
+          ...prev,
+          [curr]: parseInt(get(pagination, curr)),
+        }),
+        {}
+      );
+      const {
+        page = 1,
+        pageSize = PAGE_SIZE,
+        start = 0,
+        limit = PAGE_SIZE,
+      } = 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<Comment>(getModelUid("comment"))
+      .findMany({
+        where: {
+          ...query,
+        },
+        populate: {
+          ...populateClause,
+        },
+        ...queryExtension,
+      });
+
+    if (
+      pagination?.withCount &&
+      (pagination.withCount === "true" || pagination.withCount === true)
+    ) {
+      const total = await strapi.db
+        .query<Comment>(getModelUid("comment"))
+        .count({
+          where: {
+            ...query,
+          },
+        });
+      const pageSize = meta.pagination.pageSize || PAGE_SIZE;
+      const pageCount = Math.floor(total / pageSize);
+      meta = {
+        ...meta,
+        pagination: {
+          ...meta.pagination,
+          pageCount: !isNil(meta.pagination.page)
+            ? total % pageSize === 0
+              ? pageCount
+              : pageCount + 1
+            : undefined,
+          total,
+        },
+      };
+    }
+
+    const entriesWithThreads = await Promise.all<{
+      id: Id;
+      itemsInTread: number;
+      firstThreadItemId: Id | undefined;
+    }>(
+      entries.map(async (_: Comment) => {
+        const [nestedEntries, count] = await strapi.db
+          .query<Comment>(getModelUid("comment"))
+          .findWithCount({
+            where: {
+              threadOf: _.id,
+            },
+          });
+        return {
+          id: _.id,
+          itemsInTread: count,
+          firstThreadItemId: first<Comment | undefined>(nestedEntries)?.id,
+        };
+      })
+    );
+
+    const relatedEntities =
+      relatedEntity !== null
+        ? [relatedEntity]
+        : await this.findRelatedEntitiesFor([...entries]);
+    const hasRelatedEntitiesToMap =
+      relatedEntities.filter((_: RelatedEntity) => _).length > 0;
+
+    const result = entries.map((_: Comment) => {
+      const threadedItem = entriesWithThreads.find(
+        (item: {
+          id: Id;
+          itemsInTread: number;
+          firstThreadItemId: Id | undefined;
+        }) => item.id === _.id
+      );
+      const parsedThreadOf = isString(query.threadOf)
+        ? parseInt(query.threadOf)
+        : query.threadOf;
+
+      let authorUserPopulate = {};
+      if (isObject(populateClause?.authorUser)) {
+        authorUserPopulate = 'populate' in populateClause.authorUser ? 
+          populateClause.authorUser.populate as StringMap<unknown> : 
+          populateClause.authorUser;
+      }
+
+      return this.sanitizeCommentEntity(
+        {
+          ..._,
+          threadOf: parsedThreadOf || _.threadOf || null,
+          gotThread: (threadedItem?.itemsInTread || 0) > 0,
+          threadFirstItemId: threadedItem?.firstThreadItemId,
+        },
+        authorUserPopulate
+      );
+    });
+
+    return {
+      data: hasRelatedEntitiesToMap
+        ? result.map((_: Comment) =>
+            this.mergeRelatedEntityTo(_, relatedEntities)
+          )
+        : result,
+      ...(isEmpty(meta) ? {} : { meta }),
+    };
+  },
+
+  // Find comments and create relations tree structure
+  async findAllInHierarchy(
+    this: IServiceCommon,
+    {
+      query,
+      populate = {},
+      sort,
+      fields,
+      startingFromId = null,
+      dropBlockedThreads = false,
+    }: FindAllInHierarhyProps,
+    relatedEntity?: RelatedEntity | null | boolean
+  ): Promise<Array<Comment>> {
+    const entities = await this.findAllFlat(
+      { query, populate, sort, fields },
+      relatedEntity
+    );
+    return buildNestedStructure(
+      entities?.data,
+      startingFromId,
+      "threadOf",
+      dropBlockedThreads,
+      false
+    );
+  },
+
+  // Find single comment
+  async findOne(criteria): Promise<Comment> {
+    const entity = await strapi.db
+      .query<Comment>(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: Array<Comment> = []
+  ): Promise<Array<RelatedEntity>> {
+    const data = entities.reduce(
+      (acc: { [key: string]: Array<string | number> }, curr: Comment) => {
+        const [relatedUid, relatedStringId] = getRelatedGroups(curr.related);
+        const parsedRelatedId = parseInt(relatedStringId);
+        const relatedId = isNumber(parsedRelatedId)
+          ? parsedRelatedId
+          : relatedStringId;
+        return {
+          ...acc,
+          [relatedUid]: [...(acc[relatedUid] || []), relatedId],
+        };
+      },
+      {}
+    );
+
+    return Promise.all<Array<RelatedEntity>>(
+      Object.entries(data).map(
+        async ([relatedUid, relatedStringIds]): Promise<Array<RelatedEntity>> =>
+          strapi.db
+            .query<RelatedEntity>(relatedUid)
+            .findMany({
+              where: { id: Array.from(new Set(relatedStringIds as ToBeFixed)) },
+            })
+            .then((relatedEntities: Array<RelatedEntity>) =>
+              relatedEntities.map((_: RelatedEntity) => ({
+                ..._,
+                uid: relatedUid,
+              }))
+            )
+      )
+    ).then((result) => result.flat(2));
+  },
+
+  // Merge related entity with comment
+  mergeRelatedEntityTo(
+    entity: Comment,
+    relatedEntities: Array<RelatedEntity> = []
+  ): Comment {
+    return {
+      ...entity,
+      related: relatedEntities.find(
+        (relatedEntity) =>
+          entity.related === `${relatedEntity.uid}:${relatedEntity.id}`
+      ),
+    };
+  },
+
+  async modifiedNestedNestedComments(
+    this: IServiceCommon,
+    id: Id,
+    fieldName: string,
+    value: any
+  ): Promise<boolean> {
+    try {
+      const entitiesToChange = await strapi.db
+        .query<Comment>(getModelUid("comment"))
+        .findMany({
+          where: { threadOf: id },
+        });
+      const changedEntities = await strapi.db
+        .query<Comment>(getModelUid("comment"))
+        .updateMany({
+          where: { id: entitiesToChange.map((_: Comment) => _.id) },
+          data: { [fieldName]: value },
+        });
+      if (
+        entitiesToChange.length === changedEntities.length &&
+        changedEntities.length > 0
+      ) {
+        const nestedTransactions = await Promise.all(
+          changedEntities.map((item: Comment) =>
+            this.modifiedNestedNestedComments(item.id, fieldName, value)
+          )
+        );
+        return nestedTransactions.length === changedEntities.length;
+      }
+      return true;
+    } catch (e) {
+      return false;
+    }
+  },
+
+  sanitizeCommentEntity(
+    entity: Comment,
+    populate?: PopulateClause<OnlyStrings<keyof StrapiUser>>
+  ): Comment {
+    const fieldsToPopulate = isArray(populate)
+      ? populate
+      : Object.keys(populate || {});
+
+      console.log(fieldsToPopulate);
+
+    return {
+      ...buildAuthorModel(
+        {
+          ...entity,
+          threadOf: isObject(entity.threadOf)
+            ? buildAuthorModel(entity.threadOf, fieldsToPopulate)
+            : entity.threadOf,
+        },
+        fieldsToPopulate
+      ),
+    };
+  },
+
+  isValidUserContext(user?: any): boolean {
+    return user ? !isNil(user?.id) : true;
+  },
+
+  async parseRelationString(
+    this: IServiceCommon,
+    relation
+  ): Promise<[uid: string, relatedId: string | number]> {
+    const [uid, relatedStringId] = getRelatedGroups(relation);
+    const parsedRelatedId = parseInt(relatedStringId);
+    const relatedId = isNumber(parsedRelatedId)
+      ? parsedRelatedId
+      : relatedStringId;
+
+    const isEnabledCollection: boolean = await this.isEnabledCollection(uid);
+    const enabledCollections: Array<string> = await this.getConfig<
+      Array<string>
+    >(CONFIG_PARAMS.ENABLED_COLLECTIONS, []);
+
+    if (!isEnabledCollection) {
+      throw new PluginError(
+        403,
+        `Action not allowed for collection '${uid}'. Use one of: ${enabledCollections.join(
+          ", "
+        )}`
+      );
+    }
+    return [uid, relatedId];
+  },
+
+  async checkBadWords(
+    this: IServiceCommon,
+    content: string
+  ): Promise<boolean | string | PluginError> {
+    const config: boolean = await this.getConfig<boolean>(
+      CONFIG_PARAMS.BAD_WORDS,
+      true
+    );
+    if (config) {
+      const filter = new BadWordsFilter(
+        isObject(config) ? (config as ToBeFixed) : 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;
+  },
+
+  async isEnabledCollection(
+    this: IServiceCommon,
+    uid: string
+  ): Promise<boolean> {
+    const enabledCollections = await this.getConfig<
+      SettingsCommentsPluginConfig["enabledCollections"]
+    >("enabledCollections", []);
+    return enabledCollections.includes(uid);
+  },
+});

package/server/services/graphql.ts

@@ -0,0 +1,219 @@
+import { Primitive, StrapiContext } from "strapi-typed";
+import { IServiceGraphQL, ToBeFixed } from "../../types";
+
+import { has, propEq, isNil, isDate, isObject } from "lodash/fp";
+import { inputObjectType } from "nexus";
+
+const virtualScalarAttributes = ["id"];
+
+export = ({ strapi }: StrapiContext): IServiceGraphQL => {
+  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: ToBeFixed) => {
+    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: ToBeFixed,
+    attributeName: string,
+    attribute: ToBeFixed
+  ): void => {
+    const { naming, mappers } = strapi.plugin("graphql").service("utils");
+
+    const gqlType = mappers.strapiScalarToGraphQLScalar(attribute.type);
+
+    builder.field(attributeName, {
+      type: naming.getScalarFilterInputTypeName(gqlType),
+    });
+  };
+
+  const addRelationalAttribute = (
+    builder: ToBeFixed,
+    attributeName: string,
+    attribute: ToBeFixed
+  ): void => {
+    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<ToBeFixed>(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: ToBeFixed): ToBeFixed => {
+    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: ToBeFixed = {};
+
+    for (const [key, value] of Object.entries(data)) {
+      const isOperator = !!operators[key];
+
+      const newKey: string = isOperator ? operators[key].strapiOperator : key;
+
+      result[newKey] = recursivelyReplaceScalarOperators(value);
+    }
+
+    return result;
+  };
+
+  const graphQLFiltersToStrapiQuery = (
+    filters: ToBeFixed,
+    contentType: ToBeFixed = {}
+  ): Array<ToBeFixed> | ToBeFixed => {
+    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: ToBeFixed = {};
+    const { attributes } = contentType;
+
+    const isAttribute = (attributeName: string): boolean => {
+      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: Primitive | ToBeFixed = 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;
+  };
+
+  const serviceMethods: IServiceGraphQL = {
+    buildContentTypeFilters,
+    graphQLFiltersToStrapiQuery,
+  };
+  return serviceMethods;
+};