@atproto/ozone 0.1.173 → 0.1.174

package/src/lexicon/types/tools/ozone/report/reassignQueue.ts

@@ -0,0 +1,55 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import type * as ToolsOzoneReportDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'tools.ozone.report.reassignQueue'
+
+export type QueryParams = {}
+
+export interface InputSchema {
+  /** ID of the report to reassign */
+  reportId: number
+  /** Target queue ID. Use -1 to unassign from any queue. */
+  queueId: number
+  /** Optional moderator-only note recorded on the resulting queueActivity as internalNote. */
+  comment?: string
+}
+
+export interface OutputSchema {
+  report: ToolsOzoneReportDefs.ReportView
+}
+
+export interface HandlerInput {
+  encoding: 'application/json'
+  body: InputSchema
+}
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+  error?:
+    | 'ReportNotFound'
+    | 'ReportClosed'
+    | 'AlreadyInTargetQueue'
+    | 'QueueNotFound'
+    | 'QueueDisabled'
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess

package/src/lexicon/types/tools/ozone/report/refreshStats.ts

@@ -0,0 +1,46 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'tools.ozone.report.refreshStats'
+
+export type QueryParams = {}
+
+export interface InputSchema {
+  /** Start date for recomputation, inclusive (YYYY-MM-DD). */
+  startDate: string
+  /** End date for recomputation, inclusive (YYYY-MM-DD). */
+  endDate: string
+  /** Optional list of queue IDs to recompute. Omit to recompute all groups. */
+  queueIds?: number[]
+}
+
+export interface OutputSchema {}
+
+export interface HandlerInput {
+  encoding: 'application/json'
+  body: InputSchema
+}
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess

package/src/lexicon/types/tools/ozone/report/unassignModerator.ts

@@ -0,0 +1,44 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import type * as ToolsOzoneReportDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'tools.ozone.report.unassignModerator'
+
+export type QueryParams = {}
+
+export interface InputSchema {
+  /** The ID of the report to unassign. */
+  reportId: number
+}
+
+export type OutputSchema = ToolsOzoneReportDefs.AssignmentView
+
+export interface HandlerInput {
+  encoding: 'application/json'
+  body: InputSchema
+}
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+  error?: 'InvalidAssignment'
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess

package/src/mod-service/index.ts

@@ -62,6 +62,7 @@ import {
 import {
   ModEventType,
   ModerationEventRow,
+  ModerationEventRowWithHandle,
   ModerationSubjectStatusRow,
   ModerationSubjectStatusRowWithHandle,
   ReporterStats,
@@ -376,6 +377,29 @@ export class ModerationService {
     return { cursor: keyset.packFromResult(result), events: resultWithHandles }
   }
 
+  async getEventsByIds(ids: number[]): Promise<ModerationEventRowWithHandle[]> {
+    if (!ids.length) return []
+
+    const result = await this.db.db
+      .selectFrom('moderation_event')
+      .selectAll()
+      .where('id', 'in', ids)
+      .execute()
+
+    if (!result.length) return []
+
+    const infos = await this.views.getAccoutInfosByDid([
+      ...result.map((row) => row.subjectDid),
+      ...result.map((row) => row.createdBy),
+    ])
+
+    return result.map((r) => ({
+      ...r,
+      creatorHandle: infos.get(r.createdBy)?.handle,
+      subjectHandle: infos.get(r.subjectDid)?.handle,
+    }))
+  }
+
   async getReport(id: number): Promise<ModerationEventRow | undefined> {
     return await this.db.db
       .selectFrom('moderation_event')
@@ -591,6 +615,13 @@ export class ModerationService {
       if (isReportingMuted) {
         meta.isReporterMuted = true
       }
+      // Also capture whether the subject was muted at event-creation time, so
+      // the queue-router daemon can populate report.isMuted later without
+      // racing against subsequent mute/unmute changes.
+      const isSubjectMuted = await this.isSubjectMuted(subject.did)
+      if (isSubjectMuted) {
+        meta.isSubjectMuted = true
+      }
     }
 
     const subjectInfo = subject.info()
@@ -1035,7 +1066,7 @@ export class ModerationService {
       modTool,
     } = info
 
-    const result = await this.logEvent({
+    return await this.logEvent({
       event: {
         $type: 'tools.ozone.moderation.defs#modEventReport',
         reportType: reasonType,
@@ -1046,8 +1077,6 @@ export class ModerationService {
       createdAt,
       modTool,
     })
-
-    return result
   }
 
   async getSubjectStatuses({
@@ -1425,6 +1454,19 @@ export class ModerationService {
     return !!result
   }
 
+  // Check if a subject (the account being reported) has an active mute
+  async isSubjectMuted(did: string) {
+    const result = await this.db.db
+      .selectFrom('moderation_subject_status')
+      .where('did', '=', did)
+      .where('recordPath', '=', '')
+      .where('muteUntil', '>', new Date().toISOString())
+      .select(sql`true`.as('status'))
+      .executeTakeFirst()
+
+    return !!result
+  }
+
   async formatAndCreateLabels(
     uri: string,
     cid: string | null,

package/src/mod-service/report.ts

@@ -0,0 +1,408 @@
+import { sql } from 'kysely'
+import { AtUri } from '@atproto/syntax'
+import { Database } from '../db'
+import { Report } from '../db/schema/report'
+import { QueryParams } from '../lexicon/types/tools/ozone/report/queryReports'
+import {
+  AlreadyInTargetState,
+  InvalidStateTransition,
+  handleReportUpdate,
+} from '../report/handle-report-update'
+
+export type ReportWithEvent = Omit<Report, 'id'> & {
+  id: number
+  subjectDid: string
+  subjectUri: string | null
+  subjectCid: string | null
+  reportedBy: string
+  comment: string | null
+  meta: Record<string, string | boolean | number> | null
+}
+
+export type QueryReportsResult = {
+  reports: ReportWithEvent[]
+  cursor: string | undefined
+}
+function reportQuery(db: Database) {
+  return db.db
+    .selectFrom('report as r')
+    .innerJoin('moderation_event as me', 'me.id', 'r.eventId')
+    .where('me.action', '=', 'tools.ozone.moderation.defs#modEventReport')
+}
+
+export async function queryReports(
+  db: Database,
+  params: QueryParams,
+): Promise<QueryReportsResult> {
+  let builder = reportQuery(db)
+
+  if (params.queueId !== undefined) {
+    builder = builder.where('r.queueId', '=', params.queueId)
+  }
+
+  builder = builder.where('r.status', '=', params.status)
+
+  if (params.subject) {
+    const isRecord = params.subject.startsWith('at://')
+    if (isRecord) {
+      const uri = new AtUri(params.subject)
+      builder = builder
+        .where('r.did', '=', uri.host)
+        .where('r.recordPath', '=', `${uri.collection}/${uri.rkey}`)
+    } else {
+      builder = builder
+        .where('r.did', '=', params.subject)
+        .where('r.recordPath', '=', '')
+    }
+  }
+
+  if (params.did) {
+    builder = builder.where('r.did', '=', params.did)
+  }
+
+  if (params.subjectType) {
+    const normalizedType = params.subjectType as 'account' | 'record'
+    if (normalizedType === 'account') {
+      builder = builder.where('r.recordPath', '=', '')
+    } else if (normalizedType === 'record') {
+      builder = builder.where('r.recordPath', '!=', '')
+    }
+  }
+
+  if (params.collections?.length) {
+    // Filter by collection prefix on recordPath (uses text_pattern_ops index)
+    const collectionConditions = params.collections.map(
+      (collection) => sql`r."recordPath" LIKE ${`${collection}/%`}`,
+    )
+    builder = builder.where(sql`(${sql.join(collectionConditions, sql` OR `)})`)
+  }
+
+  if (params.reportTypes?.length) {
+    builder = builder.where('r.reportType', 'in', params.reportTypes)
+  }
+
+  if (params.isMuted !== undefined) {
+    builder = builder.where('r.isMuted', '=', params.isMuted)
+  }
+
+  if (params.reportedAfter) {
+    builder = builder.where('r.createdAt', '>', params.reportedAfter)
+  }
+
+  if (params.reportedBefore) {
+    builder = builder.where('r.createdAt', '<', params.reportedBefore)
+  }
+
+  if (params.assignedTo) {
+    builder = builder.where('r.assignedTo', '=', params.assignedTo)
+  }
+
+  const sortField = params.sortField ?? 'createdAt'
+  const sortDirection = params.sortDirection ?? 'desc'
+
+  builder = builder
+    .orderBy(
+      sortField === 'updatedAt' ? 'r.updatedAt' : 'r.createdAt',
+      sortDirection,
+    )
+    .orderBy('r.id', 'desc')
+
+  const limit = params.limit ?? 50
+  if (params.cursor) {
+    const [sortValue, id] = params.cursor.split('::')
+    const sortCol = sortField === 'updatedAt' ? 'r.updatedAt' : 'r.createdAt'
+    if (sortDirection === 'desc') {
+      builder = builder.where(sql`(
+        ${sql.ref(sortCol)} < ${sortValue}
+        OR (${sql.ref(sortCol)} = ${sortValue} AND r.id < ${Number(id)})
+      )`)
+    } else {
+      builder = builder.where(sql`(
+        ${sql.ref(sortCol)} > ${sortValue}
+        OR (${sql.ref(sortCol)} = ${sortValue} AND r.id > ${Number(id)})
+      )`)
+    }
+  }
+
+  const finalQuery = builder
+    .selectAll('r')
+    .select([
+      'me.subjectDid',
+      'me.subjectUri',
+      'me.subjectCid',
+      'me.createdBy as reportedBy',
+      'me.comment',
+      'me.meta',
+    ])
+    .limit(limit + 1)
+
+  const reports = await finalQuery.execute()
+
+  let cursor: string | undefined
+  const hasMore = reports.length > limit
+  if (hasMore) {
+    const last = reports[limit - 1]
+    const sortValue =
+      sortField === 'updatedAt' ? last.updatedAt : last.createdAt
+    cursor = `${sortValue}::${last.id}`
+  }
+
+  const reportsToReturn = hasMore ? reports.slice(0, limit) : reports
+
+  return {
+    reports: reportsToReturn,
+    cursor,
+  }
+}
+
+export async function getReportById(
+  db: Database,
+  id: number,
+): Promise<ReportWithEvent | undefined> {
+  return reportQuery(db)
+    .where('r.id', '=', id)
+    .selectAll('r')
+    .select([
+      'me.subjectDid',
+      'me.subjectUri',
+      'me.subjectCid',
+      'me.createdBy as reportedBy',
+      'me.comment',
+      'me.meta',
+    ])
+    .executeTakeFirst()
+}
+
+export async function getLatestReport(
+  db: Database,
+): Promise<ReportWithEvent | undefined> {
+  return reportQuery(db)
+    .selectAll('r')
+    .select([
+      'me.subjectDid',
+      'me.subjectUri',
+      'me.subjectCid',
+      'me.createdBy as reportedBy',
+      'me.comment',
+      'me.meta',
+    ])
+    .orderBy('r.id', 'desc')
+    .limit(1)
+    .executeTakeFirst()
+}
+
+export type FindReportsForSubjectParams = {
+  subjectDid: string
+  subjectUri?: string | null
+  reportIds?: number[]
+  reportTypes?: string[]
+  targetAll?: boolean
+}
+
+export type ReportResult = {
+  id: number
+  eventId: number
+  queueId: number | null
+  queuedAt: string | null
+  actionEventIds: number[] | null
+  actionNote: string | null
+  isMuted: boolean
+  status: string
+  createdAt: string
+  updatedAt: string
+}
+
+export async function findReportsForSubject(
+  db: Database,
+  params: FindReportsForSubjectParams,
+): Promise<ReportResult[]> {
+  let builder = reportQuery(db).where('r.did', '=', params.subjectDid)
+
+  // Filter by subject URI (if provided, match exactly; if null/undefined, match repo-level)
+  if (params.subjectUri) {
+    const uri = new AtUri(params.subjectUri)
+    builder = builder.where(
+      'r.recordPath',
+      '=',
+      `${uri.collection}/${uri.rkey}`,
+    )
+  } else {
+    builder = builder.where('r.recordPath', '=', '')
+  }
+
+  if (params.targetAll) {
+    // Target all open/escalated reports on the subject
+    builder = builder.where('r.status', 'not in', ['closed'])
+  } else if (params.reportIds?.length) {
+    // Target specific report IDs — still enforce state transition rules
+    builder = builder
+      .where('r.id', 'in', params.reportIds)
+      .where('r.status', 'not in', ['closed'])
+  } else if (params.reportTypes?.length) {
+    // Target reports matching specific report types
+    builder = builder
+      .where('r.reportType', 'in', params.reportTypes)
+      .where('r.status', 'not in', ['closed'])
+  } else {
+    // No targeting criteria provided
+    return []
+  }
+
+  const reports = await builder.selectAll('r').execute()
+
+  return reports
+}
+
+export type ProcessReportActionParams = {
+  db: Database
+  reportAction: {
+    ids?: number[]
+    types?: string[]
+    all?: boolean
+    note?: string
+  }
+  subjectDid: string
+  subjectUri: string | null
+  eventId: number
+  eventType: string
+  createdBy: string
+}
+
+/**
+ * Validates and processes a report action by:
+ * 1. Finding matching reports based on targeting criteria
+ * 2. Validating that specified report IDs exist and belong to the subject
+ * 3. Bulk-updating reports with the action event ID, note, and status
+ * 4. Bulk-inserting a report_activity row for each updated report
+ *
+ * @throws InvalidRequestError if validation fails
+ */
+export async function processReportAction(
+  params: ProcessReportActionParams,
+): Promise<number> {
+  const {
+    db,
+    reportAction,
+    subjectDid,
+    subjectUri,
+    eventId,
+    eventType,
+    createdBy,
+  } = params
+
+  // Find reports matching the criteria
+  const matchingReports = await findReportsForSubject(db, {
+    subjectDid,
+    subjectUri,
+    reportIds: reportAction.ids,
+    reportTypes: reportAction.types,
+    targetAll: reportAction.all,
+  })
+
+  // Validate that reports were found for ids and types
+  if (matchingReports.length === 0) {
+    if (reportAction.ids?.length) {
+      throw new Error(
+        'No matching reports found for the specified report IDs on this subject',
+      )
+    } else if (reportAction.types?.length) {
+      throw new Error(
+        'No matching reports found for the specified report types on this subject',
+      )
+    }
+    // For 'all', it's okay if no reports exist
+    return 0
+  }
+
+  // Validate that all specified report IDs were found
+  if (reportAction.ids?.length) {
+    const foundIds = new Set(matchingReports.map((r) => r.id))
+    const requestedIds = new Set(reportAction.ids)
+    const missingIds = [...requestedIds].filter((id) => !foundIds.has(id))
+
+    if (missingIds.length > 0) {
+      throw new Error(
+        `Report IDs ${missingIds.join(', ')} do not exist, are already closed, or do not belong to this subject`,
+      )
+    }
+  }
+
+  // Determine per-report transitions via the pure state machine.
+  // Skip reports whose current status doesn't allow the transition.
+  const validUpdates: {
+    id: number
+    nextStatus: string
+    activityType: string
+    previousStatus: string
+  }[] = []
+
+  for (const report of matchingReports) {
+    try {
+      const result = handleReportUpdate(report.status, {
+        type: 'event',
+        eventType,
+      })
+      if (result.nextStatus && result.activity) {
+        validUpdates.push({
+          id: report.id,
+          nextStatus: result.nextStatus,
+          activityType: result.activity.activityType,
+          previousStatus: result.activity.previousStatus,
+        })
+      }
+    } catch (err) {
+      if (
+        err instanceof AlreadyInTargetState ||
+        err instanceof InvalidStateTransition
+      ) {
+        // Skip reports that can't transition — silent per design
+        continue
+      }
+      throw err
+    }
+  }
+
+  if (!validUpdates.length) {
+    return 0
+  }
+
+  const now = new Date().toISOString()
+  const updateIds = validUpdates.map((u) => u.id)
+
+  // Bulk UPDATE reports that passed validation
+  // All valid reports share the same target status since they come from the
+  // same event type, so a single UPDATE is sufficient.
+  const status = validUpdates[0].nextStatus
+  const closedAt = status === 'closed' ? now : null
+  await db.db
+    .updateTable('report')
+    .set({
+      actionEventIds: sql`COALESCE("actionEventIds", '[]'::jsonb) || ${JSON.stringify(eventId)}::jsonb`,
+      actionNote: reportAction.note ?? null,
+      status,
+      updatedAt: now,
+      closedAt,
+    })
+    .where('id', 'in', updateIds)
+    .execute()
+
+  // Bulk INSERT one activity per updated report
+  await db.db
+    .insertInto('report_activity')
+    .values(
+      validUpdates.map((u) => ({
+        reportId: u.id,
+        activityType: u.activityType,
+        previousStatus: u.previousStatus,
+        internalNote: null,
+        publicNote: reportAction.note ?? null,
+        meta: null,
+        isAutomated: false,
+        createdBy,
+        createdAt: now,
+      })),
+    )
+    .execute()
+
+  return validUpdates.length
+}