@atproto/bsky 0.0.15 → 0.0.16

package/src/services/moderation/pagination.ts

@@ -0,0 +1,96 @@
+import { InvalidRequestError } from '@atproto/xrpc-server'
+import { DynamicModule, sql } from 'kysely'
+
+import { Cursor, GenericKeyset } from '../../db/pagination'
+
+type StatusKeysetParam = {
+  lastReviewedAt: string | null
+  lastReportedAt: string | null
+  id: number
+}
+
+export class StatusKeyset extends GenericKeyset<StatusKeysetParam, Cursor> {
+  labelResult(result: StatusKeysetParam): Cursor
+  labelResult(result: StatusKeysetParam) {
+    const primaryField = (
+      this.primary as ReturnType<DynamicModule['ref']>
+    ).dynamicReference.includes('lastReviewedAt')
+      ? 'lastReviewedAt'
+      : 'lastReportedAt'
+
+    return {
+      primary: result[primaryField]
+        ? new Date(`${result[primaryField]}`).getTime().toString()
+        : '',
+      secondary: result.id.toString(),
+    }
+  }
+  labeledResultToCursor(labeled: Cursor) {
+    return {
+      primary: labeled.primary,
+      secondary: labeled.secondary,
+    }
+  }
+  cursorToLabeledResult(cursor: Cursor) {
+    return {
+      primary: cursor.primary
+        ? new Date(parseInt(cursor.primary, 10)).toISOString()
+        : '',
+      secondary: cursor.secondary,
+    }
+  }
+  unpackCursor(cursorStr?: string): Cursor | undefined {
+    if (!cursorStr) return
+    const result = cursorStr.split('::')
+    const [primary, secondary, ...others] = result
+    if (!secondary || others.length > 0) {
+      throw new InvalidRequestError('Malformed cursor')
+    }
+    return {
+      primary,
+      secondary,
+    }
+  }
+  // This is specifically built to handle nullable columns as primary sorting column
+  getSql(labeled?: Cursor, direction?: 'asc' | 'desc') {
+    if (labeled === undefined) return
+    if (direction === 'asc') {
+      return !labeled.primary
+        ? sql`(${this.primary} IS NULL AND ${this.secondary} > ${labeled.secondary})`
+        : sql`((${this.primary}, ${this.secondary}) > (${labeled.primary}, ${labeled.secondary}) OR (${this.primary} is null))`
+    } else {
+      return !labeled.primary
+        ? sql`(${this.primary} IS NULL AND ${this.secondary} < ${labeled.secondary})`
+        : sql`((${this.primary}, ${this.secondary}) < (${labeled.primary}, ${labeled.secondary}) OR (${this.primary} is null))`
+    }
+  }
+}
+
+type TimeIdKeysetParam = {
+  id: number
+  createdAt: string
+}
+type TimeIdResult = TimeIdKeysetParam
+
+export class TimeIdKeyset extends GenericKeyset<TimeIdKeysetParam, Cursor> {
+  labelResult(result: TimeIdResult): Cursor
+  labelResult(result: TimeIdResult) {
+    return { primary: result.createdAt, secondary: result.id.toString() }
+  }
+  labeledResultToCursor(labeled: Cursor) {
+    return {
+      primary: new Date(labeled.primary).getTime().toString(),
+      secondary: labeled.secondary,
+    }
+  }
+  cursorToLabeledResult(cursor: Cursor) {
+    const primaryDate = new Date(parseInt(cursor.primary, 10))
+    if (isNaN(primaryDate.getTime())) {
+      throw new InvalidRequestError('Malformed cursor')
+    }
+    return {
+      primary: primaryDate.toISOString(),
+      secondary: cursor.secondary,
+    }
+  }
+}

package/src/services/moderation/status.ts

@@ -0,0 +1,244 @@
+// This may require better organization but for now, just dumping functions here containing DB queries for moderation status
+
+import { AtUri } from '@atproto/syntax'
+import { PrimaryDatabase } from '../../db'
+import {
+  ModerationEvent,
+  ModerationSubjectStatus,
+} from '../../db/tables/moderation'
+import {
+  REVIEWOPEN,
+  REVIEWCLOSED,
+  REVIEWESCALATED,
+} from '../../lexicon/types/com/atproto/admin/defs'
+import { ModerationEventRow, ModerationSubjectStatusRow } from './types'
+import { HOUR } from '@atproto/common'
+import { CID } from 'multiformats/cid'
+import { sql } from 'kysely'
+
+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,
+      }
+    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: PrimaryDatabase,
+  moderationEvent: ModerationEventRow,
+  blobCids?: CID[],
+) => {
+  const {
+    action,
+    subjectDid,
+    subjectUri,
+    subjectCid,
+    createdBy,
+    meta,
+    comment,
+    createdAt,
+  } = moderationEvent
+
+  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 (action === 'com.atproto.admin.defs#modEventComment' && meta?.sticky) {
+    newStatus.comment = comment
+    subjectStatus.comment = comment
+  }
+
+  if (blobCids?.length) {
+    const newBlobCids = sql<string[]>`${JSON.stringify(
+      blobCids.map((c) => c.toString()),
+    )}` 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: PrimaryDatabase,
+  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/services/moderation/types.ts

@@ -0,0 +1,49 @@
+import { Selectable } from 'kysely'
+import {
+  ModerationEvent,
+  ModerationSubjectStatus,
+} from '../../db/tables/moderation'
+import { AtUri } from '@atproto/syntax'
+import { CID } from 'multiformats/cid'
+import { ComAtprotoAdminDefs } from '@atproto/api'
+
+export type SubjectInfo =
+  | {
+      subjectType: 'com.atproto.admin.defs#repoRef'
+      subjectDid: string
+      subjectUri: null
+      subjectCid: null
+    }
+  | {
+      subjectType: 'com.atproto.repo.strongRef'
+      subjectDid: string
+      subjectUri: string
+      subjectCid: string
+    }
+
+export type ModerationEventRow = Selectable<ModerationEvent>
+export type ReversibleModerationEvent = Pick<
+  ModerationEventRow,
+  'createdBy' | 'comment' | 'action'
+> & {
+  createdAt?: Date
+  subject: { did: string } | { uri: AtUri; cid: CID }
+}
+
+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