@atproto/bsky 0.0.21 → 0.0.22

package/src/lexicon/types/com/atproto/admin/queryModerationStatuses.ts

@@ -32,6 +32,8 @@ export interface QueryParams {
   sortDirection: 'asc' | 'desc'
   /** Get subjects that were taken down */
   takendown?: boolean
+  /** Get subjects in unresolved appealed status */
+  appealed?: boolean
   limit: number
   cursor?: string
 }

package/src/lexicon/types/com/atproto/admin/sendEmail.ts

@@ -15,6 +15,8 @@ export interface InputSchema {
   content: string
   subject?: string
   senderDid: string
+  /** Additional comment by the sender that won't be used in the email itself but helpful to provide more context for moderators/reviewers */
+  comment?: string
   [k: string]: unknown
 }
 

package/src/lexicon/types/com/atproto/moderation/defs.ts

@@ -13,6 +13,7 @@ export type ReasonType =
   | 'com.atproto.moderation.defs#reasonSexual'
   | 'com.atproto.moderation.defs#reasonRude'
   | 'com.atproto.moderation.defs#reasonOther'
+  | 'com.atproto.moderation.defs#reasonAppeal'
   | (string & {})
 
 /** Spam: frequent unwanted promotion, replies, mentions */
@@ -27,3 +28,5 @@ export const REASONSEXUAL = 'com.atproto.moderation.defs#reasonSexual'
 export const REASONRUDE = 'com.atproto.moderation.defs#reasonRude'
 /** Other: reports not falling under another report category */
 export const REASONOTHER = 'com.atproto.moderation.defs#reasonOther'
+/** Appeal: appeal a previously taken moderation action */
+export const REASONAPPEAL = 'com.atproto.moderation.defs#reasonAppeal'

package/src/services/feed/views.ts

@@ -132,8 +132,8 @@ export class FeedViews {
         lists,
         viewer,
       )
-      // skip over not found & blocked posts
-      if (!post || blocks[post.uri]?.reply) {
+      // skip over not found post
+      if (!post) {
         continue
       }
       const feedPost = { post }
@@ -159,6 +159,7 @@ export class FeedViews {
       ) {
         const replyParent = this.formatMaybePostView(
           item.replyParent,
+          item.uri,
           actors,
           posts,
           threadgates,
@@ -171,6 +172,7 @@ export class FeedViews {
         )
         const replyRoot = this.formatMaybePostView(
           item.replyRoot,
+          item.uri,
           actors,
           posts,
           threadgates,
@@ -291,6 +293,7 @@ export class FeedViews {
 
   formatMaybePostView(
     uri: string,
+    replyUri: string | null,
     actors: ActorInfoMap,
     posts: PostInfoMap,
     threadgates: ThreadgateInfoMap,
@@ -320,7 +323,7 @@ export class FeedViews {
     if (
       post.author.viewer?.blockedBy ||
       post.author.viewer?.blocking ||
-      blocks[uri]?.reply
+      (replyUri !== null && blocks[replyUri]?.reply)
     ) {
       if (!opts?.usePostViewUnion) return
       return this.blockedPost(post)

package/src/services/moderation/index.ts

@@ -539,6 +539,7 @@ export class ModerationService {
     cursor,
     limit = 50,
     takendown,
+    appealed,
     reviewState,
     reviewedAfter,
     reviewedBefore,
@@ -554,6 +555,7 @@ export class ModerationService {
     cursor?: string
     limit?: number
     takendown?: boolean
+    appealed?: boolean | null
     reviewedBefore?: string
     reviewState?: ModerationSubjectStatusRow['reviewState']
     reviewedAfter?: string
@@ -615,6 +617,13 @@ export class ModerationService {
       builder = builder.where('takendown', '=', true)
     }
 
+    if (appealed !== undefined) {
+      builder =
+        appealed === null
+          ? builder.where('appealed', 'is', null)
+          : builder.where('appealed', '=', appealed)
+    }
+
     if (!includeMuted) {
       builder = builder.where((qb) =>
         qb

package/src/services/moderation/status.ts

@@ -12,6 +12,7 @@ import { ModerationEventRow, ModerationSubjectStatusRow } from './types'
 import { HOUR } from '@atproto/common'
 import { CID } from 'multiformats/cid'
 import { sql } from 'kysely'
+import { REASONAPPEAL } from '../../lexicon/types/com/atproto/moderation/defs'
 
 const getSubjectStatusForModerationEvent = ({
   action,
@@ -82,6 +83,10 @@ const getSubjectStatusForModerationEvent = ({
         lastReviewedBy: createdBy,
         lastReviewedAt: createdAt,
       }
+    case 'com.atproto.admin.defs#modEventResolveAppeal':
+      return {
+        appealed: false,
+      }
     default:
       return null
   }
@@ -106,6 +111,10 @@ export const adjustModerationSubjectStatus = async (
     createdAt,
   } = moderationEvent
 
+  const isAppealEvent =
+    action === 'com.atproto.admin.defs#modEventReport' &&
+    meta?.reportType === REASONAPPEAL
+
   const subjectStatus = getSubjectStatusForModerationEvent({
     action,
     createdBy,
@@ -162,6 +171,21 @@ export const adjustModerationSubjectStatus = async (
     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

package/src/services/moderation/views.ts

@@ -485,9 +485,11 @@ export class ModerationViews {
       lastReviewedBy: subjectStatus.lastReviewedBy ?? undefined,
       lastReviewedAt: subjectStatus.lastReviewedAt ?? undefined,
       lastReportedAt: subjectStatus.lastReportedAt ?? undefined,
+      lastAppealedAt: subjectStatus.lastAppealedAt ?? undefined,
       muteUntil: subjectStatus.muteUntil ?? undefined,
       suspendUntil: subjectStatus.suspendUntil ?? undefined,
       takendown: subjectStatus.takendown ?? undefined,
+      appealed: subjectStatus.appealed ?? undefined,
       subjectRepoHandle: subjectStatus.handle ?? undefined,
       subjectBlobCids: subjectStatus.blobCids || [],
       subject: !subjectStatus.recordPath

package/tests/admin/moderation-appeals.test.ts

@@ -0,0 +1,269 @@
+import { TestNetwork, SeedClient } from '@atproto/dev-env'
+import AtpAgent, {
+  ComAtprotoAdminDefs,
+  ComAtprotoAdminEmitModerationEvent,
+  ComAtprotoAdminQueryModerationStatuses,
+} from '@atproto/api'
+import basicSeed from '../seeds/basic'
+import {
+  REASONMISLEADING,
+  REASONSPAM,
+} from '../../src/lexicon/types/com/atproto/moderation/defs'
+import {
+  REVIEWCLOSED,
+  REVIEWOPEN,
+} from '@atproto/api/src/client/types/com/atproto/admin/defs'
+import { REASONAPPEAL } from '@atproto/api/src/client/types/com/atproto/moderation/defs'
+import { REVIEWESCALATED } from '../../src/lexicon/types/com/atproto/admin/defs'
+
+describe('moderation-appeals', () => {
+  let network: TestNetwork
+  let agent: AtpAgent
+  let pdsAgent: AtpAgent
+  let sc: SeedClient
+
+  const emitModerationEvent = async (
+    eventData: ComAtprotoAdminEmitModerationEvent.InputSchema,
+  ) => {
+    return pdsAgent.api.com.atproto.admin.emitModerationEvent(eventData, {
+      encoding: 'application/json',
+      headers: network.bsky.adminAuthHeaders('moderator'),
+    })
+  }
+
+  const queryModerationStatuses = (
+    statusQuery: ComAtprotoAdminQueryModerationStatuses.QueryParams,
+  ) =>
+    agent.api.com.atproto.admin.queryModerationStatuses(statusQuery, {
+      headers: network.bsky.adminAuthHeaders('moderator'),
+    })
+
+  beforeAll(async () => {
+    network = await TestNetwork.create({
+      dbPostgresSchema: 'bsky_moderation_statuses',
+    })
+    agent = network.bsky.getClient()
+    pdsAgent = network.pds.getClient()
+    sc = network.getSeedClient()
+    await basicSeed(sc)
+    await network.processAll()
+  })
+
+  afterAll(async () => {
+    await network.close()
+  })
+
+  const assertSubjectStatus = async (
+    subject: string,
+    status: string,
+    appealed: boolean | undefined,
+  ): Promise<ComAtprotoAdminDefs.SubjectStatusView | undefined> => {
+    const { data } = await queryModerationStatuses({
+      subject,
+    })
+    expect(data.subjectStatuses[0]?.reviewState).toEqual(status)
+    expect(data.subjectStatuses[0]?.appealed).toEqual(appealed)
+    return data.subjectStatuses[0]
+  }
+  describe('appeals from users', () => {
+    const getBobsPostSubject = () => ({
+      $type: 'com.atproto.repo.strongRef',
+      uri: sc.posts[sc.dids.bob][1].ref.uriStr,
+      cid: sc.posts[sc.dids.bob][1].ref.cidStr,
+    })
+    const getCarolPostSubject = () => ({
+      $type: 'com.atproto.repo.strongRef',
+      uri: sc.posts[sc.dids.carol][0].ref.uriStr,
+      cid: sc.posts[sc.dids.carol][0].ref.cidStr,
+    })
+    const assertBobsPostStatus = async (
+      status: string,
+      appealed: boolean | undefined,
+    ) => assertSubjectStatus(getBobsPostSubject().uri, status, appealed)
+
+    it('only changes subject status if original author of the content or a moderator is appealing', async () => {
+      // Create a report by alice
+      await emitModerationEvent({
+        event: {
+          $type: 'com.atproto.admin.defs#modEventReport',
+          reportType: REASONMISLEADING,
+        },
+        subject: getBobsPostSubject(),
+        createdBy: sc.dids.alice,
+      })
+
+      await assertBobsPostStatus(REVIEWOPEN, undefined)
+
+      // Create a report as normal user with appeal type
+      expect(
+        sc.createReport({
+          reportedBy: sc.dids.carol,
+          reasonType: REASONAPPEAL,
+          reason: 'appealing',
+          subject: getBobsPostSubject(),
+        }),
+      ).rejects.toThrow('You cannot appeal this report')
+
+      // Verify that the appeal status did not change
+      await assertBobsPostStatus(REVIEWOPEN, undefined)
+
+      // Emit report event as moderator
+      await emitModerationEvent({
+        event: {
+          $type: 'com.atproto.admin.defs#modEventReport',
+          reportType: REASONAPPEAL,
+        },
+        subject: getBobsPostSubject(),
+        createdBy: sc.dids.alice,
+      })
+
+      // Verify that appeal status changed when appeal report was emitted by moderator
+      const status = await assertBobsPostStatus(REVIEWOPEN, true)
+      expect(status?.appealedAt).not.toBeNull()
+
+      // Create a report as normal user for carol's post
+      await sc.createReport({
+        reportedBy: sc.dids.alice,
+        reasonType: REASONMISLEADING,
+        reason: 'lies!',
+        subject: getCarolPostSubject(),
+      })
+
+      // Verify that the appeal status on carol's post is undefined
+      await assertSubjectStatus(
+        getCarolPostSubject().uri,
+        REVIEWOPEN,
+        undefined,
+      )
+
+      await sc.createReport({
+        reportedBy: sc.dids.carol,
+        reasonType: REASONAPPEAL,
+        reason: 'appealing',
+        subject: getCarolPostSubject(),
+      })
+      // Verify that the appeal status on carol's post is true
+      await assertSubjectStatus(getCarolPostSubject().uri, REVIEWOPEN, true)
+    })
+    it('allows multiple appeals and updates last appealed timestamp', async () => {
+      // Resolve appeal with acknowledge
+      await emitModerationEvent({
+        event: {
+          $type: 'com.atproto.admin.defs#modEventResolveAppeal',
+        },
+        subject: getBobsPostSubject(),
+        createdBy: sc.dids.carol,
+      })
+
+      const previousStatus = await assertBobsPostStatus(REVIEWOPEN, false)
+
+      await emitModerationEvent({
+        event: {
+          $type: 'com.atproto.admin.defs#modEventReport',
+          reportType: REASONAPPEAL,
+        },
+        subject: getBobsPostSubject(),
+        createdBy: sc.dids.bob,
+      })
+
+      // Verify that even after the appeal event by bob for his post, the appeal status is true again with new timestamp
+      const newStatus = await assertBobsPostStatus(REVIEWOPEN, true)
+      expect(
+        new Date(`${previousStatus?.lastAppealedAt}`).getTime(),
+      ).toBeLessThan(new Date(`${newStatus?.lastAppealedAt}`).getTime())
+    })
+  })
+
+  describe('appeal resolution', () => {
+    const getAlicesPostSubject = () => ({
+      $type: 'com.atproto.repo.strongRef',
+      uri: sc.posts[sc.dids.alice][1].ref.uriStr,
+      cid: sc.posts[sc.dids.alice][1].ref.cidStr,
+    })
+    it('appeal status is maintained while review state changes based on incoming events', async () => {
+      // Bob reports alice's post
+      await emitModerationEvent({
+        event: {
+          $type: 'com.atproto.admin.defs#modEventReport',
+          reportType: REASONMISLEADING,
+        },
+        subject: getAlicesPostSubject(),
+        createdBy: sc.dids.bob,
+      })
+
+      // Moderator acknowledges the report, assume a label was applied too
+      await emitModerationEvent({
+        event: {
+          $type: 'com.atproto.admin.defs#modEventAcknowledge',
+        },
+        subject: getAlicesPostSubject(),
+        createdBy: sc.dids.carol,
+      })
+
+      // Alice appeals the report
+      await emitModerationEvent({
+        event: {
+          $type: 'com.atproto.admin.defs#modEventReport',
+          reportType: REASONAPPEAL,
+        },
+        subject: getAlicesPostSubject(),
+        createdBy: sc.dids.alice,
+      })
+
+      await assertSubjectStatus(getAlicesPostSubject().uri, REVIEWOPEN, true)
+
+      // Bob reports it again
+      await emitModerationEvent({
+        event: {
+          $type: 'com.atproto.admin.defs#modEventReport',
+          reportType: REASONSPAM,
+        },
+        subject: getAlicesPostSubject(),
+        createdBy: sc.dids.bob,
+      })
+
+      // Assert that the status is still REVIEWOPEN, as report events are meant to do
+      await assertSubjectStatus(getAlicesPostSubject().uri, REVIEWOPEN, true)
+
+      // Emit an escalation event
+      await emitModerationEvent({
+        event: {
+          $type: 'com.atproto.admin.defs#modEventEscalate',
+        },
+        subject: getAlicesPostSubject(),
+        createdBy: sc.dids.carol,
+      })
+
+      await assertSubjectStatus(
+        getAlicesPostSubject().uri,
+        REVIEWESCALATED,
+        true,
+      )
+
+      // Emit an acknowledge event
+      await emitModerationEvent({
+        event: {
+          $type: 'com.atproto.admin.defs#modEventAcknowledge',
+        },
+        subject: getAlicesPostSubject(),
+        createdBy: sc.dids.carol,
+      })
+
+      // Assert that status moved on to reviewClosed while appealed status is still true
+      await assertSubjectStatus(getAlicesPostSubject().uri, REVIEWCLOSED, true)
+
+      // Emit a resolveAppeal event
+      await emitModerationEvent({
+        event: {
+          $type: 'com.atproto.admin.defs#modEventResolveAppeal',
+          comment: 'lgtm',
+        },
+        subject: getAlicesPostSubject(),
+        createdBy: sc.dids.carol,
+      })
+
+      // Assert that status stayed the same while appealed status is still true
+      await assertSubjectStatus(getAlicesPostSubject().uri, REVIEWCLOSED, false)
+    })
+  })
+})

package/tests/auto-moderator/labeler.test.ts

@@ -9,6 +9,8 @@ import { LabelService } from '../../src/services/label'
 import usersSeed from '../seeds/users'
 import { CID } from 'multiformats/cid'
 import { ImgLabeler } from '../../src/auto-moderator/hive'
+import { ModerationService } from '../../src/services/moderation'
+import { ImageInvalidator } from '../../src/image/invalidator'
 
 // outside of test suite so that TestLabeler can access them
 let badCid1: CID | undefined = undefined
@@ -75,6 +77,10 @@ describe('labeler', () => {
   })
 
   it('labels text in posts', async () => {
+    autoMod.services.moderation = ModerationService.creator(
+      new NoopImageUriBuilder(''),
+      new NoopInvalidator(),
+    )
     const post = {
       $type: 'app.bsky.feed.post',
       text: 'blah blah label_me',
@@ -93,6 +99,28 @@ describe('labeler', () => {
       val: 'test-label',
       neg: false,
     })
+
+    // Verify that along with applying the labels, we are also leaving trace of the label as moderation event
+    // Temporarily assign an instance of moderation service to the autoMod so that we can validate label event
+    const modSrvc = autoMod.services.moderation(ctx.db)
+    const { events } = await modSrvc.getEvents({
+      includeAllUserRecords: false,
+      subject: uri.toString(),
+      limit: 10,
+      types: [],
+    })
+    expect(events.length).toBe(1)
+    expect(events[0]).toMatchObject({
+      action: 'com.atproto.admin.defs#modEventLabel',
+      subjectUri: uri.toString(),
+      createLabelVals: 'test-label',
+      negateLabelVals: null,
+      comment: `[AutoModerator]: Applying labels`,
+      createdBy: labelerDid,
+    })
+
+    // Cleanup the temporary assignment, knowing that by default, moderation service is not available
+    autoMod.services.moderation = undefined
   })
 
   it('labels embeds in posts', async () => {
@@ -165,3 +193,14 @@ class TestImgLabeler implements ImgLabeler {
     return []
   }
 }
+
+class NoopInvalidator implements ImageInvalidator {
+  async invalidate() {}
+}
+class NoopImageUriBuilder {
+  constructor(public endpoint: string) {}
+
+  getPresetUri() {
+    return ''
+  }
+}

package/tests/views/blocks.test.ts

@@ -112,6 +112,18 @@ describe('pds views with blocking', () => {
     expect(forSnapshot(thread)).toMatchSnapshot()
   })
 
+  it('loads blocked reply as anchor with no parent', async () => {
+    const { data: thread } = await agent.api.app.bsky.feed.getPostThread(
+      { depth: 1, uri: carolReplyToDan.ref.uriStr },
+      { headers: await network.serviceHeaders(alice) },
+    )
+    if (!isThreadViewPost(thread.thread)) {
+      throw new Error('Expected thread view post')
+    }
+    expect(thread.thread.post.uri).toEqual(carolReplyToDan.ref.uriStr)
+    expect(thread.thread.parent).toBeUndefined()
+  })
+
   it('blocks thread parent', async () => {
     // Parent is a post by dan
     const { data: thread } = await agent.api.app.bsky.feed.getPostThread(
@@ -498,7 +510,8 @@ describe('pds views with blocking', () => {
     const replyBlockedPost = timeline.feed.find(
       (item) => item.post.uri === replyBlockedUri,
     )
-    expect(replyBlockedPost).toBeUndefined()
+    assert(replyBlockedPost)
+    expect(replyBlockedPost.reply?.parent).toBeUndefined()
     const embedBlockedPost = timeline.feed.find(
       (item) => item.post.uri === embedBlockedUri,
     )

package/tests/views/timeline.test.ts

@@ -154,6 +154,20 @@ describe('timeline views', () => {
     expect(results(paginatedAll)).toEqual(results([full.data]))
   })
 
+  it('agrees what the first item is for limit=1 and other limits', async () => {
+    const { data: timeline } = await agent.api.app.bsky.feed.getTimeline(
+      { limit: 10 },
+      { headers: await network.serviceHeaders(alice) },
+    )
+    const { data: timelineLimit1 } = await agent.api.app.bsky.feed.getTimeline(
+      { limit: 1 },
+      { headers: await network.serviceHeaders(alice) },
+    )
+    expect(timeline.feed.length).toBeGreaterThan(1)
+    expect(timelineLimit1.feed.length).toEqual(1)
+    expect(timelineLimit1.feed[0].post.uri).toBe(timeline.feed[0].post.uri)
+  })
+
   it('reflects self-labels', async () => {
     const carolTL = await agent.api.app.bsky.feed.getTimeline(
       {},