strapi-plugin-comments 2.0.11 → 2.1.1

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

package/server/graphql/mutations/updateComment.ts

@@ -0,0 +1,40 @@
+"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("UpdateComment"),
+    },
+    async resolve(
+      _: Object,
+      args: NexusRequestProps,
+      ctx: StrapiRequestContext<never> & ToBeFixed
+    ) {
+      const { input } = args;
+      const { state: { user = undefined } = {} } = ctx;
+      const { id, relation, ...body } = input;
+      try {
+        return await getPluginService<IServiceClient>("client").update(
+          id,
+          relation,
+          body,
+          user
+        );
+      } catch (e: ToBeFixed) {
+        throw new Error(e);
+      }
+    },
+  };
+};

package/server/graphql/queries/findAllFlat.ts

@@ -0,0 +1,58 @@
+import {
+  Id,
+  IServiceCommon,
+  IServiceGraphQL,
+  StrapiGraphQLContext,
+  ToBeFixed,
+} from "../../../types";
+
+import { isEmpty } from "lodash";
+import contentType from "../../../content-types/comment";
+import { flatInput } from "../../controllers/utils/parsers";
+import { getPluginService } from "../../utils/functions";
+
+type ResponseFindAllResolverProps = {
+  relation: Id;
+  filters: ToBeFixed;
+  sort: ToBeFixed;
+  pagination: ToBeFixed;
+};
+
+export = ({ strapi, nexus }: StrapiGraphQLContext) => {
+  const { nonNull, stringArg } = nexus;
+  const { service: getService } = strapi.plugin("graphql");
+  const { args } = getService("internals");
+
+  return {
+    type: "ResponseFindAll",
+    args: {
+      relation: nonNull(stringArg()),
+      filters:
+        getPluginService<IServiceGraphQL>("gql").buildContentTypeFilters(
+          contentType
+        ),
+      pagination: args.PaginationArg,
+      sort: args.SortArg,
+    },
+    // @ts-ignore
+    async resolve(obj: Object, args: ResponseFindAllResolverProps) {
+      const { relation, filters, sort, pagination } = args;
+      return await getPluginService<IServiceCommon>("common").findAllFlat(
+        flatInput({
+          relation,
+          query: getPluginService<IServiceGraphQL>(
+            "gql"
+          ).graphQLFiltersToStrapiQuery(filters, contentType),
+          sort,
+          pagination: pagination
+            ? {
+                ...pagination,
+                withCount: !isEmpty(pagination),
+              }
+            : undefined,
+        }),
+        undefined
+      );
+    },
+  };
+};

package/server/graphql/queries/findAllInHierarchy.ts

@@ -0,0 +1,47 @@
+import { Id } from "strapi-typed";
+import {
+  IServiceCommon,
+  IServiceGraphQL,
+  StrapiGraphQLContext,
+  ToBeFixed,
+} from "../../../types";
+
+import contentType from "../../../content-types/comment";
+import { flatInput } from "../../controllers/utils/parsers";
+import { getPluginService } from "../../utils/functions";
+
+type findAllInHierarchyProps = {
+  relation: Id;
+  filters: ToBeFixed;
+  sort: ToBeFixed;
+};
+
+export = ({ strapi, nexus }: StrapiGraphQLContext) => {
+  const { nonNull, list, stringArg } = nexus;
+  const { service: getService } = strapi.plugin("graphql");
+  const { args } = getService("internals");
+
+  return {
+    type: nonNull(list("CommentNested")),
+    args: {
+      relation: nonNull(stringArg()),
+      sort: args.SortArg,
+    },
+    // @ts-ignore
+    async resolve(obj: Object, args: findAllInHierarchyProps) {
+      const { relation, filters, sort } = args;
+      return await getPluginService<IServiceCommon>(
+        "common"
+      ).findAllInHierarchy({
+        ...flatInput({
+          relation,
+          query: getPluginService<IServiceGraphQL>(
+            "gql"
+          ).graphQLFiltersToStrapiQuery(filters, contentType),
+          sort,
+        }),
+        dropBlockedThreads: true,
+      });
+    },
+  };
+};

package/server/graphql/queries/index.ts

@@ -0,0 +1,22 @@
+import { INexusType, StrapiGraphQLContext } from "../../../types";
+
+import findAllFlat from "./findAllFlat";
+import findAllInHierarchy from "./findAllInHierarchy";
+
+export = (context: StrapiGraphQLContext) => {
+  const queries = {
+    findAllFlat,
+    findAllInHierarchy,
+  };
+
+  return context.nexus.extendType({
+    type: "Query",
+    definition(t: INexusType) {
+      for (const [name, configFactory] of Object.entries(queries)) {
+        const config = configFactory(context);
+
+        t.field(name, config);
+      }
+    },
+  });
+};

package/server/graphql/resolvers-config.ts

@@ -0,0 +1,13 @@
+import { StrapiGraphQLContext } from "../../types";
+
+export = ({ config }: StrapiGraphQLContext) => {
+  const { gql: { auth = false } = {} } = config;
+  return {
+    "Query.findAllFlat": { auth },
+    "Query.findAllInHierarchy": { auth },
+    "Mutation.createComment": { auth },
+    "Mutation.updateComment": { auth },
+    "Mutation.removeComment": { auth },
+    "Mutation.createAbuseReport": { auth },
+  };
+};

package/server/graphql/types/comment-author.ts

@@ -0,0 +1,12 @@
+import { INexusType, StrapiGraphQLContext } from "../../../types";
+
+export = ({ nexus }: StrapiGraphQLContext) =>
+  nexus.objectType({
+    name: "CommentAuthor",
+    definition(t: INexusType) {
+      t.id("id");
+      t.nonNull.string("name");
+      t.string("email");
+      t.string("avatar");
+    },
+  });

package/server/graphql/types/comment-nested.ts

@@ -0,0 +1,19 @@
+import { INexusType, StrapiGraphQLContext } from "../../../types";
+
+export = ({ nexus }: StrapiGraphQLContext) =>
+  nexus.objectType({
+    name: "CommentNested",
+    definition(t: INexusType) {
+      t.id("id");
+      t.nonNull.string("content");
+      t.boolean("blocked");
+      t.boolean("blockedThread");
+      t.string("approvalStatus");
+      t.boolean("removed");
+      t.field("threadOf", { type: "CommentSingle" });
+      t.list.field("children", { type: "CommentNested" });
+      t.field("author", { type: "CommentAuthor" });
+      t.string("createdAt");
+      t.string("updatedAt");
+    },
+  });

package/server/graphql/types/comment.ts

@@ -0,0 +1,18 @@
+import { INexusType, StrapiGraphQLContext } from "../../../types";
+
+export = ({ nexus }: StrapiGraphQLContext) =>
+  nexus.objectType({
+    name: "CommentSingle",
+    definition(t: INexusType) {
+      t.id("id");
+      t.nonNull.string("content");
+      t.boolean("blocked");
+      t.boolean("blockedThread");
+      t.boolean("removed");
+      t.string("approvalStatus");
+      t.field("threadOf", { type: "CommentSingle" });
+      t.field("author", { type: "CommentAuthor" });
+      t.string("createdAt");
+      t.string("updatedAt");
+    },
+  });

package/server/graphql/types/create-comment-author.ts

@@ -0,0 +1,12 @@
+import { INexusType, StrapiGraphQLContext } from "../../../types";
+
+export = ({ nexus }: StrapiGraphQLContext) =>
+  nexus.inputObjectType({
+    name: "CreateCommentAuthor",
+    definition(t: INexusType) {
+      t.nonNull.id("id");
+      t.nonNull.string("name");
+      t.string("email");
+      t.string("avatar");
+    },
+  });

package/server/graphql/types/create-comment.ts

@@ -0,0 +1,12 @@
+import { INexusType, StrapiGraphQLContext } from "../../../types";
+
+export = ({ nexus }: StrapiGraphQLContext) =>
+  nexus.inputObjectType({
+    name: "CreateComment",
+    definition(t: INexusType) {
+      t.nonNull.string("content");
+      t.nonNull.string("relation");
+      t.id("threadOf");
+      t.field("author", { type: "CreateCommentAuthor" });
+    },
+  });

package/server/graphql/types/create-report.ts

@@ -0,0 +1,12 @@
+import { INexusType, StrapiGraphQLContext } from "../../../types";
+
+export = ({ nexus }: StrapiGraphQLContext) =>
+  nexus.inputObjectType({
+    name: "CreateReport",
+    definition(t: INexusType) {
+      t.id("commentId");
+      t.nonNull.string("relation");
+      t.nonNull.string("content");
+      t.field("reason", { type: "ReportReason" });
+    },
+  });

package/server/graphql/types/id.ts

@@ -0,0 +1,28 @@
+import { Primitive } from "strapi-typed";
+import { NexusAst, StrapiGraphQLContext } from "../../../types";
+
+const { isNumber, parseInt } = require("lodash");
+const { Kind } = require("graphql");
+
+export = ({ nexus }: StrapiGraphQLContext) =>
+  nexus.scalarType({
+    name: "Id",
+    asNexusMethod: "id",
+    description: "Id as string or int",
+    parseValue(value: Primitive) {
+      const parsedValue = parseInt(value);
+      if (isNumber(parsedValue)) {
+        return parsedValue;
+      }
+      return value;
+    },
+    serialize(value: Primitive) {
+      return value;
+    },
+    parseLiteral(ast: NexusAst) {
+      if ([Kind.INT, Kind.STRING].includes(ast.kind)) {
+        return ast.value;
+      }
+      return null;
+    },
+  });

package/server/graphql/types/identify-comment-author.ts

@@ -0,0 +1,9 @@
+import { INexusType, StrapiGraphQLContext } from "../../../types";
+
+export = ({ nexus }: StrapiGraphQLContext) =>
+  nexus.inputObjectType({
+    name: "IdentifyCommentAuthor",
+    definition(t: INexusType) {
+      t.nonNull.id("id");
+    },
+  });

package/server/graphql/types/index.ts

@@ -0,0 +1,38 @@
+import { StrapiGraphQLContext } from "../../../types";
+
+import Id from "./id";
+import Comment from "./comment";
+import CommentNested from "./comment-nested";
+import CommentAuthor from "./comment-author";
+import CreateComment from "./create-comment";
+import CreateCommentAuthor from "./create-comment-author";
+import UpdateComment from "./update-comment";
+import RemoveComment from "./remove-comment";
+import IdentifyCommentAuthor from "./identify-comment-author";
+import Report from "./report";
+import ReportReason from "./report-reason";
+import CreateReport from "./create-report";
+import ResponsePagination from "./response-pagination";
+import ResponseMeta from "./response-meta";
+import ResponseFindAll from "./response-find-all";
+
+const typesFactories = [
+  Id,
+  Comment,
+  CommentNested,
+  CommentAuthor,
+  CreateComment,
+  CreateCommentAuthor,
+  UpdateComment,
+  RemoveComment,
+  IdentifyCommentAuthor,
+  Report,
+  ReportReason,
+  CreateReport,
+  ResponsePagination,
+  ResponseMeta,
+  ResponseFindAll,
+];
+
+export = (context: StrapiGraphQLContext) =>
+  typesFactories.map((factory) => factory(context));

package/server/graphql/types/remove-comment.ts

@@ -0,0 +1,11 @@
+import { INexusType, StrapiGraphQLContext } from "../../../types";
+
+export = ({ nexus }: StrapiGraphQLContext) =>
+  nexus.inputObjectType({
+    name: "RemoveComment",
+    definition(t: INexusType) {
+      t.id("id");
+      t.nonNull.string("relation");
+      t.field("author", { type: "IdentifyCommentAuthor" });
+    },
+  });

package/server/graphql/types/report-reason.ts

@@ -0,0 +1,12 @@
+import { StrapiGraphQLContext } from "../../../types";
+
+export = ({ nexus, config }: StrapiGraphQLContext) => {
+  const { reportReasons } = config;
+  return nexus.enumType({
+    name: "ReportReason",
+    description: "Reason of abuse report",
+    members: {
+      ...reportReasons,
+    },
+  });
+};

package/server/graphql/types/report.ts

@@ -0,0 +1,14 @@
+import { INexusType, StrapiGraphQLContext } from "../../../types";
+
+export = ({ nexus }: StrapiGraphQLContext) =>
+  nexus.objectType({
+    name: "Report",
+    definition(t: INexusType) {
+      t.id("id");
+      t.nonNull.string("content");
+      t.field("reason", { type: "ReportReason" });
+      t.field("related", { type: "CommentSingle" });
+      t.string("createdAt");
+      t.string("updatedAt");
+    },
+  });

package/server/graphql/types/response-find-all.ts

@@ -0,0 +1,10 @@
+import { INexusType, StrapiGraphQLContext } from "../../../types";
+
+export = ({ nexus }: StrapiGraphQLContext) =>
+  nexus.objectType({
+    name: "ResponseFindAll",
+    definition(t: INexusType) {
+      t.list.field("data", { type: "CommentSingle" });
+      t.field("meta", { type: "ResponseMeta" });
+    },
+  });

package/server/graphql/types/response-meta.ts

@@ -0,0 +1,9 @@
+import { INexusType, StrapiGraphQLContext } from "../../../types";
+
+export = ({ nexus }: StrapiGraphQLContext) =>
+  nexus.objectType({
+    name: "ResponseMeta",
+    definition(t: INexusType) {
+      t.field("pagination", { type: "ResponsePagination" });
+    },
+  });

package/server/graphql/types/response-pagination.ts

@@ -0,0 +1,14 @@
+import { INexusType, StrapiGraphQLContext } from "../../../types";
+
+export = ({ nexus }: StrapiGraphQLContext) =>
+  nexus.objectType({
+    name: "ResponsePagination",
+    definition(t: INexusType) {
+      t.int("page");
+      t.int("pageSize");
+      t.int("pageCount");
+      t.int("total");
+      t.int("start");
+      t.int("limit");
+    },
+  });

package/server/graphql/types/update-comment.ts

@@ -0,0 +1,12 @@
+import { INexusType, StrapiGraphQLContext } from "../../../types";
+
+export = ({ nexus }: StrapiGraphQLContext) =>
+  nexus.inputObjectType({
+    name: "UpdateComment",
+    definition(t: INexusType) {
+      t.id("id");
+      t.nonNull.string("content");
+      t.nonNull.string("relation");
+      t.field("author", { type: "IdentifyCommentAuthor" });
+    },
+  });

package/server/index.ts

@@ -0,0 +1,20 @@
+import register from "./register";
+import bootstrap from "./bootstrap";
+import destroy from "./destroy";
+import config from "./config";
+import controllers from "./controllers";
+import routes from "./routes";
+import services from "./services";
+
+export default {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  controllers,
+  routes,
+  services,
+  contentTypes: {},
+  policies: {},
+  middlewares: {},
+};

package/server/register.ts

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