@atproto/ozone 0.1.77 → 0.1.78

package/tests/moderation-appeals.test.ts

@@ -98,6 +98,7 @@ describe('moderation-appeals', () => {
 
       // Verify that appeal status changed when appeal report was emitted by moderator
       const status = await assertBobsPostStatus(REVIEWESCALATED, true)
+      // @ts-expect-error unspecced ?
       expect(status?.appealedAt).not.toBeNull()
 
       // Create a report as normal user for carol's post

package/tests/moderation-events.test.ts

@@ -7,11 +7,13 @@ import {
   TestNetwork,
   basicSeed,
 } from '@atproto/dev-env'
+import { isRepoRef } from '../src/lexicon/types/com/atproto/admin/defs'
 import {
   REASONAPPEAL,
   REASONMISLEADING,
   REASONSPAM,
 } from '../src/lexicon/types/com/atproto/moderation/defs'
+import { isMain as isStrongRef } from '../src/lexicon/types/com/atproto/repo/strongRef'
 import { forSnapshot } from './_util'
 
 describe('moderation-events', () => {
@@ -361,6 +363,7 @@ describe('moderation-events', () => {
 
       expect(addAndRemoveEvent.id).toEqual(addAndRemoveFinder.events[0].id)
       expect(addAndRemoveEvent.id).toEqual(addAndRemoveFinder.events[0].id)
+      assert(ToolsOzoneModerationDefs.isModEventTag(addAndRemoveEvent.event))
       expect(addAndRemoveEvent.event.add).toEqual(['L3'])
       expect(addAndRemoveEvent.event.remove).toEqual(['L2'])
     })
@@ -411,11 +414,13 @@ describe('moderation-events', () => {
       ])
 
       expect(onlyStarterPackReports.events.length).toEqual(1)
+      assert(isStrongRef(onlyStarterPackReports.events[0].subject))
       expect(onlyStarterPackReports.events[0].subject.uri).toContain(
         'app.bsky.graph.starterpack',
       )
 
       expect(onlyAlicesStarterPackReports.events.length).toEqual(1)
+      assert(isStrongRef(onlyAlicesStarterPackReports.events[0].subject))
       expect(onlyAlicesStarterPackReports.events[0].subject.uri).toContain(
         sp.uriStr,
       )
@@ -441,20 +446,24 @@ describe('moderation-events', () => {
           }),
         ])
 
-      // only account reports are returned, no event has a uri
-      expect(
-        onlyAccountReports.events.every((e) => !e.subject.uri),
-      ).toBeTruthy()
+      assert(
+        onlyAccountReports.events.every((e) => !isStrongRef(e.subject)),
+        'only account reports are returned, no event has a uri',
+      )
 
-      // only record reports are returned, all events have a uri
-      expect(onlyRecordReports.events.every((e) => e.subject.uri)).toBeTruthy()
+      assert(
+        onlyRecordReports.events.every(
+          (e) => isStrongRef(e.subject) && e.subject.uri,
+        ),
+        'only record reports are returned, all events have a uri',
+      )
 
-      // only bob's account reports are returned, no events have a URI even though the subjectType is record
-      expect(
+      assert(
         onlyReportsOnBobsAccount.events.every(
-          (e) => !e.subject.uri && e.subject.did === sc.dids.bob,
+          (e) => isRepoRef(e.subject) && e.subject.did === sc.dids.bob,
         ),
-      ).toBeTruthy()
+        "only bob's account reports are returned, no events have a URI even though the subjectType is record",
+      )
     })
   })
 

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

@@ -1,3 +1,5 @@
+import assert from 'node:assert'
+import { ComAtprotoAdminDefs } from '@atproto/api'
 import {
   ModeratorClient,
   SeedClient,
@@ -96,14 +98,17 @@ describe('moderation-status-tags', () => {
 
       // Verify that the queue only contains 1 item with both en and ja tags which is alice's account
       expect(englishAndJapaneseQueue.subjectStatuses.length).toEqual(1)
-      expect(englishAndJapaneseQueue.subjectStatuses[0].subject.did).toEqual(
-        sc.dids.alice,
-      )
+      const { subject } = englishAndJapaneseQueue.subjectStatuses[0]
+      assert(ComAtprotoAdminDefs.isRepoRef(subject))
+      expect(subject.did).toEqual(sc.dids.alice)
 
       // Verify that when querying for either en or ja tags, both alice and bob are returned
       expect(englishOrJapaneseQueue.subjectStatuses.length).toEqual(2)
       const englishOrJapaneseDids = englishOrJapaneseQueue.subjectStatuses.map(
-        ({ subject }) => subject.did,
+        ({ subject }) => {
+          assert(ComAtprotoAdminDefs.isRepoRef(subject))
+          return subject.did
+        },
       )
       expect(englishOrJapaneseDids).toContain(sc.dids.alice)
       expect(englishOrJapaneseDids).toContain(sc.dids.bob)

package/tests/moderation-statuses.test.ts

@@ -9,10 +9,12 @@ import {
   TestNetwork,
   basicSeed,
 } from '@atproto/dev-env'
+import { isRepoRef } from '../src/lexicon/types/com/atproto/admin/defs'
 import {
   REASONMISLEADING,
   REASONSPAM,
 } from '../src/lexicon/types/com/atproto/moderation/defs'
+import { isMain as isStrongRef } from '../src/lexicon/types/com/atproto/repo/strongRef'
 import {
   REVIEWNONE,
   REVIEWOPEN,
@@ -220,10 +222,14 @@ describe('moderation-statuses', () => {
       ])
 
       expect(onlyStarterPackStatuses.subjectStatuses.length).toEqual(1)
+      assert(isStrongRef(onlyStarterPackStatuses.subjectStatuses[0].subject))
       expect(onlyStarterPackStatuses.subjectStatuses[0].subject.uri).toContain(
         'app.bsky.graph.starterpack',
       )
       expect(onlyAlicesStarterPackStatuses.subjectStatuses.length).toEqual(1)
+      assert(
+        isStrongRef(onlyAlicesStarterPackStatuses.subjectStatuses[0].subject),
+      )
       expect(
         onlyAlicesStarterPackStatuses.subjectStatuses[0].subject.uri,
       ).toEqual(sp.uriStr)
@@ -249,22 +255,26 @@ describe('moderation-statuses', () => {
         }),
       ])
 
-      // only account statuses are returned, no event has a uri
-      expect(
-        onlyAccountStatuses.subjectStatuses.every((e) => !e.subject.uri),
-      ).toBeTruthy()
+      assert(
+        onlyAccountStatuses.subjectStatuses.every(
+          (e) => !isStrongRef(e.subject),
+        ),
+        'only account statuses are returned, no event has a uri',
+      )
 
-      // only record statuses are returned, all events have a uri
-      expect(
-        onlyRecordStatuses.subjectStatuses.every((e) => e.subject.uri),
-      ).toBeTruthy()
+      assert(
+        onlyRecordStatuses.subjectStatuses.every(
+          (e) => isStrongRef(e.subject) && e.subject.uri,
+        ),
+        'only record statuses are returned, all events have a uri',
+      )
 
-      // only bob's account statuses are returned, no events have a URI even though the subjectType is record
-      expect(
+      assert(
         onlyStatusesOnBobsAccount.subjectStatuses.every(
-          (e) => !e.subject.uri && e.subject.did === sc.dids.bob,
+          (e) => isRepoRef(e.subject) && e.subject.did === sc.dids.bob,
         ),
-      ).toBeTruthy()
+        "only bob's account statuses are returned, no events have a URI even though the subjectType is record",
+      )
     })
   })
 

package/tests/moderation.test.ts

@@ -1,4 +1,8 @@
-import { AtpAgent, ToolsOzoneModerationEmitEvent } from '@atproto/api'
+import {
+  AtpAgent,
+  ChatBskyConvoDefs,
+  ToolsOzoneModerationEmitEvent,
+} from '@atproto/api'
 import { HOUR } from '@atproto/common'
 import {
   ImageRef,
@@ -24,7 +28,7 @@ import {
   REVIEWESCALATED,
 } from '../src/lexicon/types/tools/ozone/moderation/defs'
 import { TAKEDOWN_LABEL } from '../src/mod-service'
-import { forSnapshot } from './_util'
+import { forSnapshot, identity } from './_util'
 
 describe('moderation', () => {
   let network: TestNetwork
@@ -158,23 +162,26 @@ describe('moderation', () => {
       const reportA = await sc.createReport({
         reportedBy: sc.dids.alice,
         reasonType: REASONSPAM,
-        subject: {
+        // @ts-expect-error "chat.bsky.convo.defs#messageRef" is not spec'd as subject
+        subject: identity<ChatBskyConvoDefs.MessageRef>({
           $type: 'chat.bsky.convo.defs#messageRef',
           did: sc.dids.carol,
           messageId: messageId1,
           convoId: 'testconvoid1',
-        },
+        }),
       })
       const reportB = await sc.createReport({
         reportedBy: sc.dids.carol,
         reasonType: REASONOTHER,
         reason: 'defamation',
-        subject: {
+        // @ts-expect-error "chat.bsky.convo.defs#messageRef" is not spec'd as subject
+        subject: identity<ChatBskyConvoDefs.MessageRef>({
           $type: 'chat.bsky.convo.defs#messageRef',
           did: sc.dids.carol,
           messageId: messageId2,
-          // @TODO convoId intentionally missing, restore once this behavior is deprecated
-        },
+          // @ts-expect-error convoId intentionally missing, restore once this behavior is deprecated
+          convoId: undefined,
+        }),
       })
       expect(forSnapshot([reportA, reportB])).toMatchSnapshot()
       const events = await ozone.ctx.db.db
@@ -731,7 +738,7 @@ describe('moderation', () => {
       },
     ) {
       const { createLabelVals, negateLabelVals, durationInHours } = opts
-      const result = await modClient.emitEvent({
+      const event = await modClient.emitEvent({
         event: {
           $type: 'tools.ozone.moderation.defs#modEventLabel',
           createLabelVals,
@@ -742,7 +749,7 @@ describe('moderation', () => {
         reason: 'Y',
         ...opts,
       })
-      return result.data
+      return event
     }
 
     async function reverse(

package/tests/protected-tags.test.ts

@@ -50,6 +50,7 @@ describe('protected-tags', () => {
         modClient.upsertSettingOption({
           ...basicSetting,
           managerRole: ROLEADMIN,
+          // @ts-expect-error testing invalid value here
           value: ['test'],
         }),
       ).rejects.toThrow('Invalid configuration')

package/tests/record-and-account-events.test.ts

@@ -1,15 +1,20 @@
-import {
-  ComAtprotoModerationDefs,
-  ToolsOzoneModerationDefs,
-  ToolsOzoneModerationEmitEvent as EmitModerationEvent,
-} from '@atproto/api'
+import assert from 'node:assert'
 import {
   ModeratorClient,
   SeedClient,
   TestNetwork,
   basicSeed,
 } from '@atproto/dev-env'
-import { REVIEWOPEN } from '../src/lexicon/types/tools/ozone/moderation/defs'
+import { isRepoRef } from '../src/lexicon/types/com/atproto/admin/defs'
+import { REASONMISLEADING } from '../src/lexicon/types/com/atproto/moderation/defs'
+import { isMain as isStrongRef } from '../src/lexicon/types/com/atproto/repo/strongRef'
+import {
+  REVIEWOPEN,
+  SubjectStatusView,
+  isAccountHosting,
+  isRecordHosting,
+} from '../src/lexicon/types/tools/ozone/moderation/defs'
+import { InputSchema } from '../src/lexicon/types/tools/ozone/moderation/emitEvent'
 
 describe('record and account events on moderation subjects', () => {
   let network: TestNetwork
@@ -32,7 +37,7 @@ describe('record and account events on moderation subjects', () => {
 
   const getSubjectStatus = async (
     subject: string,
-  ): Promise<ToolsOzoneModerationDefs.SubjectStatusView | undefined> => {
+  ): Promise<SubjectStatusView | undefined> => {
     const res = await modClient.queryStatuses({
       subject,
     })
@@ -41,7 +46,7 @@ describe('record and account events on moderation subjects', () => {
 
   describe('record events', () => {
     const emitRecordEvent = async (
-      subject: EmitModerationEvent.InputSchema['subject'],
+      subject: InputSchema['subject'],
       op: 'create' | 'update' | 'delete',
     ) => {
       return await modClient.emitEvent(
@@ -67,26 +72,28 @@ describe('record and account events on moderation subjects', () => {
 
       await sc.createReport({
         reportedBy: sc.dids.carol,
-        reasonType: ComAtprotoModerationDefs.REASONMISLEADING,
+        reasonType: REASONMISLEADING,
         reason: 'misleading',
         subject: bobsPostSubject,
       })
 
       await emitRecordEvent(bobsPostSubject, 'update')
       const statusAfterUpdate = await getSubjectStatus(bobsPostSubject.uri)
-      expect(statusAfterUpdate?.hosting?.updatedAt).toBeTruthy()
+      assert(isRecordHosting(statusAfterUpdate?.hosting))
+      expect(statusAfterUpdate.hosting?.updatedAt).toBeTruthy()
 
       await emitRecordEvent(bobsPostSubject, 'delete')
       const statusAfterDelete = await getSubjectStatus(bobsPostSubject.uri)
-      expect(statusAfterDelete?.hosting?.deletedAt).toBeTruthy()
-      expect(statusAfterDelete?.hosting?.status).toEqual('deleted')
+      assert(isRecordHosting(statusAfterDelete?.hosting))
+      expect(statusAfterDelete.hosting?.deletedAt).toBeTruthy()
+      expect(statusAfterDelete.hosting?.status).toEqual('deleted')
       // Ensure that due to delete or update event, review state does not change
-      expect(statusAfterDelete?.reviewState).toEqual(REVIEWOPEN)
+      expect(statusAfterDelete.reviewState).toEqual(REVIEWOPEN)
     })
   })
   describe('account/identity events', () => {
     const emitAccountEvent = async (
-      subject: EmitModerationEvent.InputSchema['subject'],
+      subject: InputSchema['subject'],
       active: boolean,
       status?: 'takendown' | 'deleted' | 'deactivated' | 'suspended',
     ) => {
@@ -113,7 +120,7 @@ describe('record and account events on moderation subjects', () => {
 
       await sc.createReport({
         reportedBy: sc.dids.carol,
-        reasonType: ComAtprotoModerationDefs.REASONMISLEADING,
+        reasonType: REASONMISLEADING,
         reason: 'misleading',
         subject: carolsAccountSubject,
       })
@@ -122,17 +129,19 @@ describe('record and account events on moderation subjects', () => {
       const statusAfterDeactivation = await getSubjectStatus(
         carolsAccountSubject.did,
       )
-      expect(statusAfterDeactivation?.hosting?.deactivatedAt).toBeTruthy()
-      expect(statusAfterDeactivation?.hosting?.status).toEqual('deactivated')
-      expect(statusAfterDeactivation?.reviewState).toEqual(REVIEWOPEN)
+      assert(isAccountHosting(statusAfterDeactivation?.hosting))
+      expect(statusAfterDeactivation.hosting.deactivatedAt).toBeTruthy()
+      expect(statusAfterDeactivation.hosting.status).toEqual('deactivated')
+      expect(statusAfterDeactivation.reviewState).toEqual(REVIEWOPEN)
 
       await emitAccountEvent(carolsAccountSubject, true)
       const statusAfterReactivation = await getSubjectStatus(
         carolsAccountSubject.did,
       )
-      expect(statusAfterReactivation?.hosting?.updatedAt).toBeTruthy()
-      expect(statusAfterReactivation?.hosting?.status).toEqual('active')
-      expect(statusAfterReactivation?.hosting?.deletedAt).toBeFalsy()
+      assert(isAccountHosting(statusAfterReactivation?.hosting))
+      expect(statusAfterReactivation.hosting.updatedAt).toBeTruthy()
+      expect(statusAfterReactivation.hosting.status).toEqual('active')
+      expect(statusAfterReactivation.hosting.deletedAt).toBeFalsy()
     })
 
     it('gets statuses by hosting properties', async () => {
@@ -176,9 +185,11 @@ describe('record and account events on moderation subjects', () => {
 
       expect(deactivatedOrDeletedStatuses.length).toEqual(3)
       expect(deletedStatusesInPastDay.length).toEqual(2)
+      assert(isStrongRef(deletedStatusesInPastDay[0]?.subject))
       expect(deletedStatusesInPastDay[0]?.subject.uri).toEqual(
         sc.posts[sc.dids.bob][1].ref.uriStr,
       )
+      assert(isRepoRef(deletedStatusesInPastDay[1]?.subject))
       expect(deletedStatusesInPastDay[1]?.subject.did).toEqual(sc.dids.bob)
       expect(deletedStatusesBeforeYesterday.length).toEqual(0)
     })

package/tests/takedown.test.ts

@@ -1,3 +1,5 @@
+import assert from 'node:assert'
+import { ComAtprotoAdminDefs, ToolsOzoneModerationDefs } from '@atproto/api'
 import {
   ModeratorClient,
   SeedClient,
@@ -37,12 +39,15 @@ describe('moderation', () => {
     })
 
     // Verify that that the takedown even exposes the policy specified for it
-    const { events } = await modClient.queryEvents({
+    const { events: eventViews } = await modClient.queryEvents({
       subject: sc.dids.bob,
       types: ['tools.ozone.moderation.defs#modEventTakedown'],
     })
 
-    expect(events[0].event.policies?.[0]).toEqual('trolling')
+    const { event } = eventViews[0]
+
+    assert(ToolsOzoneModerationDefs.isModEventTakedown(event))
+    expect(event.policies?.[0]).toEqual('trolling')
 
     // Verify that event stream can be filtered by policy
     const { events: filteredEvents } = await modClient.queryEvents({
@@ -50,6 +55,9 @@ describe('moderation', () => {
       policies: ['trolling'],
     })
 
-    expect(filteredEvents[0].subject.did).toEqual(sc.dids.bob)
+    const { subject } = filteredEvents[0]
+
+    assert(ComAtprotoAdminDefs.isRepoRef(subject))
+    expect(subject.did).toEqual(sc.dids.bob)
   })
 })