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

package/content-types/comment.ts

@@ -0,0 +1,93 @@
+/**
+ * Comments Collection Type
+ */
+
+export default {
+  info: {
+    tableName: "plugin-comments-comments",
+    singularName: "comment",
+    pluralName: "comments",
+    displayName: "Comment",
+    description: "Comment content type",
+    kind: "collectionType",
+  },
+  options: {
+    draftAndPublish: false,
+  },
+  pluginOptions: {
+    "content-manager": {
+      visible: false,
+    },
+    "content-type-builder": {
+      visible: false,
+    },
+  },
+  attributes: {
+    content: {
+      type: "text",
+      configurable: false,
+      required: true,
+    },
+    blocked: {
+      type: "boolean",
+      default: false,
+      configurable: false,
+    },
+    blockedThread: {
+      type: "boolean",
+      default: false,
+      configurable: false,
+    },
+    blockReason: {
+      type: "string",
+      configurable: false,
+    },
+    authorUser: {
+      type: "relation",
+      relation: "oneToOne",
+      target: "plugin::users-permissions.user",
+      configurable: false,
+    },
+    authorId: {
+      type: "string",
+      configurable: false,
+    },
+    authorName: {
+      type: "string",
+      configurable: false,
+    },
+    authorEmail: {
+      type: "email",
+      configurable: false,
+    },
+    authorAvatar: {
+      type: "string",
+      configurable: false,
+    },
+    removed: {
+      type: "boolean",
+      configurable: false,
+    },
+    approvalStatus: {
+      type: "string",
+      configurable: false,
+    },
+    related: {
+      type: "string",
+      configurable: false,
+    },
+    reports: {
+      type: "relation",
+      relation: "oneToMany",
+      target: "plugin::comments.comment-report",
+      mappedBy: "related",
+      configurable: false,
+    },
+    threadOf: {
+      type: "relation",
+      relation: "oneToOne",
+      target: "plugin::comments.comment",
+      configurable: false,
+    },
+  },
+};

package/content-types/index.ts

@@ -0,0 +1,11 @@
+import CommentCT from "./comment";
+import ReportCT from "./report";
+
+export default {
+  comment: {
+    schema: CommentCT,
+  },
+  "comment-report": {
+    schema: ReportCT,
+  },
+};

package/content-types/report.ts

@@ -0,0 +1,50 @@
+/**
+ * Comments Collection Type
+ */
+
+export default {
+  info: {
+    tableName: "plugin-comments-reports",
+    singularName: "comment-report",
+    pluralName: "comment-reports",
+    displayName: "Reports",
+    description: "Reports content type",
+    kind: "collectionType",
+  },
+  options: {
+    draftAndPublish: false,
+  },
+  pluginOptions: {
+    "content-manager": {
+      visible: false,
+    },
+    "content-type-builder": {
+      visible: false,
+    },
+  },
+  attributes: {
+    content: {
+      type: "text",
+      configurable: false,
+    },
+    reason: {
+      type: "enumeration",
+      enum: ["BAD_LANGUAGE", "DISCRIMINATION", "OTHER"],
+      default: "OTHER",
+      configurable: false,
+      required: true,
+    },
+    resolved: {
+      type: "boolean",
+      default: false,
+      configurable: false,
+    },
+    related: {
+      type: "relation",
+      relation: "manyToOne",
+      target: "plugin::comments.comment",
+      inversedBy: "reports",
+      configurable: false,
+    },
+  },
+};

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.1.0-beta.1",
+  "version": "2.1.2",
   "description": "Strapi - Comments plugin",
   "strapi": {
     "name": "comments",
@@ -8,19 +8,48 @@
     "description": "Powerful Strapi based comments moderation tool for you and your users",
     "kind": "plugin"
   },
-  "scripts": {},
+  "scripts": {
+    "prepare": "husky install",
+    "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/plugin-graphql": "^4.1.6",
-    "@strapi/utils": "^4.1.6",
     "bad-words": "^3.0.4"
   },
-  "devDependencies": {},
+  "devDependencies": {
+    "@types/bad-words": "^3.0.1",
+    "@types/jest": "^27.4.1",
+    "codecov": "^3.7.2",
+    "copyfiles": "^2.4.1",
+    "husky": "7.0.4",
+    "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"
+    "@strapi/strapi": "4.x",
+    "@strapi/utils": "4.x",
+    "@strapi/plugin-graphql": "4.x"
   },
   "nodemonConfig": {
     "ignore": [
@@ -62,4 +91,4 @@
     "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.ts

@@ -0,0 +1,66 @@
+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: CommentsPluginConfig = await getPluginService<IServiceCommon>(
+      "common"
+    ).getConfig();
+    const { enabledCollections } = config;
+    if (!isEmpty(enabledCollections)) {
+      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"
+    );
+  }
+  // Add permissions
+  const actions = [
+    {
+      section: "plugins",
+      displayName: "Comments: Read",
+      uid: permissions.comments.read,
+      pluginName: "comments",
+    },
+    {
+      section: "plugins",
+      displayName: "Comments: Moderate",
+      uid: permissions.comments.moderate,
+      pluginName: "comments",
+    },
+    {
+      section: "plugins",
+      displayName: "Reports: Read",
+      uid: permissions.reports.read,
+      pluginName: "comments",
+    },
+    {
+      section: "plugins",
+      displayName: "Reports: Moderate",
+      uid: permissions.reports.action,
+      pluginName: "comments",
+    },
+    {
+      section: "plugins",
+      displayName: "Settings: Read",
+      uid: permissions.settings.read,
+      pluginName: "comments",
+    },
+    {
+      section: "plugins",
+      displayName: "Settings: Change",
+      uid: permissions.settings.change,
+      pluginName: "comments",
+    },
+  ];
+
+  await strapi.admin.services.permission.actionProvider.registerMany(actions);
+};

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;