strapi-plugin-comments 2.1.0 → 2.1.1

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

package/server/destroy.ts

@@ -0,0 +1,3 @@
+export = () => {
+  // destroy phase
+};

package/server/graphql/index.ts

@@ -0,0 +1,27 @@
+import { StrapiGraphQLContext } from "../../types";
+
+import getTypes from "./types";
+import getQueries from "./queries";
+import getMutations from "./mutations";
+import getResolversConfig from "./resolvers-config";
+import { getModelUid } from "../services/utils/functions";
+
+export = async ({ strapi, config }: StrapiGraphQLContext) => {
+  const extensionService = strapi.plugin("graphql").service("extension");
+  extensionService.shadowCRUD(getModelUid("comment")).disableQueries();
+  extensionService.shadowCRUD(getModelUid("comment")).disableMutations();
+  extensionService.shadowCRUD(getModelUid("comment-report")).disableQueries();
+  extensionService.shadowCRUD(getModelUid("comment-report")).disableMutations();
+
+  extensionService.use(({ strapi, nexus }: StrapiGraphQLContext) => {
+    const types = getTypes({ strapi, nexus, config });
+    const queries = getQueries({ strapi, nexus, config });
+    const mutations = getMutations({ strapi, nexus, config });
+    const resolversConfig = getResolversConfig({ strapi, config });
+
+    return {
+      types: [types, queries, mutations],
+      resolversConfig,
+    };
+  });
+};

package/server/graphql/mutations/createAbuseReport.ts

@@ -0,0 +1,38 @@
+import { StrapiRequestContext } from "strapi-typed";
+import {
+  IServiceClient,
+  NexusRequestProps,
+  StrapiGraphQLContext,
+  ToBeFixed,
+} from "../../../types";
+import { getPluginService } from "../../utils/functions";
+
+export = ({ nexus }: StrapiGraphQLContext) => {
+  const { nonNull } = nexus;
+
+  return {
+    type: nonNull("Report"),
+    args: {
+      input: nonNull("CreateReport"),
+    },
+    async resolve(
+      _: Object,
+      args: NexusRequestProps,
+      ctx: StrapiRequestContext<never> & ToBeFixed
+    ) {
+      const { input } = args;
+      const { state: { user = undefined } = {} } = ctx;
+      const { commentId, relation, ...body } = input;
+      try {
+        return await getPluginService<IServiceClient>("client").reportAbuse(
+          commentId,
+          relation,
+          body,
+          user
+        );
+      } catch (e: ToBeFixed) {
+        throw new Error(e);
+      }
+    },
+  };
+};

package/server/graphql/mutations/createComment.ts

@@ -0,0 +1,41 @@
+import { StrapiRequestContext } from "strapi-typed";
+import {
+  IServiceClient,
+  StrapiGraphQLContext,
+  ToBeFixed,
+} from "../../../types";
+
+import { getPluginService } from "../../utils/functions";
+
+type CreateCommentProps = {
+  input: ToBeFixed;
+};
+
+export = ({ nexus }: StrapiGraphQLContext) => {
+  const { nonNull } = nexus;
+
+  return {
+    type: nonNull("CommentSingle"),
+    args: {
+      input: nonNull("CreateComment"),
+    },
+    async resolve(
+      _: Object,
+      args: CreateCommentProps,
+      ctx: StrapiRequestContext<never> & ToBeFixed
+    ) {
+      const { input } = args;
+      const { state: { user = undefined } = {} } = ctx;
+      const { relation, ...body } = input;
+      try {
+        return await getPluginService<IServiceClient>("client").create(
+          relation,
+          body,
+          user
+        );
+      } catch (e: ToBeFixed) {
+        throw new Error(e);
+      }
+    },
+  };
+};

package/server/graphql/mutations/index.ts

@@ -0,0 +1,26 @@
+import { INexusType, StrapiGraphQLContext } from "../../../types";
+
+import createComment from "./createComment";
+import updateComment from "./updateComment";
+import removeComment from "./removeComment";
+import createAbuseReport from "./createAbuseReport";
+
+export = (context: StrapiGraphQLContext) => {
+  const mutations = {
+    createComment,
+    updateComment,
+    removeComment,
+    createAbuseReport,
+  };
+
+  return context.nexus.extendType({
+    type: "Mutation",
+    definition(t: INexusType) {
+      for (const [name, configFactory] of Object.entries(mutations)) {
+        const config = configFactory(context);
+
+        t.field(name, config);
+      }
+    },
+  });
+};

package/server/graphql/mutations/removeComment.ts

@@ -0,0 +1,41 @@
+"use strict";
+
+import { StrapiRequestContext } from "strapi-typed";
+import {
+  IServiceClient,
+  NexusRequestProps,
+  StrapiGraphQLContext,
+  ToBeFixed,
+} from "../../../types";
+
+import { getPluginService } from "../../utils/functions";
+
+export = ({ nexus }: StrapiGraphQLContext) => {
+  const { nonNull } = nexus;
+
+  return {
+    type: nonNull("CommentSingle"),
+    args: {
+      input: nonNull("RemoveComment"),
+    },
+    async resolve(
+      _: Object,
+      args: NexusRequestProps,
+      ctx: StrapiRequestContext<never> & ToBeFixed
+    ) {
+      const { input } = args;
+      const { state: { user = undefined } = {} } = ctx;
+      const { id, relation, author } = input;
+      try {
+        return await getPluginService<IServiceClient>("client").markAsRemoved(
+          id,
+          relation,
+          author?.id,
+          user
+        );
+      } catch (e: ToBeFixed) {
+        throw new Error(e);
+      }
+    },
+  };
+};