strapi-plugin-comments 2.0.11 → 2.1.1

package/jest.config.ts

@@ -0,0 +1,22 @@
+import type { Config } from "@jest/types";
+import { defaults as tsjPreset } from "ts-jest/presets";
+
+const config: Config.InitialOptions = {
+  name: "Unit test",
+  testMatch: ["**/__tests__/?(*.)+(spec|test).ts"],
+  transform: {
+    ...tsjPreset.transform,
+  },
+  preset: "ts-jest",
+  coverageDirectory: "./coverage/",
+  collectCoverage: true,
+  globals: {
+    "ts-jest": {
+      diagnostics: {
+        warnOnly: true,
+      },
+    },
+  },
+};
+
+export default config;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strapi-plugin-comments",
-  "version": "2.0.11",
+  "version": "2.1.1",
   "description": "Strapi - Comments plugin",
   "strapi": {
     "name": "comments",
@@ -10,30 +10,60 @@
   },
   "scripts": {
     "prepare": "husky install",
-    "publish:latest": "npm publish --tag latest",
-    "test:unit": "jest --verbose --coverage"
+    "publish:latest": "cd build && npm publish --tag latest",
+    "prepublish:latest": "npm run clean && npm run build && node build/setup-package.js",
+    "build": "tsc && yarn copy-translations",
+    "build:dev": "yarn run build && cp ./package.json ./build",
+    "copy-translations": "copyfiles admin/src/translations/*.json build/",
+    "clean": "rm -rf build",
+    "develop": "nodemon --exec \"yarn build:dev\"",
+    "test:unit": "jest --verbose --coverage",
+    "lint": "prettier --check .",
+    "format": "prettier --write ."
   },
   "repository": {
     "type": "git",
     "url": "https://github.com/VirtusLab-Open-Source/strapi-plugin-comments"
   },
   "dependencies": {
-    "@strapi/utils": "^4.1.7",
-    "@strapi/plugin-graphql": "^4.1.7",
+    "@strapi/utils": "^4.1.8",
+    "@strapi/plugin-graphql": "^4.1.8",
     "bad-words": "^3.0.4"
   },
   "devDependencies": {
+    "@types/bad-words": "^3.0.1",
+    "@types/jest": "^27.4.1",
     "codecov": "^3.7.2",
-    "jest": "^26.0.1",
-    "jest-cli": "^26.0.1",
-    "jest-styled-components": "^7.0.2",
-    "koa": "2.13.3",
+    "copyfiles": "^2.4.1",
     "husky": "7.0.4",
-    "prettier": "2.5.1"
+    "jest": "^27.5.1",
+    "jest-cli": "^27.5.1",
+    "jest-styled-components": "^7.0.8",
+    "koa": "2.13.3",
+    "nodemon": "^2.0.15",
+    "prettier": "^2.6.0",
+    "rimraf": "^3.0.2",
+    "ts-jest": "^27.1.3",
+    "ts-node": "^10.7.0",
+    "strapi-typed": "^1.0.9",
+    "typescript": "^4.6.3"
   },
   "peerDependencies": {
     "@strapi/strapi": "4.x"
   },
+  "nodemonConfig": {
+    "ignore": [
+      "./build/**/*",
+      "./__mocks__/*",
+      "./**/__tests__/*"
+    ],
+    "ext": "js,json,ts"
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "yarn format && yarn test:unit"
+    }
+  },
   "author": {
     "name": "VirtusLab",
     "email": "strapi@virtuslab.com",
@@ -55,6 +85,10 @@
     "node": ">=14.x.x <=17.x.x",
     "npm": ">=7.x.x"
   },
-  "keywords": ["strapi", "plugin", "comments"],
+  "keywords": [
+    "strapi",
+    "plugin",
+    "comments"
+  ],
   "license": "MIT"
 }

package/permissions.ts

@@ -0,0 +1,17 @@
+import { ToBeFixed } from "./types/common";
+
+export default {
+  render: (uid: ToBeFixed) => `plugin::comments.${uid}`,
+  comments: {
+    read: "read",
+    moderate: "moderate",
+  },
+  reports: {
+    read: "reports.read",
+    action: "reports.action",
+  },
+  settings: {
+    read: "settings.read",
+    change: "settings.change",
+  },
+};

package/server/{bootstrap.js → bootstrap.ts}

@@ -1,24 +1,25 @@
-'use strict';
-
-const { isEmpty } = require('lodash');
-const permissions = require('./../permissions');
-const { getPluginService } = require('./utils/functions');
-
-module.exports = async ({ strapi }) => {
+import { isEmpty } from "lodash";
+import { StrapiContext } from "strapi-typed";
+import { CommentsPluginConfig, IServiceCommon } from "../types";
+import permissions from "./../permissions";
+import { getPluginService } from "./utils/functions";
 
+export = async ({ strapi }: StrapiContext) => {
   // Provide GQL support
-  if (strapi.plugin('graphql')) {
-    const config = await getPluginService('common').getConfig();
+  if (strapi.plugin("graphql")) {
+    const config: CommentsPluginConfig = await getPluginService<IServiceCommon>(
+      "common"
+    ).getConfig();
     const { enabledCollections } = config;
     if (!isEmpty(enabledCollections)) {
-      await require('./graphql')({ strapi, config });
+      await require("./graphql")({ strapi, config });
     }
   }
 
   // Check if the plugin users-permissions is installed because the navigation needs it
   if (Object.keys(strapi.plugins).indexOf("users-permissions") === -1) {
     throw new Error(
-      "In order to make the comments plugin work the users-permissions plugin is required",
+      "In order to make the comments plugin work the users-permissions plugin is required"
     );
   }
   // Add permissions

package/server/config/index.ts

@@ -0,0 +1,19 @@
+import { StrapiConfig } from "../../types";
+
+const config: StrapiConfig = {
+  default: {
+    enabledCollections: [],
+    moderatorRoles: [],
+    approvalFlow: [],
+    entryLabel: {
+      "*": ["Title", "title", "Name", "name", "Subject", "subject"],
+    },
+    reportReasons: {
+      BAD_LANGUAGE: "BAD_LANGUAGE",
+      DISCRIMINATION: "DISCRIMINATION",
+      OTHER: "OTHER",
+    },
+  },
+};
+
+export default config;

package/server/controllers/admin.ts

@@ -0,0 +1,194 @@
+import { StrapiRequestContext } from "strapi-typed";
+import {
+  AdminFindAllProps,
+  AdminFindOneAndThreadProps,
+  AdminPaginatedResponse,
+  AdminSinglePageResponse,
+  Comment,
+  CommentReport,
+  IControllerAdmin,
+  IServiceAdmin,
+  SettingsCommentsPluginConfig,
+  ThrowablePromisedResponse,
+  ToBeFixed,
+  ViewCommentsPluginConfig,
+} from "../../types";
+
+import { assertNotEmpty, getPluginService } from "./../utils/functions";
+import { parseParams, throwError } from "./utils/functions";
+
+const controllers: IControllerAdmin = {
+  getService<T>(name = "admin") {
+    return getPluginService<T>(name);
+  },
+
+  async config(
+    ctx: StrapiRequestContext<never>
+  ): ThrowablePromisedResponse<ViewCommentsPluginConfig> {
+    try {
+      return await this.getService<IServiceAdmin>().config<ViewCommentsPluginConfig>();
+    } catch (e) {
+      throw throwError(ctx, e);
+    }
+  },
+
+  async settingsConfig(
+    ctx: StrapiRequestContext<never>
+  ): ThrowablePromisedResponse<SettingsCommentsPluginConfig> {
+    try {
+      return this.getService<IServiceAdmin>().config<SettingsCommentsPluginConfig>(
+        true
+      );
+    } catch (e) {
+      throw throwError(ctx, e);
+    }
+  },
+
+  async settingsUpdateConfig(
+    ctx: StrapiRequestContext<SettingsCommentsPluginConfig>
+  ): ThrowablePromisedResponse<SettingsCommentsPluginConfig> {
+    try {
+      const {
+        request: { body },
+      } = ctx;
+
+      assertNotEmpty<SettingsCommentsPluginConfig>(body);
+
+      return this.getService<IServiceAdmin>().updateConfig(body);
+    } catch (e) {
+      throw throwError(ctx, e);
+    }
+  },
+
+  async settingsRestoreConfig(
+    ctx: StrapiRequestContext<never>
+  ): ThrowablePromisedResponse<SettingsCommentsPluginConfig> {
+    try {
+      return this.getService<IServiceAdmin>().restoreConfig();
+    } catch (e) {
+      throw throwError(ctx, e);
+    }
+  },
+
+  async settingsRestart(
+    ctx: StrapiRequestContext<never>
+  ): ThrowablePromisedResponse<any> {
+    try {
+      await this.getService<IServiceAdmin>().restart();
+      return ctx.send({ status: 200 });
+    } catch (e) {
+      throw throwError(ctx, e);
+    }
+  },
+
+  async findAll(
+    ctx: StrapiRequestContext<never, AdminFindAllProps>
+  ): Promise<AdminPaginatedResponse<Comment>> {
+    return this.getService<IServiceAdmin>().findAll(ctx.query);
+  },
+
+  async findOne(
+    ctx: StrapiRequestContext<never, AdminFindOneAndThreadProps>
+  ): ThrowablePromisedResponse<AdminSinglePageResponse> {
+    const { params = {}, query } = ctx;
+    const { id }: ToBeFixed = parseParams(params);
+    try {
+      return await this.getService<IServiceAdmin>().findOneAndThread(id, query);
+    } catch (e) {
+      throw throwError(ctx, e);
+    }
+  },
+
+  async blockComment(
+    ctx: StrapiRequestContext<never>
+  ): ThrowablePromisedResponse<Comment> {
+    const { params = {} } = ctx;
+    const { id } = parseParams(params);
+    try {
+      return await this.getService<IServiceAdmin>().blockComment(id, true);
+    } catch (e) {
+      throw throwError(ctx, e);
+    }
+  },
+
+  async unblockComment(
+    ctx: StrapiRequestContext<never>
+  ): ThrowablePromisedResponse<Comment> {
+    const { params = {} } = ctx;
+    const { id } = parseParams(params);
+    try {
+      return await this.getService<IServiceAdmin>().blockComment(id, false);
+    } catch (e) {
+      throw throwError(ctx, e);
+    }
+  },
+
+  async blockCommentThread(
+    ctx: StrapiRequestContext<never>
+  ): ThrowablePromisedResponse<Comment> {
+    const { params = {} } = ctx;
+    const { id } = parseParams(params);
+    try {
+      return await this.getService<IServiceAdmin>().blockCommentThread(
+        id,
+        true
+      );
+    } catch (e) {
+      throw throwError(ctx, e);
+    }
+  },
+
+  async unblockCommentThread(
+    ctx: StrapiRequestContext<never>
+  ): ThrowablePromisedResponse<Comment> {
+    const { params = {} } = ctx;
+    const { id } = parseParams(params);
+    try {
+      return await this.getService<IServiceAdmin>().blockCommentThread(
+        id,
+        false
+      );
+    } catch (e) {
+      throw throwError(ctx, e);
+    }
+  },
+
+  async resolveAbuseReport(
+    ctx: StrapiRequestContext<never>
+  ): ThrowablePromisedResponse<CommentReport> {
+    const { params = {} } = ctx;
+    const { id: commentId, reportId } = parseParams(params);
+    try {
+      return await this.getService<IServiceAdmin>().resolveAbuseReport(
+        reportId,
+        commentId
+      );
+    } catch (e) {
+      throw throwError(ctx, e);
+    }
+  },
+
+  async approveComment(
+    ctx: StrapiRequestContext<never>
+  ): ThrowablePromisedResponse<Comment> {
+    const { id } = parseParams(ctx.params || {});
+    try {
+      return await this.getService<IServiceAdmin>().approveComment(id);
+    } catch (e) {
+      throw throwError(ctx, e);
+    }
+  },
+
+  async rejectComment(
+    ctx: StrapiRequestContext<never>
+  ): ThrowablePromisedResponse<Comment> {
+    const { id } = parseParams(ctx.params || {});
+    try {
+      return await this.getService<IServiceAdmin>().rejectComment(id);
+    } catch (e) {
+      throw throwError(ctx, e);
+    }
+  },
+};
+
+export default controllers;

package/server/controllers/client.ts

@@ -0,0 +1,220 @@
+import {
+  Comment,
+  CommentReport,
+  CreateCommentPayload,
+  CreateCommentReportPayload,
+  IControllerClient,
+  Id,
+  IServiceClient,
+  IServiceCommon,
+  ThrowablePromisedResponse,
+  ToBeFixed,
+  UpdateCommentPayload,
+} from "../../types";
+import { StrapiRequestContext, StrapiPaginatedResponse } from "strapi-typed";
+
+import {
+  assertNotEmpty,
+  assertParamsPresent,
+  getPluginService,
+} from "./../utils/functions";
+import { parseParams, throwError } from "./utils/functions";
+import { flatInput } from "./utils/parsers";
+import PluginError from "../utils/error";
+
+const controllers: IControllerClient = {
+  getService(name = "client") {
+    return getPluginService(name);
+  },
+
+  async findAllFlat(
+    this: IControllerClient,
+    ctx: StrapiRequestContext<never, ToBeFixed>
+  ): ThrowablePromisedResponse<StrapiPaginatedResponse<Comment>> {
+    const { params = {}, query, sort, pagination } = ctx;
+    const { relation } = parseParams<{ relation: string }>(params);
+
+    const {
+      sort: querySort,
+      pagination: queryPagination,
+      fields,
+      ...filterQuery
+    } = query || {};
+
+    try {
+      assertParamsPresent<{ relation: string }>(params, ["relation"]);
+
+      return this.getService<IServiceCommon>("common").findAllFlat(
+        flatInput({
+          relation,
+          query: filterQuery,
+          sort: sort || querySort,
+          pagination: pagination || queryPagination,
+          fields,
+        })
+      );
+    } catch (e: ToBeFixed) {
+      throw throwError(ctx, e);
+    }
+  },
+
+  async findAllInHierarchy(
+    this: IControllerClient,
+    ctx: StrapiRequestContext<never, ToBeFixed>
+  ): ThrowablePromisedResponse<Array<Comment>> {
+    const { params, query, sort } = ctx;
+    const { relation } = parseParams<{ relation: string }>(params);
+
+    const { sort: querySort, fields, ...filterQuery } = query || {};
+
+    try {
+      assertParamsPresent<{ relation: string }>(params, ["relation"]);
+
+      return await this.getService<IServiceCommon>("common").findAllInHierarchy(
+        {
+          ...flatInput<Comment>({
+            relation,
+            query: filterQuery,
+            sort: sort || querySort,
+            fields,
+          }),
+          dropBlockedThreads: true,
+        }
+      );
+    } catch (e: ToBeFixed) {
+      throw throwError(ctx, e);
+    }
+  },
+
+  async post(
+    this: IControllerClient,
+    ctx: StrapiRequestContext<CreateCommentPayload>
+  ): ThrowablePromisedResponse<Comment> {
+    const { request, params, state = {} } = ctx;
+    const { relation } = parseParams<{
+      relation: string;
+    }>(params);
+    const { user } = state;
+    const { body } = request;
+    try {
+      assertParamsPresent<{ relation: string }>(params, ["relation"]);
+      assertNotEmpty<CreateCommentPayload>(body);
+
+      const entity = await this.getService<IServiceClient>().create(
+        relation,
+        body,
+        user
+      );
+
+      if (entity) {
+        return entity;
+      }
+      throw new PluginError(400, "Comment hasn't been created");
+    } catch (e: ToBeFixed) {
+      throw throwError(ctx, e);
+    }
+  },
+
+  async put(
+    this: IControllerClient,
+    ctx: StrapiRequestContext<UpdateCommentPayload>
+  ): ThrowablePromisedResponse<Comment> {
+    const { request, state, params = {} } = ctx;
+    const { body } = request;
+    const { user } = state;
+    const { commentId, relation } = parseParams<{
+      relation: string;
+      commentId: Id;
+    }>(params);
+    try {
+      assertParamsPresent<{
+        relation: string;
+        commentId: Id;
+      }>(params, ["commentId", "relation"]);
+      assertNotEmpty<UpdateCommentPayload>(body);
+
+      return await this.getService<IServiceClient>().update(
+        commentId,
+        relation,
+        body,
+        user
+      );
+    } catch (e: ToBeFixed) {
+      throw throwError(ctx, e);
+    }
+  },
+
+  async reportAbuse(
+    this: IControllerClient,
+    ctx: StrapiRequestContext<CreateCommentReportPayload>
+  ): ThrowablePromisedResponse<CommentReport> {
+    const { request, state, params = {} } = ctx;
+    const { body } = request;
+    const { user } = state;
+    const { relation, commentId } = parseParams<{
+      relation: string;
+      commentId: Id;
+    }>(params);
+
+    try {
+      assertParamsPresent(params, ["commentId", "relation"]);
+      assertNotEmpty<CreateCommentReportPayload>(body);
+
+      if (!body.content) {
+        throw new PluginError(400, "Content field is required");
+      }
+      return await this.getService<IServiceClient>().reportAbuse(
+        commentId,
+        relation,
+        body,
+        user
+      );
+    } catch (e) {
+      throw throwError(ctx, e);
+    }
+  },
+
+  async removeComment(
+    this: IControllerClient,
+    ctx: StrapiRequestContext<never>
+  ): ThrowablePromisedResponse<Comment> {
+    const {
+      params,
+      query,
+      state: { user },
+    } = ctx;
+
+    const { relation, commentId } = parseParams<{
+      relation: string;
+      commentId: Id;
+    }>(params);
+    const { authorId } = parseParams(query);
+
+    try {
+      assertParamsPresent<{
+        relation: string;
+        commentId: Id;
+      }>(params, ["commentId", "relation"]);
+      assertParamsPresent<{
+        authorId: Id;
+      }>(query, ["authorId"]);
+
+      if (authorId || user?.id) {
+        return await this.getService<IServiceClient>().markAsRemoved(
+          commentId,
+          relation,
+          authorId,
+          user
+        );
+      }
+      return new PluginError(400, "Not provided authorId");
+    } catch (e: ToBeFixed) {
+      if (!e.isBoom) {
+        throwError(ctx, e);
+      }
+      throw e;
+    }
+  },
+};
+
+export default controllers;

package/server/controllers/index.ts

@@ -0,0 +1,13 @@
+import adminController from "./admin";
+import clientController from "./client";
+
+type PluginControllers = {
+  [key: string]: Function | Object;
+};
+
+const controllers: PluginControllers = {
+  admin: adminController,
+  client: clientController,
+};
+
+export default controllers;

package/server/controllers/utils/functions.ts

@@ -0,0 +1,27 @@
+import { Id, StringMap, StrapiRequestContext } from "strapi-typed";
+
+import PluginError from "../../utils/error";
+
+type ParseResponse = StringMap<string | number | Id>;
+
+export const parseParams = <T extends ParseResponse>(
+  params: StringMap<string | number>
+) =>
+  Object.keys(params).reduce((prev, curr): T => {
+    const value = params[curr];
+    const parsedValue = Number(value);
+    return {
+      ...prev,
+      [curr]: isNaN(parsedValue) ? value : parsedValue,
+    };
+  }, {} as T);
+
+export const throwError = <T extends {} = never>(
+  ctx: StrapiRequestContext<T>,
+  e: PluginError | Error | unknown
+): PluginError | Error | unknown | never => {
+  if (e instanceof PluginError) {
+    return ctx.throw(e.status, JSON.stringify(e));
+  }
+  return e;
+};

package/server/controllers/utils/parsers.ts

@@ -0,0 +1,59 @@
+import { OnlyStrings } from "strapi-typed";
+import { FlatInput, ToBeFixed } from "../../../types";
+
+export const flatInput = <T, TKeys = keyof T>(
+  payload: FlatInput<OnlyStrings<TKeys>>
+) => {
+  const { relation, query, sort, pagination, fields } = payload;
+
+  const { populate = {}, ...restQuery } = query;
+  const filters = restQuery?.filters || restQuery;
+  const orOperator = (filters?.$or || []).filter(
+    (_: ToBeFixed) => !Object.keys(_).includes("removed")
+  );
+
+  let basePopulate = {
+    ...populate,
+  };
+
+  let threadOfPopulate = {
+    threadOf: {
+      populate: {
+        authorUser: true,
+        ...populate,
+      },
+    },
+  };
+
+  // Cover case when someone wants to populate author instead of authorUser
+  if (populate.author) {
+    const { author, ...restPopulate } = populate;
+    basePopulate = {
+      ...restPopulate,
+      authorUser: author,
+    };
+    threadOfPopulate = {
+      threadOf: {
+        populate: {
+          authorUser: author,
+          ...restPopulate,
+        },
+      },
+    };
+  }
+
+  return {
+    query: {
+      ...filters,
+      $or: [...orOperator, { removed: { $null: true } }, { removed: false }],
+      related: relation,
+    },
+    populate: {
+      ...basePopulate,
+      ...threadOfPopulate,
+    },
+    pagination,
+    sort,
+    fields,
+  };
+};