strapi-plugin-comments 2.1.2 → 2.1.5

package/server/controllers/admin.ts

@@ -1,194 +0,0 @@
-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

@@ -1,220 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

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

package/server/graphql/index.ts

@@ -1,27 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,41 +0,0 @@
-"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);
-      }
-    },
-  };
-};