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

package/server/services/admin.js

@@ -1,38 +1,29 @@
-'use strict';
-
-const { getPluginService, parseParams } = require('./../utils/functions');
-const { isEmpty, isNil, isNumber, parseInt } = require('lodash');
-const PluginError = require('./../utils/error');
-const {
-    getModelUid,
-    getRelatedGroups,
-    filterOurResolvedReports,
-} = require('./utils/functions');
-const { APPROVAL_STATUS, REGEX } = require('./../utils/constants')
-
-/**
- * Comments Plugin - Moderation services
- */
-
- module.exports = ({ strapi }) => ({
-
+"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 functions_2 = require("./utils/functions");
+const constants_1 = require("./../utils/constants");
+module.exports = ({ strapi }) => ({
     getCommonService() {
-        return getPluginService('common');
+        return (0, functions_1.getPluginService)("common");
     },
-
-    // Config
     async config(viaSettingsPage = false) {
         const pluginStore = await this.getCommonService().getPluginStore();
-        const config = await pluginStore.get({ key: 'config' });
+        const config = await pluginStore.get({
+            key: "config",
+        });
         const additionalConfiguration = {
-            regex: Object.keys(REGEX).reduce((prev, curr) => ({
+            regex: Object.keys(constants_1.REGEX).reduce((prev, curr) => ({
                 ...prev,
-                [curr]: REGEX[curr].toString(),
+                [curr]: constants_1.REGEX[curr].toString(),
             }), {}),
         };
-
-        const isGQLPluginEnabled = !isNil(strapi.plugin('graphql'));
-
+        const getConfigProp = (key) => this.getCommonService().getLocalConfig(key);
+        const isGQLPluginEnabled = !(0, lodash_1.isNil)(strapi.plugin("graphql"));
         if (config) {
             return {
                 ...config,
@@ -40,20 +31,18 @@ const { APPROVAL_STATUS, REGEX } = require('./../utils/constants')
                 isGQLPluginEnabled: viaSettingsPage ? isGQLPluginEnabled : undefined,
             };
         }
-
-        const entryLabel = this.getCommonService().getLocalConfig('entryLabel');
-        const approvalFlow = this.getCommonService().getLocalConfig('approvalFlow');
-        const reportReasons = this.getCommonService().getLocalConfig('reportReasons');
+        const entryLabel = getConfigProp("entryLabel");
+        const approvalFlow = getConfigProp("approvalFlow");
+        const reportReasons = getConfigProp("reportReasons");
         const result = {
             entryLabel,
             approvalFlow,
             reportReasons,
             ...additionalConfiguration,
         };
-
         if (viaSettingsPage) {
-            const enabledCollections = this.getCommonService().getLocalConfig('enabledCollections');
-            const moderatorRoles = this.getCommonService().getLocalConfig('moderatorRoles');
+            const enabledCollections = getConfigProp("enabledCollections");
+            const moderatorRoles = getConfigProp("moderatorRoles");
             return {
                 ...result,
                 enabledCollections,
@@ -61,49 +50,36 @@ const { APPROVAL_STATUS, REGEX } = require('./../utils/constants')
                 isGQLPluginEnabled,
             };
         }
-
         return result;
     },
-
     async updateConfig(body) {
         const pluginStore = await this.getCommonService().getPluginStore();
-    
-        await pluginStore.set({ key: 'config', value: body });
-    
+        await pluginStore.set({ key: "config", value: body });
         return this.config();
-      },
-    
-      async restoreConfig() {
+    },
+    async restoreConfig() {
         const pluginStore = await this.getCommonService().getPluginStore();
-
-        await pluginStore.delete({key: 'config'})
-    
+        await pluginStore.delete({ key: "config" });
         return this.config();
-      },
-
+    },
     async restart() {
         setImmediate(() => strapi.reload());
     },
-
-    // Find all comments
     async findAll({ related, entity, ...query }) {
-        const { _q, orderBy, pageSize = 10, page = 1, filters, ...rest } = parseParams(query);
-
+        const { _q, orderBy, pageSize = 10, page = 1, filters, } = (0, functions_1.parseParams)(query);
         const defaultWhere = {
-            $or: [
-                { removed: false },
-                { removed: null },
-            ],
+            $or: [{ removed: false }, { removed: null }],
         };
-
         let params = {
-            where: !isEmpty(filters) ? {
-                ...defaultWhere,
-                ...filters,
-            } : { ...defaultWhere },
-            offset: (page - 1)*pageSize, 
+            where: !(0, lodash_1.isEmpty)(filters)
+                ? {
+                    ...defaultWhere,
+                    ...filters,
+                }
+                : { ...defaultWhere },
+            offset: (page - 1) * pageSize,
             limit: pageSize,
-            orderBy: orderBy || [{ createdAt: 'desc' }],
+            orderBy: orderBy || [{ createdAt: "desc" }],
         };
         if (_q) {
             params = {
@@ -111,34 +87,32 @@ const { APPROVAL_STATUS, REGEX } = require('./../utils/constants')
                 where: {
                     ...params.where,
                     content: {
-                        $contains: _q
+                        $contains: _q,
                     },
-                }
+                },
             };
         }
-    
-        const entities = await strapi.db.query(getModelUid('comment'))
+        const entities = await strapi.db
+            .query((0, functions_2.getModelUid)("comment"))
             .findMany({
-                ...params, 
-                populate: {
-                    authorUser: true,
-                    threadOf: true,
-                    reports: {
-                        where: { 
-                            resolved: false
-                        },
+            ...params,
+            populate: {
+                authorUser: true,
+                threadOf: true,
+                reports: {
+                    where: {
+                        resolved: false,
                     },
                 },
-            });
-        const total = await strapi.db.query(getModelUid('comment'))
-            .count({
-                where: params.where,
-            });
+            },
+        });
+        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(_ => filterOurResolvedReports(this.getCommonService().sanitizeCommentEntity(_)))
-            .map(_ => this.getCommonService().mergeRelatedEntityTo(_, relatedEntities));
-
+            .map((_) => (0, functions_2.filterOurResolvedReports)(this.getCommonService().sanitizeCommentEntity(_)))
+            .map((_) => this.getCommonService().mergeRelatedEntityTo(_, relatedEntities));
         const pageCount = Math.floor(total / pageSize);
         return {
             result,
@@ -150,147 +124,141 @@ const { APPROVAL_STATUS, REGEX } = require('./../utils/constants')
             },
         };
     },
-
-    // Find single comment
     async findOneAndThread(id, { removed, ...query }) {
-        const defaultWhere = !removed ? {
-            $or: [
-                { removed: false },
-                { removed: null },
-            ],
-        } : {};
-        
+        const defaultWhere = !removed
+            ? {
+                $or: [{ removed: false }, { removed: null }],
+            }
+            : {};
         const reportsPopulation = {
             reports: {
-                where: { 
+                where: {
                     resolved: false,
                 },
-            }
+            },
         };
-
         const defaultPopulate = {
             populate: {
                 authorUser: true,
                 threadOf: {
-                    populate: { 
+                    populate: {
                         authorUser: true,
-                        ...reportsPopulation
+                        ...reportsPopulation,
                     },
                 },
                 ...reportsPopulation,
             },
-        }
-
-        const entity = await strapi.db.query(getModelUid('comment')).findOne({ 
+        };
+        const entity = await strapi.db
+            .query((0, functions_2.getModelUid)("comment"))
+            .findOne({
             where: {
                 id,
             },
             ...defaultPopulate,
         });
-
-        if (!entity){
-            throw new PluginError(404, 'Not found');
+        if (!entity) {
+            throw new error_1.default(404, "Not found");
         }
-
-        const [relatedUid, relatedStringId] = getRelatedGroups(entity.related);
-        const parsedRelatedId = parseInt(relatedStringId);
-        const relatedId = isNumber(parsedRelatedId) ? parsedRelatedId : relatedStringId;
-        const relatedEntity = await strapi.db.query(relatedUid).findOne({ 
-            where: { id: relatedId }
-        }).then(_ => ({
+        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 PluginError(404, 'Relation not found');
+            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 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,
         });
-        
         return {
             entity: relatedEntity,
             selected: selectedEntity,
             level: entitiesOnSameLevel,
         };
     },
-
-    // Block / Unblock a comment
     async blockComment(id, forceStatus) {
         const existingEntity = await this.getCommonService().findOne({ id });
-        const changedEntity = await strapi.db.query(getModelUid('comment')).update({ 
+        const changedEntity = await strapi.db
+            .query((0, functions_2.getModelUid)("comment"))
+            .update({
             where: { id },
-            data: { blocked: !isNil(forceStatus) ? forceStatus : !existingEntity.blocked }
+            data: {
+                blocked: !(0, lodash_1.isNil)(forceStatus) ? forceStatus : !existingEntity.blocked,
+            },
         });
         return this.getCommonService().sanitizeCommentEntity(changedEntity);
     },
-
-    // Block / Unblock a comment thread
     async blockCommentThread(id, forceStatus) {
         const existingEntity = await this.getCommonService().findOne({ id });
-        const status = !isNil(forceStatus) ? forceStatus : !existingEntity.blockedThread;
-        const changedEntity = await strapi.db.query(getModelUid('comment')).update({ 
+        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: { 
+            data: {
                 blocked: status,
                 blockedThread: status,
             },
         });
         await this.blockNestedThreads(id, changedEntity.blockedThread);
-
         return this.getCommonService().sanitizeCommentEntity(changedEntity);
     },
-
-    // Approve comment
     async approveComment(id) {
-        const changedEntity = await strapi.db.query(getModelUid('comment'))
-          .update({
-              where: { id },
-              data: { approvalStatus: APPROVAL_STATUS.APPROVED }
-          });
-    
+        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(getModelUid('comment'))
-            .update({ 
-                where: { id }, 
-                data: { approvalStatus: APPROVAL_STATUS.REJECTED }
-            });
-
+        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)
+        return await this.getCommonService().modifiedNestedNestedComments(id, "blockedThread", blockStatus);
     },
-
-    // Resolve reported abuse for comment
     async resolveAbuseReport(id, commentId) {
-        return strapi.db.query(getModelUid('comment-report')).update({
+        return strapi.db
+            .query((0, functions_2.getModelUid)("comment-report"))
+            .update({
             where: {
                 id,
                 related: commentId,
             },
-            data: { resolved: true }
+            data: { resolved: true },
         });
-    }, 
+    },
 });
+//# sourceMappingURL=admin.js.map

package/server/services/client.d.ts

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