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

package/server/services/common.js

@@ -1,107 +1,86 @@
-'use strict';
-
-const BadWordsFilter = require('bad-words');
-const { isArray, isNumber, isObject, isNil, isString, isEmpty, first, parseInt, set, get } = require('lodash');
-const { REGEX, CONFIG_PARAMS } = require('../utils/constants');
-const PluginError = require('./../utils/error');
-const {
-    getModelUid,
-    getRelatedGroups,
-    buildNestedStructure,
-    filterOurResolvedReports,
-    buildAuthorModel,
-    buildConfigQueryProp,
-} = require('./utils/functions');
-
-/**
- * Comments Plugin - common services
- */
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const bad_words_1 = __importDefault(require("bad-words"));
+const lodash_1 = require("lodash");
+const constants_1 = require("../utils/constants");
+const error_1 = __importDefault(require("./../utils/error"));
+const functions_1 = require("./utils/functions");
+const PAGE_SIZE = 10;
 module.exports = ({ strapi }) => ({
-
     async getConfig(prop, defaultValue, useLocal = false) {
-        const queryProp = buildConfigQueryProp(prop);
+        const queryProp = (0, functions_1.buildConfigQueryProp)(prop);
         const pluginStore = await this.getPluginStore();
-        const config = await pluginStore.get({ key: 'config' });
-
+        const config = await pluginStore.get({
+            key: "config",
+        });
         let result;
         if (config && !useLocal) {
-            result = queryProp ? get(config, queryProp, defaultValue) : config;
-        } else {
+            result = queryProp ? (0, lodash_1.get)(config, queryProp, defaultValue) : config;
+        }
+        else {
             result = this.getLocalConfig(queryProp, defaultValue);
         }
-        return isNil(result) ? defaultValue : result;
+        return (0, lodash_1.isNil)(result) ? defaultValue : result;
     },
-
     async getPluginStore() {
-        return strapi.store({ type: 'plugin', name: 'comments' });
+        return strapi.store({ type: "plugin", name: "comments" });
     },
-
     getLocalConfig(prop, defaultValue) {
-        const queryProp = buildConfigQueryProp(prop);
-        const result = strapi.config.get(`plugin.comments${ queryProp ? '.' + queryProp : ''}`);
-        return isNil(result) ? defaultValue : result;
+        const queryProp = (0, functions_1.buildConfigQueryProp)(prop);
+        const result = strapi.config.get(`plugin.comments${queryProp ? "." + queryProp : ""}`);
+        return (0, lodash_1.isNil)(result) ? defaultValue : result;
     },
-
-    // Find comments in the flat structure
-    async findAllFlat({ 
-        query = {}, 
-        populate = {}, 
-        sort, 
-        pagination }, relatedEntity = null) {
-
+    async findAllFlat({ query = {}, populate = {}, sort, pagination }, relatedEntity = null) {
         const defaultPopulate = {
             authorUser: true,
         };
-
         let queryExtension = {};
-
-        if (sort && (isString(sort) || isArray(sort))) {
+        if (sort && ((0, lodash_1.isString)(sort) || (0, lodash_1.isArray)(sort))) {
             queryExtension = {
                 ...queryExtension,
-                orderBy: (isString(sort) ? [sort] : sort)
-                .map(_ => REGEX.sorting.test(_) ? _ : `${_}:asc`)
-                .reduce((prev, curr) => {
-                    const [type = 'asc', ...parts] = curr.split(':').reverse();
-                    return { ...set(prev, parts.reverse().join('.'), type) };
-                }, {})
+                orderBy: ((0, lodash_1.isString)(sort) ? [sort] : sort)
+                    .map((_) => (constants_1.REGEX.sorting.test(_) ? _ : `${_}:asc`))
+                    .reduce((prev, curr) => {
+                    const [type = "asc", ...parts] = curr.split(":").reverse();
+                    return { ...(0, lodash_1.set)(prev, parts.reverse().join("."), type) };
+                }, {}),
             };
         }
-
         let meta = {};
-        if (pagination && isObject(pagination)) {
-            const parsedPagination = Object.keys(pagination).reduce((prev, curr) => ({
+        if (pagination && (0, lodash_1.isObject)(pagination)) {
+            const parsedpagination = Object.keys(pagination).reduce((prev, curr) => ({
                 ...prev,
-                [curr]: parseInt(pagination[curr]),
+                [curr]: (0, lodash_1.parseInt)((0, lodash_1.get)(pagination, curr)),
             }), {});
-            const { page = 1, pageSize = 10, start = 0, limit = 10 } = parsedPagination;
-            const paginationByPage = !isNil(parsedPagination?.page) || !isNil(parsedPagination?.pageSize);
-
+            const { page = 1, pageSize = PAGE_SIZE, start = 0, limit = PAGE_SIZE, } = parsedpagination;
+            const paginationByPage = !(0, lodash_1.isNil)(parsedpagination?.page) || !(0, lodash_1.isNil)(parsedpagination?.pageSize);
             queryExtension = {
                 ...queryExtension,
                 offset: paginationByPage ? (page - 1) * pageSize : start,
                 limit: paginationByPage ? pageSize : limit,
             };
-
-            const metaPagination = paginationByPage ? {
-                pagination: {
-                    page,
-                    pageSize,
-                },
-            } : {
-                pagination: {
-                    start,
-                    limit,
-                },
-            };
-
+            const metapagination = paginationByPage
+                ? {
+                    pagination: {
+                        page,
+                        pageSize,
+                    },
+                }
+                : {
+                    pagination: {
+                        start,
+                        limit,
+                    },
+                };
             meta = {
-                ...metaPagination,
+                ...metapagination,
             };
         }
-        
-        const entries = await strapi.db.query(getModelUid('comment'))
-        .findMany({
+        const entries = await strapi.db
+            .query((0, functions_1.getModelUid)("comment"))
+            .findMany({
             where: {
                 ...query,
             },
@@ -111,178 +90,169 @@ module.exports = ({ strapi }) => ({
             },
             ...queryExtension,
         });
-
-        if (pagination?.withCount && (pagination.withCount === 'true' || pagination.withCount === true)) {
-            const total = await strapi.db.query(getModelUid('comment'))
+        if (pagination?.withCount &&
+            (pagination.withCount === "true" || pagination.withCount === true)) {
+            const total = await strapi.db
+                .query((0, functions_1.getModelUid)("comment"))
                 .count({
-                    where: {
-                        ...query,
-                    }
-                });
-            const pageCount = Math.floor(total / meta.pagination.pageSize);
+                where: {
+                    ...query,
+                },
+            });
+            const pageSize = meta.pagination.pageSize || PAGE_SIZE;
+            const pageCount = Math.floor(total / pageSize);
             meta = {
                 ...meta,
                 pagination: {
                     ...meta.pagination,
-                    pageCount: !isNil(meta.pagination.page) ? 
-                        total % meta.pagination.pageSize === 0 ? pageCount : pageCount + 1 : 
-                        undefined,
+                    pageCount: !(0, lodash_1.isNil)(meta.pagination.page)
+                        ? total % pageSize === 0
+                            ? pageCount
+                            : pageCount + 1
+                        : undefined,
                     total,
                 },
             };
         }
-
-        const entriesWithThreads = await Promise.all(entries.map(async _ => {
-            const [nestedEntries, count] = await strapi.db.query(getModelUid('comment'))
-                .findWithCount({ 
-                    where: {
-                        threadOf: _.id
-                    }
-                 })
-            return { id: _.id, itemsInTread: count, firstThreadItemId: first(nestedEntries)?.id }
+        const entriesWithThreads = await Promise.all(entries.map(async (_) => {
+            const [nestedEntries, count] = await strapi.db
+                .query((0, functions_1.getModelUid)("comment"))
+                .findWithCount({
+                where: {
+                    threadOf: _.id,
+                },
+            });
+            return {
+                id: _.id,
+                itemsInTread: count,
+                firstThreadItemId: (0, lodash_1.first)(nestedEntries)?.id,
+            };
         }));
-
-        const relatedEntities = relatedEntity !== null ? [relatedEntity] : await this.findRelatedEntitiesFor([...entries]);
-        const hasRelatedEntitiesToMap = relatedEntities.filter(_ => _).length > 0;
-
-        const result = entries
-            .map(_ => {
-                const threadedItem = entriesWithThreads.find(item => item.id === _.id);
-                return this.sanitizeCommentEntity({
-                    ..._,
-                    threadOf: query.threadOf || _.threadOf || null,
-                    gotThread: (threadedItem?.itemsInTread || 0) > 0,
-                    threadFirstItemId: threadedItem?.firstThreadItemId,
-                });
+        const relatedEntities = relatedEntity !== null
+            ? [relatedEntity]
+            : await this.findRelatedEntitiesFor([...entries]);
+        const hasRelatedEntitiesToMap = relatedEntities.filter((_) => _).length > 0;
+        const result = entries.map((_) => {
+            const threadedItem = entriesWithThreads.find((item) => item.id === _.id);
+            const parsedThreadOf = (0, lodash_1.isString)(query.threadOf)
+                ? (0, lodash_1.parseInt)(query.threadOf)
+                : query.threadOf;
+            return this.sanitizeCommentEntity({
+                ..._,
+                threadOf: parsedThreadOf || _.threadOf || null,
+                gotThread: (threadedItem?.itemsInTread || 0) > 0,
+                threadFirstItemId: threadedItem?.firstThreadItemId,
             });
-
+        });
         return {
-            data: hasRelatedEntitiesToMap ?
-                result.map(_ => this.mergeRelatedEntityTo(_, relatedEntities)) :
-                result,
-            ...(isEmpty(meta) ? {} : { meta }),
-        };   
+            data: hasRelatedEntitiesToMap
+                ? result.map((_) => this.mergeRelatedEntityTo(_, relatedEntities))
+                : result,
+            ...((0, lodash_1.isEmpty)(meta) ? {} : { meta }),
+        };
     },
-
-    // Find comments and create relations tree structure
-    async findAllInHierarchy ({
-        query,
-        populate = {},
-        sort,
-        startingFromId = null,
-        dropBlockedThreads = false,
-    }, relatedEntity) {
+    async findAllInHierarchy({ query, populate = {}, sort, startingFromId = null, dropBlockedThreads = false, }, relatedEntity) {
         const entities = await this.findAllFlat({ query, populate, sort }, relatedEntity);
-        return buildNestedStructure(entities?.data, startingFromId, 'threadOf', dropBlockedThreads, false);
+        return (0, functions_1.buildNestedStructure)(entities?.data, startingFromId, "threadOf", dropBlockedThreads, false);
     },
-
-    // Find single comment
     async findOne(criteria) {
-        const entity = await strapi.db.query(getModelUid('comment'))
+        const entity = await strapi.db
+            .query((0, functions_1.getModelUid)("comment"))
             .findOne({
-                where: criteria,
-                populate: {
-                    reports: true,
-                    authorUser: true,
-                },
-            });
-        if (!entity){
-            throw new PluginError(404, 'Comment does not exist. Check your payload please.');
+            where: criteria,
+            populate: {
+                reports: true,
+                authorUser: true,
+            },
+        });
+        if (!entity) {
+            throw new error_1.default(404, "Comment does not exist. Check your payload please.");
         }
-        return filterOurResolvedReports(this.sanitizeCommentEntity(entity));
+        return (0, functions_1.filterOurResolvedReports)(this.sanitizeCommentEntity(entity));
     },
-
-    // Find all related entiries
     async findRelatedEntitiesFor(entities = []) {
-        const data = entities.reduce((acc, cur) => {
-                const [relatedUid, relatedStringId] = getRelatedGroups(cur.related);
-                const parsedRelatedId = parseInt(relatedStringId);
-                const relatedId = isNumber(parsedRelatedId) ? parsedRelatedId : relatedStringId;
-                return {
-                    ...acc,
-                    [relatedUid]: [...(acc[relatedUid] || []), relatedId]
-                };
-            },
-            {}
-        );
-        return Promise.all(
-            Object.entries(data)
-            .map(async ([relatedUid, relatedStringIds]) => 
-                strapi.db.query(relatedUid).findMany({ 
-                    where: { id: Array.from(new Set(relatedStringIds)) },
-                }).then(relatedEntities => relatedEntities.map(_ => 
-                    ({
-                        ..._,
-                        uid: relatedUid,
-                    })
-                ))
-            )
-        )
-        .then(result => result.flat(2));
+        const data = entities.reduce((acc, curr) => {
+            const [relatedUid, relatedStringId] = (0, functions_1.getRelatedGroups)(curr.related);
+            const parsedRelatedId = (0, lodash_1.parseInt)(relatedStringId);
+            const relatedId = (0, lodash_1.isNumber)(parsedRelatedId)
+                ? parsedRelatedId
+                : relatedStringId;
+            return {
+                ...acc,
+                [relatedUid]: [...(acc[relatedUid] || []), relatedId],
+            };
+        }, {});
+        return Promise.all(Object.entries(data).map(async ([relatedUid, relatedStringIds]) => strapi.db
+            .query(relatedUid)
+            .findMany({
+            where: { id: Array.from(new Set(relatedStringIds)) },
+        })
+            .then((relatedEntities) => relatedEntities.map((_) => ({
+            ..._,
+            uid: relatedUid,
+        }))))).then((result) => result.flat(2));
     },
-
-    // Merge related entity with comment
     mergeRelatedEntityTo(entity, relatedEntities = []) {
         return {
             ...entity,
-            related: relatedEntities.find(relatedEntity => entity.related === `${relatedEntity.uid}:${relatedEntity.id}`)
+            related: relatedEntities.find((relatedEntity) => entity.related === `${relatedEntity.uid}:${relatedEntity.id}`),
         };
     },
-
     async modifiedNestedNestedComments(id, fieldName, value) {
         try {
-            const entitiesToChange = await strapi.bd.query(getModelUid('comment'))
+            const entitiesToChange = await strapi.db
+                .query((0, functions_1.getModelUid)("comment"))
                 .findMany({
-                    where: { threadOf: id }
-                });
-            const changedEntities = await strapi.bd.query(getModelUid('comment'))
+                where: { threadOf: id },
+            });
+            const changedEntities = await strapi.db
+                .query((0, functions_1.getModelUid)("comment"))
                 .updateMany({
-                    where: { id: entitiesToChange.map(_ => _.id) },
-                    data: { [fieldName]: value }
-                });
-            if ((entitiesToChange.length === changedEntities.length) && (changedEntities.length > 0)) {
-                const nestedTransactions = await Promise.all(
-                  changedEntities.map(item => this.modifiedNestedNestedComments(item.id, fieldName, value))
-                );
+                where: { id: entitiesToChange.map((_) => _.id) },
+                data: { [fieldName]: value },
+            });
+            if (entitiesToChange.length === changedEntities.length &&
+                changedEntities.length > 0) {
+                const nestedTransactions = await Promise.all(changedEntities.map((item) => this.modifiedNestedNestedComments(item.id, fieldName, value)));
                 return nestedTransactions.length === changedEntities.length;
             }
             return true;
-        } catch (e) {
+        }
+        catch (e) {
             return false;
         }
     },
-
     sanitizeCommentEntity(entity) {
         return {
-            ...buildAuthorModel({
+            ...(0, functions_1.buildAuthorModel)({
                 ...entity,
-                threadOf: isObject(entity.threadOf) ? buildAuthorModel(entity.threadOf) : entity.threadOf,
+                threadOf: (0, lodash_1.isObject)(entity.threadOf)
+                    ? (0, functions_1.buildAuthorModel)(entity.threadOf)
+                    : entity.threadOf,
             }),
         };
     },
-
     isValidUserContext(user) {
-        return user ? !isNil(user?.id) : true;
+        return user ? !(0, lodash_1.isNil)(user?.id) : true;
     },
-
     async parseRelationString(relation) {
-        const [ uid, relatedStringId ] = getRelatedGroups(relation);
-        const parsedRelatedId = parseInt(relatedStringId);
-        const relatedId = isNumber(parsedRelatedId) ? parsedRelatedId : relatedStringId;
-
-        const enabledCollections = await this.getConfig(CONFIG_PARAMS.ENABLED_COLLECTIONS, []);
+        const [uid, relatedStringId] = (0, functions_1.getRelatedGroups)(relation);
+        const parsedRelatedId = (0, lodash_1.parseInt)(relatedStringId);
+        const relatedId = (0, lodash_1.isNumber)(parsedRelatedId)
+            ? parsedRelatedId
+            : relatedStringId;
+        const enabledCollections = await this.getConfig(constants_1.CONFIG_PARAMS.ENABLED_COLLECTIONS, []);
         if (!enabledCollections.includes(uid)) {
-            throw new PluginError(403, `Action not allowed for collection '${uid}'. Use one of: ${ enabledCollections.join(', ') }`);
+            throw new error_1.default(403, `Action not allowed for collection '${uid}'. Use one of: ${enabledCollections.join(", ")}`);
         }
-        return [ uid, relatedId];
+        return [uid, relatedId];
     },
-
     async checkBadWords(content) {
-        const config = await this.getConfig(CONFIG_PARAMS.BAD_WORDS, true);
+        const config = await this.getConfig(constants_1.CONFIG_PARAMS.BAD_WORDS, true);
         if (config) {
-            const filter = new BadWordsFilter(isObject(config) ? config : undefined);
+            const filter = new bad_words_1.default((0, lodash_1.isObject)(config) ? config : undefined);
             if (content && filter.isProfane(content)) {
-                throw new PluginError(400, 'Bad language used! Please polite your comment...', {
+                throw new error_1.default(400, "Bad language used! Please polite your comment...", {
                     content: {
                         original: content,
                         filtered: content && filter.clean(content),
@@ -293,3 +263,4 @@ module.exports = ({ strapi }) => ({
         return content;
     },
 });
+//# sourceMappingURL=common.js.map

package/server/services/graphql.d.ts

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