strapi-plugin-comments 2.0.10 → 2.0.11

package/build/server/controllers/client.js

@@ -0,0 +1,111 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const functions_1 = require("./../utils/functions");
+const functions_2 = require("./utils/functions");
+const parsers_1 = require("./utils/parsers");
+const error_1 = __importDefault(require("../utils/error"));
+const controllers = {
+    getService(name = "client") {
+        return (0, functions_1.getPluginService)(name);
+    },
+    async findAllFlat(ctx) {
+        const { params = {}, query, sort, pagination } = ctx;
+        const { relation } = (0, functions_2.parseParams)(params);
+        const { sort: querySort, pagination: queryPagination, ...filterQuery } = query || {};
+        try {
+            (0, functions_1.assertParamsPresent)(params, ["relation"]);
+            return this.getService("common").findAllFlat((0, parsers_1.flatInput)(relation, filterQuery, sort || querySort, pagination || queryPagination));
+        }
+        catch (e) {
+            throw (0, functions_2.throwError)(ctx, e);
+        }
+    },
+    async findAllInHierarchy(ctx) {
+        const { params, query, sort } = ctx;
+        const { relation } = (0, functions_2.parseParams)(params);
+        const { sort: querySort, ...filterQuery } = query || {};
+        try {
+            (0, functions_1.assertParamsPresent)(params, ["relation"]);
+            return await this.getService("common").findAllInHierarchy({
+                ...(0, parsers_1.flatInput)(relation, filterQuery, sort || querySort),
+                dropBlockedThreads: true,
+            });
+        }
+        catch (e) {
+            throw (0, functions_2.throwError)(ctx, e);
+        }
+    },
+    async post(ctx) {
+        const { request, params, state = {} } = ctx;
+        const { relation } = (0, functions_2.parseParams)(params);
+        const { user } = state;
+        const { body } = request;
+        try {
+            (0, functions_1.assertParamsPresent)(params, ["relation"]);
+            (0, functions_1.assertNotEmpty)(body);
+            const entity = await this.getService().create(relation, body, user);
+            if (entity) {
+                return entity;
+            }
+            throw new error_1.default(400, "Comment hasn't been created");
+        }
+        catch (e) {
+            throw (0, functions_2.throwError)(ctx, e);
+        }
+    },
+    async put(ctx) {
+        const { request, state, params = {} } = ctx;
+        const { body } = request;
+        const { user } = state;
+        const { commentId, relation } = (0, functions_2.parseParams)(params);
+        try {
+            (0, functions_1.assertParamsPresent)(params, ["commentId", "relation"]);
+            (0, functions_1.assertNotEmpty)(body);
+            return await this.getService().update(commentId, relation, body, user);
+        }
+        catch (e) {
+            throw (0, functions_2.throwError)(ctx, e);
+        }
+    },
+    async reportAbuse(ctx) {
+        const { request, state, params = {} } = ctx;
+        const { body } = request;
+        const { user } = state;
+        const { relation, commentId } = (0, functions_2.parseParams)(params);
+        try {
+            (0, functions_1.assertParamsPresent)(params, ["commentId", "relation"]);
+            (0, functions_1.assertNotEmpty)(body);
+            if (!body.content) {
+                throw new error_1.default(400, "Content field is required");
+            }
+            return await this.getService().reportAbuse(commentId, relation, body, user);
+        }
+        catch (e) {
+            throw (0, functions_2.throwError)(ctx, e);
+        }
+    },
+    async removeComment(ctx) {
+        const { params, query, state: { user }, } = ctx;
+        const { relation, commentId } = (0, functions_2.parseParams)(params);
+        const { authorId } = (0, functions_2.parseParams)(query);
+        try {
+            (0, functions_1.assertParamsPresent)(params, ["commentId", "relation"]);
+            (0, functions_1.assertParamsPresent)(query, ["authorId"]);
+            if (authorId || user?.id) {
+                return await this.getService().markAsRemoved(commentId, relation, authorId, user);
+            }
+            return new error_1.default(400, "Not provided authorId");
+        }
+        catch (e) {
+            if (!e.isBoom) {
+                (0, functions_2.throwError)(ctx, e);
+            }
+            throw e;
+        }
+    },
+};
+exports.default = controllers;
+//# sourceMappingURL=client.js.map

package/build/server/controllers/index.d.ts

@@ -0,0 +1,6 @@
+declare type PluginControllers = {
+    [key: string]: Function | Object;
+};
+declare const controllers: PluginControllers;
+export default controllers;
+//# sourceMappingURL=index.d.ts.map

package/build/server/controllers/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault =
+  (this && this.__importDefault) ||
+  function (mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+Object.defineProperty(exports, "__esModule", { value: true });
+const admin_1 = __importDefault(require("./admin"));
+const client_1 = __importDefault(require("./client"));
+const controllers = {
+  admin: admin_1.default,
+  client: client_1.default,
+};
+exports.default = controllers;
+//# sourceMappingURL=index.js.map

package/build/server/controllers/utils/functions.d.ts

@@ -0,0 +1,7 @@
+import { Id, StringMap, StrapiRequestContext } from "strapi-typed";
+import PluginError from "../../utils/error";
+declare type ParseResponse = StringMap<string | number | Id>;
+export declare const parseParams: <T extends ParseResponse>(params: StringMap<string | number>) => T;
+export declare const throwError: <T extends {} = never>(ctx: StrapiRequestContext<T, {}>, e: PluginError | Error | unknown) => PluginError | Error | unknown | never;
+export {};
+//# sourceMappingURL=functions.d.ts.map

package/build/server/controllers/utils/functions.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.throwError = exports.parseParams = void 0;
+const error_1 = __importDefault(require("../../utils/error"));
+const parseParams = (params) => Object.keys(params).reduce((prev, curr) => {
+    const value = params[curr];
+    const parsedValue = Number(value);
+    return {
+        ...prev,
+        [curr]: isNaN(parsedValue) ? value : parsedValue,
+    };
+}, {});
+exports.parseParams = parseParams;
+const throwError = (ctx, e) => {
+    if (e instanceof error_1.default) {
+        return ctx.throw(e.status, JSON.stringify(e));
+    }
+    return e;
+};
+exports.throwError = throwError;
+//# sourceMappingURL=functions.js.map

package/build/server/controllers/utils/parsers.d.ts

@@ -0,0 +1,15 @@
+import { Id } from "strapi-typed";
+import { ToBeFixed } from "../../../types";
+export declare const flatInput: (relation: Id, query: ToBeFixed, sort: ToBeFixed, pagination?: ToBeFixed) => {
+    query: any;
+    populate: {
+        threadOf: {
+            populate: {
+                authorUser: boolean;
+            };
+        };
+    };
+    pagination: any;
+    sort: any;
+};
+//# sourceMappingURL=parsers.d.ts.map

package/build/server/controllers/utils/parsers.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flatInput = void 0;
+const flatInput = (relation, query, sort, pagination) => {
+  const filters = query?.filters || query;
+  const orOperator = (filters?.$or || []).filter(
+    (_) => !Object.keys(_).includes("removed")
+  );
+  return {
+    query: {
+      ...filters,
+      $or: [...orOperator, { removed: { $null: true } }, { removed: false }],
+      related: relation,
+    },
+    populate: {
+      threadOf: {
+        populate: { authorUser: true },
+      },
+    },
+    pagination,
+    sort,
+  };
+};
+exports.flatInput = flatInput;
+//# sourceMappingURL=parsers.js.map

package/build/server/destroy.d.ts

@@ -0,0 +1,3 @@
+declare const _default: () => void;
+export = _default;
+//# sourceMappingURL=destroy.d.ts.map

package/build/server/destroy.js

@@ -0,0 +1,3 @@
+"use strict";
+module.exports = () => {};
+//# sourceMappingURL=destroy.js.map

package/build/server/graphql/index.d.ts

@@ -0,0 +1,4 @@
+import { StrapiGraphQLContext } from "../../types";
+declare const _default: ({ strapi, config }: StrapiGraphQLContext) => Promise<void>;
+export = _default;
+//# sourceMappingURL=index.d.ts.map

package/build/server/graphql/index.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault =
+  (this && this.__importDefault) ||
+  function (mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+const types_1 = __importDefault(require("./types"));
+const queries_1 = __importDefault(require("./queries"));
+const mutations_1 = __importDefault(require("./mutations"));
+const resolvers_config_1 = __importDefault(require("./resolvers-config"));
+const functions_1 = require("../services/utils/functions");
+module.exports = async ({ strapi, config }) => {
+  const extensionService = strapi.plugin("graphql").service("extension");
+  extensionService
+    .shadowCRUD((0, functions_1.getModelUid)("comment"))
+    .disableQueries();
+  extensionService
+    .shadowCRUD((0, functions_1.getModelUid)("comment"))
+    .disableMutations();
+  extensionService
+    .shadowCRUD((0, functions_1.getModelUid)("comment-report"))
+    .disableQueries();
+  extensionService
+    .shadowCRUD((0, functions_1.getModelUid)("comment-report"))
+    .disableMutations();
+  extensionService.use(({ strapi, nexus }) => {
+    const types = (0, types_1.default)({ strapi, nexus, config });
+    const queries = (0, queries_1.default)({ strapi, nexus, config });
+    const mutations = (0, mutations_1.default)({ strapi, nexus, config });
+    const resolversConfig = (0, resolvers_config_1.default)({ strapi, config });
+    return {
+      types: [types, queries, mutations],
+      resolversConfig,
+    };
+  });
+};
+//# sourceMappingURL=index.js.map

package/build/server/graphql/mutations/createAbuseReport.d.ts

@@ -0,0 +1,11 @@
+import { StrapiRequestContext } from "strapi-typed";
+import { NexusRequestProps, StrapiGraphQLContext, ToBeFixed } from "../../../types";
+declare const _default: ({ nexus }: StrapiGraphQLContext) => {
+    type: any;
+    args: {
+        input: any;
+    };
+    resolve(_: Object, args: NexusRequestProps, ctx: StrapiRequestContext<never> & ToBeFixed): Promise<import("../../../types").CommentReport>;
+};
+export = _default;
+//# sourceMappingURL=createAbuseReport.d.ts.map

package/build/server/graphql/mutations/createAbuseReport.js

@@ -0,0 +1,27 @@
+"use strict";
+const functions_1 = require("../../utils/functions");
+module.exports = ({ nexus }) => {
+  const { nonNull } = nexus;
+  return {
+    type: nonNull("Report"),
+    args: {
+      input: nonNull("CreateReport"),
+    },
+    async resolve(_, args, ctx) {
+      const { input } = args;
+      const { state: { user = undefined } = {} } = ctx;
+      const { commentId, relation, ...body } = input;
+      try {
+        return await (0, functions_1.getPluginService)("client").reportAbuse(
+          commentId,
+          relation,
+          body,
+          user
+        );
+      } catch (e) {
+        throw new Error(e);
+      }
+    },
+  };
+};
+//# sourceMappingURL=createAbuseReport.js.map

package/build/server/graphql/mutations/createComment.d.ts

@@ -0,0 +1,14 @@
+import { StrapiRequestContext } from "strapi-typed";
+import { StrapiGraphQLContext, ToBeFixed } from "../../../types";
+declare type CreateCommentProps = {
+    input: ToBeFixed;
+};
+declare const _default: ({ nexus }: StrapiGraphQLContext) => {
+    type: any;
+    args: {
+        input: any;
+    };
+    resolve(_: Object, args: CreateCommentProps, ctx: StrapiRequestContext<never> & ToBeFixed): Promise<import("../../../types").Comment>;
+};
+export = _default;
+//# sourceMappingURL=createComment.d.ts.map

package/build/server/graphql/mutations/createComment.js

@@ -0,0 +1,26 @@
+"use strict";
+const functions_1 = require("../../utils/functions");
+module.exports = ({ nexus }) => {
+  const { nonNull } = nexus;
+  return {
+    type: nonNull("CommentSingle"),
+    args: {
+      input: nonNull("CreateComment"),
+    },
+    async resolve(_, args, ctx) {
+      const { input } = args;
+      const { state: { user = undefined } = {} } = ctx;
+      const { relation, ...body } = input;
+      try {
+        return await (0, functions_1.getPluginService)("client").create(
+          relation,
+          body,
+          user
+        );
+      } catch (e) {
+        throw new Error(e);
+      }
+    },
+  };
+};
+//# sourceMappingURL=createComment.js.map

package/build/server/graphql/mutations/index.d.ts

@@ -0,0 +1,4 @@
+import { StrapiGraphQLContext } from "../../../types";
+declare const _default: (context: StrapiGraphQLContext) => any;
+export = _default;
+//# sourceMappingURL=index.d.ts.map

package/build/server/graphql/mutations/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault =
+  (this && this.__importDefault) ||
+  function (mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+const createComment_1 = __importDefault(require("./createComment"));
+const updateComment_1 = __importDefault(require("./updateComment"));
+const removeComment_1 = __importDefault(require("./removeComment"));
+const createAbuseReport_1 = __importDefault(require("./createAbuseReport"));
+module.exports = (context) => {
+  const mutations = {
+    createComment: createComment_1.default,
+    updateComment: updateComment_1.default,
+    removeComment: removeComment_1.default,
+    createAbuseReport: createAbuseReport_1.default,
+  };
+  return context.nexus.extendType({
+    type: "Mutation",
+    definition(t) {
+      for (const [name, configFactory] of Object.entries(mutations)) {
+        const config = configFactory(context);
+        t.field(name, config);
+      }
+    },
+  });
+};
+//# sourceMappingURL=index.js.map

package/build/server/graphql/mutations/removeComment.d.ts

@@ -0,0 +1,11 @@
+import { StrapiRequestContext } from "strapi-typed";
+import { NexusRequestProps, StrapiGraphQLContext, ToBeFixed } from "../../../types";
+declare const _default: ({ nexus }: StrapiGraphQLContext) => {
+    type: any;
+    args: {
+        input: any;
+    };
+    resolve(_: Object, args: NexusRequestProps, ctx: StrapiRequestContext<never> & ToBeFixed): Promise<import("../../../types").Comment>;
+};
+export = _default;
+//# sourceMappingURL=removeComment.d.ts.map

package/build/server/graphql/mutations/removeComment.js

@@ -0,0 +1,27 @@
+"use strict";
+const functions_1 = require("../../utils/functions");
+module.exports = ({ nexus }) => {
+  const { nonNull } = nexus;
+  return {
+    type: nonNull("CommentSingle"),
+    args: {
+      input: nonNull("RemoveComment"),
+    },
+    async resolve(_, args, ctx) {
+      const { input } = args;
+      const { state: { user = undefined } = {} } = ctx;
+      const { id, relation, author } = input;
+      try {
+        return await (0, functions_1.getPluginService)("client").markAsRemoved(
+          id,
+          relation,
+          author?.id,
+          user
+        );
+      } catch (e) {
+        throw new Error(e);
+      }
+    },
+  };
+};
+//# sourceMappingURL=removeComment.js.map

package/build/server/graphql/mutations/updateComment.d.ts

@@ -0,0 +1,11 @@
+import { StrapiRequestContext } from "strapi-typed";
+import { NexusRequestProps, StrapiGraphQLContext, ToBeFixed } from "../../../types";
+declare const _default: ({ nexus }: StrapiGraphQLContext) => {
+    type: any;
+    args: {
+        input: any;
+    };
+    resolve(_: Object, args: NexusRequestProps, ctx: StrapiRequestContext<never> & ToBeFixed): Promise<import("../../../types").Comment>;
+};
+export = _default;
+//# sourceMappingURL=updateComment.d.ts.map

package/build/server/graphql/mutations/updateComment.js

@@ -0,0 +1,27 @@
+"use strict";
+const functions_1 = require("../../utils/functions");
+module.exports = ({ nexus }) => {
+  const { nonNull } = nexus;
+  return {
+    type: nonNull("CommentSingle"),
+    args: {
+      input: nonNull("UpdateComment"),
+    },
+    async resolve(_, args, ctx) {
+      const { input } = args;
+      const { state: { user = undefined } = {} } = ctx;
+      const { id, relation, ...body } = input;
+      try {
+        return await (0, functions_1.getPluginService)("client").update(
+          id,
+          relation,
+          body,
+          user
+        );
+      } catch (e) {
+        throw new Error(e);
+      }
+    },
+  };
+};
+//# sourceMappingURL=updateComment.js.map

package/build/server/graphql/queries/findAllFlat.d.ts

@@ -0,0 +1,19 @@
+import { Id, StrapiGraphQLContext, ToBeFixed } from "../../../types";
+declare type ResponseFindAllResolverProps = {
+    relation: Id;
+    filters: ToBeFixed;
+    sort: ToBeFixed;
+    pagination: ToBeFixed;
+};
+declare const _default: ({ strapi, nexus }: StrapiGraphQLContext) => {
+    type: string;
+    args: {
+        relation: any;
+        filters: any;
+        pagination: any;
+        sort: any;
+    };
+    resolve(obj: Object, args: ResponseFindAllResolverProps): Promise<import("strapi-typed").StrapiPaginatedResponse<import("../../../types").Comment>>;
+};
+export = _default;
+//# sourceMappingURL=findAllFlat.d.ts.map

package/build/server/graphql/queries/findAllFlat.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault =
+  (this && this.__importDefault) ||
+  function (mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+const lodash_1 = require("lodash");
+const comment_1 = __importDefault(require("../../../content-types/comment"));
+const parsers_1 = require("../../controllers/utils/parsers");
+const functions_1 = require("../../utils/functions");
+module.exports = ({ strapi, nexus }) => {
+  const { nonNull, stringArg } = nexus;
+  const { service: getService } = strapi.plugin("graphql");
+  const { args } = getService("internals");
+  return {
+    type: "ResponseFindAll",
+    args: {
+      relation: nonNull(stringArg()),
+      filters: (0, functions_1.getPluginService)("gql").buildContentTypeFilters(
+        comment_1.default
+      ),
+      pagination: args.PaginationArg,
+      sort: args.SortArg,
+    },
+    async resolve(obj, args) {
+      const { relation, filters, sort, pagination } = args;
+      return await (0, functions_1.getPluginService)("common").findAllFlat(
+        (0, parsers_1.flatInput)(
+          relation,
+          (0, functions_1.getPluginService)("gql").graphQLFiltersToStrapiQuery(
+            filters,
+            comment_1.default
+          ),
+          sort,
+          pagination
+            ? {
+                ...pagination,
+                withCount: !(0, lodash_1.isEmpty)(pagination),
+              }
+            : undefined
+        ),
+        undefined
+      );
+    },
+  };
+};
+//# sourceMappingURL=findAllFlat.js.map

package/build/server/graphql/queries/findAllInHierarchy.d.ts

@@ -0,0 +1,18 @@
+import { Id } from "strapi-typed";
+import { StrapiGraphQLContext, ToBeFixed } from "../../../types";
+declare type findAllInHierarchyProps = {
+    relation: Id;
+    filters: ToBeFixed;
+    sort: ToBeFixed;
+    pagination: ToBeFixed;
+};
+declare const _default: ({ strapi, nexus }: StrapiGraphQLContext) => {
+    type: any;
+    args: {
+        relation: any;
+        sort: any;
+    };
+    resolve(obj: Object, args: findAllInHierarchyProps): Promise<import("../../../types").Comment[]>;
+};
+export = _default;
+//# sourceMappingURL=findAllInHierarchy.d.ts.map

package/build/server/graphql/queries/findAllInHierarchy.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault =
+  (this && this.__importDefault) ||
+  function (mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+const comment_1 = __importDefault(require("../../../content-types/comment"));
+const parsers_1 = require("../../controllers/utils/parsers");
+const functions_1 = require("../../utils/functions");
+module.exports = ({ strapi, nexus }) => {
+  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,
+    },
+    async resolve(obj, args) {
+      const { relation, filters, sort } = args;
+      return await (0, functions_1.getPluginService)(
+        "common"
+      ).findAllInHierarchy({
+        ...(0, parsers_1.flatInput)(
+          relation,
+          (0, functions_1.getPluginService)("gql").graphQLFiltersToStrapiQuery(
+            filters,
+            comment_1.default
+          ),
+          sort
+        ),
+        dropBlockedThreads: true,
+      });
+    },
+  };
+};
+//# sourceMappingURL=findAllInHierarchy.js.map

package/build/server/graphql/queries/index.d.ts

@@ -0,0 +1,4 @@
+import { StrapiGraphQLContext } from "../../../types";
+declare const _default: (context: StrapiGraphQLContext) => any;
+export = _default;
+//# sourceMappingURL=index.d.ts.map

package/build/server/graphql/queries/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault =
+  (this && this.__importDefault) ||
+  function (mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+const findAllFlat_1 = __importDefault(require("./findAllFlat"));
+const findAllInHierarchy_1 = __importDefault(require("./findAllInHierarchy"));
+module.exports = (context) => {
+  const queries = {
+    findAllFlat: findAllFlat_1.default,
+    findAllInHierarchy: findAllInHierarchy_1.default,
+  };
+  return context.nexus.extendType({
+    type: "Query",
+    definition(t) {
+      for (const [name, configFactory] of Object.entries(queries)) {
+        const config = configFactory(context);
+        t.field(name, config);
+      }
+    },
+  });
+};
+//# sourceMappingURL=index.js.map

package/build/server/graphql/resolvers-config.d.ts

@@ -0,0 +1,23 @@
+import { StrapiGraphQLContext } from "../../types";
+declare const _default: ({ config }: StrapiGraphQLContext) => {
+    "Query.findAllFlat": {
+        auth: any;
+    };
+    "Query.findAllInHierarchy": {
+        auth: any;
+    };
+    "Mutation.createComment": {
+        auth: any;
+    };
+    "Mutation.updateComment": {
+        auth: any;
+    };
+    "Mutation.removeComment": {
+        auth: any;
+    };
+    "Mutation.createAbuseReport": {
+        auth: any;
+    };
+};
+export = _default;
+//# sourceMappingURL=resolvers-config.d.ts.map

package/build/server/graphql/resolvers-config.js

@@ -0,0 +1,13 @@
+"use strict";
+module.exports = ({ config }) => {
+  const { gql: { auth = false } = {} } = config;
+  return {
+    "Query.findAllFlat": { auth },
+    "Query.findAllInHierarchy": { auth },
+    "Mutation.createComment": { auth },
+    "Mutation.updateComment": { auth },
+    "Mutation.removeComment": { auth },
+    "Mutation.createAbuseReport": { auth },
+  };
+};
+//# sourceMappingURL=resolvers-config.js.map