strapi-plugin-comments 2.3.2 → 3.0.0-beta.0

package/server/routes/client.js

@@ -1,118 +0,0 @@
-"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",
-            },
-        },
-    },
-    {
-        method: "GET",
-        path: "/author/:id",
-        handler: "client.findAllPerAuthor",
-        config: {
-            policies: [],
-            description: "Find all comments created by Strapi user",
-            tag: {
-                plugin: "comments",
-                name: "Comments",
-                actionType: "find",
-            },
-        },
-    },
-    {
-        method: "GET",
-        path: "/author/:id/:type",
-        handler: "client.findAllPerAuthor",
-        config: {
-            policies: [],
-            description: "Find all comments created by specified type of user",
-            tag: {
-                plugin: "comments",
-                name: "Comments",
-                actionType: "find",
-            },
-        },
-    },
-];
-exports.default = routes;
-//# sourceMappingURL=client.js.map

package/server/routes/index.d.ts

@@ -1,11 +0,0 @@
-import { StrapiRoute } from "strapi-typed";
-type PluginRoutes = {
-    [key: string]: PluginScopeRoutes;
-};
-type PluginScopeRoutes = {
-    type: string;
-    routes: Array<StrapiRoute>;
-};
-declare const routes: PluginRoutes;
-export default routes;
-//# sourceMappingURL=index.d.ts.map

package/server/routes/index.js

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

package/server/services/admin.d.ts

@@ -1,5 +0,0 @@
-import { StrapiContext } from 'strapi-typed';
-import { IServiceAdmin } from "../../types";
-declare const _default: ({ strapi }: StrapiContext) => IServiceAdmin;
-export = _default;
-//# sourceMappingURL=admin.d.ts.map

package/server/services/admin.js

@@ -1,506 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-const functions_1 = require("./../utils/functions");
-const lodash_1 = require("lodash");
-const error_1 = __importDefault(require("./../utils/error"));
-const utils_1 = require("./../../types/utils");
-const functions_2 = require("./utils/functions");
-const constants_1 = require("./../utils/constants");
-module.exports = ({ strapi }) => ({
-    getCommonService() {
-        return (0, functions_1.getPluginService)("common");
-    },
-    async config(viaSettingsPage = false) {
-        const pluginStore = await this.getCommonService().getPluginStore();
-        const config = await pluginStore.get({
-            key: "config",
-        });
-        const additionalConfiguration = {
-            regex: Object.keys(constants_1.REGEX).reduce((prev, curr) => ({
-                ...prev,
-                [curr]: constants_1.REGEX[curr].toString(),
-            }), {}),
-        };
-        const getConfigProp = (key) => this.getCommonService().getLocalConfig(key);
-        const isGQLPluginEnabled = !(0, lodash_1.isNil)(strapi.plugin("graphql"));
-        if (config) {
-            return {
-                ...config,
-                ...additionalConfiguration,
-                isGQLPluginEnabled: viaSettingsPage ? isGQLPluginEnabled : undefined,
-            };
-        }
-        const entryLabel = getConfigProp("entryLabel");
-        const approvalFlow = getConfigProp("approvalFlow");
-        const reportReasons = getConfigProp("reportReasons");
-        const blockedAuthorProps = getConfigProp("blockedAuthorProps");
-        const result = {
-            entryLabel,
-            approvalFlow,
-            blockedAuthorProps,
-            reportReasons,
-            ...additionalConfiguration,
-        };
-        if (viaSettingsPage) {
-            const enabledCollections = getConfigProp("enabledCollections");
-            const moderatorRoles = getConfigProp("moderatorRoles");
-            return {
-                ...result,
-                enabledCollections,
-                moderatorRoles,
-                isGQLPluginEnabled,
-            };
-        }
-        return result;
-    },
-    async updateConfig(body) {
-        const pluginStore = await this.getCommonService().getPluginStore();
-        await pluginStore.set({ key: "config", value: body });
-        return this.config();
-    },
-    async restoreConfig() {
-        const pluginStore = await this.getCommonService().getPluginStore();
-        await pluginStore.delete({ key: "config" });
-        return this.config();
-    },
-    async restart() {
-        setImmediate(() => strapi.reload());
-    },
-    async findAll({ ...query }) {
-        const { _q, orderBy, pageSize = 10, page = 1, filters, } = (0, functions_1.parseParams)(query);
-        const defaultWhere = {
-            $or: [{ removed: false }, { removed: null }],
-        };
-        const defaultAuthorUserPopulate = this.getDefaultAuthorPopulate();
-        let params = {
-            where: !(0, lodash_1.isEmpty)(filters)
-                ? {
-                    ...defaultWhere,
-                    ...filters,
-                }
-                : { ...defaultWhere },
-            offset: (page - 1) * pageSize,
-            limit: pageSize,
-            orderBy: orderBy || [{ createdAt: "desc" }],
-        };
-        if (_q) {
-            params = {
-                ...params,
-                where: {
-                    ...params.where,
-                    content: {
-                        $contains: _q,
-                    },
-                },
-            };
-        }
-        const basePopulate = {
-            threadOf: true,
-            reports: {
-                where: {
-                    resolved: false,
-                },
-            },
-        };
-        const populate = defaultAuthorUserPopulate
-            ? {
-                ...basePopulate,
-                authorUser: defaultAuthorUserPopulate,
-            }
-            : basePopulate;
-        const entities = await strapi.db
-            .query((0, functions_2.getModelUid)("comment"))
-            .findMany({
-            ...params,
-            populate,
-        });
-        const total = await strapi.db.query((0, functions_2.getModelUid)("comment")).count({
-            where: params.where,
-        });
-        const relatedEntities = await this.getCommonService().findRelatedEntitiesFor(entities);
-        const result = entities
-            .map((_) => (0, functions_2.filterOurResolvedReports)(this.getCommonService().sanitizeCommentEntity(_, [], [], defaultAuthorUserPopulate?.populate)))
-            .map((_) => this.getCommonService().mergeRelatedEntityTo(_, relatedEntities));
-        const pageCount = Math.floor(total / pageSize);
-        return {
-            result,
-            pagination: {
-                page: page,
-                pageSize: pageSize,
-                pageCount: total % pageSize === 0 ? pageCount : pageCount + 1,
-                total,
-            },
-        };
-    },
-    async findReports(query) {
-        const { _q, filters, orderBy, page = 1, pageSize = 10, } = (0, functions_1.parseParams)(query);
-        const defaultWhere = {
-            resolved: { $notNull: true },
-        };
-        const defaultAuthorUserPopulate = this.getDefaultAuthorPopulate();
-        let params = {
-            where: !(0, lodash_1.isEmpty)(filters)
-                ? {
-                    ...defaultWhere,
-                    ...filters,
-                }
-                : { ...defaultWhere },
-            offset: (page - 1) * pageSize,
-            limit: pageSize,
-            orderBy: orderBy || [{ resolved: "asc" }, { createdAt: "desc" }],
-        };
-        if (_q) {
-            params = {
-                ...params,
-                where: {
-                    ...params.where,
-                    content: {
-                        $contains: _q,
-                    },
-                },
-            };
-        }
-        const entities = await strapi.db
-            .query((0, functions_2.getModelUid)("comment-report"))
-            .findMany({
-            ...params,
-            populate: ["related"],
-        });
-        const total = await strapi.db
-            .query((0, functions_2.getModelUid)("comment-report"))
-            .count({
-            where: params.where,
-        });
-        const reportedCommentsIds = entities.map((report) => report.related.id);
-        const commentsInThreads = await strapi.db
-            .query((0, functions_2.getModelUid)("comment"))
-            .findMany({
-            where: {
-                threadOf: reportedCommentsIds,
-            },
-            populate: ["threadOf"],
-            limit: Number.MAX_SAFE_INTEGER,
-        });
-        const commentWithThreadIds = [
-            ...new Set(commentsInThreads.map(({ threadOf }) => {
-                (0, utils_1.assertComment)(threadOf);
-                return threadOf.id;
-            })),
-        ];
-        const result = entities.map((_) => {
-            const isCommentWithThread = commentWithThreadIds.includes(_.related.id);
-            return (0, functions_2.filterOurResolvedReports)(this.getCommonService().sanitizeCommentEntity({
-                ..._,
-                related: this.getCommonService().sanitizeCommentEntity({
-                    ..._.related,
-                    gotThread: isCommentWithThread,
-                }, []),
-            }, [], [], defaultAuthorUserPopulate?.populate));
-        });
-        const pageCount = Math.floor(total / pageSize);
-        return {
-            result,
-            pagination: {
-                page: page,
-                pageSize: pageSize,
-                pageCount: total % pageSize === 0 ? pageCount : pageCount + 1,
-                total,
-            },
-        };
-    },
-    async findOneAndThread(id, { removed, ...query }) {
-        const defaultAuthorUserPopulate = this.getDefaultAuthorPopulate();
-        const defaultWhere = !removed
-            ? {
-                $or: [{ removed: false }, { removed: { $notNull: false } }],
-            }
-            : {};
-        const reportsPopulation = {
-            reports: {
-                where: {
-                    resolved: false,
-                },
-            },
-        };
-        const basePopulate = {
-            populate: {
-                threadOf: {
-                    populate: {
-                        ...reportsPopulation,
-                    },
-                },
-                ...reportsPopulation,
-            },
-        };
-        const defaultPopulate = defaultAuthorUserPopulate
-            ? {
-                populate: {
-                    ...basePopulate.populate,
-                    authorUser: defaultAuthorUserPopulate,
-                    threadOf: {
-                        populate: {
-                            ...basePopulate.populate.threadOf.populate,
-                            authorUser: defaultAuthorUserPopulate,
-                        },
-                    },
-                },
-            }
-            : basePopulate;
-        const entity = await strapi.db
-            .query((0, functions_2.getModelUid)("comment"))
-            .findOne({
-            where: {
-                id,
-            },
-            ...defaultPopulate,
-        });
-        if (!entity) {
-            throw new error_1.default(404, "Not found");
-        }
-        const [relatedUid, relatedStringId] = (0, functions_2.getRelatedGroups)(entity.related);
-        const parsedRelatedId = (0, lodash_1.parseInt)(relatedStringId);
-        const relatedId = (0, lodash_1.isNumber)(parsedRelatedId)
-            ? parsedRelatedId
-            : relatedStringId;
-        const relatedEntity = await strapi.db
-            .query(relatedUid)
-            .findOne({
-            where: { id: relatedId },
-        })
-            .then((_) => ({
-            ..._,
-            uid: relatedUid,
-        }));
-        if (!relatedEntity) {
-            throw new error_1.default(404, "Relation not found");
-        }
-        const levelThreadId = entity?.threadOf?.id || null;
-        const entitiesOnSameLevel = await this.getCommonService().findAllInHierarchy({
-            query: {
-                ...defaultWhere,
-                ...query,
-                threadOf: levelThreadId,
-                related: entity.related,
-            },
-            ...defaultPopulate,
-            startingFromId: levelThreadId,
-            isAdmin: true,
-        }, false);
-        const selectedEntity = this.getCommonService().sanitizeCommentEntity({
-            ...entity,
-            threadOf: entity.threadOf || null,
-        }, [], [], defaultAuthorUserPopulate?.populate);
-        return {
-            entity: relatedEntity,
-            selected: selectedEntity,
-            level: entitiesOnSameLevel,
-        };
-    },
-    async blockComment(id, forceStatus) {
-        const existingEntity = await this.getCommonService().findOne({ id });
-        const changedEntity = await strapi.db
-            .query((0, functions_2.getModelUid)("comment"))
-            .update({
-            where: { id },
-            data: {
-                blocked: !(0, lodash_1.isNil)(forceStatus) ? forceStatus : !existingEntity.blocked,
-            },
-        });
-        return this.getCommonService().sanitizeCommentEntity(changedEntity, []);
-    },
-    async deleteComment(id) {
-        const changedEntity = await strapi.db
-            .query((0, functions_2.getModelUid)("comment"))
-            .update({
-            where: { id },
-            data: {
-                removed: true,
-            },
-        });
-        return this.getCommonService().sanitizeCommentEntity(changedEntity, []);
-    },
-    async blockCommentThread(id, forceStatus) {
-        const existingEntity = await this.getCommonService().findOne({ id });
-        const status = !(0, lodash_1.isNil)(forceStatus)
-            ? forceStatus
-            : !existingEntity.blockedThread;
-        const changedEntity = await strapi.db
-            .query((0, functions_2.getModelUid)("comment"))
-            .update({
-            where: { id },
-            data: {
-                blocked: status,
-                blockedThread: status,
-            },
-        });
-        await this.blockNestedThreads(id, changedEntity.blockedThread);
-        return this.getCommonService().sanitizeCommentEntity(changedEntity, []);
-    },
-    async approveComment(id) {
-        const changedEntity = await strapi.db
-            .query((0, functions_2.getModelUid)("comment"))
-            .update({
-            where: { id },
-            data: { approvalStatus: constants_1.APPROVAL_STATUS.APPROVED },
-        });
-        return this.getCommonService().sanitizeCommentEntity(changedEntity, []);
-    },
-    async rejectComment(id) {
-        const changedEntity = await strapi.db
-            .query((0, functions_2.getModelUid)("comment"))
-            .update({
-            where: { id },
-            data: { approvalStatus: constants_1.APPROVAL_STATUS.REJECTED },
-        });
-        return this.getCommonService().sanitizeCommentEntity(changedEntity, []);
-    },
-    async blockNestedThreads(id, blockStatus) {
-        return await this.getCommonService().modifiedNestedNestedComments(id, "blockedThread", blockStatus);
-    },
-    async resolveAbuseReport(id, commentId) {
-        return strapi.db
-            .query((0, functions_2.getModelUid)("comment-report"))
-            .update({
-            where: {
-                id,
-                related: commentId,
-            },
-            data: { resolved: true },
-        });
-    },
-    async resolveCommentMultipleAbuseReports(ids, commentId) {
-        const reportsToResolve = await strapi.db
-            .query((0, functions_2.getModelUid)("comment-report"))
-            .findMany({
-            where: {
-                id: ids,
-                related: commentId,
-            },
-            populate: ["related"],
-        });
-        if (reportsToResolve.length === ids.length) {
-            return strapi.db
-                .query((0, functions_2.getModelUid)("comment-report"))
-                .updateMany({
-                where: { id: ids },
-                data: { resolved: true },
-            });
-        }
-        throw new error_1.default(400, "At least one of selected reports got invalid comment entity relation. Try again.");
-    },
-    async resolveAllAbuseReportsForComment(commentId) {
-        if (commentId) {
-            const blockedCommentReports = strapi.db
-                .query((0, functions_2.getModelUid)("comment-report"))
-                .findMany({
-                where: {
-                    related: commentId,
-                    resolved: false,
-                },
-                populate: ["related"],
-            });
-            const reportIds = (await blockedCommentReports).map((report) => report.id);
-            return strapi.db
-                .query((0, functions_2.getModelUid)("comment-report"))
-                .updateMany({
-                where: {
-                    id: reportIds,
-                },
-                data: { resolved: true },
-            });
-        }
-        throw new error_1.default(400, "There is something wrong with comment Id. Try again.");
-    },
-    async resolveAllAbuseReportsForThread(commentId) {
-        if (commentId) {
-            const commentsInThread = strapi.db
-                .query((0, functions_2.getModelUid)("comment"))
-                .findMany({
-                where: {
-                    threadOf: commentId,
-                },
-            });
-            const commentsInThreadIds = (await commentsInThread).map((comment) => comment.id);
-            commentsInThreadIds.push(commentId);
-            const reportsInThread = strapi.db
-                .query((0, functions_2.getModelUid)("comment-report"))
-                .findMany({
-                where: {
-                    related: commentsInThreadIds,
-                    resolved: false,
-                },
-                populate: ["related"],
-            });
-            const reportsInThreadIds = (await reportsInThread).map((report) => report.id);
-            return strapi.db
-                .query((0, functions_2.getModelUid)("comment-report"))
-                .updateMany({
-                where: {
-                    id: reportsInThreadIds,
-                },
-                data: { resolved: true },
-            });
-        }
-        throw new error_1.default(400, "There is something wrong with comment Id. Try again.");
-    },
-    async resolveMultipleAbuseReports(ids) {
-        if (!!ids.length) {
-            return strapi.db
-                .query((0, functions_2.getModelUid)("comment-report"))
-                .updateMany({
-                where: { id: { $in: ids } },
-                data: { resolved: true },
-            });
-        }
-        throw new error_1.default(400, "At least one of selected reports got invalid comment entity relation. Try again.");
-    },
-    async postComment(threadId, body, author) {
-        const entity = await strapi.db
-            .query((0, functions_2.getModelUid)("comment"))
-            .findOne({
-            where: {
-                id: threadId,
-            },
-        });
-        return await strapi.db
-            .query((0, functions_2.getModelUid)("comment"))
-            .create({
-            data: {
-                approvalStatus: "APPROVED",
-                authorId: author.id,
-                authorName: (0, functions_2.getAuthorName)(author),
-                authorEmail: author.email,
-                content: body,
-                threadOf: threadId,
-                related: entity.related,
-                isAdminComment: true,
-            },
-        });
-    },
-    async updateComment(id, body) {
-        const updateComment = await strapi.db
-            .query((0, functions_2.getModelUid)("comment"))
-            .update({
-            where: { id },
-            data: {
-                content: body
-            }
-        });
-        return this.getCommonService().sanitizeCommentEntity(updateComment, []);
-    },
-    getDefaultAuthorPopulate() {
-        const strapiUserTypeUid = "plugin::users-permissions.user";
-        const allowedTypes = ["media", "relation"];
-        const { attributes } = strapi.contentTypes[strapiUserTypeUid] || {};
-        const relationTypes = Object.keys(attributes)?.filter((key) => allowedTypes.includes(attributes[key]?.type));
-        if (relationTypes.includes("avatar")) {
-            return {
-                populate: { avatar: true },
-            };
-        }
-        return true;
-    },
-});
-//# sourceMappingURL=admin.js.map

package/server/services/client.d.ts

@@ -1,5 +0,0 @@
-import { StrapiContext } from "strapi-typed";
-import { IServiceClient } from "../../types";
-declare const _default: ({ strapi }: StrapiContext) => IServiceClient;
-export = _default;
-//# sourceMappingURL=client.d.ts.map