@atproto/ozone 0.2.9 → 0.2.11

package/src/mod-service/profile.ts

@@ -1,139 +0,0 @@
-import AtpAgent, { AppBskyLabelerDefs } from '@atproto/api'
-import { InvalidRequestError } from '@atproto/xrpc-server'
-import { OzoneConfig } from '../config/index.js'
-import {
-  REASONAPPEAL,
-  REASONMISLEADING,
-  REASONOTHER,
-  REASONRUDE,
-  REASONSEXUAL,
-  REASONSPAM,
-  REASONVIOLATION,
-} from '../lexicon/types/com/atproto/moderation/defs.js'
-import { httpLogger } from '../logger.js'
-
-// Reverse mapping from new ozone namespaced reason types to old com.atproto namespaced reason types
-export const NEW_TO_OLD_REASON_MAPPING: Record<string, string> = {
-  'tools.ozone.report.defs#reasonAppeal': REASONAPPEAL,
-  'tools.ozone.report.defs#reasonOther': REASONOTHER,
-
-  'tools.ozone.report.defs#reasonViolenceAnimal': REASONVIOLATION,
-  'tools.ozone.report.defs#reasonViolenceThreats': REASONVIOLATION,
-  'tools.ozone.report.defs#reasonViolenceGraphicContent': REASONVIOLATION,
-  'tools.ozone.report.defs#reasonViolenceGlorification': REASONVIOLATION,
-  'tools.ozone.report.defs#reasonViolenceExtremistContent': REASONVIOLATION,
-  'tools.ozone.report.defs#reasonViolenceTrafficking': REASONVIOLATION,
-  'tools.ozone.report.defs#reasonViolenceOther': REASONVIOLATION,
-
-  'tools.ozone.report.defs#reasonSexualAbuseContent': REASONSEXUAL,
-  'tools.ozone.report.defs#reasonSexualNCII': REASONSEXUAL,
-  'tools.ozone.report.defs#reasonSexualDeepfake': REASONSEXUAL,
-  'tools.ozone.report.defs#reasonSexualAnimal': REASONSEXUAL,
-  'tools.ozone.report.defs#reasonSexualUnlabeled': REASONSEXUAL,
-  'tools.ozone.report.defs#reasonSexualOther': REASONSEXUAL,
-
-  'tools.ozone.report.defs#reasonChildSafetyCSAM': REASONVIOLATION,
-  'tools.ozone.report.defs#reasonChildSafetyGroom': REASONVIOLATION,
-  'tools.ozone.report.defs#reasonChildSafetyPrivacy': REASONVIOLATION,
-  'tools.ozone.report.defs#reasonChildSafetyHarassment': REASONVIOLATION,
-  'tools.ozone.report.defs#reasonChildSafetyOther': REASONVIOLATION,
-
-  'tools.ozone.report.defs#reasonHarassmentTroll': REASONRUDE,
-  'tools.ozone.report.defs#reasonHarassmentTargeted': REASONRUDE,
-  'tools.ozone.report.defs#reasonHarassmentHateSpeech': REASONRUDE,
-  'tools.ozone.report.defs#reasonHarassmentDoxxing': REASONRUDE,
-  'tools.ozone.report.defs#reasonHarassmentOther': REASONRUDE,
-
-  'tools.ozone.report.defs#reasonMisleadingBot': REASONMISLEADING,
-  'tools.ozone.report.defs#reasonMisleadingImpersonation': REASONMISLEADING,
-  'tools.ozone.report.defs#reasonMisleadingSpam': REASONSPAM,
-  'tools.ozone.report.defs#reasonMisleadingScam': REASONMISLEADING,
-  'tools.ozone.report.defs#reasonMisleadingElections': REASONMISLEADING,
-  'tools.ozone.report.defs#reasonMisleadingOther': REASONMISLEADING,
-
-  'tools.ozone.report.defs#reasonRuleSiteSecurity': REASONVIOLATION,
-  'tools.ozone.report.defs#reasonRuleProhibitedSales': REASONVIOLATION,
-  'tools.ozone.report.defs#reasonRuleBanEvasion': REASONVIOLATION,
-  'tools.ozone.report.defs#reasonRuleOther': REASONVIOLATION,
-
-  'tools.ozone.report.defs#reasonSelfHarmContent': REASONVIOLATION,
-  'tools.ozone.report.defs#reasonSelfHarmED': REASONVIOLATION,
-  'tools.ozone.report.defs#reasonSelfHarmStunts': REASONVIOLATION,
-  'tools.ozone.report.defs#reasonSelfHarmSubstances': REASONVIOLATION,
-  'tools.ozone.report.defs#reasonSelfHarmOther': REASONVIOLATION,
-}
-
-interface CacheEntry {
-  profile: AppBskyLabelerDefs.LabelerViewDetailed | null
-  timestamp: number
-}
-
-export type ModerationServiceProfileCreator = () => ModerationServiceProfile
-
-export class ModerationServiceProfile {
-  private cache: CacheEntry | null = null
-  private CACHE_TTL: number
-
-  constructor(
-    private cfg: OzoneConfig,
-    private appviewAgent: AtpAgent,
-    cacheTTL?: number,
-  ) {
-    this.CACHE_TTL = cacheTTL || cfg.service.serviceRecordCacheTTL
-  }
-
-  static creator(
-    cfg: OzoneConfig,
-    appviewAgent: AtpAgent,
-  ): ModerationServiceProfileCreator {
-    return () => new ModerationServiceProfile(cfg, appviewAgent)
-  }
-
-  async getProfile() {
-    const now = Date.now()
-
-    if (!this.cache || now - this.cache.timestamp > this.CACHE_TTL) {
-      try {
-        const { data } = await this.appviewAgent.app.bsky.labeler.getServices({
-          dids: [this.cfg.service.did],
-          detailed: true,
-        })
-
-        if (AppBskyLabelerDefs.isLabelerViewDetailed(data.views?.[0])) {
-          this.cache = {
-            profile: data.views[0],
-            timestamp: now,
-          }
-        }
-      } catch (e) {
-        // On error, fail open
-        httpLogger.error(`Failed to fetch labeler profile: ${e?.['message']}`)
-      }
-    }
-
-    return this.cache?.profile || null
-  }
-
-  async validateReasonType(reasonType: string): Promise<string> {
-    const profile = await this.getProfile()
-
-    if (!Array.isArray(profile?.reasonTypes)) {
-      return reasonType
-    }
-
-    const supportedReasonTypes = profile.reasonTypes
-
-    // Check if the reason type is directly supported
-    if (supportedReasonTypes.includes(reasonType)) {
-      return reasonType
-    }
-
-    // Allow new reason types only if they map to a supported old reason type
-    const mappedOldReason = NEW_TO_OLD_REASON_MAPPING[reasonType]
-    if (mappedOldReason && supportedReasonTypes.includes(mappedOldReason)) {
-      return reasonType
-    }
-
-    throw new InvalidRequestError(`Invalid reason type: ${reasonType}`)
-  }
-}

package/src/mod-service/report.ts

@@ -1,429 +0,0 @@
-import { sql } from 'kysely'
-import { AtUri } from '@atproto/syntax'
-import { Database } from '../db/index.js'
-import { Report } from '../db/schema/report.js'
-import { QueryParams } from '../lexicon/types/tools/ozone/report/queryReports.js'
-import {
-  AlreadyInTargetState,
-  InvalidStateTransition,
-  handleReportUpdate,
-} from '../report/handle-report-update.js'
-
-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<boolean>`(${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<boolean>`(
-        ${sql.ref(sortCol)} < ${sortValue}
-        OR (${sql.ref(sortCol)} = ${sortValue} AND r.id < ${Number(id)})
-      )`)
-    } else {
-      builder = builder.where(sql<boolean>`(
-        ${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 getReportsByIds(
-  db: Database,
-  ids: number[],
-): Promise<ReportWithEvent[]> {
-  if (!ids.length) return []
-  return reportQuery(db)
-    .where('r.id', 'in', ids)
-    .selectAll('r')
-    .select([
-      'me.subjectDid',
-      'me.subjectUri',
-      'me.subjectCid',
-      'me.createdBy as reportedBy',
-      'me.comment',
-      'me.meta',
-    ])
-    .execute()
-}
-
-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
-}