@atproto/ozone 0.1.172 → 0.1.174

package/src/report/views.ts

@@ -0,0 +1,241 @@
+import { Selectable } from 'kysely'
+import {
+  AppBskyActorDefs,
+  ToolsOzoneModerationDefs,
+  ToolsOzoneQueueDefs,
+  ToolsOzoneReportDefs,
+} from '@atproto/api'
+import { addAccountInfoToRepoViewDetail } from '../api/util'
+import { ReportStat } from '../db/schema/report_stat'
+import { AccountView } from '../lexicon/types/com/atproto/admin/defs'
+import {
+  RecordViewDetail,
+  RepoView,
+} from '../lexicon/types/tools/ozone/moderation/defs'
+import { Member as TeamMember } from '../lexicon/types/tools/ozone/team/defs'
+import { ReportWithEvent } from '../mod-service/report'
+import { ParsedLabelers } from '../util'
+
+type ReportViews = {
+  repoDetails(
+    dids: string[],
+    labelers?: ParsedLabelers,
+  ): Promise<Map<string, RepoView>>
+  recordDetails(
+    subjects: { uri: string }[],
+    labelers?: ParsedLabelers,
+  ): Promise<Map<string, RecordViewDetail>>
+  getProfiles(
+    dids: string[],
+  ): Promise<Map<string, AppBskyActorDefs.ProfileViewDetailed>>
+}
+
+export type HydratedReport = {
+  partialRepos: Map<string, RepoView>
+  accountInfo: Map<string, AccountView | null>
+  recordInfo: Map<string, RecordViewDetail>
+  profiles: Map<string, AppBskyActorDefs.ProfileViewDetailed>
+  queues: Map<number, ToolsOzoneQueueDefs.QueueView>
+  memberViews: Map<string, TeamMember>
+}
+
+export async function hydrateReportInfo(
+  reports: ReportWithEvent[],
+  views: ReportViews,
+  getAccountInfos: (dids: string[]) => Promise<Map<string, AccountView | null>>,
+  getQueues: (
+    queueIds: number[],
+  ) => Promise<Map<number, ToolsOzoneQueueDefs.QueueView>>,
+  getTeamMembers: (dids: string[]) => Promise<Map<string, TeamMember>>,
+  labelers: ParsedLabelers,
+): Promise<HydratedReport> {
+  const dids = new Set<string>()
+  const uris = new Set<string>()
+  const queueIds = new Set<number>()
+  const assignmentDids: string[] = []
+
+  for (const report of reports) {
+    dids.add(report.subjectDid)
+    dids.add(report.reportedBy)
+    if (report.subjectUri) uris.add(report.subjectUri)
+    if (report.queueId && report.queueId > 0) queueIds.add(report.queueId)
+    if (report.assignedTo) {
+      dids.add(report.assignedTo)
+      assignmentDids.push(report.assignedTo)
+    }
+  }
+
+  const didsArray = Array.from(dids)
+  const [partialRepos, accountInfo, recordInfo, profiles, queues, memberViews] =
+    await Promise.all([
+      views.repoDetails(didsArray, labelers),
+      getAccountInfos(didsArray),
+      views.recordDetails(
+        Array.from(uris).map((uri) => ({ uri })),
+        labelers,
+      ),
+      views.getProfiles(didsArray),
+      getQueues(Array.from(queueIds)),
+      getTeamMembers(assignmentDids),
+    ])
+
+  return {
+    partialRepos,
+    accountInfo,
+    recordInfo,
+    profiles,
+    queues,
+    memberViews,
+  }
+}
+
+export function buildReportView(
+  report: ReportWithEvent,
+  hydrated: HydratedReport,
+  isModerator: boolean,
+  actions?: ToolsOzoneModerationDefs.ModEventView[],
+) {
+  const {
+    partialRepos,
+    accountInfo,
+    recordInfo,
+    profiles,
+    queues,
+    memberViews,
+  } = hydrated
+  const isRecord = !!report.subjectUri
+  const did = report.subjectDid
+  const partialRepo = partialRepos.get(did)
+  const repo = partialRepo
+    ? addAccountInfoToRepoViewDetail(
+        partialRepo,
+        accountInfo.get(did) || null,
+        isModerator,
+      )
+    : undefined
+  const profile = profiles.get(did)
+  const record = isRecord ? recordInfo.get(report.subjectUri!) : undefined
+  const status = isRecord
+    ? record?.moderation.subjectStatus
+    : repo?.moderation.subjectStatus
+
+  const reportType = report.meta?.reportType as string
+
+  const subject = isRecord ? report.subjectUri! : report.subjectDid
+  const subjectView = {
+    type: isRecord ? 'record' : 'account',
+    subject,
+    repo,
+    record,
+    profile: profile
+      ? {
+          $type: 'app.bsky.actor.defs#profileViewDetailed' as const,
+          ...profile,
+        }
+      : undefined,
+    status,
+  }
+
+  const reporterDid = report.reportedBy
+  const reporterPartialRepo = partialRepos.get(reporterDid)
+  const reporterRepo = reporterPartialRepo
+    ? addAccountInfoToRepoViewDetail(
+        reporterPartialRepo,
+        accountInfo.get(reporterDid) || null,
+        isModerator,
+      )
+    : undefined
+  const reporterProfile = profiles.get(reporterDid)
+  const reporterStatus = reporterRepo?.moderation.subjectStatus
+
+  const reporterView = {
+    type: 'account',
+    subject: reporterDid,
+    repo: reporterRepo,
+    profile: reporterProfile
+      ? {
+          $type: 'app.bsky.actor.defs#profileViewDetailed' as const,
+          ...reporterProfile,
+        }
+      : undefined,
+    status: reporterStatus,
+  }
+
+  const assignmentView =
+    report.assignedTo && report.assignedAt
+      ? {
+          did: report.assignedTo,
+          moderator: memberViews.get(report.assignedTo),
+          assignedAt: report.assignedAt,
+        }
+      : undefined
+
+  return {
+    id: report.id,
+    eventId: report.eventId,
+    status: report.status,
+    subject: subjectView,
+    reportType,
+    reportedBy: report.reportedBy,
+    reporter: reporterView,
+    comment: report.comment ?? undefined,
+    createdAt: report.createdAt,
+    updatedAt: report.updatedAt,
+    queuedAt: report.queuedAt ?? undefined,
+    actionEventIds:
+      report.actionEventIds && Array.isArray(report.actionEventIds)
+        ? (report.actionEventIds as number[])
+        : undefined,
+    actions: actions && actions.length ? actions : undefined,
+    actionNote: report.actionNote ?? undefined,
+    assignment: assignmentView,
+    queue:
+      report.queueId && report.queueId > 0
+        ? queues.get(report.queueId)
+        : undefined,
+    isMuted: report.isMuted,
+  }
+}
+
+export function viewQueueStats(
+  row?: Selectable<ReportStat>,
+): ToolsOzoneQueueDefs.QueueStats {
+  return {
+    pendingCount: row?.pendingCount ?? undefined,
+    actionedCount: row?.actionedCount ?? undefined,
+    escalatedCount: row?.escalatedCount ?? undefined,
+    inboundCount: row?.inboundCount ?? undefined,
+    actionRate: row?.actionRate ?? undefined,
+    avgHandlingTimeSec: row?.avgHandlingTimeSec ?? undefined,
+    lastUpdated: row?.computedAt,
+  }
+}
+
+export function viewLiveStats(
+  row?: Selectable<ReportStat>,
+): ToolsOzoneReportDefs.LiveStats {
+  return {
+    pendingCount: row?.pendingCount ?? undefined,
+    actionedCount: row?.actionedCount ?? undefined,
+    escalatedCount: row?.escalatedCount ?? undefined,
+    inboundCount: row?.inboundCount ?? undefined,
+    actionRate: row?.actionRate ?? undefined,
+    avgHandlingTimeSec: row?.avgHandlingTimeSec ?? undefined,
+    lastUpdated: row?.computedAt,
+  }
+}
+
+export function viewHistoricalStats(
+  row: Selectable<ReportStat>,
+): ToolsOzoneReportDefs.HistoricalStats {
+  return {
+    date: row.date,
+    computedAt: row.computedAt,
+    pendingCount: row.pendingCount ?? undefined,
+    actionedCount: row.actionedCount ?? undefined,
+    escalatedCount: row.escalatedCount ?? undefined,
+    inboundCount: row.inboundCount ?? undefined,
+    actionRate: row.actionRate ?? undefined,
+    avgHandlingTimeSec: row.avgHandlingTimeSec ?? undefined,
+  }
+}

package/src/team/index.ts

@@ -267,6 +267,17 @@ export class TeamService {
     } while (lastDid)
   }
 
+  async viewByDids(dids: string[]): Promise<Map<string, TeamMember>> {
+    if (!dids.length) return new Map()
+    const members = await this.db.db
+      .selectFrom('member')
+      .selectAll()
+      .where('did', 'in', dids)
+      .execute()
+    const memberViews = await this.view(members)
+    return new Map(memberViews.map((m) => [m.did, m]))
+  }
+
   async view(members: Selectable<Member>[]): Promise<TeamMember[]> {
     const profiles = await this.getProfiles(members.map(({ did }) => did))
     return members.map((member) => {

package/tests/expiring-tags.test.ts

@@ -0,0 +1,231 @@
+import {
+  ModeratorClient,
+  SeedClient,
+  TestNetwork,
+  basicSeed,
+} from '@atproto/dev-env'
+import { EventReverser } from '../src/daemon/event-reverser'
+import { REASONSPAM } from '../src/lexicon/types/com/atproto/moderation/defs'
+
+describe('expiring tags', () => {
+  let network: TestNetwork
+  let sc: SeedClient
+  let modClient: ModeratorClient
+
+  beforeAll(async () => {
+    network = await TestNetwork.create({
+      dbPostgresSchema: 'ozone_expiring_tags',
+    })
+    sc = network.getSeedClient()
+    modClient = network.ozone.getModClient()
+    await basicSeed(sc)
+    await network.processAll()
+  })
+
+  afterAll(async () => {
+    await network.close()
+  })
+
+  const emitTagEvent = (
+    did: string,
+    add: string[],
+    remove: string[],
+    durationInHours?: number,
+  ) =>
+    modClient.emitEvent({
+      subject: { $type: 'com.atproto.admin.defs#repoRef', did },
+      event: {
+        $type: 'tools.ozone.moderation.defs#modEventTag',
+        add,
+        remove,
+        ...(durationInHours !== undefined ? { durationInHours } : {}),
+      },
+    })
+
+  const getSubjectTags = async (did: string): Promise<string[]> => {
+    const result = await modClient.queryStatuses({ subject: did })
+    return result.subjectStatuses[0]?.tags ?? []
+  }
+
+  const createReverser = () =>
+    new EventReverser(
+      network.ozone.ctx.db,
+      // @ts-expect-error Error due to circular dependency with the dev-env package
+      network.ozone.ctx.modService,
+    )
+
+  it('creates expiring_tag rows when durationInHours is set', async () => {
+    // Create a report so the subject exists in moderation_subject_status
+    await sc.createReport({
+      reasonType: REASONSPAM,
+      reason: 'test',
+      subject: { $type: 'com.atproto.admin.defs#repoRef', did: sc.dids.bob },
+      reportedBy: sc.dids.alice,
+    })
+
+    await emitTagEvent(sc.dids.bob, ['temp-tag-1', 'temp-tag-2'], [], 1)
+
+    const tags = await getSubjectTags(sc.dids.bob)
+    expect(tags).toContain('temp-tag-1')
+    expect(tags).toContain('temp-tag-2')
+
+    // Verify expiring_tag rows were created
+    const expiringRows = await network.ozone.ctx.db.db
+      .selectFrom('expiring_tag')
+      .where('did', '=', sc.dids.bob)
+      .selectAll()
+      .execute()
+
+    expect(expiringRows).toHaveLength(2)
+    expect(expiringRows.map((r) => r.tag).sort()).toEqual([
+      'temp-tag-1',
+      'temp-tag-2',
+    ])
+    expect(expiringRows[0].expiresAt).toBeTruthy()
+  })
+
+  it('does not create expiring_tag rows without durationInHours', async () => {
+    await emitTagEvent(sc.dids.bob, ['permanent-tag'], [])
+
+    const tags = await getSubjectTags(sc.dids.bob)
+    expect(tags).toContain('permanent-tag')
+
+    const expiringRows = await network.ozone.ctx.db.db
+      .selectFrom('expiring_tag')
+      .where('did', '=', sc.dids.bob)
+      .where('tag', '=', 'permanent-tag')
+      .selectAll()
+      .execute()
+
+    expect(expiringRows).toHaveLength(0)
+  })
+
+  it('daemon reverts expired tags', async () => {
+    // Manually expire the tags in the DB
+    await network.ozone.ctx.db.db
+      .updateTable('expiring_tag')
+      .set({ expiresAt: new Date(Date.now() - 1000).toISOString() })
+      .where('did', '=', sc.dids.bob)
+      .execute()
+
+    const reverser = createReverser()
+    await reverser.findAndRevertDueActions()
+
+    const tags = await getSubjectTags(sc.dids.bob)
+    expect(tags).not.toContain('temp-tag-1')
+    expect(tags).not.toContain('temp-tag-2')
+    // Permanent tag should still be there
+    expect(tags).toContain('permanent-tag')
+
+    // Verify expiring_tag rows are cleaned up
+    const remainingRows = await network.ozone.ctx.db.db
+      .selectFrom('expiring_tag')
+      .where('did', '=', sc.dids.bob)
+      .selectAll()
+      .execute()
+
+    expect(remainingRows).toHaveLength(0)
+  })
+
+  it('daemon emits a modEventTag removal event', async () => {
+    const events = await modClient.queryEvents({
+      subject: sc.dids.bob,
+      types: ['tools.ozone.moderation.defs#modEventTag'],
+    })
+
+    const lastTagEvent = events.events[0]
+    expect(lastTagEvent.event).toMatchObject({
+      $type: 'tools.ozone.moderation.defs#modEventTag',
+      add: [],
+      remove: expect.arrayContaining(['temp-tag-1', 'temp-tag-2']),
+      comment:
+        '[SCHEDULED_REVERSAL] Reverting temporary tags as originally scheduled',
+    })
+  })
+
+  it('cleans up expiring_tag rows when tags are manually removed', async () => {
+    await sc.createReport({
+      reasonType: REASONSPAM,
+      reason: 'test',
+      subject: {
+        $type: 'com.atproto.admin.defs#repoRef',
+        did: sc.dids.carol,
+      },
+      reportedBy: sc.dids.alice,
+    })
+
+    await emitTagEvent(sc.dids.carol, ['auto-remove-tag'], [], 24)
+
+    // Verify the expiring_tag row exists
+    let expiringRows = await network.ozone.ctx.db.db
+      .selectFrom('expiring_tag')
+      .where('did', '=', sc.dids.carol)
+      .where('tag', '=', 'auto-remove-tag')
+      .selectAll()
+      .execute()
+    expect(expiringRows).toHaveLength(1)
+
+    // Manually remove the tag
+    await emitTagEvent(sc.dids.carol, [], ['auto-remove-tag'])
+
+    // Verify the expiring_tag row is cleaned up
+    expiringRows = await network.ozone.ctx.db.db
+      .selectFrom('expiring_tag')
+      .where('did', '=', sc.dids.carol)
+      .where('tag', '=', 'auto-remove-tag')
+      .selectAll()
+      .execute()
+    expect(expiringRows).toHaveLength(0)
+  })
+
+  it('daemon skips tags already manually removed', async () => {
+    await emitTagEvent(sc.dids.carol, ['skip-tag'], [], 1)
+
+    // Manually remove the tag first
+    await emitTagEvent(sc.dids.carol, [], ['skip-tag'])
+
+    // Re-insert an expiring_tag row to simulate the race condition
+    // (row wasn't cleaned up for some reason)
+    await network.ozone.ctx.db.db
+      .insertInto('expiring_tag')
+      .values({
+        eventId: 0,
+        did: sc.dids.carol,
+        recordPath: '',
+        tag: 'skip-tag',
+        expiresAt: new Date(Date.now() - 1000).toISOString(),
+        createdBy: sc.dids.alice,
+      })
+      .execute()
+
+    const tagsBefore = await getSubjectTags(sc.dids.carol)
+    expect(tagsBefore).not.toContain('skip-tag')
+
+    const reverser = createReverser()
+    await reverser.findAndRevertDueActions()
+
+    // Verify no removal event was emitted for a tag that's already gone
+    const events = await modClient.queryEvents({
+      subject: sc.dids.carol,
+      types: ['tools.ozone.moderation.defs#modEventTag'],
+    })
+
+    // The last tag event should be the manual removal, not a scheduled reversal
+    const lastEvent = events.events[0]
+    expect(lastEvent.event).toMatchObject({
+      $type: 'tools.ozone.moderation.defs#modEventTag',
+      remove: ['skip-tag'],
+    })
+    const comment = (lastEvent.event as { comment?: string }).comment ?? ''
+    expect(comment).not.toContain('SCHEDULED_REVERSAL')
+
+    // Verify the expiring_tag row is still cleaned up
+    const remainingRows = await network.ozone.ctx.db.db
+      .selectFrom('expiring_tag')
+      .where('did', '=', sc.dids.carol)
+      .where('tag', '=', 'skip-tag')
+      .selectAll()
+      .execute()
+    expect(remainingRows).toHaveLength(0)
+  })
+})

package/tests/get-report.test.ts

@@ -0,0 +1,136 @@
+import AtpAgent from '@atproto/api'
+import {
+  ModeratorClient,
+  SeedClient,
+  TestNetwork,
+  basicSeed,
+} from '@atproto/dev-env'
+import { ids } from '../src/lexicon/lexicons'
+import { REASONSPAM } from '../src/lexicon/types/com/atproto/moderation/defs'
+
+describe('ozone-get-report', () => {
+  let network: TestNetwork
+  let agent: AtpAgent
+  let sc: SeedClient
+  let modClient: ModeratorClient
+
+  const modHeaders = async (nsid: string) =>
+    network.ozone.modHeaders(nsid, 'admin')
+
+  beforeAll(async () => {
+    network = await TestNetwork.create({
+      dbPostgresSchema: 'ozone_get_report',
+    })
+    agent = network.ozone.getAgent()
+    sc = network.getSeedClient()
+    modClient = network.ozone.getModClient()
+    await basicSeed(sc)
+    await network.processAll()
+  })
+
+  afterAll(async () => {
+    await network.close()
+  })
+
+  it('returns a single report by id', async () => {
+    // Create a report on Alice's account
+    await sc.createReport({
+      reasonType: REASONSPAM,
+      subject: {
+        $type: 'com.atproto.admin.defs#repoRef',
+        did: sc.dids.alice,
+      },
+      reportedBy: sc.dids.bob,
+    })
+    await network.processAll()
+
+    // Fetch the report list to get the report ID
+    const { data: list } = await agent.tools.ozone.report.queryReports(
+      { status: 'open', subject: sc.dids.alice },
+      { headers: await modHeaders(ids.ToolsOzoneReportQueryReports) },
+    )
+    expect(list.reports.length).toBeGreaterThan(0)
+    const reportId = list.reports[0].id
+
+    // Fetch the single report by ID
+    const { data: report } = await agent.tools.ozone.report.getReport(
+      { id: reportId },
+      { headers: await modHeaders(ids.ToolsOzoneReportGetReport) },
+    )
+
+    expect(report.id).toBe(reportId)
+    expect(report.subject.type).toBe('account')
+    expect(report.subject.subject).toBe(sc.dids.alice)
+    expect(report.reportType).toBe('com.atproto.moderation.defs#reasonSpam')
+    expect(report.status).toBe('open')
+  })
+
+  it('hydrates actions for reports that have been actioned', async () => {
+    const bobsAccount = {
+      $type: 'com.atproto.admin.defs#repoRef' as const,
+      did: sc.dids.bob,
+    }
+
+    await sc.createReport({
+      reasonType: REASONSPAM,
+      subject: bobsAccount,
+      reportedBy: sc.dids.alice,
+    })
+    await network.processAll()
+
+    const { data: list } = await agent.tools.ozone.report.queryReports(
+      { status: 'open', subject: sc.dids.bob },
+      { headers: await modHeaders(ids.ToolsOzoneReportQueryReports) },
+    )
+    const reportId = list.reports[0].id
+
+    const event = await modClient.emitEvent({
+      event: { $type: 'tools.ozone.moderation.defs#modEventAcknowledge' },
+      subject: bobsAccount,
+      reportAction: {
+        ids: [reportId],
+        note: 'Reviewed',
+      },
+    })
+
+    const { data: report } = await agent.tools.ozone.report.getReport(
+      { id: reportId },
+      { headers: await modHeaders(ids.ToolsOzoneReportGetReport) },
+    )
+
+    expect(report.status).toBe('closed')
+    expect(report.actionEventIds).toEqual([event.id])
+    expect(report.actions).toBeDefined()
+    expect(report.actions).toHaveLength(1)
+    expect(report.actions![0].id).toBe(event.id)
+    expect(report.actions![0].event.$type).toBe(
+      'tools.ozone.moderation.defs#modEventAcknowledge',
+    )
+  })
+
+  it('omits actions when the report has not been actioned', async () => {
+    await sc.createReport({
+      reasonType: REASONSPAM,
+      subject: {
+        $type: 'com.atproto.admin.defs#repoRef',
+        did: sc.dids.carol,
+      },
+      reportedBy: sc.dids.alice,
+    })
+    await network.processAll()
+
+    const { data: list } = await agent.tools.ozone.report.queryReports(
+      { status: 'open', subject: sc.dids.carol },
+      { headers: await modHeaders(ids.ToolsOzoneReportQueryReports) },
+    )
+    const reportId = list.reports[0].id
+
+    const { data: report } = await agent.tools.ozone.report.getReport(
+      { id: reportId },
+      { headers: await modHeaders(ids.ToolsOzoneReportGetReport) },
+    )
+
+    expect(report.actionEventIds).toBeFalsy()
+    expect(report.actions).toBeUndefined()
+  })
+})