@atproto/ozone 0.1.53 → 0.1.55

package/tests/__snapshots__/get-record.test.ts.snap

@@ -29,6 +29,10 @@ Object {
   "moderation": Object {
     "subjectStatus": Object {
       "createdAt": "1970-01-01T00:00:00.000Z",
+      "hosting": Object {
+        "$type": "tools.ozone.moderation.defs#recordHosting",
+        "status": "unknown",
+      },
       "id": 1,
       "lastReportedAt": "1970-01-01T00:00:00.000Z",
       "lastReviewedAt": "1970-01-01T00:00:00.000Z",
@@ -129,6 +133,10 @@ Object {
   "moderation": Object {
     "subjectStatus": Object {
       "createdAt": "1970-01-01T00:00:00.000Z",
+      "hosting": Object {
+        "$type": "tools.ozone.moderation.defs#recordHosting",
+        "status": "unknown",
+      },
       "id": 1,
       "lastReportedAt": "1970-01-01T00:00:00.000Z",
       "lastReviewedAt": "1970-01-01T00:00:00.000Z",

package/tests/__snapshots__/get-records.test.ts.snap

@@ -32,6 +32,10 @@ Object {
       "moderation": Object {
         "subjectStatus": Object {
           "createdAt": "1970-01-01T00:00:00.000Z",
+          "hosting": Object {
+            "$type": "tools.ozone.moderation.defs#recordHosting",
+            "status": "unknown",
+          },
           "id": 1,
           "lastReportedAt": "1970-01-01T00:00:00.000Z",
           "lastReviewedAt": "1970-01-01T00:00:00.000Z",

package/tests/__snapshots__/get-repo.test.ts.snap

@@ -23,6 +23,10 @@ Object {
   "moderation": Object {
     "subjectStatus": Object {
       "createdAt": "1970-01-01T00:00:00.000Z",
+      "hosting": Object {
+        "$type": "tools.ozone.moderation.defs#accountHosting",
+        "status": "unknown",
+      },
       "id": 1,
       "lastReportedAt": "1970-01-01T00:00:00.000Z",
       "lastReviewedAt": "1970-01-01T00:00:00.000Z",

package/tests/__snapshots__/get-repos.test.ts.snap

@@ -26,6 +26,10 @@ Object {
       "moderation": Object {
         "subjectStatus": Object {
           "createdAt": "1970-01-01T00:00:00.000Z",
+          "hosting": Object {
+            "$type": "tools.ozone.moderation.defs#accountHosting",
+            "status": "unknown",
+          },
           "id": 1,
           "lastReportedAt": "1970-01-01T00:00:00.000Z",
           "lastReviewedAt": "1970-01-01T00:00:00.000Z",

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

@@ -19,6 +19,10 @@ Object {
     "moderation": Object {
       "subjectStatus": Object {
         "createdAt": "1970-01-01T00:00:00.000Z",
+        "hosting": Object {
+          "$type": "tools.ozone.moderation.defs#accountHosting",
+          "status": "unknown",
+        },
         "id": 1,
         "lastReportedAt": "1970-01-01T00:00:00.000Z",
         "lastReviewedAt": "1970-01-01T00:00:00.000Z",

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

@@ -4,6 +4,10 @@ exports[`moderation-statuses query statuses returns statuses filtered by subject
 Array [
   Object {
     "createdAt": "1970-01-01T00:00:00.000Z",
+    "hosting": Object {
+      "$type": "tools.ozone.moderation.defs#recordHosting",
+      "status": "unknown",
+    },
     "id": 7,
     "lastReportedAt": "1970-01-01T00:00:00.000Z",
     "reviewState": "tools.ozone.moderation.defs#reviewOpen",
@@ -23,6 +27,10 @@ Array [
   },
   Object {
     "createdAt": "1970-01-01T00:00:00.000Z",
+    "hosting": Object {
+      "$type": "tools.ozone.moderation.defs#accountHosting",
+      "status": "unknown",
+    },
     "id": 5,
     "lastReportedAt": "1970-01-01T00:00:00.000Z",
     "reviewState": "tools.ozone.moderation.defs#reviewOpen",
@@ -46,6 +54,10 @@ exports[`moderation-statuses query statuses returns statuses for subjects that r
 Array [
   Object {
     "createdAt": "1970-01-01T00:00:00.000Z",
+    "hosting": Object {
+      "$type": "tools.ozone.moderation.defs#recordHosting",
+      "status": "unknown",
+    },
     "id": 7,
     "lastReportedAt": "1970-01-01T00:00:00.000Z",
     "reviewState": "tools.ozone.moderation.defs#reviewOpen",
@@ -65,6 +77,10 @@ Array [
   },
   Object {
     "createdAt": "1970-01-01T00:00:00.000Z",
+    "hosting": Object {
+      "$type": "tools.ozone.moderation.defs#accountHosting",
+      "status": "unknown",
+    },
     "id": 5,
     "lastReportedAt": "1970-01-01T00:00:00.000Z",
     "reviewState": "tools.ozone.moderation.defs#reviewOpen",
@@ -83,6 +99,10 @@ Array [
   },
   Object {
     "createdAt": "1970-01-01T00:00:00.000Z",
+    "hosting": Object {
+      "$type": "tools.ozone.moderation.defs#recordHosting",
+      "status": "unknown",
+    },
     "id": 3,
     "lastReportedAt": "1970-01-01T00:00:00.000Z",
     "reviewState": "tools.ozone.moderation.defs#reviewOpen",
@@ -101,6 +121,10 @@ Array [
   },
   Object {
     "createdAt": "1970-01-01T00:00:00.000Z",
+    "hosting": Object {
+      "$type": "tools.ozone.moderation.defs#accountHosting",
+      "status": "unknown",
+    },
     "id": 1,
     "lastReportedAt": "1970-01-01T00:00:00.000Z",
     "reviewState": "tools.ozone.moderation.defs#reviewOpen",

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

@@ -0,0 +1,52 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`ozone-settings listOptions returns all personal settings 1`] = `
+Array [
+  Object {
+    "createdAt": "1970-01-01T00:00:00.000Z",
+    "createdBy": "user(1)",
+    "description": "List of external labelers that will be plugged into the client views",
+    "did": "user(1)",
+    "key": "tools.ozone.setting.client.externalLabelers",
+    "lastUpdatedBy": "user(1)",
+    "managerRole": "tools.ozone.team.defs#roleAdmin",
+    "scope": "instance",
+    "updatedAt": "1970-01-01T00:00:00.000Z",
+    "value": Object {
+      "dids": Array [
+        "user(0)",
+      ],
+    },
+  },
+  Object {
+    "createdAt": "1970-01-01T00:00:00.000Z",
+    "createdBy": "user(1)",
+    "description": "This determines how each queue is balanced when sorted by oldest first",
+    "did": "user(1)",
+    "key": "tools.ozone.setting.client.queueHash",
+    "lastUpdatedBy": "user(1)",
+    "managerRole": "tools.ozone.team.defs#roleAdmin",
+    "scope": "instance",
+    "updatedAt": "1970-01-01T00:00:00.000Z",
+    "value": Object {
+      "val": 10.5,
+    },
+  },
+  Object {
+    "createdAt": "1970-01-01T00:00:00.000Z",
+    "createdBy": "user(1)",
+    "description": "This determines how many queues the client interface will show",
+    "did": "user(1)",
+    "key": "tools.ozone.setting.client.queues",
+    "lastUpdatedBy": "user(1)",
+    "managerRole": "tools.ozone.team.defs#roleAdmin",
+    "scope": "instance",
+    "updatedAt": "1970-01-01T00:00:00.000Z",
+    "value": Object {
+      "stratosphere": Object {
+        "name": "Stratosphere",
+      },
+    },
+  },
+]
+`;

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

@@ -0,0 +1,185 @@
+import {
+  TestNetwork,
+  SeedClient,
+  basicSeed,
+  ModeratorClient,
+} from '@atproto/dev-env'
+import {
+  ComAtprotoModerationDefs,
+  ToolsOzoneModerationDefs,
+} from '@atproto/api'
+import { REVIEWOPEN } from '../src/lexicon/types/tools/ozone/moderation/defs'
+import { ToolsOzoneModerationEmitEvent as EmitModerationEvent } from '@atproto/api'
+describe('record and account events on moderation subjects', () => {
+  let network: TestNetwork
+  let sc: SeedClient
+  let modClient: ModeratorClient
+
+  beforeAll(async () => {
+    network = await TestNetwork.create({
+      dbPostgresSchema: 'ozone_record_and_account_events',
+    })
+    sc = network.getSeedClient()
+    modClient = network.ozone.getModClient()
+    await basicSeed(sc)
+    await network.processAll()
+  })
+
+  afterAll(async () => {
+    await network.close()
+  })
+
+  const getSubjectStatus = async (
+    subject: string,
+  ): Promise<ToolsOzoneModerationDefs.SubjectStatusView | undefined> => {
+    const res = await modClient.queryStatuses({
+      subject,
+    })
+    return res.subjectStatuses[0]
+  }
+
+  describe('record events', () => {
+    const emitRecordEvent = async (
+      subject: EmitModerationEvent.InputSchema['subject'],
+      op: 'create' | 'update' | 'delete',
+    ) => {
+      return await modClient.emitEvent(
+        {
+          event: {
+            op,
+            timestamp: new Date().toISOString(),
+            $type: 'tools.ozone.moderation.defs#recordEvent',
+          },
+          subject,
+          createdBy: 'did:example:admin',
+        },
+        'admin',
+      )
+    }
+
+    it('saves updated and deleted timestamps and record status', async () => {
+      const bobsPostSubject = {
+        $type: 'com.atproto.repo.strongRef',
+        uri: sc.posts[sc.dids.bob][1].ref.uriStr,
+        cid: sc.posts[sc.dids.bob][1].ref.cidStr,
+      }
+
+      await sc.createReport({
+        reportedBy: sc.dids.carol,
+        reasonType: ComAtprotoModerationDefs.REASONMISLEADING,
+        reason: 'misleading',
+        subject: bobsPostSubject,
+      })
+
+      await emitRecordEvent(bobsPostSubject, 'update')
+      const statusAfterUpdate = await getSubjectStatus(bobsPostSubject.uri)
+      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')
+      // Ensure that due to delete or update event, review state does not change
+      expect(statusAfterDelete?.reviewState).toEqual(REVIEWOPEN)
+    })
+  })
+  describe('account/identity events', () => {
+    const emitAccountEvent = async (
+      subject: EmitModerationEvent.InputSchema['subject'],
+      active: boolean,
+      status?: 'takendown' | 'deleted' | 'deactivated' | 'suspended',
+    ) => {
+      return await modClient.emitEvent(
+        {
+          event: {
+            status,
+            active,
+            timestamp: new Date().toISOString(),
+            $type: 'tools.ozone.moderation.defs#accountEvent',
+          },
+          subject,
+          createdBy: 'did:example:admin',
+        },
+        'admin',
+      )
+    }
+
+    it('saves updated and deleted timestamps and account status', async () => {
+      const carolsAccountSubject = {
+        $type: 'com.atproto.admin.defs#repoRef',
+        did: sc.dids.carol,
+      }
+
+      await sc.createReport({
+        reportedBy: sc.dids.carol,
+        reasonType: ComAtprotoModerationDefs.REASONMISLEADING,
+        reason: 'misleading',
+        subject: carolsAccountSubject,
+      })
+
+      await emitAccountEvent(carolsAccountSubject, false, 'deactivated')
+      const statusAfterDeactivation = await getSubjectStatus(
+        carolsAccountSubject.did,
+      )
+      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()
+    })
+
+    it('gets statuses by hosting properties', async () => {
+      await Promise.all([
+        emitAccountEvent(
+          {
+            $type: 'com.atproto.admin.defs#repoRef',
+            did: sc.dids.carol,
+          },
+          false,
+          'deactivated',
+        ),
+        emitAccountEvent(
+          {
+            $type: 'com.atproto.admin.defs#repoRef',
+            did: sc.dids.bob,
+          },
+          false,
+          'deleted',
+        ),
+      ])
+      const [
+        { subjectStatuses: deactivatedOrDeletedStatuses },
+        { subjectStatuses: deletedStatusesInPastDay },
+        { subjectStatuses: deletedStatusesBeforeYesterday },
+      ] = await Promise.all([
+        modClient.queryStatuses({
+          hostingStatuses: ['deactivated', 'deleted'],
+        }),
+        modClient.queryStatuses({
+          hostingDeletedAfter: new Date(
+            Date.now() - 1000 * 60 * 60 * 24,
+          ).toISOString(),
+        }),
+        modClient.queryStatuses({
+          hostingDeletedBefore: new Date(
+            Date.now() - 1000 * 60 * 60 * 24,
+          ).toISOString(),
+        }),
+      ])
+
+      expect(deactivatedOrDeletedStatuses.length).toEqual(3)
+      expect(deletedStatusesInPastDay.length).toEqual(2)
+      expect(deletedStatusesInPastDay[0]?.subject.uri).toEqual(
+        sc.posts[sc.dids.bob][1].ref.uriStr,
+      )
+      expect(deletedStatusesInPastDay[1]?.subject.did).toEqual(sc.dids.bob)
+      expect(deletedStatusesBeforeYesterday.length).toEqual(0)
+    })
+  })
+})

package/tests/settings.test.ts

@@ -0,0 +1,310 @@
+import { TestNetwork, SeedClient, basicSeed } from '@atproto/dev-env'
+import AtpAgent, {
+  ToolsOzoneSettingListOptions,
+  ToolsOzoneSettingUpsertOption,
+} from '@atproto/api'
+import { ids } from '../src/lexicon/lexicons'
+import { SettingScope } from '../dist/db/schema/setting'
+import { forSnapshot } from './_util'
+
+describe('ozone-settings', () => {
+  let network: TestNetwork
+  let agent: AtpAgent
+  let sc: SeedClient
+
+  const upsertOption = async (
+    setting: ToolsOzoneSettingUpsertOption.InputSchema,
+    callerRole: 'admin' | 'moderator' | 'triage' = 'admin',
+  ) => {
+    const { data } = await agent.tools.ozone.setting.upsertOption(setting, {
+      encoding: 'application/json',
+      headers: await network.ozone.modHeaders(
+        ids.ToolsOzoneSettingUpsertOption,
+        callerRole,
+      ),
+    })
+
+    return data
+  }
+
+  const removeOptions = async (
+    keys: string[],
+    scope: SettingScope,
+    callerRole: 'admin' | 'moderator' | 'triage' = 'admin',
+  ) => {
+    await agent.tools.ozone.setting.removeOptions(
+      { keys, scope },
+      {
+        encoding: 'application/json',
+        headers: await network.ozone.modHeaders(
+          ids.ToolsOzoneSettingRemoveOptions,
+          callerRole,
+        ),
+      },
+    )
+  }
+
+  const listOptions = async (
+    params: ToolsOzoneSettingListOptions.QueryParams,
+    callerRole: 'admin' | 'moderator' | 'triage' = 'moderator',
+  ) => {
+    const { data } = await agent.tools.ozone.setting.listOptions(params, {
+      headers: await network.ozone.modHeaders(
+        ids.ToolsOzoneSettingListOptions,
+        callerRole,
+      ),
+    })
+    return data
+  }
+
+  beforeAll(async () => {
+    network = await TestNetwork.create({
+      dbPostgresSchema: 'ozone_settings',
+    })
+    agent = network.ozone.getClient()
+    sc = network.getSeedClient()
+    await basicSeed(sc)
+    await network.processAll()
+  })
+
+  afterAll(async () => {
+    await network.close()
+  })
+
+  describe('upsertOption', () => {
+    afterAll(async () => {
+      await removeOptions(
+        ['tools.ozone.setting.upsertTest.labelers'],
+        'personal',
+      )
+    })
+    it('only allows managerRole to update instance settings', async () => {
+      await upsertOption({
+        scope: 'instance',
+        key: 'tools.ozone.setting.upsertTest.labelers',
+        value: { dids: ['did:plc:xyz'] },
+        description: 'triage users can not update this',
+        managerRole: 'tools.ozone.team.defs#roleModerator',
+      })
+
+      await expect(
+        upsertOption(
+          {
+            scope: 'instance',
+            key: 'tools.ozone.setting.upsertTest.labelers',
+            value: { noDids: 'test' },
+            description: 'triage users can not update this',
+            managerRole: 'tools.ozone.team.defs#roleModerator',
+          },
+          'triage',
+        ),
+      ).rejects.toThrow(/Not permitted/gi)
+
+      await upsertOption(
+        {
+          scope: 'instance',
+          key: 'tools.ozone.setting.upsertTest.labelers',
+          value: { noDids: 'test' },
+          description:
+            'My personal labelers that i want to use when browsing ozone',
+          managerRole: 'tools.ozone.team.defs#roleModerator',
+        },
+        'moderator',
+      )
+
+      const afterUpdatedByModerator = await listOptions(
+        {
+          scope: 'instance',
+          prefix: 'tools.ozone.setting.upsertTest.labelers',
+        },
+        'moderator',
+      )
+      expect(afterUpdatedByModerator.options[0].value?.['dids']).toBeFalsy()
+      expect(afterUpdatedByModerator.options[0].value?.['noDids']).toEqual(
+        'test',
+      )
+      await upsertOption(
+        {
+          scope: 'instance',
+          key: 'tools.ozone.setting.upsertTest.labelers',
+          value: { dids: 'test' },
+          description:
+            'My personal labelers that i want to use when browsing ozone',
+          managerRole: 'tools.ozone.team.defs#roleModerator',
+        },
+        'moderator',
+      )
+
+      const afterUpdatedByAdmin = await listOptions(
+        {
+          scope: 'instance',
+          prefix: 'tools.ozone.setting.upsertTest.labelers',
+        },
+        'admin',
+      )
+      expect(afterUpdatedByAdmin.options[0].value?.['noDids']).toBeFalsy()
+      expect(afterUpdatedByAdmin.options[0].value?.['dids']).toEqual('test')
+    })
+  })
+
+  describe('listOptions', () => {
+    beforeAll(async () => {
+      await Promise.all([
+        upsertOption({
+          scope: 'instance',
+          key: 'tools.ozone.setting.client.queues',
+          value: { stratosphere: { name: 'Stratosphere' } },
+          description:
+            'This determines how many queues the client interface will show',
+          managerRole: 'tools.ozone.team.defs#roleAdmin',
+        }),
+        upsertOption({
+          scope: 'instance',
+          key: 'tools.ozone.setting.client.queueHash',
+          value: { val: 10.5 },
+          description:
+            'This determines how each queue is balanced when sorted by oldest first',
+          managerRole: 'tools.ozone.team.defs#roleAdmin',
+        }),
+        upsertOption({
+          scope: 'instance',
+          key: 'tools.ozone.setting.client.externalLabelers',
+          value: { dids: ['did:plc:xyz'] },
+          description:
+            'List of external labelers that will be plugged into the client views',
+          managerRole: 'tools.ozone.team.defs#roleAdmin',
+        }),
+      ])
+    })
+
+    afterAll(async () => {
+      await removeOptions(
+        [
+          'tools.ozone.setting.client.queues',
+          'tools.ozone.setting.client.queueHash',
+          'tools.ozone.setting.client.externalLabelers',
+        ],
+        'instance',
+      )
+    })
+
+    it('returns all personal settings', async () => {
+      const result = await listOptions({ prefix: 'tools.ozone.setting.client' })
+      expect(result.options.length).toBe(3)
+
+      expect(forSnapshot(result.options)).toMatchSnapshot()
+    })
+
+    it('allows paginating options', async () => {
+      const params = { prefix: 'tools.ozone.setting.client', limit: 1 }
+      const pageOne = await listOptions(params)
+      const pageTwo = await listOptions({
+        ...params,
+        cursor: pageOne.cursor,
+      })
+      const pageThree = await listOptions({
+        ...params,
+        cursor: pageTwo.cursor,
+      })
+      const pageFour = await listOptions({
+        ...params,
+        cursor: pageThree.cursor,
+      })
+
+      expect(pageFour.options.length).toBe(0)
+      expect(pageFour.cursor).toBeUndefined()
+    })
+  })
+
+  describe('removeOptions', () => {
+    afterAll(async () => {
+      await Promise.all([
+        removeOptions(['tools.ozone.setting.personal.labelers'], 'personal'),
+        removeOptions(
+          ['tools.ozone.setting.only.mod', 'tools.ozone.setting.only.admin'],
+          'instance',
+        ),
+      ])
+    })
+
+    it('only allows the owner to delete personal setting', async () => {
+      await upsertOption({
+        scope: 'personal',
+        key: 'tools.ozone.setting.personal.labelers',
+        value: { dids: ['did:plc:xyz'] },
+        description:
+          'My personal labelers that i want to use when browsing ozone',
+        managerRole: 'tools.ozone.team.defs#roleOwner',
+      })
+
+      // one user can't remove personal setting of another
+      await removeOptions(
+        ['tools.ozone.setting.personal.labelers'],
+        'personal',
+        'triage',
+      )
+      const list = await listOptions({ scope: 'personal' }, 'admin')
+      expect(list.options.length).toBe(1)
+
+      // the owner of the personal setting can remove their own setting
+      await removeOptions(['tools.ozone.setting.personal.labelers'], 'personal')
+      const listAfterRemoval = await listOptions({ scope: 'personal' }, 'admin')
+      expect(listAfterRemoval.options.length).toBe(0)
+    })
+
+    it('only allows managerRole to delete instance setting', async () => {
+      await Promise.all([
+        upsertOption({
+          scope: 'instance',
+          key: 'tools.ozone.setting.only.mod',
+          value: { dids: ['did:plc:xyz'] },
+          description: 'Triage mods can not manage these',
+          managerRole: 'tools.ozone.team.defs#roleModerator',
+        }),
+        upsertOption({
+          scope: 'instance',
+          key: 'tools.ozone.setting.only.admin',
+          value: { dids: ['did:plc:xyz'] },
+          description: 'Moderators or triage mods can not manage these',
+          managerRole: 'tools.ozone.team.defs#roleAdmin',
+        }),
+      ])
+
+      await Promise.all([
+        removeOptions(['tools.ozone.setting.only.mod'], 'instance', 'triage'),
+        removeOptions(
+          ['tools.ozone.setting.only.admin'],
+          'instance',
+          'moderator',
+        ),
+        removeOptions(['tools.ozone.setting.only.admin'], 'instance', 'triage'),
+      ])
+
+      const afterFailedAttempt = await listOptions(
+        { scope: 'instance', prefix: 'tools.ozone.setting.only' },
+        'admin',
+      )
+      const keysAfterFailedAttempt = afterFailedAttempt.options.map(
+        (o) => o.key,
+      )
+
+      const keys = [
+        'tools.ozone.setting.only.mod',
+        'tools.ozone.setting.only.admin',
+      ]
+
+      keys.forEach((key) => expect(keysAfterFailedAttempt).toContain(key))
+
+      await Promise.all([
+        removeOptions(['tools.ozone.setting.only.mod'], 'instance', 'admin'),
+        removeOptions(['tools.ozone.setting.only.admin'], 'instance', 'admin'),
+      ])
+
+      const afterRemoval = await listOptions(
+        { scope: 'instance', prefix: 'tools.ozone.setting.only' },
+        'admin',
+      )
+      expect(afterRemoval.options.length).toBe(0)
+    })
+  })
+})