strapi-plugin-comments 2.0.11 → 2.1.1

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";

package/types/services.d.ts

@@ -0,0 +1,166 @@
+import {
+  Id,
+  KeyValueSet,
+  StrapiPagination,
+  StrapiPaginatedResponse,
+  StrapiResponseMeta,
+  StrapiStore,
+  StrapiQueryParams,
+  StrapiQueryParamsParsed,
+  StrapiQueryParamsParsedFilters,
+  StrapiQueryParamsParsedOrderBy,
+  StrapiUser,
+  OnlyStrings,
+  StringMap,
+  StrapiRequestQueryFieldsClause,
+  PopulateClause,
+} from "strapi-typed";
+import { ToBeFixed } from "./common";
+import {
+  AnyConfig,
+  CommentsPluginConfig,
+  SettingsCommentsPluginConfig,
+  ViewCommentsPluginConfig,
+} from "./config";
+import { Comment, CommentReport, RelatedEntity } from "./contentTypes";
+
+import PluginError from "../server/utils/error";
+
+export type AdminPaginatedResponse<T> = {
+  result: Array<T>;
+} & StrapiResponseMeta;
+
+export type FindAllFlatProps<T, TFields = keyof T> = {
+  query: {
+    threadOf?: number | string | null;
+    [key: string]: any;
+  } & {};
+  populate?: PopulateClause<OnlyStrings<TFields>>;
+  sort?: StringMap<unknown>;
+  fields?: StrapiRequestQueryFieldsClause<OnlyStrings<TFields>>;
+  pagination?: StrapiPagination;
+};
+
+export type FindAllInHierarhyProps = Omit<FindAllFlatProps, "pagination"> & {
+  startingFromId?: Id | null;
+  dropBlockedThreads?: boolean;
+  isAdmin?: boolean;
+};
+
+export type AdminFindAllProps = {
+  related: string;
+  entity: any;
+} & StrapiQueryParams;
+
+export type AdminFindAllQueryParamsParsed = {
+  _q: string;
+  orderBy: StrapiQueryParamsParsedOrderBy;
+  pageSize: number;
+  page: number;
+  filters: StrapiQueryParamsParsedFilters;
+} & StrapiQueryParamsParsed;
+
+export type AdminFindOneAndThreadProps = {
+  removed: boolean;
+} & StrapiQueryParams;
+
+export type AdminSinglePageResponse = {
+  entity: RelatedEntity;
+  selected: Comment;
+  level: Array<Comment>;
+};
+
+export interface IServiceCommon {
+  getConfig<T>(path?: string, defaultValue?: any): Promise<T>;
+  getPluginStore(): Promise<StrapiStore>;
+  getLocalConfig<T>(path?: string, defaultValue?: any): T;
+  findAllFlat(
+    props: FindAllFlatProps<Comment>,
+    relatedEntity?: RelatedEntity | null | boolean
+  ): Promise<StrapiPaginatedResponse<Comment>>;
+  findAllInHierarchy(
+    props: FindAllInHierarhyProps,
+    relatedEntity?: RelatedEntity | null | boolean
+  ): Promise<Array<Comment>>;
+  findOne(criteria: KeyValueSet<any>): Promise<Comment>;
+  findRelatedEntitiesFor(entities: Array<Comment>): Promise<RelatedEntity[]>;
+  mergeRelatedEntityTo(
+    entity: ToBeFixed,
+    relatedEntities: Array<RelatedEntity>
+  ): Comment;
+  modifiedNestedNestedComments(
+    id: Id,
+    fieldName: string,
+    value: any
+  ): Promise<boolean>;
+  sanitizeCommentEntity(
+    entity: Comment,
+    populate?: PopulateClause<OnlyStrings<keyof StrapiUser>>
+  ): Comment;
+  isValidUserContext(user?: any): boolean;
+  parseRelationString(
+    relation: string
+  ): Promise<[uid: string, relatedId: string | number]>;
+  checkBadWords(content: string): Promise<boolean | string | PluginError>;
+  isEnabledCollection(uid: string): Promise<boolean>;
+}
+
+export interface IServiceAdmin {
+  getCommonService(): IServiceCommon;
+  config<T extends AnyConfig>(viaSettingsPage?: boolean): Promise<T>;
+  updateConfig(
+    body: SettingsCommentsPluginConfig | undefined
+  ): Promise<SettingsCommentsPluginConfig>;
+  restoreConfig(): Promise<SettingsCommentsPluginConfig>;
+  restart(): void;
+  findAll(props: AdminFindAllProps): Promise<AdminPaginatedResponse<Comment>>;
+  findOneAndThread(
+    id: Id,
+    props: AdminFindOneAndThreadProps
+  ): Promise<AdminSinglePageResponse>;
+  blockComment(id: Id, forceStatus?: boolean): Promise<Comment>;
+  blockCommentThread(id: Id, forceStatus?: boolean): Promise<Comment>;
+  approveComment(id: Id): Promise<Comment>;
+  rejectComment(id: Id): Promise<Comment>;
+  blockNestedThreads(id: Id, blockStatus?: boolean): Promise<boolean>;
+  resolveAbuseReport(id: Id, commentId: Id): Promise<CommentReport>;
+}
+
+export interface IServiceClient {
+  getCommonService(): IServiceCommon;
+  create(
+    relation: string,
+    data: CreateCommentPayload,
+    user?: StrapiUser
+  ): Promise<Comment>;
+  update(
+    id: Id,
+    relation: string,
+    data: UpdateCommentPayload,
+    user?: StrapiUser
+  ): Promise<Comment>;
+  reportAbuse(
+    id: Id,
+    relation: string,
+    payload: CreateCommentReportPayload,
+    user?: StrapiUser
+  ): Promise<CommentReport>;
+  markAsRemoved(
+    id: Id,
+    relation: string,
+    authorId: Id,
+    user?: StrapiUser
+  ): Promise<Comment>;
+  sendAbuseReportEmail(reason: string, content: string): Promise<void>;
+  markAsRemovedNested(id: Id, status: boolean): Promise<boolean>;
+}
+
+export interface IServiceGraphQL {
+  buildContentTypeFilters(contentType: ToBeFixed);
+  graphQLFiltersToStrapiQuery(filters: ToBeFixed, contentType: ToBeFixed = {});
+}
+
+export type CommentsPluginServices =
+  | IServiceCommon
+  | IServiceClient
+  | IServiceAdmin;

package/__mocks__/initSetup.js

@@ -1,108 +0,0 @@
-const { get, set, isEmpty } = require('lodash');
-
-module.exports = (config = {}, toStore = false, database = {}) => {
-  const dbConfig = toStore ? {
-    plugin: {
-      comments: {
-        config: { ...config },
-      },
-    },
-  }: {};
-
-  let mock = {
-    db: {
-      query: (uid) => {
-        const [handler, rest] = uid.split('::');
-        const [collection] = rest.split('.');
-        const values = get(mock.db, `${handler}.${collection}.records`, []);
-        return {
-          findOne: async () => new Promise(resolve => resolve(values[0])),
-          findMany: async () => new Promise(resolve => resolve(values)),
-          findWithCount: async () => new Promise(resolve => resolve([values, values.length])),
-          count: async () => new Promise(resolve => resolve(values.length)),
-          create: async (value) => new Promise(resolve => resolve(value)), 
-          update: async (value) => new Promise(resolve => resolve(value)), 
-          delete: async (value) => new Promise(resolve => resolve(value)),
-        };
-      },
-      ...dbConfig,
-    },
-    getRef: function() {
-      return this;
-    },
-    plugin: function(name) {
-      return this.plugins[name];
-    },
-    store: async function(storeProps) {
-      const { type, name } = storeProps; // { type: 'plugin', name: 'comments' }
-
-      const mockedStore = {
-        get: async function(props) { // { key: 'config' }
-          const { key } = props;
-          return new Promise(resolve => resolve(get(mock.db, `${type}.${name}.${key}`, undefined)));
-        },
-        set: async function(props) { // { key: 'config', value: {...} }
-          const { key, value } = props;
-          set(mock.db, `${type}.${name}.${key}`, value);
-          return this.get(key);
-        },
-        delete: async function(props) { // { key: 'config' }
-          const { key } = props;
-          set(mock.db, `${type}.${name}.${key}`, undefined);
-          return new Promise(resolve => resolve(true));
-        },
-      };
-
-      return new Promise(resolve => resolve(mockedStore));
-    },
-    plugins: {
-      comments: {
-        service: function(name) {
-            return this.services[name]({ strapi: mock.getRef() });
-        },
-        package: require('../package.json'),
-        services: {
-          common: require('../server/services/common'),
-          client: require('../server/services/client'),
-          admin: require('../server/services/admin'),
-        },
-        contentTypes: {
-          comment: {
-            ...require('../content-types/comment'),
-            uid: 'plugins::comments.comment',
-          },
-          'comment-report': {
-            ...require('../content-types/report'),
-            uid: 'plugins::comments.comment-report'
-          },
-        }
-      }
-    },
-    config: {
-      get: function(prop = '') {
-        return get(this.plugins, prop.replace('plugin.', ''));
-      },
-      set: function(prop = '', value) {
-        return set(this.plugins, prop.replace('plugin.', ''), value);
-      },
-      plugins: {
-        comments: {
-          approvalFlow: ['api::blog-post.blog-post'],
-          entryLabel: {
-            'api::blog-post.blog-post': ['alternative_subject'],
-          },
-          ...(toStore ? {} : config)
-        }
-      }
-    }
-  };
-
-  if (!isEmpty(database)) {
-    Object.keys(database).forEach((uid) => {
-      const [handler, collection] = uid.split('::');
-      set(mock.db, `${handler}.${collection}.records`, database[uid]);
-    });
-  }
-
-  return mock;
-};

package/admin/src/components/ActionButton/styles.js

@@ -1,10 +0,0 @@
-
-import styled from 'styled-components';
-import { Button } from '@strapi/design-system/Button';
-
-export const ActionButton = styled(Button)`
-    padding: 7px 16px;
-    margin-left: ${({ isSingle }) => isSingle ? '0' : '.5rem'};
-
-    white-space: nowrap;
-`;

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

@@ -1,56 +0,0 @@
-/**
- *
- * Entity Details
- *
- */
-
- import React from 'react';
- import PropTypes from 'prop-types';
- import { Button } from '@strapi/design-system/Button';
- import { Dialog, DialogBody, DialogFooter } from '@strapi/design-system/Dialog';
- import { Flex } from '@strapi/design-system/Flex';
- import { Stack } from '@strapi/design-system/Stack';
- import { Typography } from '@strapi/design-system/Typography';
- import { ExclamationMarkCircle, Check } from '@strapi/icons';
-import { getMessage } from '../../utils';
-
-const ConfirmationDialog = ({ 
-    isVisible = false,
-    isActionAsync = false,
-    children, 
-    onConfirm, 
-    onCancel, 
-    header, 
-    labelCancel, 
-    labelConfirm, 
-    iconConfirm 
-}) => (
-    <Dialog onClose={onCancel} title={header || getMessage('compontents.confirmation.dialog.header', 'Confirmation')} isOpen={isVisible}>
-        <DialogBody icon={<ExclamationMarkCircle />}>
-        <Stack size={2}>
-            <Flex justifyContent="center">
-                <Typography id="dialog-confirm-description">{children || getMessage('compontents.confirmation.dialog.description') }</Typography>
-            </Flex>
-        </Stack>
-        </DialogBody>
-        <DialogFooter startAction={<Button onClick={onCancel} variant="tertiary" disabled={isActionAsync}>
-            { labelCancel || getMessage('compontents.confirmation.dialog.button.cancel', 'Cancel') }
-            </Button>} endAction={<Button onClick={onConfirm} variant="danger-light" startIcon={iconConfirm || <Check />} disabled={isActionAsync}>
-            { labelConfirm || getMessage('compontents.confirmation.dialog.button.confirm', 'Confirm') }
-            </Button>} />
-    </Dialog>
-  );
-
-  ConfirmationDialog.propTypes = {
-    isVisible: PropTypes.bool,
-    isActionAsync: PropTypes.bool,
-    children: PropTypes.array.isRequired,
-    header: PropTypes.string,
-    labelCancel: PropTypes.string,
-    labelConfirm: PropTypes.string,
-    iconConfirm: PropTypes.object,
-    onConfirm: PropTypes.func.isRequired,
-    onCancel: PropTypes.func.isRequired,
-};
-
-  export default ConfirmationDialog;

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

@@ -1,33 +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 { Status } from '@strapi/design-system/Status';
-import { Typography } from '@strapi/design-system/Typography';
-import { getMessage } from '../../utils';
-
-const DiscussionStatus = ({ blocked, blockedThread }) => {
-    let variant = 'success';
-
-    return (
-        <Box styles={{ marginBottom: 10 }}>
-            <Status variant={variant}>
-                <Typography>
-                    { getMessage('page.details.panel.status', 'Discussion is') } <Typography fontWeight="bold">{ getMessage('page.details.panel.open', 'OPEN') } </Typography>
-                </Typography>
-            </Status>
-        </Box>);
-};
-
-DiscussionStatus.propTypes = {
-
-};
-
-export default DiscussionStatus;
- 

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

@@ -1,62 +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 { Flex } from '@strapi/design-system/Flex';
-import { Link } from '@strapi/design-system/Link';
-import { Typography } from '@strapi/design-system/Typography';
-import { ArrowUp } from '@strapi/icons';
-import DiscussionThreadItem from '../DiscussionThreadItem';
-import { getMessage, getUrl } from '../../utils';
-import LoadingIndicatorOverlay from '../LoadingIndicatorOverlay';
-import { LoadingIndicatorContainer } from '../LoadingIndicatorOverlay/styles';
-
-const DiscussionThread = ({ level = [], selected = {}, allowedActions, isReloading }) => {
-    const rootThread = selected?.threadOf;
-    return (<LoadingIndicatorContainer as={Box} padding={4}>
-        { isReloading && <LoadingIndicatorOverlay />}
-        <Flex as={Box} direction="row" justifyContent="space-between" marginBottom={2}>
-            <Typography variant="delta" textColor="neutral800" id="discussion-thread">
-                { getMessage('page.details.panel.discussion', 'Discussion') }
-            </Typography>
-            { rootThread && (<Link to={getUrl(`discover/${rootThread.id}`)} startIcon={<ArrowUp />}>
-                        { getMessage('page.details.panel.discussion.nav.back') }
-                    </Link>) }
-        </Flex>
-        <Flex as="ul" direction="column" alignItems="flex-start">
-            { rootThread && (<DiscussionThreadItem {...rootThread} allowedActions={allowedActions} isThreadAuthor root pinned />) }
-            { level.map(item => {
-                const isSelected = selected.id === item.id;
-                const isThreadAuthor = !isNil(selected?.threadOf?.author?.id) && (selected?.threadOf?.author?.id === item?.author?.id);
-                return (<DiscussionThreadItem 
-                    key={`comment-${item.id}`}
-                    {...item} 
-                    allowedActions={allowedActions}
-                    root={isNil(rootThread)}
-                    blockedThread={rootThread?.blockedThread || item.blockedThread}
-                    isSelected={isSelected} 
-                    isThreadAuthor={isThreadAuthor} 
-                />);
-            })}
-        </Flex>
-    </LoadingIndicatorContainer>);
-};
-
-DiscussionThread.propTypes = {
-    level: PropTypes.array.isRequired,
-    selected: PropTypes.object.isRequired,
-    allowedActions: PropTypes.shape({
-        canModerate: PropTypes.bool,
-        canAccessReports: PropTypes.bool,
-        canReviewReports: PropTypes.bool,
-    }),
-    isReloading: PropTypes.bool,
-};
-
-export default DiscussionThread;