@atproto/ozone 0.0.2

package/src/mod-service/status.ts

@@ -0,0 +1,264 @@
+// This may require better organization but for now, just dumping functions here containing DB queries for moderation status
+
+import { AtUri } from '@atproto/syntax'
+import { Database } from '../db'
+import { ModerationSubjectStatus } from '../db/schema/moderation_subject_status'
+import {
+  REVIEWOPEN,
+  REVIEWCLOSED,
+  REVIEWESCALATED,
+} from '../lexicon/types/com/atproto/admin/defs'
+import { ModerationEventRow, ModerationSubjectStatusRow } from './types'
+import { HOUR } from '@atproto/common'
+import { sql } from 'kysely'
+import { REASONAPPEAL } from '../lexicon/types/com/atproto/moderation/defs'
+
+const getSubjectStatusForModerationEvent = ({
+  action,
+  createdBy,
+  createdAt,
+  durationInHours,
+}: {
+  action: string
+  createdBy: string
+  createdAt: string
+  durationInHours: number | null
+}): Partial<ModerationSubjectStatusRow> | null => {
+  switch (action) {
+    case 'com.atproto.admin.defs#modEventAcknowledge':
+      return {
+        lastReviewedBy: createdBy,
+        reviewState: REVIEWCLOSED,
+        lastReviewedAt: createdAt,
+      }
+    case 'com.atproto.admin.defs#modEventReport':
+      return {
+        reviewState: REVIEWOPEN,
+        lastReportedAt: createdAt,
+      }
+    case 'com.atproto.admin.defs#modEventEscalate':
+      return {
+        lastReviewedBy: createdBy,
+        reviewState: REVIEWESCALATED,
+        lastReviewedAt: createdAt,
+      }
+    case 'com.atproto.admin.defs#modEventReverseTakedown':
+      return {
+        lastReviewedBy: createdBy,
+        reviewState: REVIEWCLOSED,
+        takendown: false,
+        suspendUntil: null,
+        lastReviewedAt: createdAt,
+      }
+    case 'com.atproto.admin.defs#modEventUnmute':
+      return {
+        lastReviewedBy: createdBy,
+        muteUntil: null,
+        reviewState: REVIEWOPEN,
+        lastReviewedAt: createdAt,
+      }
+    case 'com.atproto.admin.defs#modEventTakedown':
+      return {
+        takendown: true,
+        lastReviewedBy: createdBy,
+        reviewState: REVIEWCLOSED,
+        lastReviewedAt: createdAt,
+        suspendUntil: durationInHours
+          ? new Date(Date.now() + durationInHours * HOUR).toISOString()
+          : null,
+      }
+    case 'com.atproto.admin.defs#modEventMute':
+      return {
+        lastReviewedBy: createdBy,
+        reviewState: REVIEWOPEN,
+        lastReviewedAt: createdAt,
+        // By default, mute for 24hrs
+        muteUntil: new Date(
+          Date.now() + (durationInHours || 24) * HOUR,
+        ).toISOString(),
+      }
+    case 'com.atproto.admin.defs#modEventComment':
+      return {
+        lastReviewedBy: createdBy,
+        lastReviewedAt: createdAt,
+      }
+    case 'com.atproto.admin.defs#modEventResolveAppeal':
+      return {
+        appealed: false,
+      }
+    default:
+      return null
+  }
+}
+
+// Based on a given moderation action event, this function will update the moderation status of the subject
+// If there's no existing status, it will create one
+// If the action event does not affect the status, it will do nothing
+export const adjustModerationSubjectStatus = async (
+  db: Database,
+  moderationEvent: ModerationEventRow,
+  blobCids?: string[],
+) => {
+  const {
+    action,
+    subjectDid,
+    subjectUri,
+    subjectCid,
+    createdBy,
+    meta,
+    comment,
+    createdAt,
+  } = moderationEvent
+
+  const isAppealEvent =
+    action === 'com.atproto.admin.defs#modEventReport' &&
+    meta?.reportType === REASONAPPEAL
+
+  const subjectStatus = getSubjectStatusForModerationEvent({
+    action,
+    createdBy,
+    createdAt,
+    durationInHours: moderationEvent.durationInHours,
+  })
+
+  // If there are no subjectStatus that means there are no side-effect of the incoming event
+  if (!subjectStatus) {
+    return null
+  }
+
+  const now = new Date().toISOString()
+  // If subjectUri exists, it's not a repoRef so pass along the uri to get identifier back
+  const identifier = getStatusIdentifierFromSubject(subjectUri || subjectDid)
+
+  db.assertTransaction()
+
+  const currentStatus = await db.db
+    .selectFrom('moderation_subject_status')
+    .where('did', '=', identifier.did)
+    .where('recordPath', '=', identifier.recordPath)
+    .selectAll()
+    .executeTakeFirst()
+
+  if (
+    currentStatus?.reviewState === REVIEWESCALATED &&
+    subjectStatus.reviewState === REVIEWOPEN
+  ) {
+    // If the current status is escalated and the incoming event is to open the review
+    // We want to keep the status as escalated
+    subjectStatus.reviewState = REVIEWESCALATED
+  }
+
+  // Set these because we don't want to override them if they're already set
+  const defaultData = {
+    comment: null,
+    // Defaulting reviewState to open for any event may not be the desired behavior.
+    // For instance, if a subject never had any event and we just want to leave a comment to keep an eye on it
+    // that shouldn't mean we want to review the subject
+    reviewState: REVIEWOPEN,
+    recordCid: subjectCid || null,
+  }
+  const newStatus = {
+    ...defaultData,
+    ...subjectStatus,
+  }
+
+  if (
+    action === 'com.atproto.admin.defs#modEventReverseTakedown' &&
+    !subjectStatus.takendown
+  ) {
+    newStatus.takendown = false
+    subjectStatus.takendown = false
+  }
+
+  if (isAppealEvent) {
+    newStatus.appealed = true
+    subjectStatus.appealed = true
+    newStatus.lastAppealedAt = createdAt
+    subjectStatus.lastAppealedAt = createdAt
+  }
+
+  if (
+    action === 'com.atproto.admin.defs#modEventResolveAppeal' &&
+    subjectStatus.appealed
+  ) {
+    newStatus.appealed = false
+    subjectStatus.appealed = false
+  }
+
+  if (action === 'com.atproto.admin.defs#modEventComment' && meta?.sticky) {
+    newStatus.comment = comment
+    subjectStatus.comment = comment
+  }
+
+  if (blobCids?.length) {
+    const newBlobCids = sql<string[]>`${JSON.stringify(
+      blobCids,
+    )}` as unknown as ModerationSubjectStatusRow['blobCids']
+    newStatus.blobCids = newBlobCids
+    subjectStatus.blobCids = newBlobCids
+  }
+
+  const insertQuery = db.db
+    .insertInto('moderation_subject_status')
+    .values({
+      ...identifier,
+      ...newStatus,
+      createdAt: now,
+      updatedAt: now,
+      // TODO: Need to get the types right here.
+    } as ModerationSubjectStatusRow)
+    .onConflict((oc) =>
+      oc.constraint('moderation_status_unique_idx').doUpdateSet({
+        ...subjectStatus,
+        updatedAt: now,
+      }),
+    )
+
+  const status = await insertQuery.executeTakeFirst()
+  return status
+}
+
+type ModerationSubjectStatusFilter =
+  | Pick<ModerationSubjectStatus, 'did'>
+  | Pick<ModerationSubjectStatus, 'did' | 'recordPath'>
+  | Pick<ModerationSubjectStatus, 'did' | 'recordPath' | 'recordCid'>
+export const getModerationSubjectStatus = async (
+  db: Database,
+  filters: ModerationSubjectStatusFilter,
+) => {
+  let builder = db.db
+    .selectFrom('moderation_subject_status')
+    // DID will always be passed at the very least
+    .where('did', '=', filters.did)
+    .where('recordPath', '=', 'recordPath' in filters ? filters.recordPath : '')
+
+  if ('recordCid' in filters) {
+    builder = builder.where('recordCid', '=', filters.recordCid)
+  } else {
+    builder = builder.where('recordCid', 'is', null)
+  }
+
+  return builder.executeTakeFirst()
+}
+
+export const getStatusIdentifierFromSubject = (
+  subject: string | AtUri,
+): { did: string; recordPath: string } => {
+  const isSubjectString = typeof subject === 'string'
+  if (isSubjectString && subject.startsWith('did:')) {
+    return {
+      did: subject,
+      recordPath: '',
+    }
+  }
+
+  if (isSubjectString && !subject.startsWith('at://')) {
+    throw new Error('Subject is neither a did nor an at-uri')
+  }
+
+  const uri = isSubjectString ? new AtUri(subject) : subject
+  return {
+    did: uri.host,
+    recordPath: `${uri.collection}/${uri.rkey}`,
+  }
+}

package/src/mod-service/subject.ts

@@ -0,0 +1,136 @@
+import { AtUri } from '@atproto/syntax'
+import { InputSchema as ReportInput } from '../lexicon/types/com/atproto/moderation/createReport'
+import { InputSchema as ActionInput } from '../lexicon/types/com/atproto/admin/emitModerationEvent'
+import { InvalidRequestError } from '@atproto/xrpc-server'
+import { ModerationEventRow, ModerationSubjectStatusRow } from './types'
+import { RepoRef } from '../lexicon/types/com/atproto/admin/defs'
+import { Main as StrongRef } from '../lexicon/types/com/atproto/repo/strongRef'
+
+type SubjectInput = ReportInput['subject'] | ActionInput['subject']
+
+export const subjectFromInput = (
+  subject: SubjectInput,
+  blobs?: string[],
+): ModSubject => {
+  if (
+    subject.$type === 'com.atproto.admin.defs#repoRef' &&
+    typeof subject.did === 'string'
+  ) {
+    if (blobs && blobs.length > 0) {
+      throw new InvalidRequestError('Blobs do not apply to repo subjects')
+    }
+    return new RepoSubject(subject.did)
+  }
+  if (
+    subject.$type === 'com.atproto.repo.strongRef' &&
+    typeof subject.uri === 'string' &&
+    typeof subject.cid === 'string'
+  ) {
+    return new RecordSubject(subject.uri, subject.cid, blobs)
+  }
+  throw new InvalidRequestError('Invalid subject')
+}
+
+export const subjectFromEventRow = (row: ModerationEventRow): ModSubject => {
+  if (
+    row.subjectType === 'com.atproto.repo.strongRef' &&
+    row.subjectUri &&
+    row.subjectCid
+  ) {
+    return new RecordSubject(row.subjectUri, row.subjectCid)
+  } else {
+    return new RepoSubject(row.subjectDid)
+  }
+}
+
+export const subjectFromStatusRow = (
+  row: ModerationSubjectStatusRow,
+): ModSubject => {
+  if (row.recordPath && row.recordCid) {
+    // Not too intuitive but the recordpath is basically <collection>/<rkey>
+    // which is what the last 2 params of .make() arguments are
+    const uri = AtUri.make(row.did, ...row.recordPath.split('/')).toString()
+    return new RecordSubject(uri.toString(), row.recordCid)
+  } else {
+    return new RepoSubject(row.did)
+  }
+}
+
+type SubjectInfo = {
+  subjectType: 'com.atproto.admin.defs#repoRef' | 'com.atproto.repo.strongRef'
+  subjectDid: string
+  subjectUri: string | null
+  subjectCid: string | null
+}
+
+export interface ModSubject {
+  did: string
+  recordPath: string | undefined
+  blobCids?: string[]
+  isRepo(): this is RepoSubject
+  isRecord(): this is RecordSubject
+  info(): SubjectInfo
+  lex(): RepoRef | StrongRef
+}
+
+export class RepoSubject implements ModSubject {
+  blobCids = undefined
+  recordPath = undefined
+  constructor(public did: string) {}
+  isRepo() {
+    return true
+  }
+  isRecord() {
+    return false
+  }
+  info() {
+    return {
+      subjectType: 'com.atproto.admin.defs#repoRef' as const,
+      subjectDid: this.did,
+      subjectUri: null,
+      subjectCid: null,
+    }
+  }
+  lex(): RepoRef {
+    return {
+      $type: 'com.atproto.admin.defs#repoRef',
+      did: this.did,
+    }
+  }
+}
+
+export class RecordSubject implements ModSubject {
+  parsedUri: AtUri
+  did: string
+  recordPath: string
+  constructor(
+    public uri: string,
+    public cid: string,
+    public blobCids?: string[],
+  ) {
+    this.parsedUri = new AtUri(uri)
+    this.did = this.parsedUri.hostname
+    this.recordPath = `${this.parsedUri.collection}/${this.parsedUri.rkey}`
+  }
+  isRepo() {
+    return false
+  }
+  isRecord() {
+    return true
+  }
+  info() {
+    return {
+      subjectType: 'com.atproto.repo.strongRef' as const,
+      subjectDid: this.did,
+      subjectUri: this.uri,
+      subjectCid: this.cid,
+    }
+  }
+  lex(): StrongRef {
+    return {
+      $type: 'com.atproto.repo.strongRef',
+      uri: this.uri,
+      cid: this.cid,
+    }
+  }
+}

package/src/mod-service/types.ts

@@ -0,0 +1,32 @@
+import { Selectable } from 'kysely'
+import { ModerationEvent } from '../db/schema/moderation_event'
+import { ModerationSubjectStatus } from '../db/schema/moderation_subject_status'
+import { ComAtprotoAdminDefs } from '@atproto/api'
+import { ModSubject } from './subject'
+
+export type ModerationEventRow = Selectable<ModerationEvent>
+export type ReversibleModerationEvent = Pick<
+  ModerationEventRow,
+  'createdBy' | 'comment' | 'action'
+> & {
+  createdAt?: Date
+  subject: ModSubject
+}
+
+export type ModerationEventRowWithHandle = ModerationEventRow & {
+  subjectHandle?: string | null
+  creatorHandle?: string | null
+}
+export type ModerationSubjectStatusRow = Selectable<ModerationSubjectStatus>
+export type ModerationSubjectStatusRowWithHandle =
+  ModerationSubjectStatusRow & { handle: string | null }
+
+export type ModEventType =
+  | ComAtprotoAdminDefs.ModEventTakedown
+  | ComAtprotoAdminDefs.ModEventAcknowledge
+  | ComAtprotoAdminDefs.ModEventEscalate
+  | ComAtprotoAdminDefs.ModEventComment
+  | ComAtprotoAdminDefs.ModEventLabel
+  | ComAtprotoAdminDefs.ModEventReport
+  | ComAtprotoAdminDefs.ModEventMute
+  | ComAtprotoAdminDefs.ModEventReverseTakedown