strapi-plugin-comments 2.1.1 → 2.1.4

package/server/services/common.ts

@@ -1,503 +0,0 @@
-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

@@ -1,219 +0,0 @@
-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;
-};