@atproto/ozone 0.1.79 → 0.1.81

package/src/lexicon/lexicons.ts

@@ -3661,6 +3661,67 @@ export const schemaDict = {
       },
     },
   },
+  ComAtprotoSyncListReposByCollection: {
+    lexicon: 1,
+    id: 'com.atproto.sync.listReposByCollection',
+    defs: {
+      main: {
+        type: 'query',
+        description:
+          'Enumerates all the DIDs which have records with the given collection NSID.',
+        parameters: {
+          type: 'params',
+          required: ['collection'],
+          properties: {
+            collection: {
+              type: 'string',
+              format: 'nsid',
+            },
+            limit: {
+              type: 'integer',
+              description:
+                'Maximum size of response set. Recommend setting a large maximum (1000+) when enumerating large DID lists.',
+              minimum: 1,
+              maximum: 2000,
+              default: 500,
+            },
+            cursor: {
+              type: 'string',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['repos'],
+            properties: {
+              cursor: {
+                type: 'string',
+              },
+              repos: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:com.atproto.sync.listReposByCollection#repo',
+                },
+              },
+            },
+          },
+        },
+      },
+      repo: {
+        type: 'object',
+        required: ['did'],
+        properties: {
+          did: {
+            type: 'string',
+            format: 'did',
+          },
+        },
+      },
+    },
+  },
   ComAtprotoSyncNotifyOfUpdate: {
     lexicon: 1,
     id: 'com.atproto.sync.notifyOfUpdate',
@@ -12219,6 +12280,64 @@ export const schemaDict = {
           },
         },
       },
+      reporterStats: {
+        type: 'object',
+        required: [
+          'did',
+          'accountReportCount',
+          'recordReportCount',
+          'reportedAccountCount',
+          'reportedRecordCount',
+          'takendownAccountCount',
+          'takendownRecordCount',
+          'labeledAccountCount',
+          'labeledRecordCount',
+        ],
+        properties: {
+          did: {
+            type: 'string',
+            format: 'did',
+          },
+          accountReportCount: {
+            type: 'integer',
+            description:
+              'The total number of reports made by the user on accounts.',
+          },
+          recordReportCount: {
+            type: 'integer',
+            description:
+              'The total number of reports made by the user on records.',
+          },
+          reportedAccountCount: {
+            type: 'integer',
+            description: 'The total number of accounts reported by the user.',
+          },
+          reportedRecordCount: {
+            type: 'integer',
+            description: 'The total number of records reported by the user.',
+          },
+          takendownAccountCount: {
+            type: 'integer',
+            description:
+              "The total number of accounts taken down as a result of the user's reports.",
+          },
+          takendownRecordCount: {
+            type: 'integer',
+            description:
+              "The total number of records taken down as a result of the user's reports.",
+          },
+          labeledAccountCount: {
+            type: 'integer',
+            description:
+              "The total number of accounts labeled as a result of the user's reports.",
+          },
+          labeledRecordCount: {
+            type: 'integer',
+            description:
+              "The total number of records labeled as a result of the user's reports.",
+          },
+        },
+      },
     },
   },
   ToolsOzoneModerationEmitEvent: {
@@ -12430,6 +12549,46 @@ export const schemaDict = {
       },
     },
   },
+  ToolsOzoneModerationGetReporterStats: {
+    lexicon: 1,
+    id: 'tools.ozone.moderation.getReporterStats',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Get reporter stats for a list of users.',
+        parameters: {
+          type: 'params',
+          required: ['dids'],
+          properties: {
+            dids: {
+              type: 'array',
+              maxLength: 100,
+              items: {
+                type: 'string',
+                format: 'did',
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['stats'],
+            properties: {
+              stats: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:tools.ozone.moderation.defs#reporterStats',
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
   ToolsOzoneModerationGetRepos: {
     lexicon: 1,
     id: 'tools.ozone.moderation.getRepos',
@@ -13794,6 +13953,15 @@ export const schemaDict = {
         parameters: {
           type: 'params',
           properties: {
+            disabled: {
+              type: 'boolean',
+            },
+            roles: {
+              type: 'array',
+              items: {
+                type: 'string',
+              },
+            },
             limit: {
               type: 'integer',
               minimum: 1,
@@ -13993,6 +14161,7 @@ export const ids = {
   ComAtprotoSyncGetRepoStatus: 'com.atproto.sync.getRepoStatus',
   ComAtprotoSyncListBlobs: 'com.atproto.sync.listBlobs',
   ComAtprotoSyncListRepos: 'com.atproto.sync.listRepos',
+  ComAtprotoSyncListReposByCollection: 'com.atproto.sync.listReposByCollection',
   ComAtprotoSyncNotifyOfUpdate: 'com.atproto.sync.notifyOfUpdate',
   ComAtprotoSyncRequestCrawl: 'com.atproto.sync.requestCrawl',
   ComAtprotoSyncSubscribeRepos: 'com.atproto.sync.subscribeRepos',
@@ -14133,6 +14302,8 @@ export const ids = {
   ToolsOzoneModerationGetRecord: 'tools.ozone.moderation.getRecord',
   ToolsOzoneModerationGetRecords: 'tools.ozone.moderation.getRecords',
   ToolsOzoneModerationGetRepo: 'tools.ozone.moderation.getRepo',
+  ToolsOzoneModerationGetReporterStats:
+    'tools.ozone.moderation.getReporterStats',
   ToolsOzoneModerationGetRepos: 'tools.ozone.moderation.getRepos',
   ToolsOzoneModerationQueryEvents: 'tools.ozone.moderation.queryEvents',
   ToolsOzoneModerationQueryStatuses: 'tools.ozone.moderation.queryStatuses',

package/src/lexicon/types/com/atproto/sync/listReposByCollection.ts

@@ -0,0 +1,68 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import { $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'com.atproto.sync.listReposByCollection'
+
+export interface QueryParams {
+  collection: string
+  /** Maximum size of response set. Recommend setting a large maximum (1000+) when enumerating large DID lists. */
+  limit: number
+  cursor?: string
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  cursor?: string
+  repos: Repo[]
+}
+
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput
+
+export interface Repo {
+  $type?: 'com.atproto.sync.listReposByCollection#repo'
+  did: string
+}
+
+const hashRepo = 'repo'
+
+export function isRepo<V>(v: V) {
+  return is$typed(v, id, hashRepo)
+}
+
+export function validateRepo<V>(v: V) {
+  return validate<Repo & V>(v, id, hashRepo)
+}

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

@@ -836,3 +836,34 @@ export function isRecordHosting<V>(v: V) {
 export function validateRecordHosting<V>(v: V) {
   return validate<RecordHosting & V>(v, id, hashRecordHosting)
 }
+
+export interface ReporterStats {
+  $type?: 'tools.ozone.moderation.defs#reporterStats'
+  did: string
+  /** The total number of reports made by the user on accounts. */
+  accountReportCount: number
+  /** The total number of reports made by the user on records. */
+  recordReportCount: number
+  /** The total number of accounts reported by the user. */
+  reportedAccountCount: number
+  /** The total number of records reported by the user. */
+  reportedRecordCount: number
+  /** The total number of accounts taken down as a result of the user's reports. */
+  takendownAccountCount: number
+  /** The total number of records taken down as a result of the user's reports. */
+  takendownRecordCount: number
+  /** The total number of accounts labeled as a result of the user's reports. */
+  labeledAccountCount: number
+  /** The total number of records labeled as a result of the user's reports. */
+  labeledRecordCount: number
+}
+
+const hashReporterStats = 'reporterStats'
+
+export function isReporterStats<V>(v: V) {
+  return is$typed(v, id, hashReporterStats)
+}
+
+export function validateReporterStats<V>(v: V) {
+  return validate<ReporterStats & V>(v, id, hashReporterStats)
+}

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

@@ -0,0 +1,50 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import { $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as ToolsOzoneModerationDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'tools.ozone.moderation.getReporterStats'
+
+export interface QueryParams {
+  dids: string[]
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  stats: ToolsOzoneModerationDefs.ReporterStats[]
+}
+
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

package/src/lexicon/types/tools/ozone/team/listMembers.ts

@@ -14,6 +14,8 @@ const is$typed = _is$typed,
 const id = 'tools.ozone.team.listMembers'
 
 export interface QueryParams {
+  disabled?: boolean
+  roles?: string[]
   limit: number
   cursor?: string
 }

package/src/mod-service/index.ts

@@ -58,6 +58,8 @@ import {
   ModerationEventRow,
   ModerationSubjectStatusRow,
   ModerationSubjectStatusRowWithHandle,
+  ReporterStats,
+  ReporterStatsResult,
   ReversibleModerationEvent,
 } from './types'
 import { formatLabel, formatLabelRow, signLabel } from './util'
@@ -1272,6 +1274,130 @@ export class ModerationService {
       throw new InvalidRequestError('Email was accepted but not sent')
     }
   }
+
+  buildModerationQuery(
+    subjectType: 'account' | 'record',
+    createdByDids: string[],
+    isActionQuery: boolean,
+  ): Promise<(Partial<ReporterStatsResult> & { did: string })[]> {
+    const isAccount = subjectType === 'account'
+    const actionTypes = [
+      'tools.ozone.moderation.defs#modEventTakedown',
+      'tools.ozone.moderation.defs#modEventLabel',
+    ] as const
+
+    const query = this.db.db
+      .selectFrom('moderation_event as reports')
+      .where(
+        'reports.action',
+        '=',
+        'tools.ozone.moderation.defs#modEventReport',
+      )
+      .where('reports.subjectUri', isAccount ? 'is' : 'is not', null)
+      .where('reports.createdBy', 'in', createdByDids)
+      .select(['reports.createdBy as did'])
+
+    if (isActionQuery) {
+      return query
+        .leftJoin('moderation_event as actions', (join) =>
+          join
+            .onRef('actions.subjectDid', '=', 'reports.subjectDid')
+            .on('actions.subjectUri', isAccount ? 'is' : 'is not', null)
+            .onRef('actions.createdAt', '>', 'reports.createdAt')
+            .on('actions.action', 'in', actionTypes),
+        )
+        .select([
+          () =>
+            sql<number>`COUNT(DISTINCT actions."subjectDid") FILTER (
+              WHERE actions."action" = 'tools.ozone.moderation.defs#modEventTakedown'
+            )`.as(`takendown${isAccount ? 'Account' : 'Record'}Count`),
+
+          () =>
+            sql<number>`COUNT(DISTINCT actions."subjectDid") FILTER (
+              WHERE actions."action" = 'tools.ozone.moderation.defs#modEventLabel'
+            )`.as(`labeled${isAccount ? 'Account' : 'Record'}Count`),
+        ])
+        .groupBy('reports.createdBy')
+        .execute()
+    }
+
+    return query
+      .select([
+        (eb) =>
+          eb.fn.count<number>('reports.id').as(`${subjectType}ReportCount`),
+        (eb) =>
+          eb.fn
+            .count<number>(
+              isAccount ? 'reports.subjectDid' : 'reports.subjectUri',
+            )
+            .distinct()
+            .as(`reported${isAccount ? 'Account' : 'Record'}Count`),
+      ])
+      .groupBy('reports.createdBy')
+      .execute()
+  }
+
+  async getReporterStats(dids: string[]) {
+    const [accountReports, recordReports, accountActions, recordActions] =
+      await Promise.all([
+        this.buildModerationQuery('account', dids, false),
+        this.buildModerationQuery('record', dids, false),
+        this.buildModerationQuery('account', dids, true),
+        this.buildModerationQuery('record', dids, true),
+      ])
+
+    // Create a map to hold the aggregated stats for each `did`
+    const statsMap = new Map<string, ReporterStats>()
+
+    // Helper function to ensure a `did` entry exists in the map
+    const ensureDidEntry = (did: string) => {
+      if (!statsMap.has(did)) {
+        statsMap.set(did, {
+          did,
+          accountReportCount: 0,
+          recordReportCount: 0,
+          reportedAccountCount: 0,
+          reportedRecordCount: 0,
+          takendownAccountCount: 0,
+          takendownRecordCount: 0,
+          labeledAccountCount: 0,
+          labeledRecordCount: 0,
+        })
+      }
+      return statsMap.get(did)!
+    }
+
+    // Merge accountReports
+    for (const report of accountReports) {
+      const entry = ensureDidEntry(report.did)
+      entry.accountReportCount = report.accountReportCount ?? 0
+      entry.reportedAccountCount = report.reportedAccountCount ?? 0
+    }
+
+    // Merge recordReports
+    for (const report of recordReports) {
+      const entry = ensureDidEntry(report.did)
+      entry.recordReportCount = report.recordReportCount ?? 0
+      entry.reportedRecordCount = report.reportedRecordCount ?? 0
+    }
+
+    // Merge accountActions
+    for (const action of accountActions) {
+      const entry = ensureDidEntry(action.did)
+      entry.takendownAccountCount = action.takendownAccountCount ?? 0
+      entry.labeledAccountCount = action.labeledAccountCount ?? 0
+    }
+
+    // Merge recordActions
+    for (const action of recordActions) {
+      const entry = ensureDidEntry(action.did)
+      entry.takendownRecordCount = action.takendownRecordCount ?? 0
+      entry.labeledRecordCount = action.labeledRecordCount ?? 0
+    }
+
+    // Convert map values to an array and return
+    return Array.from(statsMap.values())
+  }
 }
 
 const parseTags = (tags?: string[]) =>

package/src/mod-service/types.ts

@@ -65,3 +65,26 @@ type RecordHostingView = {
 export type ModerationSubjectHostingView =
   | AccountHostingView
   | RecordHostingView
+
+export type ReporterStats = {
+  did: string
+  accountReportCount: number
+  recordReportCount: number
+  reportedAccountCount: number
+  reportedRecordCount: number
+  takendownAccountCount: number
+  takendownRecordCount: number
+  labeledAccountCount: number
+  labeledRecordCount: number
+}
+
+export type ReporterStatsResult = {
+  accountReportCount?: number
+  recordReportCount?: number
+  reportedAccountCount?: number
+  reportedRecordCount?: number
+  takendownAccountCount?: number
+  takendownRecordCount?: number
+  labeledAccountCount?: number
+  labeledRecordCount?: number
+}

package/src/team/index.ts

@@ -21,14 +21,34 @@ export class TeamService {
   async list({
     cursor,
     limit = 25,
+    roles,
+    disabled,
   }: {
     cursor?: string
     limit?: number
+    disabled?: boolean
+    roles?: string[]
   }): Promise<{ members: Selectable<Member>[]; cursor?: string }> {
     let builder = this.db.db.selectFrom('member').selectAll()
     if (cursor) {
       builder = builder.where('createdAt', '>', new Date(cursor))
     }
+    if (roles !== undefined) {
+      const knownRoles = roles.filter(
+        (r) =>
+          r === 'tools.ozone.team.defs#roleAdmin' ||
+          r === 'tools.ozone.team.defs#roleModerator' ||
+          r === 'tools.ozone.team.defs#roleTriage',
+      )
+
+      // Optimization: no need to query to know that no values will be returned
+      if (!knownRoles.length) return { members: [] }
+
+      builder = builder.where('role', 'in', knownRoles)
+    }
+    if (disabled !== undefined) {
+      builder = builder.where('disabled', disabled ? 'is' : 'is not', true)
+    }
     const members = await builder
       .limit(limit)
       .orderBy('createdAt', 'asc')