strapi-plugin-comments 2.1.0-beta.1 → 2.1.2

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;
+};

package/types/contentTypes.ts

@@ -0,0 +1,56 @@
+import { OnlyStrings, StrapiUser, StringMap } from "strapi-typed";
+
+export type Id = number | string;
+
+export type Comment<TAuthor = CommentAuthor> = {
+  id: Id;
+  content: string;
+  author?: TAuthor;
+  children?: Array<Comment>;
+  reports?: Array<CommentReport>;
+  threadOf: Comment | number | null;
+  gotThread?: boolean;
+  related?: any;
+  blocked?: boolean;
+  blockedThread?: boolean;
+  itemsInTread?: number;
+  approvalStatus?: CommentApprovalStatus | null;
+  firstThreadItemId?: Id;
+  threadFirstItemId?: Id;
+} & CommentAuthorPartial;
+
+export type CommentModelKeys = OnlyStrings<keyof Comment>;
+
+type CommentApprovalStatus = "PENDING" | "APPROVED" | "REJECTED";
+
+export type CommentAuthor = {
+  id: Id;
+  name?: string;
+  email?: string;
+  avatar?: string | object;
+};
+
+export type CommentAuthorPartial = {
+  authorId?: Id;
+  authorName?: string;
+  authorEmail?: string;
+  authorAvatar?: string;
+  authorUser?: StrapiUser;
+};
+
+export type CommentAuthorResolved<TExtension = StringMap<unknown>> =
+  CommentAuthor & TExtension;
+
+export type CommentReport = {
+  id: Id;
+  related: Comment | Id;
+  reason: any;
+  content: string;
+  resolved: boolean;
+};
+
+export type RelatedEntity = {
+  id: Id;
+  uid: string;
+  requireCommentsApproval?: boolean;
+};

package/types/controllers.d.ts

@@ -0,0 +1,125 @@
+import {
+  Id,
+  KeyValueSet,
+  StrapiPagination,
+  StrapiPaginatedResponse,
+  StrapiRequestContext,
+  StrapiResponseMeta,
+  StrapiStore,
+  StrapiQueryParams,
+  StrapiQueryParamsParsed,
+  StrapiQueryParamsParsedFilters,
+  StrapiQueryParamsParsedOrderBy,
+  StrapiUser,
+  StrapiRequestQueryFieldsClause,
+  OnlyStrings,
+} from "strapi-typed";
+import { ToBeFixed } from "./common";
+import {
+  CommentsPluginConfig,
+  SettingsCommentsPluginConfig,
+  ViewCommentsPluginConfig,
+} from "./config";
+import {
+  Comment,
+  CommentAuthor,
+  CommentModelKeys,
+  CommentReport,
+  RelatedEntity,
+} from "./contentTypes";
+
+import PluginError from "../server/utils/error";
+import {
+  AdminFindOneAndThreadProps,
+  AdminPaginatedResponse,
+  AdminSinglePageResponse,
+  CommentsPluginServices,
+} from "./services";
+
+export type FlatInput<TKeys extends string> = {
+  relation: Id;
+  query: ToBeFixed;
+  sort: ToBeFixed;
+  pagination?: ToBeFixed;
+  fields?: StrapiRequestQueryFieldsClause<TKeys>;
+};
+
+export type ThrowableResponse<T> = T | PluginError | never;
+export type ThrowablePromisedResponse<T> = Promise<ThrowableResponse<T>>;
+
+export type CreateCommentPayload = {
+  content: Comment["content"];
+  threadOf: Comment["threadOf"];
+  author?: Comment["author"];
+  approvalStatus?: Comment["approvalStatus"];
+};
+
+export type UpdateCommentPayload = {
+  content: Comment["content"];
+  author: {
+    id: CommentAuthor["id"];
+  };
+};
+
+export type CreateCommentReportPayload = {
+  reason: CommentReport["reason"];
+  content: CommentReport["content"];
+};
+
+export interface IControllerAdmin {
+  getService<T extends CommentsPluginServices>(name?: string): T;
+  config(
+    ctx: StrapiRequestContext
+  ): ThrowablePromisedResponse<ViewCommentsPluginConfig>;
+  settingsConfig(
+    ctx: StrapiRequestContext
+  ): ThrowablePromisedResponse<SettingsCommentsPluginConfig>;
+  settingsUpdateConfig(
+    ctx: StrapiRequestContext<SettingsCommentsPluginConfig>
+  ): ThrowablePromisedResponse<SettingsCommentsPluginConfig>;
+  settingsRestoreConfig(
+    ctx: StrapiRequestContext<SettingsCommentsPluginConfig>
+  ): ThrowablePromisedResponse<SettingsCommentsPluginConfig>;
+  settingsRestart(
+    ctx: StrapiRequestContext
+  ): ThrowablePromisedResponse<unknown>;
+  findAll(ctx: StrapiRequestContext): Promise<AdminPaginatedResponse<Comment>>;
+  findOne(
+    ctx: StrapiRequestContext<never, AdminFindOneAndThreadProps>
+  ): ThrowablePromisedResponse<AdminSinglePageResponse>;
+  blockComment(ctx: StrapiRequestContext): ThrowablePromisedResponse<Comment>;
+  unblockComment(ctx: StrapiRequestContext): ThrowablePromisedResponse<Comment>;
+  blockCommentThread(
+    ctx: StrapiRequestContext
+  ): ThrowablePromisedResponse<Comment>;
+  unblockCommentThread(
+    ctx: StrapiRequestContext
+  ): ThrowablePromisedResponse<Comment>;
+  resolveAbuseReport(
+    ctx: StrapiRequestContext
+  ): ThrowablePromisedResponse<CommentReport>;
+  approveComment(ctx: StrapiRequestContext): ThrowablePromisedResponse<Comment>;
+  rejectComment(ctx: StrapiRequestContext): ThrowablePromisedResponse<Comment>;
+}
+
+export interface IControllerClient {
+  getService<T extends CommentsPluginServices>(name?: string): T;
+  findAllFlat(
+    ctx: StrapiRequestContext<never>
+  ): ThrowablePromisedResponse<StrapiPaginatedResponse<Comment>>;
+  findAllInHierarchy(
+    ctx: StrapiRequestContext<never>
+  ): ThrowablePromisedResponse<Array<Comment>>;
+  post(
+    ctx: StrapiRequestContext<CreateCommentPayload>
+  ): ThrowablePromisedResponse<Comment>;
+  put(
+    ctx: StrapiRequestContext<UpdateCommentPayload>
+  ): ThrowablePromisedResponse<Comment>;
+  reportAbuse(
+    ctx: StrapiRequestContext<CreateCommentReportPayload>
+  ): ThrowablePromisedResponse<CommentReport>;
+  removeComment(
+    ctx: StrapiRequestContext<never>
+  ): ThrowablePromisedResponse<Comment>;
+}

package/types/graphql.d.ts

@@ -0,0 +1,24 @@
+import { Primitive, StrapiContext } from "strapi-typed";
+import { ToBeFixed } from "./common";
+
+export type StrapiGraphQLContext = StrapiContext & ToBeFixed;
+
+export interface INexusType {
+  field(name: string, config?: ToBeFixed): void;
+  id(name: string);
+  boolean(name: string);
+  string(name: string);
+  int(name: string);
+
+  nonNull: INexusType;
+  list: INexusType;
+}
+
+export type NexusRequestProps<T = ToBeFixed> = {
+  input?: T;
+};
+
+export type NexusAst = {
+  kind: string;
+  value: Primitive;
+};

package/types/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./common";
+export * from "./config";
+export * from "./contentTypes";
+export * from "./constants";
+export * from "./controllers";
+export * from "./graphql";
+export * from "./services";