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

package/{server → build/server}/controllers/client.js

@@ -1,8 +1,12 @@
 "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);
@@ -10,35 +14,46 @@ const controllers = {
     async findAllFlat(ctx) {
         const { params = {}, query, sort, pagination } = ctx;
         const { relation } = (0, functions_2.parseParams)(params);
-        const { sort: querySort, pagination: queryPagination, ...filterQuery } = query || {};
+        const { sort: querySort, pagination: queryPagination, fields, ...filterQuery } = query || {};
         try {
             (0, functions_1.assertParamsPresent)(params, ["relation"]);
-            return this.getService("common").findAllFlat((0, parsers_1.flatInput)(relation, filterQuery, sort || querySort, pagination || queryPagination));
+            return this.getService("common").findAllFlat((0, parsers_1.flatInput)({
+                relation,
+                query: filterQuery,
+                sort: sort || querySort,
+                pagination: pagination || queryPagination,
+                fields,
+            }));
         }
         catch (e) {
-            (0, functions_2.throwError)(ctx, e);
+            throw (0, functions_2.throwError)(ctx, e);
         }
     },
     async findAllInHierarchy(ctx) {
-        const { params = {}, query, sort } = ctx;
+        const { params, query, sort } = ctx;
         const { relation } = (0, functions_2.parseParams)(params);
-        const { sort: querySort, ...filterQuery } = query || {};
+        const { sort: querySort, fields, ...filterQuery } = query || {};
         try {
             (0, functions_1.assertParamsPresent)(params, ["relation"]);
             return await this.getService("common").findAllInHierarchy({
-                ...(0, parsers_1.flatInput)(relation, filterQuery, sort || querySort),
+                ...(0, parsers_1.flatInput)({
+                    relation,
+                    query: filterQuery,
+                    sort: sort || querySort,
+                    fields,
+                }),
                 dropBlockedThreads: true,
             });
         }
         catch (e) {
-            (0, functions_2.throwError)(ctx, e);
+            throw (0, functions_2.throwError)(ctx, e);
         }
     },
     async post(ctx) {
-        const { request, params = {}, state = {} } = ctx;
+        const { request, params, state = {} } = ctx;
         const { relation } = (0, functions_2.parseParams)(params);
         const { user } = state;
-        const { body = {} } = request;
+        const { body } = request;
         try {
             (0, functions_1.assertParamsPresent)(params, ["relation"]);
             (0, functions_1.assertNotEmpty)(body);
@@ -46,14 +61,15 @@ const controllers = {
             if (entity) {
                 return entity;
             }
+            throw new error_1.default(400, "Comment hasn't been created");
         }
         catch (e) {
-            (0, functions_2.throwError)(ctx, e);
+            throw (0, functions_2.throwError)(ctx, e);
         }
     },
     async put(ctx) {
         const { request, state, params = {} } = ctx;
-        const { body = {} } = request;
+        const { body } = request;
         const { user } = state;
         const { commentId, relation } = (0, functions_2.parseParams)(params);
         try {
@@ -62,37 +78,37 @@ const controllers = {
             return await this.getService().update(commentId, relation, body, user);
         }
         catch (e) {
-            (0, functions_2.throwError)(ctx, e);
+            throw (0, functions_2.throwError)(ctx, e);
         }
     },
     async reportAbuse(ctx) {
         const { request, state, params = {} } = ctx;
-        const { body = {} } = request;
-        (0, functions_1.assertNotEmpty)(body);
-        if (!body.content) {
-            return ctx.badRequest(null, "Content field is required");
-        }
+        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) {
-            (0, functions_2.throwError)(ctx, e);
+            throw (0, functions_2.throwError)(ctx, e);
         }
     },
     async removeComment(ctx) {
         const { params, query, state: { user }, } = ctx;
-        const { relationId, commentId } = (0, functions_2.parseParams)(params);
+        const { relation, commentId } = (0, functions_2.parseParams)(params);
         const { authorId } = (0, functions_2.parseParams)(query);
         try {
-            (0, functions_1.assertParamsPresent)(params, ["commentId", "relationId"]);
+            (0, functions_1.assertParamsPresent)(params, ["commentId", "relation"]);
             (0, functions_1.assertParamsPresent)(query, ["authorId"]);
             if (authorId || user?.id) {
-                return await this.getService().markAsRemoved(commentId, relationId, authorId, user);
+                return await this.getService().markAsRemoved(commentId, relation, authorId, user);
             }
-            return ctx.badRequest("Not provided authorId");
+            return new error_1.default(400, "Not provided authorId");
         }
         catch (e) {
             if (!e.isBoom) {

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, StringMap<string | number>, StringMap<string | number>>, e: PluginError | Error | unknown) => PluginError | Error | unknown | never;
+export {};
+//# sourceMappingURL=functions.d.ts.map

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

@@ -0,0 +1,10 @@
+import { OnlyStrings } from "strapi-typed";
+import { FlatInput } from "../../../types";
+export declare const flatInput: <T, TKeys = keyof T>(payload: FlatInput<OnlyStrings<TKeys>>) => {
+    query: any;
+    populate: any;
+    pagination: any;
+    sort: any;
+    fields: import("strapi-typed").StrapiRequestQueryFieldsClause<OnlyStrings<TKeys>> | undefined;
+};
+//# sourceMappingURL=parsers.d.ts.map

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flatInput = void 0;
+const flatInput = (payload) => {
+    const { relation, query, sort, pagination, fields } = payload;
+    const { populate = {}, ...restQuery } = query;
+    const filters = restQuery?.filters || restQuery;
+    const orOperator = (filters?.$or || []).filter((_) => !Object.keys(_).includes("removed"));
+    let basePopulate = {
+        ...populate,
+    };
+    let threadOfPopulate = {
+        threadOf: {
+            populate: {
+                authorUser: true,
+                ...populate,
+            },
+        },
+    };
+    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,
+    };
+};
+exports.flatInput = flatInput;
+//# sourceMappingURL=parsers.js.map

package/{server → build/server}/graphql/mutations/createComment.d.ts

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

package/{server → build/server}/graphql/mutations/removeComment.d.ts

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

package/{server → build/server}/graphql/mutations/updateComment.d.ts

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

package/{server → build/server}/graphql/queries/findAllFlat.d.ts

@@ -13,7 +13,7 @@ declare const _default: ({ strapi, nexus }: StrapiGraphQLContext) => {
         pagination: any;
         sort: any;
     };
-    resolve(obj: Object, args: ResponseFindAllResolverProps): Promise<import("strapi-typed").StrapiPaginatedResponse<import("../../../types").Comment>>;
+    resolve(obj: Object, args: ResponseFindAllResolverProps): Promise<import("strapi-typed").StrapiPaginatedResponse<import("../../../types").Comment<import("../../../types").CommentAuthor>>>;
 };
 export = _default;
 //# sourceMappingURL=findAllFlat.d.ts.map

package/{server → build/server}/graphql/queries/findAllFlat.js

@@ -20,12 +20,17 @@ module.exports = ({ strapi, nexus }) => {
         },
         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);
+            return await (0, functions_1.getPluginService)("common").findAllFlat((0, parsers_1.flatInput)({
+                relation,
+                query: (0, functions_1.getPluginService)("gql").graphQLFiltersToStrapiQuery(filters, comment_1.default),
+                sort,
+                pagination: pagination
+                    ? {
+                        ...pagination,
+                        withCount: !(0, lodash_1.isEmpty)(pagination),
+                    }
+                    : undefined,
+            }), undefined);
         },
     };
 };

package/{server → build/server}/graphql/queries/findAllInHierarchy.d.ts

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

package/{server → build/server}/graphql/queries/findAllInHierarchy.js

@@ -18,7 +18,11 @@ module.exports = ({ strapi, nexus }) => {
         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),
+                ...(0, parsers_1.flatInput)({
+                    relation,
+                    query: (0, functions_1.getPluginService)("gql").graphQLFiltersToStrapiQuery(filters, comment_1.default),
+                    sort,
+                }),
                 dropBlockedThreads: true,
             });
         },

package/build/server/routes/client.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const routes = [
+    {
+        method: "GET",
+        path: "/:relation",
+        handler: "client.findAllInHierarchy",
+        config: {
+            policies: [],
+            description: "Find all comments related to configured Collection / Single Type and return them in a nested structure",
+            tag: {
+                plugin: "comments",
+                name: "Comments",
+                actionType: "find",
+            },
+        },
+    },
+    {
+        method: "POST",
+        path: "/:relation",
+        handler: "client.post",
+        config: {
+            policies: [],
+            description: "Post a comment against configured Collection / Single Type",
+            tag: {
+                plugin: "comments",
+                name: "Comments",
+                actionType: "create",
+            },
+        },
+    },
+    {
+        method: "GET",
+        path: "/:relation/flat",
+        handler: "client.findAllFlat",
+        config: {
+            policies: [],
+            description: "Find all comments related to configured Collection / Single Type and return them in a flat structure for further processing",
+            tag: {
+                plugin: "comments",
+                name: "Comments",
+                actionType: "find",
+            },
+        },
+    },
+    {
+        method: "PUT",
+        path: "/:relation/comment/:commentId",
+        handler: "client.put",
+        config: {
+            policies: [],
+            description: "Update comment related to configured Collection / Single Type if user is the author",
+            tag: {
+                plugin: "comments",
+                name: "Comments",
+                actionType: "update",
+            },
+        },
+    },
+    {
+        method: "POST",
+        path: "/:relation/comment/:commentId/report-abuse",
+        handler: "client.reportAbuse",
+        config: {
+            policies: [],
+            description: "Report an abuse against comment for configured Collection / Single Type",
+            tag: {
+                plugin: "comments",
+                name: "Comments",
+                actionType: "create",
+            },
+        },
+    },
+    {
+        method: "DELETE",
+        path: "/:relation/comment/:commentId",
+        handler: "client.removeComment",
+        config: {
+            policies: [],
+            description: "Remove comment related to configured Collection / Single Type if user is the author",
+            tag: {
+                plugin: "comments",
+                name: "Comments",
+                actionType: "delete",
+            },
+        },
+    },
+];
+exports.default = routes;
+//# sourceMappingURL=client.js.map

package/{server → build/server}/services/admin.js

@@ -7,6 +7,7 @@ const lodash_1 = require("lodash");
 const error_1 = __importDefault(require("./../utils/error"));
 const functions_2 = require("./utils/functions");
 const constants_1 = require("./../utils/constants");
+const DEFAULT_AUTHOR_POPULATE = { avatar: true };
 module.exports = ({ strapi }) => ({
     getCommonService() {
         return (0, functions_1.getPluginService)("common");
@@ -97,7 +98,7 @@ module.exports = ({ strapi }) => ({
             .findMany({
             ...params,
             populate: {
-                authorUser: true,
+                authorUser: { populate: DEFAULT_AUTHOR_POPULATE },
                 threadOf: true,
                 reports: {
                     where: {
@@ -111,7 +112,7 @@ module.exports = ({ strapi }) => ({
         });
         const relatedEntities = await this.getCommonService().findRelatedEntitiesFor(entities);
         const result = entities
-            .map((_) => (0, functions_2.filterOurResolvedReports)(this.getCommonService().sanitizeCommentEntity(_)))
+            .map((_) => (0, functions_2.filterOurResolvedReports)(this.getCommonService().sanitizeCommentEntity(_, DEFAULT_AUTHOR_POPULATE)))
             .map((_) => this.getCommonService().mergeRelatedEntityTo(_, relatedEntities));
         const pageCount = Math.floor(total / pageSize);
         return {
@@ -139,10 +140,14 @@ module.exports = ({ strapi }) => ({
         };
         const defaultPopulate = {
             populate: {
-                authorUser: true,
+                authorUser: {
+                    populate: DEFAULT_AUTHOR_POPULATE,
+                },
                 threadOf: {
                     populate: {
-                        authorUser: true,
+                        authorUser: {
+                            populate: DEFAULT_AUTHOR_POPULATE,
+                        },
                         ...reportsPopulation,
                     },
                 },
@@ -192,7 +197,7 @@ module.exports = ({ strapi }) => ({
         const selectedEntity = this.getCommonService().sanitizeCommentEntity({
             ...entity,
             threadOf: entity.threadOf || null,
-        });
+        }, DEFAULT_AUTHOR_POPULATE);
         return {
             entity: relatedEntity,
             selected: selectedEntity,