@atproto/ozone 0.2.9 → 0.2.11

package/src/api/queue/deleteQueue.ts

@@ -1,56 +0,0 @@
-import { AuthRequiredError, InvalidRequestError } from '@atproto/xrpc-server'
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.queue.deleteQueue({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ input, auth }) => {
-      const access = auth.credentials
-
-      if (!access.isModerator) {
-        throw new AuthRequiredError('Must be a moderator to delete a queue')
-      }
-
-      const { queueId, migrateToQueueId } = input.body
-
-      const queueService = ctx.queueService(ctx.db)
-
-      const existing = await queueService.getById(queueId)
-      if (!existing) {
-        throw new InvalidRequestError(
-          `Queue with id ${queueId} does not exist`,
-          'QueueNotFound',
-        )
-      }
-
-      if (migrateToQueueId !== undefined) {
-        const targetQueue = await queueService.getById(migrateToQueueId)
-        if (!targetQueue) {
-          throw new InvalidRequestError(
-            `Target queue with id ${migrateToQueueId} does not exist`,
-            'QueueNotFound',
-          )
-        }
-      }
-
-      // Migrate non-closed reports before soft-deleting the queue.
-      // Closed reports are left assigned to the deleted queue — their history is preserved.
-      // Non-closed reports go to migrateToQueueId if specified, otherwise to -1 (unmatched).
-      const reportsMigrated = await queueService.migrateReports(
-        queueId,
-        migrateToQueueId,
-      )
-
-      await queueService.delete(queueId)
-
-      return {
-        encoding: 'application/json',
-        body: {
-          deleted: true,
-          reportsMigrated,
-        },
-      }
-    },
-  })
-}

package/src/api/queue/getAssignments.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.queue.getAssignments({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ params }) => {
-      const result = await ctx.assignmentService.getQueueAssignments(params)
-
-      return {
-        encoding: 'application/json',
-        body: {
-          assignments: result.assignments,
-          cursor: result.cursor,
-        },
-      }
-    },
-  })
-}

package/src/api/queue/listQueues.ts

@@ -1,39 +0,0 @@
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.queue.listQueues({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ params }) => {
-      const {
-        limit = 50,
-        cursor,
-        enabled,
-        subjectType,
-        collection,
-        reportTypes,
-      } = params
-
-      const queueService = ctx.queueService(ctx.db)
-
-      const result = await queueService.list({
-        limit,
-        cursor,
-        enabled,
-        subjectType,
-        collection,
-        reportTypes,
-      })
-
-      const queues = await queueService.viewsWithStats(result.queues)
-
-      return {
-        encoding: 'application/json',
-        body: {
-          queues,
-          cursor: result.cursor,
-        },
-      }
-    },
-  })
-}

package/src/api/queue/routeReports.ts

@@ -1,44 +0,0 @@
-import { AuthRequiredError, InvalidRequestError } from '@atproto/xrpc-server'
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-
-const MAX_REPORTS = 5000
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.queue.routeReports({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ input, auth }) => {
-      const access = auth.credentials
-      const { startReportId, endReportId } = input.body
-
-      if (!access.isModerator) {
-        throw new AuthRequiredError('Must be an admin to re-route reports')
-      }
-      if (startReportId > endReportId) {
-        throw new InvalidRequestError(
-          'startReportId must be less than or equal to endReportId',
-        )
-      }
-      if (endReportId - startReportId + 1 > MAX_REPORTS) {
-        throw new InvalidRequestError(
-          `Cannot route more than ${MAX_REPORTS} reports at a time`,
-          'OutOfRange',
-        )
-      }
-
-      const queueService = ctx.queueService(ctx.db)
-      const { assigned, unmatched } = await queueService.assignReportBatch(
-        { start: startReportId, end: endReportId, limit: MAX_REPORTS },
-        { includeUnmatched: true },
-      )
-
-      return {
-        encoding: 'application/json',
-        body: {
-          assigned,
-          unmatched,
-        },
-      }
-    },
-  })
-}

package/src/api/queue/unassignModerator.ts

@@ -1,26 +0,0 @@
-import { ForbiddenError } from '@atproto/xrpc-server'
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-import { getAuthDid } from '../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.queue.unassignModerator({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ input, auth }) => {
-      const { queueId, did } = input.body
-      const authDid = getAuthDid(auth, ctx.cfg.service.did)
-
-      // RBAC
-      if (!auth.credentials.isModerator) {
-        throw new ForbiddenError('Unauthorized')
-      }
-
-      // RuBAC
-      if (did !== authDid && !auth.credentials.isAdmin) {
-        throw new ForbiddenError('Unauthorized')
-      }
-
-      await ctx.assignmentService.unassignQueue({ did, queueId })
-    },
-  })
-}

package/src/api/queue/updateQueue.ts

@@ -1,54 +0,0 @@
-import { AuthRequiredError, InvalidRequestError } from '@atproto/xrpc-server'
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.queue.updateQueue({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ input, auth }) => {
-      const access = auth.credentials
-
-      if (!access.isModerator) {
-        throw new AuthRequiredError('Must be a moderator to update a queue')
-      }
-
-      const { queueId, name, enabled, description } = input.body
-
-      if (
-        name === undefined &&
-        enabled === undefined &&
-        description === undefined
-      ) {
-        throw new InvalidRequestError(
-          'At least one of name, enabled, or description must be provided',
-        )
-      }
-
-      const queueService = ctx.queueService(ctx.db)
-
-      const existing = await queueService.getById(queueId)
-      if (!existing) {
-        throw new InvalidRequestError(
-          `Queue with id ${queueId} does not exist`,
-          'QueueNotFound',
-        )
-      }
-
-      const updates: {
-        name?: string
-        enabled?: boolean
-        description?: string
-      } = {}
-      if (name !== undefined) updates.name = name
-      if (enabled !== undefined) updates.enabled = enabled
-      if (description !== undefined) updates.description = description
-
-      const queue = await queueService.update(queueId, updates)
-
-      return {
-        encoding: 'application/json',
-        body: { queue: queueService.view(queue) },
-      }
-    },
-  })
-}

package/src/api/report/assignModerator.ts

@@ -1,36 +0,0 @@
-import { ForbiddenError } from '@atproto/xrpc-server'
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-import { getAuthDid } from '../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.report.assignModerator({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ input, auth }) => {
-      const authDid = getAuthDid(auth, ctx.cfg.service.did)
-      const did = input.body.did ?? authDid
-
-      if (!did) {
-        throw new ForbiddenError('No one to assign report to')
-      }
-
-      // RuBAC: only admins can assign to a different user
-      if (did !== authDid && !auth.credentials.isAdmin) {
-        throw new ForbiddenError('Unauthorized')
-      }
-
-      const result = await ctx.assignmentService.assignReport({
-        did,
-        createdBy: authDid,
-        reportId: input.body.reportId,
-        queueId: input.body.queueId,
-        isPermanent: input.body.isPermanent,
-      })
-
-      return {
-        encoding: 'application/json',
-        body: result,
-      }
-    },
-  })
-}

package/src/api/report/createActivity.ts

@@ -1,57 +0,0 @@
-import { InvalidRequestError } from '@atproto/xrpc-server'
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-import {
-  ActivityType,
-  createReportActivity,
-  formatActivityView,
-} from '../../report/activity.js'
-import { getAuthDid } from '../util.js'
-
-const VALID_ACTIVITY_TYPES = new Set<ActivityType>([
-  'queueActivity',
-  'assignmentActivity',
-  'escalationActivity',
-  'closeActivity',
-  'reopenActivity',
-  'noteActivity',
-])
-
-const DEFS_PREFIX = 'tools.ozone.report.defs#'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.report.createActivity({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ input, auth }) => {
-      const createdBy = getAuthDid(auth, ctx.cfg.service.did)
-      const { reportId, activity, internalNote, publicNote, isAutomated } =
-        input.body
-
-      const rawType = activity.$type ?? ''
-      const activityType = rawType.startsWith(DEFS_PREFIX)
-        ? rawType.slice(DEFS_PREFIX.length)
-        : rawType
-
-      if (!VALID_ACTIVITY_TYPES.has(activityType as ActivityType)) {
-        throw new InvalidRequestError(
-          `Unknown activity type: ${rawType}`,
-          'InvalidActivityType',
-        )
-      }
-
-      const row = await createReportActivity(ctx.db, {
-        reportId,
-        activityType: activityType as ActivityType,
-        internalNote: internalNote ?? undefined,
-        publicNote: publicNote ?? undefined,
-        isAutomated: isAutomated ?? false,
-        createdBy: createdBy ?? ctx.cfg.service.did,
-      })
-
-      return {
-        encoding: 'application/json',
-        body: { activity: formatActivityView(row) },
-      }
-    },
-  })
-}

package/src/api/report/createReport.ts

@@ -1,93 +0,0 @@
-import { ForbiddenError } from '@atproto/xrpc-server'
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-import { ReasonType } from '../../lexicon/types/com/atproto/moderation/defs.js'
-import { ModerationService } from '../../mod-service/index.js'
-import { subjectFromInput } from '../../mod-service/subject.js'
-import { TagService } from '../../tag-service/index.js'
-import { getTagForReport } from '../../tag-service/util.js'
-import { isAppealReport } from '../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.moderation.createReport({
-    auth: ctx.authVerifier.standard,
-    handler: async ({ input, auth }) => {
-      const requester =
-        'iss' in auth.credentials ? auth.credentials.iss : ctx.cfg.service.did
-      const { reasonType, reason, modTool } = input.body
-      const subject = subjectFromInput(input.body.subject)
-
-      // If the report is an appeal, the requester must be the author of the subject
-      if (isAppealReport(reasonType) && requester !== subject.did) {
-        throw new ForbiddenError('You cannot appeal this report')
-      }
-
-      const db = ctx.db
-
-      await ctx.moderationServiceProfile().validateReasonType(reasonType)
-      await assertValidReporter(ctx.modService(db), reasonType, requester)
-
-      const report = await db.transaction(async (dbTxn) => {
-        const moderationTxn = ctx.modService(dbTxn)
-        const { event: reportEvent, subjectStatus } =
-          await moderationTxn.report({
-            reason,
-            subject,
-            reasonType,
-            reportedBy: requester || ctx.cfg.service.did,
-            modTool,
-          })
-
-        const tagService = new TagService(
-          subject,
-          subjectStatus,
-          ctx.cfg.service.did,
-          moderationTxn,
-        )
-        await tagService.evaluateForSubject([getTagForReport(reasonType)])
-
-        return reportEvent
-      })
-
-      const body = ctx.modService(db).views.formatReport(report)
-      return {
-        encoding: 'application/json',
-        body,
-      }
-    },
-  })
-}
-
-const assertValidReporter = async (
-  modService: ModerationService,
-  reasonType: ReasonType,
-  did: string,
-) => {
-  const reporterStatus = await modService.getCurrentStatus({ did })
-
-  // If we don't have a mod status for the reporter, no need to do further checks
-  if (!reporterStatus.length) {
-    return
-  }
-
-  // For appeals, we just need to make sure that the account does not have pending appeal
-  if (isAppealReport(reasonType)) {
-    if (reporterStatus[0]?.appealed) {
-      throw new ForbiddenError(
-        'Awaiting decision on previous appeal',
-        'AlreadyAppealed',
-      )
-    }
-    return
-  }
-
-  // For non appeals, we need to make sure the reporter account is not already in takendown status
-  // This is necessary because we allow takendown accounts call createReport but that's only meant for appeals
-  // and we need to make sure takendown accounts don't abuse this endpoint
-  if (reporterStatus[0]?.takendown) {
-    throw new ForbiddenError(
-      'Report not accepted from takendown account',
-      'AccountTakedown',
-    )
-  }
-}

package/src/api/report/getAssignments.ts

@@ -1,20 +0,0 @@
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.report.getAssignments({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ params }) => {
-      const { assignments, cursor } =
-        await ctx.assignmentService.getReportAssignments(params)
-
-      return {
-        encoding: 'application/json',
-        body: {
-          assignments,
-          cursor,
-        },
-      }
-    },
-  })
-}

package/src/api/report/getHistoricalStats.ts

@@ -1,41 +0,0 @@
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-import { viewHistoricalStats } from '../../report/views.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.report.getHistoricalStats({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ params }) => {
-      const {
-        queueId,
-        moderatorDid,
-        reportTypes,
-        startDate,
-        endDate,
-        limit,
-        cursor,
-      } = params
-
-      const reportStatsService = ctx.reportStatsService(ctx.db)
-      const result = await reportStatsService.getHistoricalStats({
-        group: {
-          queueId: queueId ?? null,
-          moderatorDid: moderatorDid ?? null,
-          reportTypes: reportTypes?.length ? reportTypes : null,
-        },
-        startDate,
-        endDate,
-        limit: limit ?? 30,
-        cursor,
-      })
-
-      return {
-        encoding: 'application/json',
-        body: {
-          stats: result.stats.map(viewHistoricalStats),
-          cursor: result.cursor,
-        },
-      }
-    },
-  })
-}

package/src/api/report/getLatestReport.ts

@@ -1,44 +0,0 @@
-import { InvalidRequestError } from '@atproto/xrpc-server'
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-import { getLatestReport } from '../../mod-service/report.js'
-import { buildReportView, hydrateReportInfo } from '../../report/views.js'
-import { getPdsAccountInfos } from '../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.report.getLatestReport({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ auth, req }) => {
-      const db = ctx.db
-      const modService = ctx.modService(db)
-      const labelers = ctx.reqLabelers(req)
-
-      const report = await getLatestReport(db)
-      if (!report) {
-        throw new InvalidRequestError('No report found', 'NotFound')
-      }
-
-      const queueService = ctx.queueService(db)
-      const teamService = ctx.teamService(db)
-      const hydrated = await hydrateReportInfo(
-        [report],
-        modService.views,
-        (dids) => getPdsAccountInfos(ctx, dids),
-        (queueIds) => queueService.getViewsByIds(queueIds),
-        (dids) => teamService.viewByDids(dids),
-        labelers,
-      )
-
-      return {
-        encoding: 'application/json',
-        body: {
-          report: buildReportView(
-            report,
-            hydrated,
-            auth.credentials.isModerator,
-          ),
-        },
-      }
-    },
-  })
-}

package/src/api/report/getLiveStats.ts

@@ -1,26 +0,0 @@
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-import { viewLiveStats } from '../../report/views.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.report.getLiveStats({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ params }) => {
-      const { queueId, moderatorDid, reportTypes } = params
-
-      const reportStatsService = ctx.reportStatsService(ctx.db)
-      const row = await reportStatsService.getLiveStats({
-        queueId: queueId ?? null,
-        moderatorDid: moderatorDid ?? null,
-        reportTypes: reportTypes?.length ? reportTypes : null,
-      })
-
-      return {
-        encoding: 'application/json',
-        body: {
-          stats: viewLiveStats(row),
-        },
-      }
-    },
-  })
-}

package/src/api/report/getReport.ts

@@ -1,55 +0,0 @@
-import { InvalidRequestError } from '@atproto/xrpc-server'
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-import { getReportById } from '../../mod-service/report.js'
-import { buildReportView, hydrateReportInfo } from '../../report/views.js'
-import { getPdsAccountInfos } from '../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.report.getReport({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ params, auth, req }) => {
-      const db = ctx.db
-      const modService = ctx.modService(db)
-      const labelers = ctx.reqLabelers(req)
-
-      const report = await getReportById(db, params.id)
-      if (!report) {
-        throw new InvalidRequestError(
-          `Report not found: ${params.id}`,
-          'NotFound',
-        )
-      }
-
-      const queueService = ctx.queueService(db)
-      const teamService = ctx.teamService(db)
-      const [hydrated, actionEvents] = await Promise.all([
-        hydrateReportInfo(
-          [report],
-          modService.views,
-          (dids) => getPdsAccountInfos(ctx, dids),
-          (queueIds) => queueService.getViewsByIds(queueIds),
-          (dids) => teamService.viewByDids(dids),
-          labelers,
-        ),
-        Array.isArray(report.actionEventIds) && report.actionEventIds.length
-          ? modService.getEventsByIds(report.actionEventIds as number[])
-          : Promise.resolve([]),
-      ])
-
-      const actions = actionEvents.map((evt) =>
-        modService.views.formatEvent(evt),
-      )
-
-      return {
-        encoding: 'application/json',
-        body: buildReportView(
-          report,
-          hydrated,
-          auth.credentials.isModerator,
-          actions,
-        ),
-      }
-    },
-  })
-}

package/src/api/report/listActivities.ts

@@ -1,37 +0,0 @@
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-import {
-  formatActivityView,
-  listReportActivities,
-} from '../../report/activity.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.report.listActivities({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ params }) => {
-      const { reportId, limit, cursor } = params
-
-      const { activities, cursor: nextCursor } = await listReportActivities(
-        ctx.db,
-        { reportId, limit, cursor },
-      )
-
-      // Fetch team members for all createdBy DIDs
-      const createdByDids = Array.from(
-        new Set(activities.map((a) => a.createdBy)),
-      )
-      const teamService = ctx.teamService(ctx.db)
-      const memberViews = await teamService.viewByDids(createdByDids)
-
-      return {
-        encoding: 'application/json',
-        body: {
-          activities: activities.map((activity) =>
-            formatActivityView(activity, memberViews),
-          ),
-          cursor: nextCursor,
-        },
-      }
-    },
-  })
-}