strapi-plugin-comments 2.0.11 → 2.1.1

package/server/services/{graphql.js → graphql.ts}

@@ -1,24 +1,26 @@
-'use strict';
+import { Primitive, StrapiContext } from "strapi-typed";
+import { IServiceGraphQL, ToBeFixed } from "../../types";
 
-const { has, propEq, isNil, isDate, isObject } = require('lodash/fp');
-const { inputObjectType } = require('nexus');
+import { has, propEq, isNil, isDate, isObject } from "lodash/fp";
+import { inputObjectType } from "nexus";
 
-const virtualScalarAttributes = ['id'];
+const virtualScalarAttributes = ["id"];
 
-module.exports = ({ strapi }) => {
-  const { service: getService } = strapi.plugin('graphql');
+export = ({ strapi }: StrapiContext): IServiceGraphQL => {
+  const { service: getService } = strapi.plugin("graphql");
 
   const rootLevelOperators = () => {
-    const { operators } = strapi.plugin('graphql').service('builders').filters;
+    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 buildContentTypeFilters = (contentType: ToBeFixed) => {
+    const utils = strapi.plugin("graphql").service("utils");
+    const extension = strapi.plugin("graphql").service("extension");
 
-    const { getFiltersInputTypeName, getScalarFilterInputTypeName } = utils.naming;
+    const { getFiltersInputTypeName, getScalarFilterInputTypeName } =
+      utils.naming;
     const { isStrapiScalar, isRelation } = utils.attributes;
 
     const { attributes } = contentType;
@@ -29,20 +31,21 @@ module.exports = ({ strapi }) => {
       name: filtersTypeName,
 
       definition(t) {
-        const validAttributes = Object.entries(attributes).filter(([attributeName]) =>
-          extension
-            .shadowCRUD(contentType.uid)
-            .field(attributeName)
-            .hasFiltersEnabeld()
+        const validAttributes = Object.entries(attributes).filter(
+          ([attributeName]) =>
+            extension
+              .shadowCRUD(contentType.uid)
+              .field(attributeName)
+              .hasFiltersEnabeld()
         );
 
         const isIDFilterEnabled = extension
           .shadowCRUD(contentType.uid)
-          .field('id')
+          .field("id")
           .hasFiltersEnabeld();
         // Add an ID filter to the collection types
-        if (contentType.kind === 'collectionType' && isIDFilterEnabled) {
-          t.field('id', { type: getScalarFilterInputTypeName('ID') });
+        if (contentType.kind === "collectionType" && isIDFilterEnabled) {
+          t.field("id", { type: getScalarFilterInputTypeName("ID") });
         }
 
         // Add every defined attribute
@@ -66,21 +69,31 @@ module.exports = ({ strapi }) => {
     });
   };
 
-  const addScalarAttribute = (builder, attributeName, attribute) => {
-    const { naming, mappers } = strapi.plugin('graphql').service('utils');
+  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) });
+    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 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(attribute.target);
+    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
@@ -92,8 +105,8 @@ module.exports = ({ strapi }) => {
     builder.field(attributeName, { type: getFiltersInputTypeName(model) });
   };
 
-  const recursivelyReplaceScalarOperators = data => {
-    const { operators } = getService('builders').filters;
+  const recursivelyReplaceScalarOperators = (data: ToBeFixed): ToBeFixed => {
+    const { operators } = getService("builders").filters;
 
     if (Array.isArray(data)) {
       return data.map(recursivelyReplaceScalarOperators);
@@ -105,12 +118,12 @@ module.exports = ({ strapi }) => {
       return data;
     }
 
-    const result = {};
+    const result: ToBeFixed = {};
 
     for (const [key, value] of Object.entries(data)) {
       const isOperator = !!operators[key];
 
-      const newKey = isOperator ? operators[key].strapiOperator : key;
+      const newKey: string = isOperator ? operators[key].strapiOperator : key;
 
       result[newKey] = recursivelyReplaceScalarOperators(value);
     }
@@ -118,9 +131,13 @@ module.exports = ({ strapi }) => {
     return result;
   };
 
-  const graphQLFiltersToStrapiQuery = (filters, contentType = {}) => {
-    const { isStrapiScalar, isMedia, isRelation } = getService('utils').attributes;
-    const { operators } = getService('builders').filters;
+  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];
 
@@ -131,25 +148,31 @@ module.exports = ({ strapi }) => {
 
     // If filters is a collection, then apply the transformation to every item of the list
     if (Array.isArray(filters)) {
-      return filters.map(filtersItem =>
+      return filters.map((filtersItem) =>
         graphQLFiltersToStrapiQuery(filtersItem, contentType)
       );
     }
 
-    const resultMap = {};
+    const resultMap: ToBeFixed = {};
     const { attributes } = contentType;
 
-    const isAttribute = attributeName => {
-      return virtualScalarAttributes.includes(attributeName) || has(attributeName, attributes);
+    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 = attributes[key];
+        const attribute: Primitive | ToBeFixed = attributes[key];
 
         // If it's a scalar attribute
-        if (virtualScalarAttributes.includes(key) || isStrapiScalar(attribute)) {
+        if (
+          virtualScalarAttributes.includes(key) ||
+          isStrapiScalar(attribute)
+        ) {
           // Replace (recursively) every GraphQL scalar operator with the associated Strapi operator
           resultMap[key] = recursivelyReplaceScalarOperators(value);
         }
@@ -167,7 +190,9 @@ module.exports = ({ strapi }) => {
 
       // Handle the case where the key is not an attribute (operator, ...)
       else {
-        const rootLevelOperator = ROOT_LEVEL_OPERATORS.find(propEq('fieldName', key));
+        const rootLevelOperator = ROOT_LEVEL_OPERATORS.find(
+          propEq("fieldName", key)
+        );
 
         // If it's a root level operator (AND, NOT, OR, ...)
         if (rootLevelOperator) {
@@ -175,7 +200,10 @@ module.exports = ({ strapi }) => {
 
           // 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);
+          resultMap[strapiOperator] = graphQLFiltersToStrapiQuery(
+            value,
+            contentType
+          );
         }
       }
     }
@@ -183,8 +211,9 @@ module.exports = ({ strapi }) => {
     return resultMap;
   };
 
-  return {
+  const serviceMethods: IServiceGraphQL = {
     buildContentTypeFilters,
     graphQLFiltersToStrapiQuery,
   };
-};
+  return serviceMethods;
+};

package/server/services/index.ts

@@ -0,0 +1,13 @@
+"use strict";
+
+import adminServices from "./admin";
+import clientServices from "./client";
+import commonServices from "./common";
+import graphQLService from "./graphql";
+
+export default {
+  admin: adminServices,
+  client: clientServices,
+  common: commonServices,
+  gql: graphQLService,
+};

package/server/services/utils/functions.ts

@@ -0,0 +1,150 @@
+import { Id, IStrapi, StrapiUser } from "strapi-typed";
+import { Comment, CommentAuthor, ToBeFixed } from "../../../types";
+
+import PluginError from "./../../utils/error";
+import { REGEX } from "./../../utils/constants";
+import { first, get, isObject, isArray, isEmpty, isString } from "lodash";
+
+declare var strapi: IStrapi;
+
+export const buildNestedStructure = (
+  entities: Array<Comment>,
+  id: Id | null = null,
+  field: string = "threadOf",
+  dropBlockedThreads = false,
+  blockNestedThreads = false
+): Array<Comment> =>
+  entities
+    .filter((entity: Comment) => {
+      // mongo by default not return `null` for empty data
+      const entityField: any = get(entity, field);
+      if (entityField === null && id === null) {
+        return true;
+      }
+      let data = entityField;
+      if (data && typeof id === "string") {
+        data = data.toString();
+      }
+      return (
+        (data && data === id) ||
+        (isObject(entityField) && (entityField as any).id === id)
+      );
+    })
+    .map((entity: Comment) => ({
+      ...entity,
+      [field]: undefined,
+      related: undefined,
+      blockedThread: blockNestedThreads || entity.blockedThread,
+      children:
+        entity.blockedThread && dropBlockedThreads
+          ? []
+          : buildNestedStructure(
+              entities,
+              entity.id,
+              field,
+              dropBlockedThreads,
+              entity.blockedThread
+            ),
+    }));
+
+export const isEqualEntity = (
+  existing: Comment,
+  data: ToBeFixed,
+  user: StrapiUser
+): boolean => {
+  const { author: existingAuthor = {} as CommentAuthor } = 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;
+};
+
+export const getRelatedGroups = (related: string): Array<string> =>
+  related.split(REGEX.relatedUid).filter((s) => s && s.length > 0);
+
+export const getModelUid = (name: string): string => {
+  return strapi.plugin("comments").contentTypes[name]?.uid;
+};
+
+export const filterOurResolvedReports = (item: Comment): Comment =>
+  item
+    ? {
+        ...item,
+        reports: (item.reports || []).filter((report) => !report.resolved),
+      }
+    : item;
+
+export const convertContentTypeNameToSlug = (str: string): string => {
+  const plainConversion = str.replace(
+    /[A-Z]/g,
+    (letter) => `-${letter.toLowerCase()}`
+  );
+  return first(plainConversion) === "-"
+    ? plainConversion.slice(1, plainConversion.length)
+    : plainConversion;
+};
+
+export const buildAuthorModel = (
+  item: Comment,
+  fieldsToPopulate: Array<string> = []
+): Comment => {
+  const {
+    authorUser,
+    authorId,
+    authorName,
+    authorEmail,
+    authorAvatar,
+    ...rest
+  } = item;
+  let author: CommentAuthor = {} as CommentAuthor;
+  if (authorUser) {
+    author = fieldsToPopulate.reduce(
+      (prev, curr) => ({
+        ...prev,
+        [curr]: authorUser[curr],
+      }),
+      {
+        id: authorUser.id,
+        name: authorUser.username,
+        email: authorUser.email,
+        avatar:
+          isString(authorUser.avatar) || isObject(authorUser.avatar)
+            ? authorUser.avatar
+            : undefined,
+      }
+    );
+  } else if (authorId) {
+    author = {
+      id: authorId,
+      name: authorName,
+      email: authorEmail,
+      avatar: authorAvatar,
+    };
+  }
+  return {
+    ...rest,
+    author: isEmpty(author) ? undefined : author,
+  };
+};
+
+export const buildConfigQueryProp = (
+  prop: undefined | string | Array<string> = ""
+): string => (isArray(prop) ? prop.join(".") : prop ?? "");
+
+export const resolveUserContextError = (user: StrapiUser): PluginError => {
+  if (user) {
+    throw new PluginError(401, "Not authenticated");
+  } else {
+    throw new PluginError(403, "Not authorized");
+  }
+};

package/server/utils/constants.ts

@@ -0,0 +1,23 @@
+import { ConfigParamKeys, RegExpCollection } from "../../types";
+
+export const CONFIG_PARAMS: ConfigParamKeys = {
+  ENABLED_COLLECTIONS: "enabledCollections",
+  APPROVAL_FLOW: "approvalFlow",
+  ENTRY_LABEL: "entryLabel",
+  MODERATOR_ROLES: "moderatorRoles",
+  BAD_WORDS: "badWords",
+};
+
+export const APPROVAL_STATUS = {
+  PENDING: "PENDING",
+  APPROVED: "APPROVED",
+  REJECTED: "REJECTED",
+};
+
+export const REGEX: RegExpCollection = {
+  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,
+};

package/server/utils/error.ts

@@ -0,0 +1,44 @@
+type ErrorPayload =
+  | {
+      [key: string]: any;
+    }
+  | undefined;
+
+interface IPluginError extends Error {
+  status: number;
+  payload: ErrorPayload;
+}
+
+export default class PluginError extends Error implements IPluginError {
+  status: number;
+  payload: ErrorPayload;
+
+  constructor(
+    status: number,
+    message: string,
+    payload: ErrorPayload = undefined
+  ) {
+    super();
+    this.name = "Strapi:Plugin:Comments";
+    this.status = status || 500;
+    this.message = message || "Internal error";
+    this.payload = payload;
+
+    Object.setPrototypeOf(this, PluginError.prototype);
+  }
+
+  toString(e: PluginError = this): string {
+    return `${e.name} - ${e.message}`;
+  }
+
+  toJSON() {
+    if (this.payload) {
+      return {
+        name: this.name,
+        message: this.message,
+        ...(this.payload || {}),
+      };
+    }
+    return this;
+  }
+}

package/server/utils/functions.ts

@@ -0,0 +1,55 @@
+import {
+  StrapiQueryParams,
+  StrapiQueryParamsParsed,
+  IStrapi,
+} from "strapi-typed";
+import PluginError from "./error";
+
+declare var strapi: IStrapi;
+
+export const getPluginService = <T>(name: string): T =>
+  strapi.plugin("comments").service(name);
+
+export const parseParams = <T = StrapiQueryParamsParsed>(
+  params: StrapiQueryParams
+): T =>
+  Object.keys(params).reduce((prev: T, curr: string) => {
+    const value = params[curr];
+    const parsedValue = Number(value);
+    return {
+      ...prev,
+      [curr]: isNaN(parsedValue) ? value : parsedValue,
+    };
+  }, {} as unknown as T);
+
+export const assertParamsPresent: <T>(
+  params: unknown,
+  keys: string[]
+) => asserts params is T = (params, keys) => {
+  const missingParams =
+    params instanceof Object
+      ? keys.filter((key) => !params.hasOwnProperty(key))
+      : keys;
+
+  if (missingParams.length === 0) {
+    return;
+  }
+
+  throw new PluginError(
+    400,
+    `Expected params missing: ${missingParams.join(", ")}`
+  );
+};
+
+export const assertNotEmpty: <T>(
+  value: T | null | undefined,
+  customError?: Error
+) => asserts value is T = (value, customError) => {
+  if (value) {
+    return;
+  }
+
+  throw (
+    customError ?? new PluginError(400, "Non-empty value expected, empty given")
+  );
+};

package/strapi-admin.ts

@@ -0,0 +1,5 @@
+"use strict";
+
+import admin from "./admin/src";
+
+export default admin;

package/strapi-server.ts

@@ -0,0 +1,77 @@
+import { PropType } from "strapi-typed";
+import { CommentsPluginConfig } from "./types";
+
+import { isArray, isEmpty, isString } from "lodash";
+
+import { REGEX, CONFIG_PARAMS } from "./server/utils/constants";
+import server from "./server";
+import contentTypes from "./content-types";
+
+export = () => ({
+  ...server,
+  contentTypes,
+  config: {
+    ...server.config,
+    default: () => ({
+      ...server.config.default,
+    }),
+    validator: (config: CommentsPluginConfig) => {
+      // Check enabledCollections values
+      const enabledCollections: PropType<
+        CommentsPluginConfig,
+        "enabledCollections"
+      > = config[CONFIG_PARAMS.ENABLED_COLLECTIONS];
+      const enabledCollectionsValid: boolean =
+        enabledCollections.filter((_: string) => !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 moderatorRoles: PropType<CommentsPluginConfig, "moderatorRoles"> =
+        config[CONFIG_PARAMS.MODERATOR_ROLES];
+      const moderatorRolesValid: boolean =
+        moderatorRoles.filter((_: string) => !isString(_)).length === 0;
+
+      if (!moderatorRolesValid) {
+        throw new Error(`'moderatorRoles' must roles keys`);
+      }
+
+      // Check approvalFlow values
+      const approvalFlow: PropType<CommentsPluginConfig, "approvalFlow"> =
+        config[CONFIG_PARAMS.APPROVAL_FLOW];
+      const approvalFlowValid: boolean =
+        approvalFlow.filter((_: string) => !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 entryLabels: PropType<CommentsPluginConfig, "entryLabel"> =
+        config[CONFIG_PARAMS.ENTRY_LABEL];
+      const entryLabelKeysValid: boolean =
+        Object.keys(entryLabels)
+          .filter((_: string) => _ !== "*")
+          .filter(
+            (_: string) =>
+              !(
+                REGEX.uid.test(_) &&
+                isArray(entryLabels[_]) &&
+                !isEmpty(entryLabels[_])
+              )
+          ).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/tsconfig.json

@@ -0,0 +1,38 @@
+{
+  "compilerOptions": {
+    "rootDir": "./",
+    "outDir": "build",
+    "target": "esnext",
+    "module": "commonjs",
+    "jsx": "react",
+    "moduleResolution": "node",
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "removeComments": true,
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+    "downlevelIteration": true,
+    "incremental": true,
+    "allowJs": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true
+  },
+  "include": [
+    "./server/**/*",
+    "./admin/**/*",
+    "./strapi-server.*",
+    "./strapi-admin.*",
+    "./setup-package.ts",
+    "./permissions.*"
+  ],
+  "exclude": [
+    "**/node_modules/**/*",
+    "**/__tests__/**/*",
+    "**/__mocks__/**/*",
+    "**/build/**/*"
+  ]
+}

package/types/common.d.ts

@@ -0,0 +1 @@
+export type ToBeFixed = any;

package/types/config.d.ts

@@ -0,0 +1,35 @@
+import { StrapiPluginConfig, TypeResult } from "strapi-typed";
+import { RegExpCollection } from "./constants";
+
+export type CommentsPluginConfig = StrapiPluginConfig<{
+  enabledCollections: Array<string>;
+  moderatorRoles: Array<string>;
+  approvalFlow: Array<string>;
+  entryLabel: PluginConfigEntryLabels;
+  reportReasons: PluginConfigReportReasons;
+  badWords?: boolean;
+}>;
+
+export type PluginConfigKeys = keyof CommentsPluginConfig;
+
+export type ViewCommentsPluginConfig = {
+  approvalFlow: TypeResult<SettingsCommentsPluginConfig["approvalFlow"]>;
+  entryLabel: TypeResult<SettingsCommentsPluginConfig["entryLabel"]>;
+  reportReasons: TypeResult<SettingsCommentsPluginConfig["reportReasons"]>;
+  regex?: RegExpCollection;
+};
+
+export type SettingsCommentsPluginConfig = CommentsPluginConfig & {
+  isGQLPluginEnabled?: boolean;
+  regex?: RegExpCollection;
+};
+
+export type AnyConfig = ViewCommentsPluginConfig | SettingsCommentsPluginConfig;
+
+export type StrapiConfig = {
+  default: CommentsPluginConfig;
+};
+
+export type ConfigParamKeys = {
+  [key: string]: PluginConfigKeys;
+};

package/types/constants.d.ts

@@ -0,0 +1,3 @@
+export type RegExpCollection = {
+  [key: string]: RegExp;
+};