@atproto/ozone 0.1.57 → 0.1.58

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/ozone",
-  "version": "0.1.57",
+  "version": "0.1.58",
   "license": "MIT",
   "description": "Backend service for moderating the Bluesky network.",
   "keywords": [
@@ -32,7 +32,7 @@
     "structured-headers": "^1.0.1",
     "typed-emitter": "^2.1.0",
     "uint8arrays": "3.0.0",
-    "@atproto/api": "^0.13.18",
+    "@atproto/api": "^0.13.19",
     "@atproto/common": "^0.4.4",
     "@atproto/crypto": "^0.4.2",
     "@atproto/identity": "^0.4.3",
@@ -53,7 +53,7 @@
     "ts-node": "^10.8.2",
     "typescript": "^5.6.3",
     "@atproto/lex-cli": "^0.5.2",
-    "@atproto/pds": "^0.4.73"
+    "@atproto/pds": "^0.4.75"
   },
   "scripts": {
     "codegen": "lex gen-server --yes ./src/lexicon ../../lexicons/com/atproto/*/* ../../lexicons/app/bsky/*/* ../../lexicons/chat/bsky/*/* ../../lexicons/tools/ozone/*/*",

package/src/api/moderation/emitEvent.ts

@@ -2,6 +2,7 @@ import { AuthRequiredError, InvalidRequestError } from '@atproto/xrpc-server'
 import { Server } from '../../lexicon'
 import AppContext from '../../context'
 import {
+  isModEventAcknowledge,
   isModEventDivert,
   isModEventEmail,
   isModEventLabel,
@@ -39,6 +40,7 @@ const handleModerationEvent = async ({
   const moderationService = ctx.modService(db)
   const settingService = ctx.settingService(db)
   const { event } = input.body
+  const isAcknowledgeEvent = isModEventAcknowledge(event)
   const isTakedownEvent = isModEventTakedown(event)
   const isReverseTakedownEvent = isModEventReverseTakedown(event)
   const isLabelEvent = isModEventLabel(event)
@@ -219,8 +221,15 @@ const handleModerationEvent = async ({
       }
     }
 
-    if (isTakedownEvent && result.event.meta?.acknowledgeAccountSubjects) {
-      await moderationTxn.resolveSubjectsForAccount(subject.did, createdBy)
+    if (
+      (isTakedownEvent || isAcknowledgeEvent) &&
+      result.event.meta?.acknowledgeAccountSubjects
+    ) {
+      await moderationTxn.resolveSubjectsForAccount(
+        subject.did,
+        createdBy,
+        result.event,
+      )
     }
 
     if (isLabelEvent) {

package/src/lexicon/lexicons.ts

@@ -11310,6 +11310,11 @@ export const schemaDict = {
           comment: {
             type: 'string',
           },
+          acknowledgeAccountSubjects: {
+            type: 'boolean',
+            description:
+              'If true, all other reports on content authored by this account will be resolved (acknowledged).',
+          },
         },
       },
       modEventEscalate: {
@@ -12218,7 +12223,7 @@ export const schemaDict = {
             comment: {
               type: 'string',
               description:
-                'If specified, only events with comments containing the keyword are returned',
+                'If specified, only events with comments containing the keyword are returned. Apply || separator to use multiple keywords and match using OR condition.',
             },
             addedLabels: {
               type: 'array',
@@ -13489,8 +13494,9 @@ export const schemaDict = {
       },
     },
   },
-}
-export const schemas: LexiconDoc[] = Object.values(schemaDict) as LexiconDoc[]
+} as const satisfies Record<string, LexiconDoc>
+
+export const schemas = Object.values(schemaDict)
 export const lexicons: Lexicons = new Lexicons(schemas)
 export const ids = {
   ComAtprotoAdminDefs: 'com.atproto.admin.defs',

package/src/lexicon/types/tools/ozone/moderation/defs.ts

@@ -300,6 +300,8 @@ export function validateModEventLabel(v: unknown): ValidationResult {
 
 export interface ModEventAcknowledge {
   comment?: string
+  /** If true, all other reports on content authored by this account will be resolved (acknowledged). */
+  acknowledgeAccountSubjects?: boolean
   [k: string]: unknown
 }
 

package/src/lexicon/types/tools/ozone/moderation/queryEvents.ts

@@ -29,7 +29,7 @@ export interface QueryParams {
   limit: number
   /** If true, only events with comments are returned */
   hasComment?: boolean
-  /** If specified, only events with comments containing the keyword are returned */
+  /** If specified, only events with comments containing the keyword are returned. Apply || separator to use multiple keywords and match using OR condition. */
   comment?: string
   /** If specified, only events where all of these labels were added are returned */
   addedLabels?: string[]

package/src/mod-service/index.ts

@@ -23,6 +23,7 @@ import {
   isRecordEvent,
   REVIEWESCALATED,
   REVIEWOPEN,
+  isModEventAcknowledge,
 } from '../lexicon/types/tools/ozone/moderation/defs'
 import { RepoRef, RepoBlobRef } from '../lexicon/types/com/atproto/admin/defs'
 import {
@@ -222,8 +223,20 @@ export class ModerationService {
     if (createdBefore) {
       builder = builder.where('createdAt', '<=', createdBefore)
     }
+
     if (comment) {
-      builder = builder.where('comment', 'ilike', `%${comment}%`)
+      // the input may end in || in which case, there may be item in the array which is just '' and we want to ignore those
+      const keywords = comment.split('||').filter((keyword) => !!keyword.trim())
+      if (keywords.length > 1) {
+        builder = builder.where((qb) => {
+          keywords.forEach((keyword) => {
+            qb = qb.orWhere('comment', 'ilike', `%${keyword}%`)
+          })
+          return qb
+        })
+      } else if (keywords.length === 1) {
+        builder = builder.where('comment', 'ilike', `%${keywords[0]}%`)
+      }
     }
     if (hasComment) {
       builder = builder.where('comment', 'is not', null)
@@ -302,7 +315,11 @@ export class ModerationService {
     return await builder.execute()
   }
 
-  async resolveSubjectsForAccount(did: string, createdBy: string) {
+  async resolveSubjectsForAccount(
+    did: string,
+    createdBy: string,
+    accountEvent: ModerationEventRow,
+  ) {
     const subjectsToBeResolved = await this.db.db
       .selectFrom('moderation_subject_status')
       .where('did', '=', did)
@@ -315,6 +332,10 @@ export class ModerationService {
       return
     }
 
+    let accountEventInfo = `Account Event ID: ${accountEvent.id}`
+    if (accountEvent.comment) {
+      accountEventInfo += ` | Account Event Comment: ${accountEvent.comment}`
+    }
     // Process subjects in chunks of 100 since each of these will trigger multiple db queries
     for (const subjects of chunkArray(subjectsToBeResolved, 100)) {
       await Promise.all(
@@ -323,13 +344,13 @@ export class ModerationService {
             createdBy,
             subject: subjectFromStatusRow(subject),
           }
+
           // For consistency's sake, when acknowledging appealed subjects, we should first resolve the appeal
           if (subject.appealed) {
             await this.logEvent({
               event: {
                 $type: 'tools.ozone.moderation.defs#modEventResolveAppeal',
-                comment:
-                  '[AUTO_RESOLVE_FOR_TAKENDOWN_ACCOUNT]: Automatically resolving all appealed content for a takendown account',
+                comment: `[AUTO_RESOLVE_ON_ACCOUNT_ACTION]: Automatically resolving all appealed content due to account level action | ${accountEventInfo}`,
               },
               ...eventData,
             })
@@ -338,8 +359,7 @@ export class ModerationService {
           await this.logEvent({
             event: {
               $type: 'tools.ozone.moderation.defs#modEventAcknowledge',
-              comment:
-                '[AUTO_RESOLVE_FOR_TAKENDOWN_ACCOUNT]: Automatically resolving all reported content for a takendown account',
+              comment: `[AUTO_RESOLVE_ON_ACCOUNT_ACTION]: Automatically resolving all reported content due to account level action | ${accountEventInfo}`,
             },
             ...eventData,
           })
@@ -408,7 +428,10 @@ export class ModerationService {
       if (event.cid) meta.cid = event.cid
     }
 
-    if (isModEventTakedown(event) && event.acknowledgeAccountSubjects) {
+    if (
+      (isModEventTakedown(event) || isModEventAcknowledge(event)) &&
+      event.acknowledgeAccountSubjects
+    ) {
       meta.acknowledgeAccountSubjects = true
     }
 

package/src/mod-service/views.ts

@@ -127,12 +127,13 @@ export class ModerationViews {
     }
 
     if (
-      event.action === 'tools.ozone.moderation.defs#modEventTakedown' &&
+      (event.action === 'tools.ozone.moderation.defs#modEventTakedown' ||
+        event.action === 'tools.ozone.moderation.defs#modEventAcknowledge') &&
       event.meta?.acknowledgeAccountSubjects
     ) {
       eventView.event = {
         ...eventView.event,
-        acknowledgeAccountSubjects: event.meta?.acknowledgeAccountSubjects,
+        acknowledgeAccountSubjects: event.meta.acknowledgeAccountSubjects,
       }
     }
 

package/tests/__snapshots__/moderation-events.test.ts.snap

@@ -197,3 +197,126 @@ Array [
   },
 ]
 `;
+
+exports[`moderation-events query events returns events matching multiple keywords in comment 1`] = `
+Array [
+  Object {
+    "createdAt": "1970-01-01T00:00:00.000Z",
+    "createdBy": "user(1)",
+    "creatorHandle": "bob.test",
+    "event": Object {
+      "$type": "tools.ozone.moderation.defs#modEventReport",
+      "comment": "rainy days feel lazy",
+      "isReporterMuted": false,
+      "reportType": "com.atproto.moderation.defs#reasonSpam",
+    },
+    "id": 16,
+    "subject": Object {
+      "$type": "com.atproto.admin.defs#repoRef",
+      "did": "user(0)",
+    },
+    "subjectBlobCids": Array [],
+    "subjectHandle": "alice.test",
+  },
+  Object {
+    "createdAt": "1970-01-01T00:00:00.000Z",
+    "createdBy": "user(1)",
+    "creatorHandle": "bob.test",
+    "event": Object {
+      "$type": "tools.ozone.moderation.defs#modEventReport",
+      "comment": "november rain",
+      "isReporterMuted": false,
+      "reportType": "com.atproto.moderation.defs#reasonSpam",
+    },
+    "id": 15,
+    "subject": Object {
+      "$type": "com.atproto.admin.defs#repoRef",
+      "did": "user(0)",
+    },
+    "subjectBlobCids": Array [],
+    "subjectHandle": "alice.test",
+  },
+]
+`;
+
+exports[`moderation-events query events returns events matching multiple keywords in comment 2`] = `
+Array [
+  Object {
+    "createdAt": "1970-01-01T00:00:00.000Z",
+    "createdBy": "user(1)",
+    "creatorHandle": "bob.test",
+    "event": Object {
+      "$type": "tools.ozone.moderation.defs#modEventReport",
+      "comment": "rainy days feel lazy",
+      "isReporterMuted": false,
+      "reportType": "com.atproto.moderation.defs#reasonSpam",
+    },
+    "id": 16,
+    "subject": Object {
+      "$type": "com.atproto.admin.defs#repoRef",
+      "did": "user(0)",
+    },
+    "subjectBlobCids": Array [],
+    "subjectHandle": "alice.test",
+  },
+  Object {
+    "createdAt": "1970-01-01T00:00:00.000Z",
+    "createdBy": "user(1)",
+    "creatorHandle": "bob.test",
+    "event": Object {
+      "$type": "tools.ozone.moderation.defs#modEventReport",
+      "comment": "november rain",
+      "isReporterMuted": false,
+      "reportType": "com.atproto.moderation.defs#reasonSpam",
+    },
+    "id": 15,
+    "subject": Object {
+      "$type": "com.atproto.admin.defs#repoRef",
+      "did": "user(0)",
+    },
+    "subjectBlobCids": Array [],
+    "subjectHandle": "alice.test",
+  },
+]
+`;
+
+exports[`moderation-events query events returns events matching multiple keywords in comment 3`] = `
+Array [
+  Object {
+    "createdAt": "1970-01-01T00:00:00.000Z",
+    "createdBy": "user(1)",
+    "creatorHandle": "bob.test",
+    "event": Object {
+      "$type": "tools.ozone.moderation.defs#modEventReport",
+      "comment": "rainy days feel lazy",
+      "isReporterMuted": false,
+      "reportType": "com.atproto.moderation.defs#reasonSpam",
+    },
+    "id": 16,
+    "subject": Object {
+      "$type": "com.atproto.admin.defs#repoRef",
+      "did": "user(0)",
+    },
+    "subjectBlobCids": Array [],
+    "subjectHandle": "alice.test",
+  },
+  Object {
+    "createdAt": "1970-01-01T00:00:00.000Z",
+    "createdBy": "user(1)",
+    "creatorHandle": "bob.test",
+    "event": Object {
+      "$type": "tools.ozone.moderation.defs#modEventReport",
+      "comment": "november rain",
+      "isReporterMuted": false,
+      "reportType": "com.atproto.moderation.defs#reasonSpam",
+    },
+    "id": 15,
+    "subject": Object {
+      "$type": "com.atproto.admin.defs#repoRef",
+      "did": "user(0)",
+    },
+    "subjectBlobCids": Array [],
+    "subjectHandle": "alice.test",
+  },
+]
+`;

package/tests/ack-all-subjects-of-account.test.ts

@@ -35,28 +35,28 @@ describe('moderation', () => {
     cid: ref.cidStr,
   })
 
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'ozone_ack_all_subjects_of_account',
+  const getReviewStateBySubject = (subjects: SubjectStatusView[]) => {
+    const states = new Map<string, SubjectStatusView>()
+
+    subjects.forEach((item) => {
+      if (ComAtprotoRepoStrongRef.isMain(item.subject)) {
+        states.set(item.subject.uri, item)
+      } else if (isRepoRef(item.subject)) {
+        states.set(item.subject.did, item)
+      }
     })
-    sc = network.getSeedClient()
-    modClient = network.ozone.getModClient()
-    await basicSeed(sc)
-    await network.processAll()
-  })
 
-  afterAll(async () => {
-    await network.close()
-  })
+    return states
+  }
 
-  it('acknowledges all open/escalated review subjects.', async () => {
-    const postOne = sc.posts[sc.dids.bob][0].ref
-    const postTwo = sc.posts[sc.dids.bob][1].ref
+  const reportUserAndPost = async (did: string) => {
+    const postOne = sc.posts[did][0].ref
+    const postTwo = sc.posts[did][1].ref
     await Promise.all([
       sc.createReport({
         reasonType: REASONSPAM,
-        subject: repoSubject(sc.dids.bob),
-        reportedBy: sc.dids.alice,
+        subject: repoSubject(did),
+        reportedBy: sc.dids.carol,
       }),
       sc.createReport({
         reasonType: REASONOTHER,
@@ -71,7 +71,6 @@ describe('moderation', () => {
         reportedBy: sc.dids.carol,
       }),
     ])
-
     await modClient.emitEvent({
       event: {
         $type: 'tools.ozone.moderation.defs#modEventReport',
@@ -80,6 +79,26 @@ describe('moderation', () => {
       subject: recordSubject(postTwo),
     })
 
+    return { postOne, postTwo }
+  }
+
+  beforeAll(async () => {
+    network = await TestNetwork.create({
+      dbPostgresSchema: 'ozone_ack_all_subjects_of_account',
+    })
+    sc = network.getSeedClient()
+    modClient = network.ozone.getModClient()
+    await basicSeed(sc)
+    await network.processAll()
+  })
+
+  afterAll(async () => {
+    await network.close()
+  })
+
+  it('acknowledges all open/escalated review subjects with takedown.', async () => {
+    const { postOne, postTwo } = await reportUserAndPost(sc.dids.bob)
+
     const { subjectStatuses: statusesBefore } = await modClient.queryStatuses({
       subject: sc.dids.bob,
       includeAllUserRecords: true,
@@ -95,19 +114,46 @@ describe('moderation', () => {
       includeAllUserRecords: true,
     })
 
-    const getReviewStateBySubject = (subjects: SubjectStatusView[]) => {
-      const states = new Map<string, SubjectStatusView>()
+    const reviewStatesBefore = getReviewStateBySubject(statusesBefore)
+    const reviewStatesAfter = getReviewStateBySubject(statusesAfter)
+
+    // Check that review states before were different for different subjects
+    expect(reviewStatesBefore.get(postOne.uriStr)?.reviewState).toBe(REVIEWOPEN)
+    expect(reviewStatesBefore.get(postTwo.uriStr)?.reviewState).toBe(
+      REVIEWESCALATED,
+    )
+    expect(reviewStatesBefore.get(sc.dids.bob)?.reviewState).toBe(REVIEWOPEN)
 
-      subjects.forEach((item) => {
-        if (ComAtprotoRepoStrongRef.isMain(item.subject)) {
-          states.set(item.subject.uri, item)
-        } else if (isRepoRef(item.subject)) {
-          states.set(item.subject.did, item)
-        }
-      })
+    // Check that review states after are all closed
+    expect(reviewStatesAfter.get(postOne.uriStr)?.reviewState).toBe(
+      REVIEWCLOSED,
+    )
+    expect(reviewStatesAfter.get(postTwo.uriStr)?.reviewState).toBe(
+      REVIEWCLOSED,
+    )
+    expect(reviewStatesAfter.get(sc.dids.bob)?.reviewState).toBe(REVIEWCLOSED)
+  })
 
-      return states
-    }
+  it('acknowledges all open/escalated review subjects with acknowledge.', async () => {
+    const { postOne, postTwo } = await reportUserAndPost(sc.dids.alice)
+
+    const { subjectStatuses: statusesBefore } = await modClient.queryStatuses({
+      subject: sc.dids.alice,
+      includeAllUserRecords: true,
+    })
+
+    await modClient.emitEvent({
+      subject: repoSubject(sc.dids.alice),
+      event: {
+        $type: 'tools.ozone.moderation.defs#modEventAcknowledge',
+        acknowledgeAccountSubjects: true,
+      },
+    })
+
+    const { subjectStatuses: statusesAfter } = await modClient.queryStatuses({
+      subject: sc.dids.alice,
+      includeAllUserRecords: true,
+    })
 
     const reviewStatesBefore = getReviewStateBySubject(statusesBefore)
     const reviewStatesAfter = getReviewStateBySubject(statusesAfter)
@@ -117,7 +163,7 @@ describe('moderation', () => {
     expect(reviewStatesBefore.get(postTwo.uriStr)?.reviewState).toBe(
       REVIEWESCALATED,
     )
-    expect(reviewStatesBefore.get(sc.dids.bob)?.reviewState).toBe(REVIEWOPEN)
+    expect(reviewStatesBefore.get(sc.dids.alice)?.reviewState).toBe(REVIEWOPEN)
 
     // Check that review states after are all closed
     expect(reviewStatesAfter.get(postOne.uriStr)?.reviewState).toBe(
@@ -126,6 +172,6 @@ describe('moderation', () => {
     expect(reviewStatesAfter.get(postTwo.uriStr)?.reviewState).toBe(
       REVIEWCLOSED,
     )
-    expect(reviewStatesAfter.get(sc.dids.bob)?.reviewState).toBe(REVIEWCLOSED)
+    expect(reviewStatesAfter.get(sc.dids.alice)?.reviewState).toBe(REVIEWCLOSED)
   })
 })

package/tests/moderation-events.test.ts

@@ -224,6 +224,46 @@ describe('moderation-events', () => {
       expect(eventsWithComment.events.length).toEqual(10)
     })
 
+    it('returns events matching multiple keywords in comment', async () => {
+      await sc.createReport({
+        reasonType: REASONSPAM,
+        reason: 'november rain',
+        subject: {
+          $type: 'com.atproto.admin.defs#repoRef',
+          did: sc.dids.alice,
+        },
+        reportedBy: sc.dids.bob,
+      })
+      await sc.createReport({
+        reasonType: REASONSPAM,
+        reason: 'rainy days feel lazy',
+        subject: {
+          $type: 'com.atproto.admin.defs#repoRef',
+          did: sc.dids.alice,
+        },
+        reportedBy: sc.dids.bob,
+      })
+      const [eventsMatchingBothKeywords, unusedTrailingSeparator, extraSpaces] =
+        await Promise.all([
+          modClient.queryEvents({
+            hasComment: true,
+            comment: 'november||lazy',
+          }),
+          modClient.queryEvents({
+            hasComment: true,
+            comment: 'november||lazy||',
+          }),
+          modClient.queryEvents({
+            hasComment: true,
+            comment: '||november||lazy||  ',
+          }),
+        ])
+
+      expect(forSnapshot(eventsMatchingBothKeywords.events)).toMatchSnapshot()
+      expect(forSnapshot(unusedTrailingSeparator.events)).toMatchSnapshot()
+      expect(forSnapshot(extraSpaces.events)).toMatchSnapshot()
+    })
+
     it('returns events matching filter params for labels', async () => {
       const [negatedLabelEvent, createdLabelEvent] = await Promise.all([
         modClient.emitEvent({