@atproto/ozone 0.1.176 → 0.2.0

package/src/mod-service/views.ts

@@ -51,7 +51,11 @@ import { Un$Typed, asPredicate } from '../lexicon/util.js'
 import { dbLogger, httpLogger } from '../logger.js'
 import { ParsedLabelers } from '../util.js'
 import { moderationSubjectStatusQueryBuilder } from './status.js'
-import { subjectFromEventRow, subjectFromStatusRow } from './subject.js'
+import {
+  ModSubject,
+  subjectFromEventRow,
+  subjectFromStatusRow,
+} from './subject.js'
 import {
   ModerationEventRowWithHandle,
   ModerationSubjectStatusRowWithHandle,
@@ -297,14 +301,8 @@ export class ModerationViews {
   async eventDetail(
     result: ModerationEventRowWithHandle,
   ): Promise<ModEventViewDetail> {
-    const subjectId =
-      result.subjectType === 'com.atproto.admin.defs#repoRef'
-        ? result.subjectDid
-        : result.subjectUri
-    if (!subjectId) {
-      throw new Error(`Bad subject: ${result.id}`)
-    }
-    const subject = await this.subject(subjectId)
+    const modSubject = subjectFromEventRow(result)
+    const subject = await this.subject(modSubject)
     const eventView = this.formatEvent(result)
     const allBlobs = 'value' in subject ? findBlobRefs(subject.value) : []
     const subjectBlobs = await this.blob(
@@ -555,10 +553,16 @@ export class ModerationViews {
   }
   // Partial view for subjects
 
-  async subject(subject: string): Promise<SubjectView> {
-    if (subject.startsWith('did:')) {
-      const repos = await this.repos([subject])
-      const repo = repos.get(subject)
+  async subject(subject: ModSubject): Promise<SubjectView> {
+    if (subject.isConvo()) {
+      return {
+        $type: 'tools.ozone.moderation.defs#convoView',
+        did: subject.did,
+        convoId: subject.convoId,
+      }
+    } else if (subject.isRepo()) {
+      const repos = await this.repos([subject.did])
+      const repo = repos.get(subject.did)
       if (repo) {
         return {
           ...repo,
@@ -567,24 +571,24 @@ export class ModerationViews {
       } else {
         return {
           $type: 'tools.ozone.moderation.defs#repoViewNotFound',
-          did: subject,
+          did: subject.did,
         }
       }
-    } else {
-      const records = await this.records([{ uri: subject }])
-      const record = records.get(subject)
+    } else if (subject.isRecord()) {
+      const uri = subject.uri
+      const records = await this.records([{ uri }])
+      const record = records.get(uri)
       if (record) {
         return {
           ...record,
           $type: 'tools.ozone.moderation.defs#recordView',
         }
-      } else {
-        return {
-          $type: 'tools.ozone.moderation.defs#recordViewNotFound',
-          uri: subject,
-        }
       }
     }
+    return {
+      $type: 'tools.ozone.moderation.defs#repoViewNotFound',
+      did: subject.did,
+    }
   }
 
   // Partial view for blobs
@@ -691,7 +695,8 @@ export class ModerationViews {
                 'moderation_subject_status.recordPath',
                 '=',
                 sub.recordPath ?? '',
-              ),
+              )
+              .where('moderation_subject_status.convoId', '=', ''),
           )
         }
         return qb

package/src/queue/service.ts

@@ -13,7 +13,7 @@ import { viewQueueStats } from '../report/views.js'
 const MOD_EVENT_REPORT_ACTION = 'tools.ozone.moderation.defs#modEventReport'
 const REASON_OTHER = 'com.atproto.moderation.defs#reasonOther'
 
-type SubjectType = 'account' | 'record' | 'message'
+type SubjectType = 'account' | 'record' | 'message' | 'conversation'
 
 type ResolvedAssignment = {
   queueId: number
@@ -478,6 +478,7 @@ export class QueueService {
         'subjectDid',
         'subjectUri',
         'subjectMessageId',
+        'subjectConvoId',
         'meta',
         'createdAt',
       ])
@@ -503,9 +504,11 @@ export class QueueService {
     const rows = events.map((event) => {
       const subjectType: SubjectType = event.subjectMessageId
         ? 'message'
-        : event.subjectUri
-          ? 'record'
-          : 'account'
+        : event.subjectConvoId
+          ? 'conversation'
+          : event.subjectUri
+            ? 'record'
+            : 'account'
 
       let collection: string | null = null
       let recordPath = ''
@@ -545,6 +548,7 @@ export class QueueService {
         did: event.subjectDid,
         recordPath,
         subjectMessageId: event.subjectMessageId,
+        subjectConvoId: event.subjectConvoId,
         createdAt: now,
         updatedAt: now,
       }

package/tests/__snapshots__/verification.test.ts.snap

@@ -122,6 +122,8 @@ exports[`verification list returns paginated list of verifications 1`] = `
           "createdAt": "1970-01-01T00:00:00.000Z",
           "isValid": true,
           "issuer": "user(0)",
+          "issuerDisplayName": "ali",
+          "issuerHandle": "alice.test",
           "uri": "record(0)",
         },
       ],

package/tests/expiring-tags.test.ts

@@ -192,6 +192,7 @@ describe('expiring tags', () => {
         eventId: 0,
         did: sc.dids.carol,
         recordPath: '',
+        convoId: '',
         tag: 'skip-tag',
         expiresAt: new Date(Date.now() - 1000).toISOString(),
         createdBy: sc.dids.alice,

package/tests/moderation-events.test.ts

@@ -207,8 +207,25 @@ describe('moderation-events', () => {
         }),
       ])
 
-      expect(misleadingEvents.events.length).toEqual(2)
+      // Verify all spam events have the correct report type
       expect(spamEvents.events.length).toEqual(6)
+      spamEvents.events.forEach((event) => {
+        expect(event.event.$type).toEqual(
+          'tools.ozone.moderation.defs#modEventReport',
+        )
+        expect((event.event as any).reportType).toEqual(REASONSPAM)
+      })
+
+      // Verify all misleading events have one of the correct report types
+      expect(misleadingEvents.events.length).toEqual(2)
+      misleadingEvents.events.forEach((event) => {
+        expect(event.event.$type).toEqual(
+          'tools.ozone.moderation.defs#modEventReport',
+        )
+        expect([REASONMISLEADING, REASONAPPEAL]).toContain(
+          (event.event as any).reportType,
+        )
+      })
     })
 
     it('returns events matching keyword in comment', async () => {
@@ -501,6 +518,96 @@ describe('moderation-events', () => {
         expect(event.createdBy).toEqual(network.ozone.moderatorAccnt.did)
       })
     })
+
+    it('queries events by conversation', async () => {
+      const convoId1 = 'conversation-123'
+      const convoId2 = 'conversation-456'
+
+      // create reports
+      await sc.createReport({
+        reasonType: REASONSPAM,
+        reason: 'spam in convo 1',
+        subject: {
+          $type: 'chat.bsky.convo.defs#convoRef',
+          did: sc.dids.carol,
+          convoId: convoId1,
+        },
+        reportedBy: sc.dids.alice,
+      })
+      await sc.createReport({
+        reasonType: REASONMISLEADING,
+        reason: 'misleading in convo 1',
+        subject: {
+          $type: 'chat.bsky.convo.defs#convoRef',
+          did: sc.dids.carol,
+          convoId: convoId1,
+        },
+        reportedBy: sc.dids.bob,
+      })
+      await sc.createReport({
+        reasonType: REASONSPAM,
+        reason: 'spam in convo 2',
+        subject: {
+          $type: 'chat.bsky.convo.defs#convoRef',
+          did: sc.dids.carol,
+          convoId: convoId2,
+        },
+        reportedBy: sc.dids.alice,
+      })
+
+      // Query events (filter by report type since auto-tagging creates extra events)
+      const convo1Events = await modClient.queryEvents({
+        subject: `at://${sc.dids.carol}/chat.bsky.convo/${convoId1}`,
+        includeAllUserRecords: false,
+        types: ['tools.ozone.moderation.defs#modEventReport'],
+      })
+      const convo2Events = await modClient.queryEvents({
+        subject: `at://${sc.dids.carol}/chat.bsky.convo/${convoId2}`,
+        includeAllUserRecords: false,
+        types: ['tools.ozone.moderation.defs#modEventReport'],
+      })
+
+      // Verify conversation 1 events are correct
+      expect(convo1Events.events.length).toBeGreaterThan(0)
+      convo1Events.events.forEach((e) => {
+        // All events should be conversation refs
+        expect(e.subject.$type).toEqual('chat.bsky.convo.defs#convoRef')
+        // All events should be for conversation 1
+        const subject = e.subject as any
+        expect(subject.convoId).toEqual(convoId1)
+        expect(subject.did).toEqual(sc.dids.carol)
+        // All events should be reports
+        expect(e.event.$type).toEqual(
+          'tools.ozone.moderation.defs#modEventReport',
+        )
+      })
+      // Verify we got both reports we created
+      const convo1Comments = convo1Events.events.map(
+        (e) => (e.event as any).comment,
+      )
+      expect(convo1Comments).toContain('spam in convo 1')
+      expect(convo1Comments).toContain('misleading in convo 1')
+
+      // Verify conversation 2 events are correct
+      expect(convo2Events.events.length).toBeGreaterThan(0)
+      convo2Events.events.forEach((e) => {
+        // All events should be conversation refs
+        expect(e.subject.$type).toEqual('chat.bsky.convo.defs#convoRef')
+        // All events should be for conversation 2
+        const subject = e.subject as any
+        expect(subject.convoId).toEqual(convoId2)
+        expect(subject.did).toEqual(sc.dids.carol)
+        // All events should be reports
+        expect(e.event.$type).toEqual(
+          'tools.ozone.moderation.defs#modEventReport',
+        )
+      })
+      // Verify we got the report we created
+      const convo2Comments = convo2Events.events.map(
+        (e) => (e.event as any).comment,
+      )
+      expect(convo2Comments).toContain('spam in convo 2')
+    })
   })
 
   describe('get event', () => {

package/tests/moderation-status-tags.test.ts

@@ -113,5 +113,28 @@ describe('moderation-status-tags', () => {
       expect(englishOrJapaneseDids).toContain(sc.dids.alice)
       expect(englishOrJapaneseDids).toContain(sc.dids.bob)
     })
+
+    it('adds tag to conversation', async () => {
+      const subject = {
+        $type: 'chat.bsky.convo.defs#convoRef',
+        did: sc.dids.alice,
+        convoId: '123',
+      }
+      await modClient.emitEvent({
+        subject: subject,
+        event: {
+          $type: 'tools.ozone.moderation.defs#modEventTag',
+          add: ['interaction-churn'],
+          remove: [],
+        },
+      })
+      const status = await network.ozone.ctx.db.db
+        .selectFrom('moderation_subject_status')
+        .selectAll()
+        .where('did', '=', subject.did)
+        .where('convoId', '=', subject.convoId)
+        .executeTakeFirstOrThrow()
+      expect(status.tags).toContain('interaction-churn')
+    })
   })
 })

package/tests/moderation-statuses.test.ts

@@ -276,6 +276,88 @@ describe('moderation-statuses', () => {
         "only bob's account statuses are returned, no events have a URI even though the subjectType is record",
       )
     })
+
+    it('returns statuses for conversations', async () => {
+      const convoId1 = 'test-convo-123'
+      const convoId2 = 'test-convo-456'
+
+      // Create reports for conversation 1
+      await sc.createReport({
+        reasonType: REASONSPAM,
+        reason: 'spam in convo 1',
+        subject: {
+          $type: 'chat.bsky.convo.defs#convoRef',
+          did: sc.dids.carol,
+          convoId: convoId1,
+        },
+        reportedBy: sc.dids.alice,
+      })
+
+      // Create another report for conversation 1
+      await sc.createReport({
+        reasonType: REASONMISLEADING,
+        reason: 'misleading in convo 1',
+        subject: {
+          $type: 'chat.bsky.convo.defs#convoRef',
+          did: sc.dids.carol,
+          convoId: convoId1,
+        },
+        reportedBy: sc.dids.bob,
+      })
+
+      // Create report for conversation 2
+      await sc.createReport({
+        reasonType: REASONSPAM,
+        reason: 'spam in convo 2',
+        subject: {
+          $type: 'chat.bsky.convo.defs#convoRef',
+          did: sc.dids.carol,
+          convoId: convoId2,
+        },
+        reportedBy: sc.dids.alice,
+      })
+
+      // Query statuses for conversation 1 using AT URI format
+      const convo1Statuses = await modClient.queryStatuses({
+        subject: `at://${sc.dids.carol}/chat.bsky.convo/${convoId1}`,
+      })
+
+      // Query statuses for conversation 2
+      const convo2Statuses = await modClient.queryStatuses({
+        subject: `at://${sc.dids.carol}/chat.bsky.convo/${convoId2}`,
+      })
+
+      // Query all conversation statuses for carol
+      const allCarolConvoStatuses = await modClient.queryStatuses({
+        subject: sc.dids.carol,
+        includeAllUserRecords: true,
+      })
+
+      // Verify conversation 1 has exactly 1 status (multiple reports create one status)
+      expect(convo1Statuses.subjectStatuses.length).toEqual(1)
+      expect(convo1Statuses.subjectStatuses[0].subject.$type).toEqual(
+        'chat.bsky.convo.defs#convoRef',
+      )
+      expect(convo1Statuses.subjectStatuses[0].reviewState).toEqual(REVIEWOPEN)
+
+      // Verify conversation 2 has exactly 1 status
+      expect(convo2Statuses.subjectStatuses.length).toEqual(1)
+      expect(convo2Statuses.subjectStatuses[0].subject.$type).toEqual(
+        'chat.bsky.convo.defs#convoRef',
+      )
+
+      // Verify statuses are properly isolated by conversation
+      const convo1Subject = convo1Statuses.subjectStatuses[0].subject as any
+      const convo2Subject = convo2Statuses.subjectStatuses[0].subject as any
+      expect(convo1Subject.convoId).toEqual(convoId1)
+      expect(convo2Subject.convoId).toEqual(convoId2)
+
+      // Verify includeAllUserRecords includes conversations
+      const convoStatuses = allCarolConvoStatuses.subjectStatuses.filter(
+        (s) => s.subject.$type === 'chat.bsky.convo.defs#convoRef',
+      )
+      expect(convoStatuses.length).toBeGreaterThanOrEqual(2)
+    })
   })
 
   describe('reviewState changes', () => {

package/tests/moderation.test.ts

@@ -197,6 +197,53 @@ describe('moderation', () => {
         ),
       ).toBe(true)
     })
+
+    it('creates reports of convo', async () => {
+      const convoId1 = 'convoId1'
+      const convoId2 = 'convoId2'
+      const reportA = await sc.createReport({
+        reportedBy: sc.dids.alice,
+        reasonType: REASONSPAM,
+        subject: {
+          $type: 'chat.bsky.convo.defs#convoRef',
+          did: sc.dids.carol,
+          convoId: convoId1,
+        },
+      })
+      const reportB = await sc.createReport({
+        reportedBy: sc.dids.carol,
+        reasonType: REASONOTHER,
+        reason: 'defamation',
+        subject: {
+          $type: 'chat.bsky.convo.defs#convoRef',
+          did: sc.dids.carol,
+          convoId: convoId2,
+        },
+      })
+
+      // Verify reportA
+      expect(reportA.subject.$type).toBe('chat.bsky.convo.defs#convoRef')
+      expect(ChatBskyConvoDefs.isConvoRef(reportA.subject)).toBe(true)
+      if (ChatBskyConvoDefs.isConvoRef(reportA.subject)) {
+        expect(reportA.subject.convoId).toBe(convoId1)
+        expect(reportA.subject.did).toBe(sc.dids.carol)
+      }
+      expect(reportA.reasonType).toBe(REASONSPAM)
+      expect(reportA.reportedBy).toBe(sc.dids.alice)
+      expect(reportA.id).toBeGreaterThan(0)
+
+      // Verify reportB
+      expect(reportB.subject.$type).toBe('chat.bsky.convo.defs#convoRef')
+      expect(ChatBskyConvoDefs.isConvoRef(reportB.subject)).toBe(true)
+      if (ChatBskyConvoDefs.isConvoRef(reportB.subject)) {
+        expect(reportB.subject.convoId).toBe(convoId2)
+        expect(reportB.subject.did).toBe(sc.dids.carol)
+      }
+      expect(reportB.reasonType).toBe(REASONOTHER)
+      expect(reportB.reason).toBe('defamation')
+      expect(reportB.reportedBy).toBe(sc.dids.carol)
+      expect(reportB.id).toBeGreaterThan(reportA.id)
+    })
   })
 
   describe('actioning', () => {
@@ -729,6 +776,32 @@ describe('moderation', () => {
       })
     })
 
+    it('allows conversation escalate', async () => {
+      const subject = {
+        $type: 'chat.bsky.convo.defs#convoRef',
+        did: sc.dids.bob,
+        convoId: '123',
+      }
+      await modClient.emitEvent({
+        event: {
+          $type: 'tools.ozone.moderation.defs#modEventEscalate',
+          comment: 'Y',
+        },
+        subject,
+        createdBy: 'did:example:admin',
+      })
+
+      const status = await network.ozone.ctx.db.db
+        .selectFrom('moderation_subject_status')
+        .selectAll()
+        .where('did', '=', subject.did)
+        .where('recordPath', '=', '')
+        .where('convoId', '=', subject.convoId)
+        .executeTakeFirst()
+
+      expect(status?.reviewState).toEqual(REVIEWESCALATED)
+    })
+
     async function emitLabelEvent(
       opts: Partial<ToolsOzoneModerationEmitEvent.InputSchema> & {
         subject: ToolsOzoneModerationEmitEvent.InputSchema['subject']