@atproto/ozone 0.1.133 → 0.1.134

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/ozone",
-  "version": "0.1.133",
+  "version": "0.1.134",
   "license": "MIT",
   "description": "Backend service for moderating the Bluesky network.",
   "keywords": [
@@ -35,14 +35,14 @@
     "uint8arrays": "3.0.0",
     "undici": "^6.14.1",
     "ws": "^8.12.0",
-    "@atproto/api": "^0.16.0",
     "@atproto/common": "^0.4.11",
+    "@atproto/api": "^0.16.1",
     "@atproto/crypto": "^0.4.4",
     "@atproto/identity": "^0.4.8",
     "@atproto/lexicon": "^0.4.12",
     "@atproto/syntax": "^0.4.0",
     "@atproto/xrpc": "^0.7.1",
-    "@atproto/xrpc-server": "^0.9.0"
+    "@atproto/xrpc-server": "^0.9.1"
   },
   "devDependencies": {
     "@did-plc/server": "^0.0.1",
@@ -55,7 +55,7 @@
     "ts-node": "^10.8.2",
     "typescript": "^5.6.3",
     "@atproto/lex-cli": "^0.9.1",
-    "@atproto/pds": "^0.4.163"
+    "@atproto/pds": "^0.4.164"
   },
   "scripts": {
     "codegen": "lex gen-server --yes ./src/lexicon ../../lexicons/com/atproto/*/* ../../lexicons/app/bsky/*/* ../../lexicons/chat/bsky/*/* ../../lexicons/tools/ozone/*/*",

package/src/api/index.ts

@@ -9,6 +9,7 @@ import fetchLabels from './label/fetchLabels'
 import queryLabels from './label/queryLabels'
 import subscribeLabels from './label/subscribeLabels'
 import emitEvent from './moderation/emitEvent'
+import getAccountTimeline from './moderation/getAccountTimeline'
 import getEvent from './moderation/getEvent'
 import adminGetRecord from './moderation/getRecord'
 import adminGetRecords from './moderation/getRecords'
@@ -92,5 +93,6 @@ export default function (server: Server, ctx: AppContext) {
   removeSafelinkRule(server, ctx)
   querySafelinkEvents(server, ctx)
   querySafelinkRules(server, ctx)
+  getAccountTimeline(server, ctx)
   return server
 }

package/src/api/moderation/getAccountTimeline.ts

@@ -0,0 +1,160 @@
+import { ToolsOzoneModerationGetAccountTimeline } from '@atproto/api'
+import { AppContext } from '../../context'
+import { Server } from '../../lexicon'
+import { ids } from '../../lexicon/lexicons'
+import { dateFromDatetime } from '../../mod-service/util'
+
+export default function (server: Server, ctx: AppContext) {
+  server.tools.ozone.moderation.getAccountTimeline({
+    auth: ctx.authVerifier.modOrAdminToken,
+    handler: async ({ params }) => {
+      const { did } = params
+      const db = ctx.db
+      const modService = ctx.modService(db)
+      const [modEventHistory, accountHistory, plcHistory] =
+        await Promise.allSettled([
+          modService.getAccountTimeline(did),
+          getAccountHistory(ctx, did),
+          getPlcHistory(ctx, did),
+        ])
+      const timelineByDay = new Map<
+        string,
+        ToolsOzoneModerationGetAccountTimeline.TimelineItemSummary[]
+      >()
+
+      if (modEventHistory.status === 'fulfilled') {
+        for (const row of modEventHistory.value) {
+          const day = timelineByDay.get(row.day)
+          const summary = {
+            eventSubjectType: row.subjectUri ? 'record' : 'account',
+            eventType: row.action,
+            count: row.count,
+          }
+          if (day) {
+            day.push(summary)
+            timelineByDay.set(row.day, day)
+          } else {
+            timelineByDay.set(row.day, [summary])
+          }
+        }
+      } else {
+        throw modEventHistory.reason
+      }
+
+      if (accountHistory.status === 'fulfilled') {
+        for (const [rowDay, row] of Object.entries(accountHistory.value)) {
+          const day = timelineByDay.get(rowDay)
+          const summaries: ToolsOzoneModerationGetAccountTimeline.TimelineItemSummary[] =
+            []
+          for (const [eventType, count] of Object.entries(row)) {
+            summaries.push({
+              eventSubjectType: 'account',
+              eventType,
+              count,
+            })
+          }
+          if (day) {
+            day.push(...summaries)
+            timelineByDay.set(rowDay, day)
+          } else {
+            timelineByDay.set(rowDay, summaries)
+          }
+        }
+      }
+
+      if (plcHistory.status === 'fulfilled') {
+        for (const [rowDay, row] of Object.entries(plcHistory.value)) {
+          const day = timelineByDay.get(rowDay)
+          const summaries: ToolsOzoneModerationGetAccountTimeline.TimelineItemSummary[] =
+            []
+          for (const [eventType, count] of Object.entries(row)) {
+            summaries.push({
+              eventSubjectType: 'account',
+              eventType,
+              count,
+            })
+          }
+          if (day) {
+            day.push(...summaries)
+            timelineByDay.set(rowDay, day)
+          } else {
+            timelineByDay.set(rowDay, summaries)
+          }
+        }
+      }
+
+      const timeline: ToolsOzoneModerationGetAccountTimeline.TimelineItem[] = []
+
+      for (const [day, summary] of timelineByDay.entries()) {
+        timeline.push({ day, summary: summary.flat() })
+      }
+
+      return {
+        encoding: 'application/json',
+        body: { timeline },
+      }
+    },
+  })
+}
+
+const getAccountHistory = async (ctx: AppContext, did: string) => {
+  const events: Record<string, Record<string, number>> = {}
+
+  if (!ctx.pdsAgent) {
+    return events
+  }
+
+  const auth = await ctx.pdsAuth(ids.ToolsOzoneHostingGetAccountHistory)
+  let cursor: string | undefined = undefined
+
+  do {
+    const { data } = await ctx.pdsAgent.tools.ozone.hosting.getAccountHistory(
+      { did, cursor },
+      auth,
+    )
+    cursor = data.cursor
+    for (const event of data.events) {
+      // This should never happen and the check is here only because typescript screams at us otherwise
+      if (!event.$type) {
+        continue
+      }
+
+      const day = dateFromDatetime(new Date(event.createdAt))
+      events[day] ??= {}
+      events[day][event.$type] ??= 0
+      events[day][event.$type]++
+    }
+  } while (cursor)
+
+  return events
+}
+
+const PLC_OPERATION_MAP = {
+  create: 'tools.ozone.moderation.defs#timelineEventPlcCreate',
+  plc_operation: 'tools.ozone.moderation.defs#timelineEventPlcOperation',
+  plc_tombstone: 'tools.ozone.moderation.defs#timelineEventPlcTombstone',
+}
+
+const getPlcHistory = async (ctx: AppContext, did: string) => {
+  const events: Record<string, Record<string, number>> = {}
+
+  if (!ctx.plcClient) {
+    return events
+  }
+
+  const result = await ctx.plcClient.getAuditableLog(did)
+  for (const event of result) {
+    // Skip events that are not mapped, this means we will have to add correct mapping if/when new event types are introduced here
+    if (!Object.hasOwn(PLC_OPERATION_MAP, event.operation.type)) {
+      continue
+    }
+    const day = dateFromDatetime(new Date(event.createdAt))
+    events[day] ??= {}
+    const eventType =
+      PLC_OPERATION_MAP[event.operation.type] || event.operation.type
+    events[day][eventType] ??= 0
+    events[day][eventType]++
+  }
+
+  return events
+}

package/src/lexicon/index.ts

@@ -201,6 +201,7 @@ import * as ToolsOzoneCommunicationListTemplates from './types/tools/ozone/commu
 import * as ToolsOzoneCommunicationUpdateTemplate from './types/tools/ozone/communication/updateTemplate.js'
 import * as ToolsOzoneHostingGetAccountHistory from './types/tools/ozone/hosting/getAccountHistory.js'
 import * as ToolsOzoneModerationEmitEvent from './types/tools/ozone/moderation/emitEvent.js'
+import * as ToolsOzoneModerationGetAccountTimeline from './types/tools/ozone/moderation/getAccountTimeline.js'
 import * as ToolsOzoneModerationGetEvent from './types/tools/ozone/moderation/getEvent.js'
 import * as ToolsOzoneModerationGetRecord from './types/tools/ozone/moderation/getRecord.js'
 import * as ToolsOzoneModerationGetRecords from './types/tools/ozone/moderation/getRecords.js'
@@ -275,6 +276,12 @@ export const TOOLS_OZONE_MODERATION = {
   DefsReviewEscalated: 'tools.ozone.moderation.defs#reviewEscalated',
   DefsReviewClosed: 'tools.ozone.moderation.defs#reviewClosed',
   DefsReviewNone: 'tools.ozone.moderation.defs#reviewNone',
+  DefsTimelineEventPlcCreate:
+    'tools.ozone.moderation.defs#timelineEventPlcCreate',
+  DefsTimelineEventPlcOperation:
+    'tools.ozone.moderation.defs#timelineEventPlcOperation',
+  DefsTimelineEventPlcTombstone:
+    'tools.ozone.moderation.defs#timelineEventPlcTombstone',
 }
 export const TOOLS_OZONE_TEAM = {
   DefsRoleAdmin: 'tools.ozone.team.defs#roleAdmin',
@@ -2918,6 +2925,18 @@ export class ToolsOzoneModerationNS {
     return this._server.xrpc.method(nsid, cfg)
   }
 
+  getAccountTimeline<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneModerationGetAccountTimeline.QueryParams,
+      ToolsOzoneModerationGetAccountTimeline.HandlerInput,
+      ToolsOzoneModerationGetAccountTimeline.HandlerOutput
+    >,
+  ) {
+    const nsid = 'tools.ozone.moderation.getAccountTimeline' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
   getEvent<A extends Auth = void>(
     cfg: MethodConfigOrHandler<
       A,

package/src/lexicon/lexicons.ts

@@ -15006,6 +15006,21 @@ export const schemaDict = {
           },
         },
       },
+      timelineEventPlcCreate: {
+        type: 'token',
+        description:
+          'Moderation event timeline event for a PLC create operation',
+      },
+      timelineEventPlcOperation: {
+        type: 'token',
+        description:
+          'Moderation event timeline event for generic PLC operation',
+      },
+      timelineEventPlcTombstone: {
+        type: 'token',
+        description:
+          'Moderation event timeline event for a PLC tombstone operation',
+      },
     },
   },
   ToolsOzoneModerationEmitEvent: {
@@ -15097,6 +15112,110 @@ export const schemaDict = {
       },
     },
   },
+  ToolsOzoneModerationGetAccountTimeline: {
+    lexicon: 1,
+    id: 'tools.ozone.moderation.getAccountTimeline',
+    defs: {
+      main: {
+        type: 'query',
+        description:
+          'Get timeline of all available events of an account. This includes moderation events, account history and did history.',
+        parameters: {
+          type: 'params',
+          required: ['did'],
+          properties: {
+            did: {
+              type: 'string',
+              format: 'did',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['timeline'],
+            properties: {
+              timeline: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:tools.ozone.moderation.getAccountTimeline#timelineItem',
+                },
+              },
+            },
+          },
+        },
+        errors: [
+          {
+            name: 'RepoNotFound',
+          },
+        ],
+      },
+      timelineItem: {
+        type: 'object',
+        required: ['day', 'summary'],
+        properties: {
+          day: {
+            type: 'string',
+          },
+          summary: {
+            type: 'array',
+            items: {
+              type: 'ref',
+              ref: 'lex:tools.ozone.moderation.getAccountTimeline#timelineItemSummary',
+            },
+          },
+        },
+      },
+      timelineItemSummary: {
+        type: 'object',
+        required: ['eventSubjectType', 'eventType', 'count'],
+        properties: {
+          eventSubjectType: {
+            type: 'string',
+            knownValues: ['account', 'record', 'chat'],
+          },
+          eventType: {
+            type: 'string',
+            knownValues: [
+              'tools.ozone.moderation.defs#modEventTakedown',
+              'tools.ozone.moderation.defs#modEventReverseTakedown',
+              'tools.ozone.moderation.defs#modEventComment',
+              'tools.ozone.moderation.defs#modEventReport',
+              'tools.ozone.moderation.defs#modEventLabel',
+              'tools.ozone.moderation.defs#modEventAcknowledge',
+              'tools.ozone.moderation.defs#modEventEscalate',
+              'tools.ozone.moderation.defs#modEventMute',
+              'tools.ozone.moderation.defs#modEventUnmute',
+              'tools.ozone.moderation.defs#modEventMuteReporter',
+              'tools.ozone.moderation.defs#modEventUnmuteReporter',
+              'tools.ozone.moderation.defs#modEventEmail',
+              'tools.ozone.moderation.defs#modEventResolveAppeal',
+              'tools.ozone.moderation.defs#modEventDivert',
+              'tools.ozone.moderation.defs#modEventTag',
+              'tools.ozone.moderation.defs#accountEvent',
+              'tools.ozone.moderation.defs#identityEvent',
+              'tools.ozone.moderation.defs#recordEvent',
+              'tools.ozone.moderation.defs#modEventPriorityScore',
+              'tools.ozone.moderation.defs#ageAssuranceEvent',
+              'tools.ozone.moderation.defs#ageAssuranceOverrideEvent',
+              'tools.ozone.moderation.defs#timelineEventPlcCreate',
+              'tools.ozone.moderation.defs#timelineEventPlcOperation',
+              'tools.ozone.moderation.defs#timelineEventPlcTombstone',
+              'tools.ozone.hosting.getAccountHistory#accountCreated',
+              'tools.ozone.hosting.getAccountHistory#emailConfirmed',
+              'tools.ozone.hosting.getAccountHistory#passwordUpdated',
+              'tools.ozone.hosting.getAccountHistory#handleUpdated',
+            ],
+          },
+          count: {
+            type: 'integer',
+          },
+        },
+      },
+    },
+  },
   ToolsOzoneModerationGetEvent: {
     lexicon: 1,
     id: 'tools.ozone.moderation.getEvent',
@@ -17914,6 +18033,8 @@ export const ids = {
   ToolsOzoneHostingGetAccountHistory: 'tools.ozone.hosting.getAccountHistory',
   ToolsOzoneModerationDefs: 'tools.ozone.moderation.defs',
   ToolsOzoneModerationEmitEvent: 'tools.ozone.moderation.emitEvent',
+  ToolsOzoneModerationGetAccountTimeline:
+    'tools.ozone.moderation.getAccountTimeline',
   ToolsOzoneModerationGetEvent: 'tools.ozone.moderation.getEvent',
   ToolsOzoneModerationGetRecord: 'tools.ozone.moderation.getRecord',
   ToolsOzoneModerationGetRecords: 'tools.ozone.moderation.getRecords',

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

@@ -980,3 +980,10 @@ export function isModTool<V>(v: V) {
 export function validateModTool<V>(v: V) {
   return validate<ModTool & V>(v, id, hashModTool)
 }
+
+/** Moderation event timeline event for a PLC create operation */
+export const TIMELINEEVENTPLCCREATE = `${id}#timelineEventPlcCreate`
+/** Moderation event timeline event for generic PLC operation */
+export const TIMELINEEVENTPLCOPERATION = `${id}#timelineEventPlcOperation`
+/** Moderation event timeline event for a PLC tombstone operation */
+export const TIMELINEEVENTPLCTOMBSTONE = `${id}#timelineEventPlcTombstone`

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

@@ -0,0 +1,102 @@
+/**
+ * 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.moderation.getAccountTimeline'
+
+export type QueryParams = {
+  did: string
+}
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  timeline: TimelineItem[]
+}
+
+export type HandlerInput = void
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+  error?: 'RepoNotFound'
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess
+
+export interface TimelineItem {
+  $type?: 'tools.ozone.moderation.getAccountTimeline#timelineItem'
+  day: string
+  summary: TimelineItemSummary[]
+}
+
+const hashTimelineItem = 'timelineItem'
+
+export function isTimelineItem<V>(v: V) {
+  return is$typed(v, id, hashTimelineItem)
+}
+
+export function validateTimelineItem<V>(v: V) {
+  return validate<TimelineItem & V>(v, id, hashTimelineItem)
+}
+
+export interface TimelineItemSummary {
+  $type?: 'tools.ozone.moderation.getAccountTimeline#timelineItemSummary'
+  eventSubjectType: 'account' | 'record' | 'chat' | (string & {})
+  eventType:
+    | 'tools.ozone.moderation.defs#modEventTakedown'
+    | 'tools.ozone.moderation.defs#modEventReverseTakedown'
+    | 'tools.ozone.moderation.defs#modEventComment'
+    | 'tools.ozone.moderation.defs#modEventReport'
+    | 'tools.ozone.moderation.defs#modEventLabel'
+    | 'tools.ozone.moderation.defs#modEventAcknowledge'
+    | 'tools.ozone.moderation.defs#modEventEscalate'
+    | 'tools.ozone.moderation.defs#modEventMute'
+    | 'tools.ozone.moderation.defs#modEventUnmute'
+    | 'tools.ozone.moderation.defs#modEventMuteReporter'
+    | 'tools.ozone.moderation.defs#modEventUnmuteReporter'
+    | 'tools.ozone.moderation.defs#modEventEmail'
+    | 'tools.ozone.moderation.defs#modEventResolveAppeal'
+    | 'tools.ozone.moderation.defs#modEventDivert'
+    | 'tools.ozone.moderation.defs#modEventTag'
+    | 'tools.ozone.moderation.defs#accountEvent'
+    | 'tools.ozone.moderation.defs#identityEvent'
+    | 'tools.ozone.moderation.defs#recordEvent'
+    | 'tools.ozone.moderation.defs#modEventPriorityScore'
+    | 'tools.ozone.moderation.defs#ageAssuranceEvent'
+    | 'tools.ozone.moderation.defs#ageAssuranceOverrideEvent'
+    | 'tools.ozone.moderation.defs#timelineEventPlcCreate'
+    | 'tools.ozone.moderation.defs#timelineEventPlcOperation'
+    | 'tools.ozone.moderation.defs#timelineEventPlcTombstone'
+    | 'tools.ozone.hosting.getAccountHistory#accountCreated'
+    | 'tools.ozone.hosting.getAccountHistory#emailConfirmed'
+    | 'tools.ozone.hosting.getAccountHistory#passwordUpdated'
+    | 'tools.ozone.hosting.getAccountHistory#handleUpdated'
+    | (string & {})
+  count: number
+}
+
+const hashTimelineItemSummary = 'timelineItemSummary'
+
+export function isTimelineItemSummary<V>(v: V) {
+  return is$typed(v, id, hashTimelineItemSummary)
+}
+
+export function validateTimelineItemSummary<V>(v: V) {
+  return validate<TimelineItemSummary & V>(v, id, hashTimelineItemSummary)
+}

package/src/mod-service/index.ts

@@ -64,6 +64,7 @@ import {
   ReversibleModerationEvent,
 } from './types'
 import {
+  dateFromDbDatetime,
   formatLabel,
   formatLabelRow,
   getPdsAgentForRepo,
@@ -1545,6 +1546,29 @@ export class ModerationService {
     // Convert map values to an array and return
     return Array.from(statsMap.values())
   }
+
+  async getAccountTimeline(did: string) {
+    const { ref } = this.db.db.dynamic
+    // Without the subquery approach, pg tries to do the sort operation first which can be super expensive when a subjectDid has too many entries
+    const result = await this.db.db
+      .selectFrom(
+        this.db.db
+          .selectFrom('moderation_event')
+          .where('subjectDid', '=', did)
+          .select([
+            dateFromDbDatetime(ref('createdAt')).as('day'),
+            'subjectUri',
+            'action',
+            sql<number>`count(*)`.as('count'),
+          ])
+          .groupBy(['day', 'subjectUri', 'action'])
+          .as('results'),
+      )
+      .selectAll()
+      .orderBy('day', 'desc')
+      .execute()
+    return result
+  }
 }
 
 const parseTags = (tags?: string[]) =>

package/src/mod-service/util.ts

@@ -1,9 +1,11 @@
 import net from 'node:net'
+import { sql } from 'kysely'
 import AtpAgent from '@atproto/api'
 import { cborEncode, noUndefinedVals } from '@atproto/common'
 import { Keypair } from '@atproto/crypto'
 import { IdResolver } from '@atproto/identity'
 import { LabelRow } from '../db/schema/label'
+import { DbRef } from '../db/types'
 import { Label } from '../lexicon/types/com/atproto/label/defs'
 
 export type SignedLabel = Label & { sig: Uint8Array }
@@ -83,3 +85,12 @@ export const getPdsAgentForRepo = async (
 
   return { url, agent: new AtpAgent({ service: url }) }
 }
+
+export const dateFromDatetime = (datetime: Date) => {
+  const [date] = datetime.toISOString().split('T')
+  return date
+}
+
+export const dateFromDbDatetime = (dateRef: DbRef) => {
+  return sql<string>`SPLIT_PART(${dateRef}, 'T', 1)`
+}

package/tests/__snapshots__/get-account-timeline.test.ts.snap

@@ -0,0 +1,36 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`account timeline Returns entire timeline of events for a given account 1`] = `
+Array [
+  Object {
+    "count": 1,
+    "eventSubjectType": "record",
+    "eventType": "tools.ozone.moderation.defs#modEventReport",
+  },
+  Object {
+    "count": 1,
+    "eventSubjectType": "record",
+    "eventType": "tools.ozone.moderation.defs#modEventTag",
+  },
+  Object {
+    "count": 2,
+    "eventSubjectType": "account",
+    "eventType": "tools.ozone.moderation.defs#modEventReport",
+  },
+  Object {
+    "count": 1,
+    "eventSubjectType": "account",
+    "eventType": "tools.ozone.moderation.defs#modEventTag",
+  },
+  Object {
+    "count": 1,
+    "eventSubjectType": "account",
+    "eventType": "tools.ozone.moderation.defs#modEventTakedown",
+  },
+  Object {
+    "count": 1,
+    "eventSubjectType": "account",
+    "eventType": "tools.ozone.moderation.defs#timelineEventPlcOperation",
+  },
+]
+`;

package/tests/get-account-timeline.test.ts

@@ -0,0 +1,85 @@
+import AtpAgent from '@atproto/api'
+import {
+  ModeratorClient,
+  SeedClient,
+  TestNetwork,
+  basicSeed,
+} from '@atproto/dev-env'
+import { REASONSPAM } from '../dist/lexicon/types/com/atproto/moderation/defs'
+import { ids } from '../src/lexicon/lexicons'
+import { forSnapshot } from './_util'
+
+describe('account timeline', () => {
+  let network: TestNetwork
+  let sc: SeedClient
+  let modClient: ModeratorClient
+  let agent: AtpAgent
+
+  beforeAll(async () => {
+    network = await TestNetwork.create({
+      dbPostgresSchema: 'ozone_account_timeline_test',
+    })
+    sc = network.getSeedClient()
+    agent = network.ozone.getClient()
+    modClient = network.ozone.getModClient()
+    await basicSeed(sc)
+
+    // Trigger some moderation events
+    await Promise.all([
+      sc.createReport({
+        subject: {
+          $type: 'com.atproto.admin.defs#repoRef',
+          did: sc.dids.alice,
+        },
+        reasonType: REASONSPAM,
+        reportedBy: sc.dids.bob,
+      }),
+      sc.createReport({
+        subject: {
+          $type: 'com.atproto.admin.defs#repoRef',
+          did: sc.dids.alice,
+        },
+        reasonType: REASONSPAM,
+        reportedBy: sc.dids.carol,
+      }),
+      sc.createReport({
+        subject: {
+          $type: 'com.atproto.repo.strongRef',
+          uri: sc.posts[sc.dids.alice][0].ref.uriStr,
+          cid: sc.posts[sc.dids.alice][0].ref.cidStr,
+        },
+        reasonType: REASONSPAM,
+        reportedBy: sc.dids.bob,
+      }),
+    ])
+    await modClient.performTakedown({
+      subject: {
+        $type: 'com.atproto.admin.defs#repoRef',
+        did: sc.dids.alice,
+      },
+    })
+    await network.processAll()
+  })
+
+  afterAll(async () => {
+    await network.close()
+  })
+
+  it('Returns entire timeline of events for a given account', async () => {
+    const getAccountTimeline = async (did: string) =>
+      agent.tools.ozone.moderation.getAccountTimeline(
+        { did },
+        {
+          headers: await network.ozone.modHeaders(
+            ids.ToolsOzoneModerationGetAccountTimeline,
+          ),
+        },
+      )
+
+    const {
+      data: { timeline },
+    } = await getAccountTimeline(sc.dids.alice)
+
+    expect(forSnapshot(timeline[0].summary)).toMatchSnapshot()
+  })
+})