@atproto/ozone 0.0.7 → 0.0.8

package/tests/moderation-events.test.ts

@@ -1,7 +1,12 @@
+import assert from 'node:assert'
 import { TestNetwork, SeedClient, basicSeed } from '@atproto/dev-env'
-import AtpAgent, { ComAtprotoAdminDefs } from '@atproto/api'
+import AtpAgent, {
+  ComAtprotoAdminDefs,
+  ComAtprotoAdminEmitModerationEvent,
+} from '@atproto/api'
 import { forSnapshot } from './_util'
 import {
+  REASONAPPEAL,
   REASONMISLEADING,
   REASONSPAM,
 } from '../src/lexicon/types/com/atproto/moderation/defs'
@@ -12,7 +17,9 @@ describe('moderation-events', () => {
   let pdsAgent: AtpAgent
   let sc: SeedClient
 
-  const emitModerationEvent = async (eventData) => {
+  const emitModerationEvent = async (
+    eventData: ComAtprotoAdminEmitModerationEvent.InputSchema,
+  ) => {
     return pdsAgent.api.com.atproto.admin.emitModerationEvent(eventData, {
       encoding: 'application/json',
       headers: network.bsky.adminAuthHeaders('moderator'),
@@ -201,20 +208,166 @@ describe('moderation-events', () => {
       expect(reversedEvents.length).toEqual(allEvents.data.events.length)
       expect(reversedEvents[0].id).toEqual(defaultEvents[4].id)
     })
+
+    it('returns report events matching reportType filters', async () => {
+      const [spamEvents, misleadingEvents] = await Promise.all([
+        queryModerationEvents({
+          reportTypes: [REASONSPAM],
+        }),
+        queryModerationEvents({
+          reportTypes: [REASONMISLEADING, REASONAPPEAL],
+        }),
+      ])
+
+      expect(misleadingEvents.data.events.length).toEqual(2)
+      expect(spamEvents.data.events.length).toEqual(6)
+    })
+
+    it('returns events matching keyword in comment', async () => {
+      const [eventsWithX, eventsWithTest, eventsWithComment] =
+        await Promise.all([
+          queryModerationEvents({
+            comment: 'X',
+          }),
+          queryModerationEvents({
+            comment: 'test',
+          }),
+          queryModerationEvents({
+            hasComment: true,
+          }),
+        ])
+
+      expect(eventsWithX.data.events.length).toEqual(10)
+      expect(eventsWithTest.data.events.length).toEqual(0)
+      expect(eventsWithComment.data.events.length).toEqual(12)
+    })
+
+    it('returns events matching filter params for columns', async () => {
+      const [negatedLabelEvent, createdLabelEvent] = await Promise.all([
+        emitModerationEvent({
+          event: {
+            $type: 'com.atproto.admin.defs#modEventLabel',
+            comment: 'X',
+            negateLabelVals: ['L1', 'L2'],
+            createLabelVals: [],
+          },
+          //   Report bob's account by alice and vice versa
+          subject: {
+            $type: 'com.atproto.admin.defs#repoRef',
+            did: sc.dids.alice,
+          },
+          createdBy: sc.dids.bob,
+        }),
+        emitModerationEvent({
+          event: {
+            $type: 'com.atproto.admin.defs#modEventLabel',
+            comment: 'X',
+            createLabelVals: ['L1', 'L2'],
+            negateLabelVals: [],
+          },
+          //   Report bob's account by alice and vice versa
+          subject: {
+            $type: 'com.atproto.admin.defs#repoRef',
+            did: sc.dids.bob,
+          },
+          createdBy: sc.dids.alice,
+        }),
+      ])
+      const [withTwoLabels, withoutTwoLabels, withOneLabel, withoutOneLabel] =
+        await Promise.all([
+          queryModerationEvents({
+            addedLabels: ['L1', 'L3'],
+          }),
+          queryModerationEvents({
+            removedLabels: ['L1', 'L2'],
+          }),
+          queryModerationEvents({
+            addedLabels: ['L1'],
+          }),
+          queryModerationEvents({
+            removedLabels: ['L2'],
+          }),
+        ])
+
+      // Verify that when querying for events where 2 different labels were added
+      // events where all of the labels from the list was added are returned
+      expect(withTwoLabels.data.events.length).toEqual(0)
+      expect(negatedLabelEvent.data.id).toEqual(
+        withoutTwoLabels.data.events[0].id,
+      )
+
+      expect(createdLabelEvent.data.id).toEqual(withOneLabel.data.events[0].id)
+      expect(negatedLabelEvent.data.id).toEqual(
+        withoutOneLabel.data.events[0].id,
+      )
+    })
   })
 
   describe('get event', () => {
     it('gets an event by specific id', async () => {
       const { data } = await pdsAgent.api.com.atproto.admin.getModerationEvent(
-        {
-          id: 1,
+        { id: 1 },
+        { headers: network.bsky.adminAuthHeaders('moderator') },
+      )
+      expect(forSnapshot(data)).toMatchSnapshot()
+    })
+  })
+
+  describe('blobs', () => {
+    it('are tracked on takedown event', async () => {
+      const post = sc.posts[sc.dids.carol][0]
+      assert(post.images.length > 1)
+      await emitModerationEvent({
+        event: {
+          $type: 'com.atproto.admin.defs#modEventTakedown',
         },
-        {
-          headers: network.bsky.adminAuthHeaders('moderator'),
+        subject: {
+          $type: 'com.atproto.repo.strongRef',
+          uri: post.ref.uriStr,
+          cid: post.ref.cidStr,
         },
-      )
+        subjectBlobCids: [post.images[0].image.ref.toString()],
+        createdBy: sc.dids.alice,
+      })
+      const { data: result } =
+        await pdsAgent.api.com.atproto.admin.queryModerationEvents(
+          { subject: post.ref.uriStr },
+          { headers: network.ozone.adminAuthHeaders('moderator') },
+        )
+      expect(result.events[0]).toMatchObject({
+        createdBy: sc.dids.alice,
+        event: {
+          $type: 'com.atproto.admin.defs#modEventTakedown',
+        },
+        subjectBlobCids: [post.images[0].image.ref.toString()],
+      })
+    })
 
-      expect(forSnapshot(data)).toMatchSnapshot()
+    it("are tracked on reverse-takedown event even if they aren't specified", async () => {
+      const post = sc.posts[sc.dids.carol][0]
+      await emitModerationEvent({
+        event: {
+          $type: 'com.atproto.admin.defs#modEventReverseTakedown',
+        },
+        subject: {
+          $type: 'com.atproto.repo.strongRef',
+          uri: post.ref.uriStr,
+          cid: post.ref.cidStr,
+        },
+        createdBy: sc.dids.alice,
+      })
+      const { data: result } =
+        await pdsAgent.api.com.atproto.admin.queryModerationEvents(
+          { subject: post.ref.uriStr },
+          { headers: network.ozone.adminAuthHeaders('moderator') },
+        )
+      expect(result.events[0]).toMatchObject({
+        createdBy: sc.dids.alice,
+        event: {
+          $type: 'com.atproto.admin.defs#modEventReverseTakedown',
+        },
+        subjectBlobCids: [post.images[0].image.ref.toString()],
+      })
     })
   })
 })

package/tests/moderation-statuses.test.ts

@@ -1,3 +1,4 @@
+import assert from 'node:assert'
 import { TestNetwork, SeedClient, basicSeed } from '@atproto/dev-env'
 import AtpAgent, {
   ComAtprotoAdminDefs,
@@ -141,4 +142,58 @@ describe('moderation-statuses', () => {
       expect(listReviewedFirst.length).toEqual(list.length)
     })
   })
+
+  describe('blobs', () => {
+    it('are tracked on takendown subject', async () => {
+      const post = sc.posts[sc.dids.carol][0]
+      assert(post.images.length > 1)
+      await emitModerationEvent({
+        event: {
+          $type: 'com.atproto.admin.defs#modEventTakedown',
+        },
+        subject: {
+          $type: 'com.atproto.repo.strongRef',
+          uri: post.ref.uriStr,
+          cid: post.ref.cidStr,
+        },
+        subjectBlobCids: [post.images[0].image.ref.toString()],
+        createdBy: sc.dids.alice,
+      })
+      const { data: result } =
+        await pdsAgent.api.com.atproto.admin.queryModerationStatuses(
+          { subject: post.ref.uriStr },
+          { headers: network.ozone.adminAuthHeaders('moderator') },
+        )
+      expect(result.subjectStatuses.length).toBe(1)
+      expect(result.subjectStatuses[0]).toMatchObject({
+        takendown: true,
+        subjectBlobCids: [post.images[0].image.ref.toString()],
+      })
+    })
+
+    it('are tracked on reverse-takendown subject based on previous status', async () => {
+      const post = sc.posts[sc.dids.carol][0]
+      await emitModerationEvent({
+        event: {
+          $type: 'com.atproto.admin.defs#modEventReverseTakedown',
+        },
+        subject: {
+          $type: 'com.atproto.repo.strongRef',
+          uri: post.ref.uriStr,
+          cid: post.ref.cidStr,
+        },
+        createdBy: sc.dids.alice,
+      })
+      const { data: result } =
+        await pdsAgent.api.com.atproto.admin.queryModerationStatuses(
+          { subject: post.ref.uriStr },
+          { headers: network.ozone.adminAuthHeaders('moderator') },
+        )
+      expect(result.subjectStatuses.length).toBe(1)
+      expect(result.subjectStatuses[0]).toMatchObject({
+        takendown: false,
+        subjectBlobCids: [post.images[0].image.ref.toString()],
+      })
+    })
+  })
 })

package/tests/moderation.test.ts

@@ -25,6 +25,10 @@ import {
 } from '../src/lexicon/types/com/atproto/admin/defs'
 import { EventReverser } from '../src'
 import { TestOzone } from '@atproto/dev-env/src/ozone'
+import {
+  UNSPECCED_TAKEDOWN_BLOBS_LABEL,
+  UNSPECCED_TAKEDOWN_LABEL,
+} from '../src/mod-service/types'
 
 type BaseCreateReportParams =
   | { account: string }
@@ -40,6 +44,7 @@ describe('moderation', () => {
   let network: TestNetwork
   let ozone: TestOzone
   let agent: AtpAgent
+  let bskyAgent: AtpAgent
   let pdsAgent: AtpAgent
   let sc: SeedClient
 
@@ -139,12 +144,23 @@ describe('moderation', () => {
     return data
   }
 
+  const getLabel = async (uri: string, val: string, neg = false) => {
+    return ozone.ctx.db.db
+      .selectFrom('label')
+      .selectAll()
+      .where('uri', '=', uri)
+      .where('val', '=', val)
+      .where('neg', '=', neg)
+      .executeTakeFirst()
+  }
+
   beforeAll(async () => {
     network = await TestNetwork.create({
       dbPostgresSchema: 'ozone_moderation',
     })
     ozone = network.ozone
     agent = network.ozone.getClient()
+    bskyAgent = network.bsky.getClient()
     pdsAgent = network.pds.getClient()
     sc = network.getSeedClient()
     await basicSeed(sc)
@@ -444,12 +460,9 @@ describe('moderation', () => {
         cid: post.cidStr,
       }
       const modService = ctx.modService(ctx.db)
-      await modService.formatAndCreateLabels(
-        ctx.cfg.service.did,
-        post.uriStr,
-        post.cidStr,
-        { create: ['kittens'] },
-      )
+      await modService.formatAndCreateLabels(post.uriStr, post.cidStr, {
+        create: ['kittens'],
+      })
       await emitLabelEvent({
         negateLabelVals: ['kittens'],
         createLabelVals: [],
@@ -464,12 +477,9 @@ describe('moderation', () => {
       })
       await expect(getRecordLabels(post.uriStr)).resolves.toEqual(['kittens'])
       // Cleanup
-      await modService.formatAndCreateLabels(
-        ctx.cfg.service.did,
-        post.uriStr,
-        post.cidStr,
-        { negate: ['kittens'] },
-      )
+      await modService.formatAndCreateLabels(post.uriStr, post.cidStr, {
+        negate: ['kittens'],
+      })
     })
 
     it('no-ops when negating an already-negated label and reverses.', async () => {
@@ -497,12 +507,9 @@ describe('moderation', () => {
       })
       await expect(getRecordLabels(post.uriStr)).resolves.toEqual(['bears'])
       // Cleanup
-      await modService.formatAndCreateLabels(
-        ctx.cfg.service.did,
-        post.uriStr,
-        post.cidStr,
-        { negate: ['bears'] },
-      )
+      await modService.formatAndCreateLabels(post.uriStr, post.cidStr, {
+        negate: ['bears'],
+      })
     })
 
     it('creates non-existing labels and reverses.', async () => {
@@ -559,12 +566,9 @@ describe('moderation', () => {
     it('creates and negates labels on a repo and reverses.', async () => {
       const { ctx } = ozone
       const modService = ctx.modService(ctx.db)
-      await modService.formatAndCreateLabels(
-        ctx.cfg.service.did,
-        sc.dids.bob,
-        null,
-        { create: ['kittens'] },
-      )
+      await modService.formatAndCreateLabels(sc.dids.bob, null, {
+        create: ['kittens'],
+      })
       await emitLabelEvent({
         createLabelVals: ['puppies'],
         negateLabelVals: ['kittens'],
@@ -632,34 +636,62 @@ describe('moderation', () => {
       ).rejects.toThrow('Subject is not taken down')
     })
 
-    it('fans out repo takedowns to pds', async () => {
+    it('fans out repo takedowns', async () => {
       await performTakedown({
         account: sc.dids.bob,
       })
       await ozone.processAll()
 
-      const res1 = await pdsAgent.api.com.atproto.admin.getSubjectStatus(
+      const pdsRes1 = await pdsAgent.api.com.atproto.admin.getSubjectStatus(
         {
           did: sc.dids.bob,
         },
         { headers: network.pds.adminAuthHeaders() },
       )
-      expect(res1.data.takedown?.applied).toBe(true)
+      expect(pdsRes1.data.takedown?.applied).toBe(true)
+
+      const bskyRes1 = await bskyAgent.api.com.atproto.admin.getSubjectStatus(
+        {
+          did: sc.dids.bob,
+        },
+        { headers: network.pds.adminAuthHeaders() },
+      )
+      expect(bskyRes1.data.takedown?.applied).toBe(true)
+
+      const takedownLabel1 = await getLabel(
+        sc.dids.bob,
+        UNSPECCED_TAKEDOWN_LABEL,
+      )
+      expect(takedownLabel1).toBeDefined()
 
       // cleanup
       await performReverseTakedown({ account: sc.dids.bob })
       await ozone.processAll()
 
-      const res2 = await pdsAgent.api.com.atproto.admin.getSubjectStatus(
+      const pdsRes2 = await pdsAgent.api.com.atproto.admin.getSubjectStatus(
         {
           did: sc.dids.bob,
         },
         { headers: network.pds.adminAuthHeaders() },
       )
-      expect(res2.data.takedown?.applied).toBe(false)
+      expect(pdsRes2.data.takedown?.applied).toBe(false)
+
+      const bskyRes2 = await bskyAgent.api.com.atproto.admin.getSubjectStatus(
+        {
+          did: sc.dids.bob,
+        },
+        { headers: network.bsky.adminAuthHeaders() },
+      )
+      expect(bskyRes2.data.takedown?.applied).toBe(false)
+
+      const takedownLabel2 = await getLabel(
+        sc.dids.bob,
+        UNSPECCED_TAKEDOWN_LABEL,
+      )
+      expect(takedownLabel2).toBeUndefined()
     })
 
-    it('fans out record takedowns to pds', async () => {
+    it('fans out record takedowns', async () => {
       const post = sc.posts[sc.dids.bob][0]
       const uri = post.ref.uriStr
       const cid = post.ref.cidStr
@@ -667,21 +699,39 @@ describe('moderation', () => {
         content: { uri, cid },
       })
       await ozone.processAll()
-      const res1 = await pdsAgent.api.com.atproto.admin.getSubjectStatus(
+
+      const pdsRes1 = await pdsAgent.api.com.atproto.admin.getSubjectStatus(
         { uri },
         { headers: network.pds.adminAuthHeaders() },
       )
-      expect(res1.data.takedown?.applied).toBe(true)
+      expect(pdsRes1.data.takedown?.applied).toBe(true)
+
+      const bskyRes1 = await bskyAgent.api.com.atproto.admin.getSubjectStatus(
+        { uri },
+        { headers: network.bsky.adminAuthHeaders() },
+      )
+      expect(bskyRes1.data.takedown?.applied).toBe(true)
+
+      const takedownLabel1 = await getLabel(uri, UNSPECCED_TAKEDOWN_LABEL)
+      expect(takedownLabel1).toBeDefined()
 
       // cleanup
       await performReverseTakedown({ content: { uri, cid } })
       await ozone.processAll()
 
-      const res2 = await pdsAgent.api.com.atproto.admin.getSubjectStatus(
+      const pdsRes2 = await pdsAgent.api.com.atproto.admin.getSubjectStatus(
         { uri },
         { headers: network.pds.adminAuthHeaders() },
       )
-      expect(res2.data.takedown?.applied).toBe(false)
+      expect(pdsRes2.data.takedown?.applied).toBe(false)
+      const bskyRes2 = await bskyAgent.api.com.atproto.admin.getSubjectStatus(
+        { uri },
+        { headers: network.bsky.adminAuthHeaders() },
+      )
+      expect(bskyRes2.data.takedown?.applied).toBe(false)
+
+      const takedownLabel2 = await getLabel(uri, UNSPECCED_TAKEDOWN_LABEL)
+      expect(takedownLabel2).toBeUndefined()
     })
 
     it('allows full moderators to takedown.', async () => {
@@ -732,6 +782,7 @@ describe('moderation', () => {
         'Must be a full moderator to perform an account takedown',
       )
     })
+
     it('automatically reverses actions marked with duration', async () => {
       await createReport({
         reasonType: REASONSPAM,
@@ -791,6 +842,22 @@ describe('moderation', () => {
       })
     })
 
+    it('serves label when authed', async () => {
+      const { data: unauthed } = await agent.api.com.atproto.temp.fetchLabels(
+        {},
+      )
+      expect(unauthed.labels.map((l) => l.val)).not.toContain(
+        UNSPECCED_TAKEDOWN_LABEL,
+      )
+      const { data: authed } = await agent.api.com.atproto.temp.fetchLabels(
+        {},
+        { headers: network.bsky.adminAuthHeaders() },
+      )
+      expect(authed.labels.map((l) => l.val)).toContain(
+        UNSPECCED_TAKEDOWN_LABEL,
+      )
+    })
+
     async function emitLabelEvent(
       opts: Partial<ComAtprotoAdminEmitModerationEvent.InputSchema> & {
         subject: ComAtprotoAdminEmitModerationEvent.InputSchema['subject']
@@ -924,6 +991,14 @@ describe('moderation', () => {
       expect(res.data.takedown?.applied).toBe(true)
     })
 
+    it('creates a takedown blobs label', async () => {
+      const label = await getLabel(
+        post.ref.uriStr,
+        UNSPECCED_TAKEDOWN_BLOBS_LABEL,
+      )
+      expect(label).toBeDefined()
+    })
+
     it('restores blob when action is reversed.', async () => {
       await performReverseTakedown({
         content: {
@@ -957,5 +1032,29 @@ describe('moderation', () => {
       )
       expect(res.data.takedown?.applied).toBe(false)
     })
+
+    it('serves label when authed', async () => {
+      const { data: unauthed } = await agent.api.com.atproto.temp.fetchLabels(
+        {},
+      )
+      expect(unauthed.labels.map((l) => l.val)).not.toContain(
+        UNSPECCED_TAKEDOWN_BLOBS_LABEL,
+      )
+      const { data: authed } = await agent.api.com.atproto.temp.fetchLabels(
+        {},
+        { headers: network.bsky.adminAuthHeaders() },
+      )
+      expect(authed.labels.map((l) => l.val)).toContain(
+        UNSPECCED_TAKEDOWN_BLOBS_LABEL,
+      )
+    })
+
+    it('negates takedown blobs label on reversal', async () => {
+      const label = await getLabel(
+        post.ref.uriStr,
+        UNSPECCED_TAKEDOWN_BLOBS_LABEL,
+      )
+      expect(label).toBeUndefined()
+    })
   })
 })

package/dist/lexicon/types/app/bsky/unspecced/getTimelineSkeleton.d.ts

@@ -1,35 +0,0 @@
-import express from 'express';
-import { HandlerAuth } from '@atproto/xrpc-server';
-import * as AppBskyFeedDefs from '../feed/defs';
-export interface QueryParams {
-    limit: number;
-    cursor?: string;
-}
-export type InputSchema = undefined;
-export interface OutputSchema {
-    cursor?: string;
-    feed: AppBskyFeedDefs.SkeletonFeedPost[];
-    [k: string]: unknown;
-}
-export type HandlerInput = undefined;
-export interface HandlerSuccess {
-    encoding: 'application/json';
-    body: OutputSchema;
-    headers?: {
-        [key: string]: string;
-    };
-}
-export interface HandlerError {
-    status: number;
-    message?: string;
-    error?: 'UnknownFeed';
-}
-export type HandlerOutput = HandlerError | HandlerSuccess;
-export type HandlerReqCtx<HA extends HandlerAuth = never> = {
-    auth: HA;
-    params: QueryParams;
-    input: HandlerInput;
-    req: express.Request;
-    res: express.Response;
-};
-export type Handler<HA extends HandlerAuth = never> = (ctx: HandlerReqCtx<HA>) => Promise<HandlerOutput> | HandlerOutput;

package/src/lexicon/types/app/bsky/unspecced/getTimelineSkeleton.ts

@@ -1,49 +0,0 @@
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-import express from 'express'
-import { ValidationResult, BlobRef } from '@atproto/lexicon'
-import { lexicons } from '../../../../lexicons'
-import { isObj, hasProp } from '../../../../util'
-import { CID } from 'multiformats/cid'
-import { HandlerAuth } from '@atproto/xrpc-server'
-import * as AppBskyFeedDefs from '../feed/defs'
-
-export interface QueryParams {
-  limit: number
-  cursor?: string
-}
-
-export type InputSchema = undefined
-
-export interface OutputSchema {
-  cursor?: string
-  feed: AppBskyFeedDefs.SkeletonFeedPost[]
-  [k: string]: unknown
-}
-
-export type HandlerInput = undefined
-
-export interface HandlerSuccess {
-  encoding: 'application/json'
-  body: OutputSchema
-  headers?: { [key: string]: string }
-}
-
-export interface HandlerError {
-  status: number
-  message?: string
-  error?: 'UnknownFeed'
-}
-
-export type HandlerOutput = HandlerError | HandlerSuccess
-export type HandlerReqCtx<HA extends HandlerAuth = never> = {
-  auth: HA
-  params: QueryParams
-  input: HandlerInput
-  req: express.Request
-  res: express.Response
-}
-export type Handler<HA extends HandlerAuth = never> = (
-  ctx: HandlerReqCtx<HA>,
-) => Promise<HandlerOutput> | HandlerOutput