@atproto/ozone 0.2.9 → 0.2.11

package/src/api/moderation/getAccountTimeline.ts

@@ -1,160 +0,0 @@
-import { ToolsOzoneModerationGetAccountTimeline } from '@atproto/api'
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-import { ids } from '../../lexicon/lexicons.js'
-import { dateFromDatetime } from '../../mod-service/util.js'
-
-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/api/moderation/getEvent.ts

@@ -1,19 +0,0 @@
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.moderation.getEvent({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ params }) => {
-      const { id } = params
-      const db = ctx.db
-      const modService = ctx.modService(db)
-      const event = await modService.getEventOrThrow(id)
-      const eventDetail = await modService.views.eventDetail(event)
-      return {
-        encoding: 'application/json',
-        body: eventDetail,
-      }
-    },
-  })
-}

package/src/api/moderation/getRecord.ts

@@ -1,40 +0,0 @@
-import { AtUri } from '@atproto/syntax'
-import { InvalidRequestError } from '@atproto/xrpc-server'
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-import { addAccountInfoToRepoView, getPdsAccountInfos } from '../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.moderation.getRecord({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ params, auth, req }) => {
-      const db = ctx.db
-      const labelers = ctx.reqLabelers(req)
-
-      const [records, accountInfos] = await Promise.all([
-        ctx.modService(db).views.recordDetails([params], labelers),
-        getPdsAccountInfos(ctx, [new AtUri(params.uri).hostname]),
-      ])
-
-      const record = records.get(params.uri)
-
-      if (!record) {
-        throw new InvalidRequestError(
-          `Could not locate record: ${params.uri}`,
-          'RecordNotFound',
-        )
-      }
-
-      record.repo = addAccountInfoToRepoView(
-        record.repo,
-        accountInfos.get(record.repo.did) || null,
-        auth.credentials.isModerator,
-      )
-
-      return {
-        encoding: 'application/json',
-        body: record,
-      }
-    },
-  })
-}

package/src/api/moderation/getRecords.ts

@@ -1,50 +0,0 @@
-import { AtUri } from '@atproto/syntax'
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-import { addAccountInfoToRepoView, getPdsAccountInfos } from '../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.moderation.getRecords({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ params, auth, req }) => {
-      const db = ctx.db
-      const labelers = ctx.reqLabelers(req)
-
-      const [records, accountInfos] = await Promise.all([
-        ctx.modService(db).views.recordDetails(
-          params.uris.map((uri) => ({ uri })),
-          labelers,
-        ),
-        getPdsAccountInfos(
-          ctx,
-          params.uris.map((uri) => new AtUri(uri).hostname),
-        ),
-      ])
-
-      const results = params.uris.map((uri) => {
-        const record = records.get(uri)
-        if (!record) {
-          return {
-            uri,
-            $type: 'tools.ozone.moderation.defs#recordViewNotFound',
-          }
-        }
-
-        return {
-          $type: 'tools.ozone.moderation.defs#recordViewDetail',
-          ...record,
-          repo: addAccountInfoToRepoView(
-            record.repo,
-            accountInfos.get(record.repo.did) || null,
-            auth.credentials.isModerator,
-          ),
-        }
-      })
-
-      return {
-        encoding: 'application/json',
-        body: { records: results },
-      }
-    },
-  })
-}

package/src/api/moderation/getRepo.ts

@@ -1,34 +0,0 @@
-import { InvalidRequestError } from '@atproto/xrpc-server'
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-import { addAccountInfoToRepoViewDetail, getPdsAccountInfos } from '../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.moderation.getRepo({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ params, auth, req }) => {
-      const { did } = params
-      const db = ctx.db
-      const labelers = ctx.reqLabelers(req)
-      const [partialRepos, accountInfo] = await Promise.all([
-        ctx.modService(db).views.repoDetails([did], labelers),
-        getPdsAccountInfos(ctx, [did]),
-      ])
-
-      const partialRepo = partialRepos.get(did)
-      if (!partialRepo) {
-        throw new InvalidRequestError('Repo not found', 'RepoNotFound')
-      }
-
-      const repo = addAccountInfoToRepoViewDetail(
-        partialRepo,
-        accountInfo.get(did) || null,
-        auth.credentials.isModerator,
-      )
-      return {
-        encoding: 'application/json',
-        body: repo,
-      }
-    },
-  })
-}

package/src/api/moderation/getReporterStats.ts

@@ -1,18 +0,0 @@
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.moderation.getReporterStats({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ params }) => {
-      const db = ctx.db
-
-      const stats = await ctx.modService(db).getReporterStats(params.dids)
-
-      return {
-        encoding: 'application/json',
-        body: { stats },
-      }
-    },
-  })
-}

package/src/api/moderation/getRepos.ts

@@ -1,41 +0,0 @@
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-import { addAccountInfoToRepoViewDetail, getPdsAccountInfos } from '../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.moderation.getRepos({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ params, auth, req }) => {
-      const { dids } = params
-      const db = ctx.db
-      const labelers = ctx.reqLabelers(req)
-      const [partialRepos, accountInfo] = await Promise.all([
-        ctx.modService(db).views.repoDetails(dids, labelers),
-        getPdsAccountInfos(ctx, dids),
-      ])
-
-      const repos = dids.map((did) => {
-        const partialRepo = partialRepos.get(did)
-        if (!partialRepo) {
-          return {
-            did,
-            $type: 'tools.ozone.moderation.defs#repoViewNotFound',
-          }
-        }
-        return {
-          ...addAccountInfoToRepoViewDetail(
-            partialRepo,
-            accountInfo.get(did) || null,
-            auth.credentials.isModerator,
-          ),
-          $type: 'tools.ozone.moderation.defs#repoViewDetail',
-        }
-      })
-
-      return {
-        encoding: 'application/json',
-        body: { repos },
-      }
-    },
-  })
-}

package/src/api/moderation/getSubjects.ts

@@ -1,101 +0,0 @@
-import { ToolsOzoneModerationDefs } from '@atproto/api'
-import { AtUri } from '@atproto/syntax'
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-import { SubjectView } from '../../lexicon/types/tools/ozone/moderation/defs.js'
-import { addAccountInfoToRepoViewDetail, getPdsAccountInfos } from '../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.moderation.getSubjects({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ params, auth, req }) => {
-      const { subjects } = params
-      const db = ctx.db
-      const labelers = ctx.reqLabelers(req)
-      const uris = new Set<string>()
-      const dids = new Set<string>()
-
-      for (const subject of subjects) {
-        if (subject.startsWith('did:')) {
-          dids.add(subject)
-        }
-        if (subject.startsWith('at://')) {
-          uris.add(subject)
-          dids.add(new AtUri(subject).host)
-        }
-      }
-
-      const didsArray = Array.from(dids)
-      const modViews = ctx.modService(db).views
-      const [partialRepos, accountInfo, recordInfo, profiles] =
-        await Promise.all([
-          modViews.repoDetails(didsArray, labelers),
-          getPdsAccountInfos(ctx, didsArray),
-          modViews.recordDetails(
-            Array.from(uris).map((uri) => ({ uri })),
-            labelers,
-          ),
-          modViews.getProfiles(didsArray),
-        ])
-
-      const missingSubjects: string[] = []
-      const subjectWithDetails = new Map<string, SubjectView>()
-
-      for (const subject of subjects) {
-        const type = subject.startsWith('did:') ? 'account' : 'record'
-        const did = type === 'account' ? subject : new AtUri(subject).host
-        const partialRepo = partialRepos.get(did)
-        const repo = partialRepo
-          ? addAccountInfoToRepoViewDetail(
-              partialRepo,
-              accountInfo.get(did) || null,
-              auth.credentials.isModerator,
-            )
-          : undefined
-        const profile = profiles.get(did)
-        const record = type === 'record' ? recordInfo.get(subject) : undefined
-        const status =
-          type === 'record'
-            ? record?.moderation.subjectStatus
-            : repo?.moderation.subjectStatus
-
-        subjectWithDetails.set(subject, {
-          type,
-          repo,
-          record,
-          profile: profile && {
-            $type: 'app.bsky.actor.defs#profileViewDetailed',
-            ...profile,
-          },
-          status,
-          subject,
-        })
-
-        if ((type === 'record' && !record) || (type === 'account' && !repo)) {
-          missingSubjects.push(subject)
-        }
-      }
-
-      // When a subject is repo or record but the repo/record was deleted, we still want to attach moderation status if any exists
-      const missingSubjectStatuses =
-        await modViews.getSubjectStatus(missingSubjects)
-
-      for (const [subject, status] of missingSubjectStatuses) {
-        const subjectView = subjectWithDetails.get(subject)
-        if (subjectView)
-          subjectView.status = modViews.formatSubjectStatus(status)
-      }
-
-      const allSubjects: ToolsOzoneModerationDefs.SubjectView[] = []
-      for (const subject of subjects) {
-        const subjectView = subjectWithDetails.get(subject)
-        if (subjectView) allSubjects.push(subjectView)
-      }
-
-      return {
-        encoding: 'application/json',
-        body: { subjects: allSubjects },
-      }
-    },
-  })
-}

package/src/api/moderation/listScheduledActions.ts

@@ -1,45 +0,0 @@
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-import { getScheduledActionStatus } from '../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.moderation.listScheduledActions({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ input }) => {
-      const db = ctx.db
-      const {
-        startsAfter,
-        endsBefore,
-        subjects,
-        statuses,
-        limit = 50,
-        cursor,
-      } = input.body
-
-      const scheduledActionService = ctx.scheduledActionService(db)
-
-      const parsedStatuses = statuses.map((status) =>
-        getScheduledActionStatus(status),
-      )
-
-      const result = await scheduledActionService.listScheduledActions({
-        cursor,
-        limit,
-        startTime: startsAfter ? new Date(startsAfter) : undefined,
-        endTime: endsBefore ? new Date(endsBefore) : undefined,
-        subjects,
-        statuses: parsedStatuses,
-      })
-
-      return {
-        encoding: 'application/json',
-        body: {
-          actions: result.actions.map((action) =>
-            scheduledActionService.formatScheduledAction(action),
-          ),
-          cursor: result.cursor,
-        },
-      }
-    },
-  })
-}

package/src/api/moderation/queryEvents.ts

@@ -1,72 +0,0 @@
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-import { getEventType } from '../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.moderation.queryEvents({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ params }) => {
-      const {
-        subject,
-        limit = 50,
-        cursor,
-        sortDirection = 'desc',
-        types,
-        includeAllUserRecords = false,
-        hasComment,
-        comment,
-        createdBy,
-        createdAfter,
-        createdBefore,
-        addedLabels = [],
-        removedLabels = [],
-        addedTags = [],
-        removedTags = [],
-        reportTypes,
-        collections = [],
-        subjectType,
-        policies,
-        modTool,
-        ageAssuranceState,
-        batchId,
-        withStrike,
-      } = params
-      const db = ctx.db
-      const modService = ctx.modService(db)
-      const results = await modService.getEvents({
-        types: types?.length ? types.map(getEventType) : [],
-        subject,
-        createdBy,
-        limit,
-        cursor,
-        sortDirection,
-        includeAllUserRecords,
-        hasComment,
-        comment,
-        createdAfter,
-        createdBefore,
-        addedLabels,
-        addedTags,
-        removedLabels,
-        removedTags,
-        reportTypes,
-        collections,
-        subjectType,
-        policies,
-        modTool,
-        ageAssuranceState,
-        batchId,
-        withStrike,
-      })
-      return {
-        encoding: 'application/json',
-        body: {
-          cursor: results.cursor,
-          events: results.events.map((evt) =>
-            modService.views.formatEvent(evt),
-          ),
-        },
-      }
-    },
-  })
-}

package/src/api/moderation/queryStatuses.ts

@@ -1,23 +0,0 @@
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.moderation.queryStatuses({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ params }) => {
-      const db = ctx.db
-      const modService = ctx.modService(db)
-      const results = await modService.getSubjectStatuses(params)
-      const subjectStatuses = results.statuses.map((status) =>
-        modService.views.formatSubjectStatus(status),
-      )
-      return {
-        encoding: 'application/json',
-        body: {
-          cursor: results.cursor,
-          subjectStatuses,
-        },
-      }
-    },
-  })
-}