@atproto/ozone 0.1.69 → 0.1.70

package/src/lexicon/lexicons.ts

@@ -11322,6 +11322,85 @@ export const schemaDict = {
               type: 'string',
             },
           },
+          accountStats: {
+            description: 'Statistics related to the account subject',
+            type: 'ref',
+            ref: 'lex:tools.ozone.moderation.defs#accountStats',
+          },
+          recordsStats: {
+            description:
+              "Statistics related to the record subjects authored by the subject's account",
+            type: 'ref',
+            ref: 'lex:tools.ozone.moderation.defs#recordsStats',
+          },
+        },
+      },
+      accountStats: {
+        description: 'Statistics about a particular account subject',
+        type: 'object',
+        properties: {
+          reportCount: {
+            description: 'Total number of reports on the account',
+            type: 'integer',
+          },
+          appealCount: {
+            description:
+              'Total number of appeals against a moderation action on the account',
+            type: 'integer',
+          },
+          suspendCount: {
+            description: 'Number of times the account was suspended',
+            type: 'integer',
+          },
+          escalateCount: {
+            description: 'Number of times the account was escalated',
+            type: 'integer',
+          },
+          takedownCount: {
+            description: 'Number of times the account was taken down',
+            type: 'integer',
+          },
+        },
+      },
+      recordsStats: {
+        description: 'Statistics about a set of record subject items',
+        type: 'object',
+        properties: {
+          totalReports: {
+            description:
+              'Cumulative sum of the number of reports on the items in the set',
+            type: 'integer',
+          },
+          reportedCount: {
+            description: 'Number of items that were reported at least once',
+            type: 'integer',
+          },
+          escalatedCount: {
+            description: 'Number of items that were escalated at least once',
+            type: 'integer',
+          },
+          appealedCount: {
+            description: 'Number of items that were appealed at least once',
+            type: 'integer',
+          },
+          subjectCount: {
+            description: 'Total number of item in the set',
+            type: 'integer',
+          },
+          pendingCount: {
+            description:
+              'Number of item currently in "reviewOpen" or "reviewEscalated" state',
+            type: 'integer',
+          },
+          processedCount: {
+            description:
+              'Number of item currently in "reviewNone" or "reviewClosed" state',
+            type: 'integer',
+          },
+          takendownCount: {
+            description: 'Number of item currently taken down',
+            type: 'integer',
+          },
         },
       },
       subjectReviewState: {
@@ -12570,7 +12649,12 @@ export const schemaDict = {
             sortField: {
               type: 'string',
               default: 'lastReportedAt',
-              enum: ['lastReviewedAt', 'lastReportedAt'],
+              enum: [
+                'lastReviewedAt',
+                'lastReportedAt',
+                'reportedRecordsCount',
+                'takendownRecordsCount',
+              ],
             },
             sortDirection: {
               type: 'string',
@@ -12625,6 +12709,21 @@ export const schemaDict = {
                 "If specified, subjects of the given type (account or record) will be returned. When this is set to 'account' the 'collections' parameter will be ignored. When includeAllUserRecords or subject is set, this will be ignored.",
               knownValues: ['account', 'record'],
             },
+            minAccountSuspendCount: {
+              type: 'integer',
+              description:
+                'If specified, only subjects that belong to an account that has at least this many suspensions will be returned.',
+            },
+            minReportedRecordsCount: {
+              type: 'integer',
+              description:
+                'If specified, only subjects that belong to an account that has at least this many reported records will be returned.',
+            },
+            minTakendownRecordsCount: {
+              type: 'integer',
+              description:
+                'If specified, only subjects that belong to an account that has at least this many taken down records will be returned.',
+            },
           },
         },
         output: {

package/src/lexicon/types/tools/ozone/moderation/defs.ts

@@ -136,6 +136,8 @@ export interface SubjectStatusView {
   appealed?: boolean
   suspendUntil?: string
   tags?: string[]
+  accountStats?: AccountStats
+  recordsStats?: RecordsStats
   [k: string]: unknown
 }
 
@@ -151,6 +153,66 @@ export function validateSubjectStatusView(v: unknown): ValidationResult {
   return lexicons.validate('tools.ozone.moderation.defs#subjectStatusView', v)
 }
 
+/** Statistics about a particular account subject */
+export interface AccountStats {
+  /** Total number of reports on the account */
+  reportCount?: number
+  /** Total number of appeals against a moderation action on the account */
+  appealCount?: number
+  /** Number of times the account was suspended */
+  suspendCount?: number
+  /** Number of times the account was escalated */
+  escalateCount?: number
+  /** Number of times the account was taken down */
+  takedownCount?: number
+  [k: string]: unknown
+}
+
+export function isAccountStats(v: unknown): v is AccountStats {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'tools.ozone.moderation.defs#accountStats'
+  )
+}
+
+export function validateAccountStats(v: unknown): ValidationResult {
+  return lexicons.validate('tools.ozone.moderation.defs#accountStats', v)
+}
+
+/** Statistics about a set of record subject items */
+export interface RecordsStats {
+  /** Cumulative sum of the number of reports on the items in the set */
+  totalReports?: number
+  /** Number of items that were reported at least once */
+  reportedCount?: number
+  /** Number of items that were escalated at least once */
+  escalatedCount?: number
+  /** Number of items that were appealed at least once */
+  appealedCount?: number
+  /** Total number of item in the set */
+  subjectCount?: number
+  /** Number of item currently in "reviewOpen" or "reviewEscalated" state */
+  pendingCount?: number
+  /** Number of item currently in "reviewNone" or "reviewClosed" state */
+  processedCount?: number
+  /** Number of item currently taken down */
+  takendownCount?: number
+  [k: string]: unknown
+}
+
+export function isRecordsStats(v: unknown): v is RecordsStats {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'tools.ozone.moderation.defs#recordsStats'
+  )
+}
+
+export function validateRecordsStats(v: unknown): ValidationResult {
+  return lexicons.validate('tools.ozone.moderation.defs#recordsStats', v)
+}
+
 export type SubjectReviewState =
   | 'lex:tools.ozone.moderation.defs#reviewOpen'
   | 'lex:tools.ozone.moderation.defs#reviewEscalated'

package/src/lexicon/types/tools/ozone/moderation/queryStatuses.ts

@@ -49,7 +49,11 @@ export interface QueryParams {
   ignoreSubjects?: string[]
   /** Get all subject statuses that were reviewed by a specific moderator */
   lastReviewedBy?: string
-  sortField: 'lastReviewedAt' | 'lastReportedAt'
+  sortField:
+    | 'lastReviewedAt'
+    | 'lastReportedAt'
+    | 'reportedRecordsCount'
+    | 'takendownRecordsCount'
   sortDirection: 'asc' | 'desc'
   /** Get subjects that were taken down */
   takendown?: boolean
@@ -63,6 +67,12 @@ export interface QueryParams {
   collections?: string[]
   /** If specified, subjects of the given type (account or record) will be returned. When this is set to 'account' the 'collections' parameter will be ignored. When includeAllUserRecords or subject is set, this will be ignored. */
   subjectType?: 'account' | 'record' | (string & {})
+  /** If specified, only subjects that belong to an account that has at least this many suspensions will be returned. */
+  minAccountSuspendCount?: number
+  /** If specified, only subjects that belong to an account that has at least this many reported records will be returned. */
+  minReportedRecordsCount?: number
+  /** If specified, only subjects that belong to an account that has at least this many taken down records will be returned. */
+  minTakendownRecordsCount?: number
 }
 
 export type InputSchema = undefined

package/src/mod-service/index.ts

@@ -1,5 +1,5 @@
 import net from 'node:net'
-import { Insertable, SelectQueryBuilder, sql } from 'kysely'
+import { Insertable, sql } from 'kysely'
 import { CID } from 'multiformats/cid'
 import { AtUri, INVALID_HANDLE } from '@atproto/syntax'
 import { InvalidRequestError } from '@atproto/xrpc-server'
@@ -29,16 +29,19 @@ import { RepoRef, RepoBlobRef } from '../lexicon/types/com/atproto/admin/defs'
 import {
   adjustModerationSubjectStatus,
   getStatusIdentifierFromSubject,
+  moderationSubjectStatusQueryBuilder,
 } from './status'
 import {
   ModEventType,
   ModerationEventRow,
   ModerationSubjectStatusRow,
+  ModerationSubjectStatusRowWithHandle,
   ReversibleModerationEvent,
 } from './types'
 import { ModerationEvent } from '../db/schema/moderation_event'
 import { StatusKeyset, TimeIdKeyset, paginate } from '../db/pagination'
 import { Label } from '../lexicon/types/com/atproto/label/defs'
+import { QueryParams as QueryStatusParams } from '../lexicon/types/tools/ozone/moderation/queryStatuses'
 import {
   ModSubject,
   RecordSubject,
@@ -56,6 +59,7 @@ import { httpLogger as log } from '../logger'
 import { OzoneConfig } from '../config'
 import { LABELER_HEADER_NAME, ParsedLabelers } from '../util'
 import { ids } from '../lexicon/lexicons'
+import { getReviewState } from '../api/util'
 
 export type ModerationServiceCreator = (db: Database) => ModerationService
 
@@ -805,45 +809,6 @@ export class ModerationService {
     return result
   }
 
-  applyTagFilter = (
-    builder: SelectQueryBuilder<any, any, any>,
-    tags: string[],
-  ) => {
-    const { ref } = this.db.db.dynamic
-    // Build an array of conditions
-    const conditions = tags
-      .map((tag) => {
-        if (tag.includes('&&')) {
-          // Split by '&&' for AND logic
-          const subTags = tag
-            .split('&&')
-            // Make sure spaces on either sides of '&&' are trimmed
-            .map((subTag) => subTag.trim())
-            // Remove empty strings after trimming is applied
-            .filter(Boolean)
-
-          if (!subTags.length) return null
-
-          return sql`(${sql.join(
-            subTags.map(
-              (subTag) =>
-                sql`${ref('moderation_subject_status.tags')} ? ${subTag}`,
-            ),
-            sql` AND `,
-          )})`
-        } else {
-          // Single tag condition
-          return sql`${ref('moderation_subject_status.tags')} ? ${tag}`
-        }
-      })
-      .filter(Boolean)
-
-    if (!conditions.length) return builder
-
-    // Combine all conditions with OR
-    return builder.where(sql`(${sql.join(conditions, sql` OR `)})`)
-  }
-
   async getSubjectStatuses({
     queueCount,
     queueIndex,
@@ -858,54 +823,31 @@ export class ModerationService {
     reviewedBefore,
     reportedAfter,
     reportedBefore,
-    includeMuted,
+    includeMuted = false,
     hostingDeletedBefore,
     hostingDeletedAfter,
     hostingUpdatedBefore,
     hostingUpdatedAfter,
     hostingStatuses,
-    onlyMuted,
+    onlyMuted = false,
     ignoreSubjects,
-    sortDirection,
+    sortDirection = 'desc',
     lastReviewedBy,
-    sortField,
+    sortField = 'lastReportedAt',
     subject,
     tags,
     excludeTags,
     collections,
     subjectType,
-  }: {
-    queueCount?: number
-    queueIndex?: number
-    queueSeed?: string
-    includeAllUserRecords?: boolean
+    minAccountSuspendCount,
+    minReportedRecordsCount,
+    minTakendownRecordsCount,
+  }: QueryStatusParams): Promise<{
+    statuses: ModerationSubjectStatusRowWithHandle[]
     cursor?: string
-    limit?: number
-    takendown?: boolean
-    appealed?: boolean
-    reviewedBefore?: string
-    reviewState?: ModerationSubjectStatusRow['reviewState']
-    reviewedAfter?: string
-    reportedAfter?: string
-    reportedBefore?: string
-    includeMuted?: boolean
-    hostingDeletedBefore?: string
-    hostingDeletedAfter?: string
-    hostingUpdatedBefore?: string
-    hostingUpdatedAfter?: string
-    hostingStatuses?: string[]
-    onlyMuted?: boolean
-    subject?: string
-    ignoreSubjects?: string[]
-    sortDirection: 'asc' | 'desc'
-    lastReviewedBy?: string
-    sortField: 'lastReviewedAt' | 'lastReportedAt'
-    tags: string[]
-    excludeTags: string[]
-    collections: string[]
-    subjectType?: string
-  }) {
-    let builder = this.db.db.selectFrom('moderation_subject_status').selectAll()
+  }> {
+    let builder = moderationSubjectStatusQueryBuilder(this.db.db)
+
     const { ref } = this.db.db.dynamic
 
     if (subject) {
@@ -919,14 +861,18 @@ export class ModerationService {
       if (!includeAllUserRecords) {
         builder = builder.where((qb) =>
           subjectInfo.recordPath
-            ? qb.where('recordPath', '=', subjectInfo.recordPath)
-            : qb.where('recordPath', '=', ''),
+            ? qb.where(
+                'moderation_subject_status.recordPath',
+                '=',
+                subjectInfo.recordPath,
+              )
+            : qb.where('moderation_subject_status.recordPath', '=', ''),
         )
       }
     } else if (subjectType === 'account') {
-      builder = builder.where('recordPath', '=', '')
+      builder = builder.where('moderation_subject_status.recordPath', '=', '')
     } else if (subjectType === 'record') {
-      builder = builder.where('recordPath', '!=', '')
+      builder = builder.where('moderation_subject_status.recordPath', '!=', '')
     }
 
     // Only fetch items that belongs to the specified queue when specified
@@ -948,110 +894,216 @@ export class ModerationService {
     }
 
     // If subjectType is set to 'account' let that take priority and ignore collections filter
-    if (collections.length && subjectType !== 'account') {
-      builder = builder.where('recordPath', '!=', '').where((qb) => {
-        collections.forEach((collection) => {
-          qb = qb.orWhere('recordPath', 'like', `${collection}/%`)
+    if (subjectType !== 'account' && collections?.length) {
+      builder = builder
+        .where('moderation_subject_status.recordPath', '!=', '')
+        .where((qb) => {
+          for (const collection of collections) {
+            qb = qb.orWhere(
+              'moderation_subject_status.recordPath',
+              'like',
+              `${collection}/%`,
+            )
+          }
+          return qb
         })
-        return qb
-      })
     }
 
     if (ignoreSubjects?.length) {
       builder = builder
-        .where('did', 'not in', ignoreSubjects)
-        .where('recordPath', 'not in', ignoreSubjects)
+        .where('moderation_subject_status.did', 'not in', ignoreSubjects)
+        .where('moderation_subject_status.recordPath', 'not in', ignoreSubjects)
     }
 
-    if (reviewState) {
-      builder = builder.where('reviewState', '=', reviewState)
+    const reviewStateNormalized = getReviewState(reviewState)
+    if (reviewStateNormalized) {
+      builder = builder.where(
+        'moderation_subject_status.reviewState',
+        '=',
+        reviewStateNormalized,
+      )
     }
 
     if (lastReviewedBy) {
-      builder = builder.where('lastReviewedBy', '=', lastReviewedBy)
+      builder = builder.where(
+        'moderation_subject_status.lastReviewedBy',
+        '=',
+        lastReviewedBy,
+      )
     }
 
     if (reviewedAfter) {
-      builder = builder.where('lastReviewedAt', '>', reviewedAfter)
+      builder = builder.where(
+        'moderation_subject_status.lastReviewedAt',
+        '>',
+        reviewedAfter,
+      )
     }
 
     if (reviewedBefore) {
-      builder = builder.where('lastReviewedAt', '<', reviewedBefore)
+      builder = builder.where(
+        'moderation_subject_status.lastReviewedAt',
+        '<',
+        reviewedBefore,
+      )
     }
 
     if (hostingUpdatedAfter) {
-      builder = builder.where('hostingUpdatedAt', '>', hostingUpdatedAfter)
+      builder = builder.where(
+        'moderation_subject_status.hostingUpdatedAt',
+        '>',
+        hostingUpdatedAfter,
+      )
     }
 
     if (hostingUpdatedBefore) {
-      builder = builder.where('hostingUpdatedAt', '<', hostingUpdatedBefore)
+      builder = builder.where(
+        'moderation_subject_status.hostingUpdatedAt',
+        '<',
+        hostingUpdatedBefore,
+      )
     }
 
     if (hostingDeletedAfter) {
-      builder = builder.where('hostingDeletedAt', '>', hostingDeletedAfter)
+      builder = builder.where(
+        'moderation_subject_status.hostingDeletedAt',
+        '>',
+        hostingDeletedAfter,
+      )
     }
 
     if (hostingDeletedBefore) {
-      builder = builder.where('hostingDeletedAt', '<', hostingDeletedBefore)
+      builder = builder.where(
+        'moderation_subject_status.hostingDeletedAt',
+        '<',
+        hostingDeletedBefore,
+      )
     }
 
     if (hostingStatuses?.length) {
-      builder = builder.where('hostingStatus', 'in', hostingStatuses)
+      builder = builder.where(
+        'moderation_subject_status.hostingStatus',
+        'in',
+        hostingStatuses,
+      )
     }
 
     if (reportedAfter) {
-      builder = builder.where('lastReviewedAt', '>', reportedAfter)
+      builder = builder.where(
+        'moderation_subject_status.lastReviewedAt',
+        '>',
+        reportedAfter,
+      )
     }
 
     if (reportedBefore) {
-      builder = builder.where('lastReportedAt', '<', reportedBefore)
+      builder = builder.where(
+        'moderation_subject_status.lastReportedAt',
+        '<',
+        reportedBefore,
+      )
     }
 
     if (takendown) {
-      builder = builder.where('takendown', '=', true)
+      builder = builder.where('moderation_subject_status.takendown', '=', true)
     }
 
     if (appealed !== undefined) {
       builder =
         appealed === false
-          ? builder.where('appealed', 'is', null)
-          : builder.where('appealed', '=', appealed)
+          ? builder.where('moderation_subject_status.appealed', 'is', null)
+          : builder.where('moderation_subject_status.appealed', '=', appealed)
     }
 
     if (!includeMuted) {
       builder = builder.where((qb) =>
         qb
-          .where('muteUntil', '<', new Date().toISOString())
-          .orWhere('muteUntil', 'is', null),
+          .where(
+            'moderation_subject_status.muteUntil',
+            '<',
+            new Date().toISOString(),
+          )
+          .orWhere('moderation_subject_status.muteUntil', 'is', null),
       )
     }
 
     if (onlyMuted) {
       builder = builder.where((qb) =>
         qb
-          .where('muteUntil', '>', new Date().toISOString())
-          .orWhere('muteReportingUntil', '>', new Date().toISOString()),
+          .where(
+            'moderation_subject_status.muteUntil',
+            '>',
+            new Date().toISOString(),
+          )
+          .orWhere(
+            'moderation_subject_status.muteReportingUntil',
+            '>',
+            new Date().toISOString(),
+          ),
       )
     }
 
-    if (tags.length) {
-      builder = this.applyTagFilter(builder, tags)
+    // ["tag1", "tag2 && tag3", "tag4"] => [["tag1"], ["tag2", "tag3"], ["tag4"]]
+    const conditions = parseTags(tags)
+    if (conditions?.length) {
+      // [["tag1"], ["tag2", "tag3"], ["tag4"]] => (tags ? 'tag1') OR (tags ? 'tag2' AND tags ? 'tag3') OR (tags ? 'tag4')
+      builder = builder.where((qb) => {
+        for (const subTags of conditions) {
+          // OR between every conditions items (subTags)
+          qb = qb.orWhere((qb) => {
+            // AND between every subTags items (subTag)
+            for (const subTag of subTags) {
+              qb = qb.where(
+                sql`${ref('moderation_subject_status.tags')} ? ${subTag}`,
+              )
+            }
+            return qb
+          })
+        }
+        return qb
+      })
     }
 
-    if (excludeTags.length) {
+    if (excludeTags?.length) {
       builder = builder.where((qb) =>
         qb
           .where(
-            sql`NOT(${ref(
-              'moderation_subject_status.tags',
-            )} ?| array[${sql.join(excludeTags)}]::TEXT[])`,
+            sql`NOT(${ref('moderation_subject_status.tags')} ?| array[${sql.join(excludeTags)}]::TEXT[])`,
           )
           .orWhere('tags', 'is', null),
       )
     }
 
+    if (minAccountSuspendCount != null && minAccountSuspendCount > 0) {
+      builder = builder.where(
+        'account_events_stats.suspendCount',
+        '>=',
+        minAccountSuspendCount,
+      )
+    }
+
+    if (minTakendownRecordsCount != null && minTakendownRecordsCount > 0) {
+      builder = builder.where(
+        'account_record_status_stats.takendownCount',
+        '>=',
+        minTakendownRecordsCount,
+      )
+    }
+
+    if (minReportedRecordsCount != null && minReportedRecordsCount > 0) {
+      builder = builder.where(
+        'account_record_events_stats.reportedCount',
+        '>=',
+        minReportedRecordsCount,
+      )
+    }
+
     const keyset = new StatusKeyset(
-      ref(`moderation_subject_status.${sortField}`),
+      sortField === 'reportedRecordsCount'
+        ? ref(`account_record_events_stats.reportedCount`)
+        : sortField === 'takendownRecordsCount'
+          ? ref(`account_record_status_stats.takendownCount`)
+          : ref(`moderation_subject_status.${sortField}`),
       ref('moderation_subject_status.id'),
     )
     const paginatedBuilder = paginate(builder, {
@@ -1067,13 +1119,12 @@ export class ModerationService {
     const infos = await this.views.getAccoutInfosByDid(
       results.map((r) => r.did),
     )
-    const resultsWithHandles = results.map((r) => ({
-      ...r,
-      handle: infos.get(r.did)?.handle ?? INVALID_HANDLE,
-    }))
 
     return {
-      statuses: resultsWithHandles,
+      statuses: results.map((r) => ({
+        ...r,
+        handle: infos.get(r.did)?.handle ?? INVALID_HANDLE,
+      })),
       cursor: keyset.packFromResult(results),
     }
   }
@@ -1195,6 +1246,18 @@ export class ModerationService {
   }
 }
 
+const parseTags = (tags?: string[]) =>
+  tags
+    ?.map((tag) =>
+      tag
+        .split(/\s*&&\s*/g)
+        .map((subTag) => subTag.trim())
+        // Ignore invalid syntax ("", "tag1 &&", "&& tag2", "tag1 && && tag2", etc.)
+        .filter(Boolean),
+    )
+    // Ignore invalid items
+    .filter((subTags): subTags is [string, ...string[]] => subTags.length > 0)
+
 const isSafeUrl = (url: URL) => {
   if (url.protocol !== 'https:') return false
   if (!url.hostname || url.hostname === 'localhost') return false