@atproto/ozone 0.1.44 → 0.1.46

package/src/lexicon/types/app/bsky/actor/defs.ts

@@ -7,6 +7,7 @@ import { isObj, hasProp } from '../../../../util'
 import { CID } from 'multiformats/cid'
 import * as ComAtprotoLabelDefs from '../../../com/atproto/label/defs'
 import * as AppBskyGraphDefs from '../graph/defs'
+import * as ComAtprotoRepoStrongRef from '../../../com/atproto/repo/strongRef'
 
 export interface ProfileViewBasic {
   did: string
@@ -74,6 +75,7 @@ export interface ProfileViewDetailed {
   createdAt?: string
   viewer?: ViewerState
   labels?: ComAtprotoLabelDefs.Label[]
+  pinnedPost?: ComAtprotoRepoStrongRef.Main
   [k: string]: unknown
 }
 
@@ -469,6 +471,8 @@ export interface BskyAppStatePref {
   activeProgressGuide?: BskyAppProgressGuide
   /** An array of tokens which identify nudges (modals, popups, tours, highlight dots) that should be shown to the user. */
   queuedNudges?: string[]
+  /** Storage for NUXs the user has encountered. */
+  nuxs?: Nux[]
   [k: string]: unknown
 }
 
@@ -501,3 +505,24 @@ export function isBskyAppProgressGuide(v: unknown): v is BskyAppProgressGuide {
 export function validateBskyAppProgressGuide(v: unknown): ValidationResult {
   return lexicons.validate('app.bsky.actor.defs#bskyAppProgressGuide', v)
 }
+
+/** A new user experiences (NUX) storage object */
+export interface Nux {
+  id: string
+  completed: boolean
+  /** Arbitrary data for the NUX. The structure is defined by the NUX itself. Limited to 300 characters. */
+  data?: string
+  /** The date and time at which the NUX will expire and should be considered completed. */
+  expiresAt?: string
+  [k: string]: unknown
+}
+
+export function isNux(v: unknown): v is Nux {
+  return (
+    isObj(v) && hasProp(v, '$type') && v.$type === 'app.bsky.actor.defs#nux'
+  )
+}
+
+export function validateNux(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.actor.defs#nux', v)
+}

package/src/lexicon/types/app/bsky/actor/profile.ts

@@ -20,6 +20,7 @@ export interface Record {
     | ComAtprotoLabelDefs.SelfLabels
     | { $type: string; [k: string]: unknown }
   joinedViaStarterPack?: ComAtprotoRepoStrongRef.Main
+  pinnedPost?: ComAtprotoRepoStrongRef.Main
   createdAt?: string
   [k: string]: unknown
 }

package/src/lexicon/types/app/bsky/feed/defs.ts

@@ -55,6 +55,7 @@ export interface ViewerState {
   threadMuted?: boolean
   replyDisabled?: boolean
   embeddingDisabled?: boolean
+  pinned?: boolean
   [k: string]: unknown
 }
 
@@ -73,7 +74,7 @@ export function validateViewerState(v: unknown): ValidationResult {
 export interface FeedViewPost {
   post: PostView
   reply?: ReplyRef
-  reason?: ReasonRepost | { $type: string; [k: string]: unknown }
+  reason?: ReasonRepost | ReasonPin | { $type: string; [k: string]: unknown }
   /** Context provided by feed generator that may be passed back alongside interactions. */
   feedContext?: string
   [k: string]: unknown
@@ -134,6 +135,22 @@ export function validateReasonRepost(v: unknown): ValidationResult {
   return lexicons.validate('app.bsky.feed.defs#reasonRepost', v)
 }
 
+export interface ReasonPin {
+  [k: string]: unknown
+}
+
+export function isReasonPin(v: unknown): v is ReasonPin {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.feed.defs#reasonPin'
+  )
+}
+
+export function validateReasonPin(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.feed.defs#reasonPin', v)
+}
+
 export interface ThreadViewPost {
   post: PostView
   parent?:
@@ -265,7 +282,10 @@ export function validateGeneratorViewerState(v: unknown): ValidationResult {
 
 export interface SkeletonFeedPost {
   post: string
-  reason?: SkeletonReasonRepost | { $type: string; [k: string]: unknown }
+  reason?:
+    | SkeletonReasonRepost
+    | SkeletonReasonPin
+    | { $type: string; [k: string]: unknown }
   /** Context that will be passed through to client and may be passed to feed generator back alongside interactions. */
   feedContext?: string
   [k: string]: unknown
@@ -300,6 +320,22 @@ export function validateSkeletonReasonRepost(v: unknown): ValidationResult {
   return lexicons.validate('app.bsky.feed.defs#skeletonReasonRepost', v)
 }
 
+export interface SkeletonReasonPin {
+  [k: string]: unknown
+}
+
+export function isSkeletonReasonPin(v: unknown): v is SkeletonReasonPin {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.feed.defs#skeletonReasonPin'
+  )
+}
+
+export function validateSkeletonReasonPin(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.feed.defs#skeletonReasonPin', v)
+}
+
 export interface ThreadgateView {
   uri?: string
   cid?: string

package/src/lexicon/types/app/bsky/feed/getAuthorFeed.ts

@@ -20,6 +20,7 @@ export interface QueryParams {
     | 'posts_with_media'
     | 'posts_and_author_threads'
     | (string & {})
+  includePins: boolean
 }
 
 export type InputSchema = undefined

package/src/lexicon/types/app/bsky/graph/getSuggestedFollowsByActor.ts

@@ -17,6 +17,8 @@ export type InputSchema = undefined
 
 export interface OutputSchema {
   suggestions: AppBskyActorDefs.ProfileView[]
+  /** If true, response has fallen-back to generic results, and is not scoped using relativeToDid */
+  isFallback?: boolean
   [k: string]: unknown
 }
 

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

@@ -23,6 +23,8 @@ export type InputSchema = undefined
 export interface OutputSchema {
   cursor?: string
   actors: AppBskyUnspeccedDefs.SkeletonSearchActor[]
+  /** DID of the account these suggestions are relative to. If this is returned undefined, suggestions are based on the viewer. */
+  relativeToDid?: string
   [k: string]: unknown
 }
 

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

@@ -162,6 +162,8 @@ export interface ModEventTakedown {
   comment?: string
   /** Indicates how long the takedown should be in effect before automatically expiring. */
   durationInHours?: number
+  /** 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/queryStatuses.ts

@@ -10,6 +10,9 @@ import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
 import * as ToolsOzoneModerationDefs from './defs'
 
 export interface QueryParams {
+  /** All subjects belonging to the account specified in the 'subject' param will be returned. */
+  includeAllUserRecords?: boolean
+  /** The subject to get the status for. */
   subject?: string
   /** Search subjects by keyword from comments */
   comment?: string

package/src/mod-service/index.ts

@@ -3,7 +3,7 @@ import { Insertable, sql } from 'kysely'
 import { CID } from 'multiformats/cid'
 import { AtUri, INVALID_HANDLE } from '@atproto/syntax'
 import { InvalidRequestError } from '@atproto/xrpc-server'
-import { addHoursToDate } from '@atproto/common'
+import { addHoursToDate, chunkArray } from '@atproto/common'
 import { Keypair } from '@atproto/crypto'
 import { IdResolver } from '@atproto/identity'
 import { AtpAgent } from '@atproto/api'
@@ -18,6 +18,8 @@ import {
   isModEventTakedown,
   isModEventEmail,
   isModEventTag,
+  REVIEWESCALATED,
+  REVIEWOPEN,
 } from '../lexicon/types/tools/ozone/moderation/defs'
 import { RepoRef, RepoBlobRef } from '../lexicon/types/com/atproto/admin/defs'
 import {
@@ -279,6 +281,52 @@ export class ModerationService {
     return await builder.execute()
   }
 
+  async resolveSubjectsForAccount(did: string, createdBy: string) {
+    const subjectsToBeResolved = await this.db.db
+      .selectFrom('moderation_subject_status')
+      .where('did', '=', did)
+      .where('recordPath', '!=', '')
+      .where('reviewState', 'in', [REVIEWESCALATED, REVIEWOPEN])
+      .selectAll()
+      .execute()
+
+    if (subjectsToBeResolved.length === 0) {
+      return
+    }
+
+    // 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(
+        subjects.map(async (subject) => {
+          const eventData = {
+            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',
+              },
+              ...eventData,
+            })
+          }
+
+          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',
+            },
+            ...eventData,
+          })
+        }),
+      )
+    }
+  }
+
   async logEvent(info: {
     event: ModEventType
     subject: ModSubject
@@ -320,6 +368,10 @@ export class ModerationService {
       }
     }
 
+    if (isModEventTakedown(event) && event.acknowledgeAccountSubjects) {
+      meta.acknowledgeAccountSubjects = true
+    }
+
     // Keep trace of reports that came in while the reporter was in muted stated
     if (isModEventReport(event)) {
       const isReportingMuted = await this.isReportingMutedForSubject(createdBy)
@@ -677,6 +729,7 @@ export class ModerationService {
   }
 
   async getSubjectStatuses({
+    includeAllUserRecords,
     cursor,
     limit = 50,
     takendown,
@@ -696,6 +749,7 @@ export class ModerationService {
     tags,
     excludeTags,
   }: {
+    includeAllUserRecords?: boolean
     cursor?: string
     limit?: number
     takendown?: boolean
@@ -720,13 +774,19 @@ export class ModerationService {
 
     if (subject) {
       const subjectInfo = getStatusIdentifierFromSubject(subject)
-      builder = builder
-        .where('moderation_subject_status.did', '=', subjectInfo.did)
-        .where((qb) =>
+      builder = builder.where(
+        'moderation_subject_status.did',
+        '=',
+        subjectInfo.did,
+      )
+
+      if (!includeAllUserRecords) {
+        builder = builder.where((qb) =>
           subjectInfo.recordPath
             ? qb.where('recordPath', '=', subjectInfo.recordPath)
             : qb.where('recordPath', '=', ''),
         )
+      }
     }
 
     if (ignoreSubjects?.length) {

package/src/mod-service/views.ts

@@ -122,6 +122,16 @@ export class ModerationViews {
       }
     }
 
+    if (
+      event.action === 'tools.ozone.moderation.defs#modEventTakedown' &&
+      event.meta?.acknowledgeAccountSubjects
+    ) {
+      eventView.event = {
+        ...eventView.event,
+        acknowledgeAccountSubjects: event.meta?.acknowledgeAccountSubjects,
+      }
+    }
+
     if (event.action === 'tools.ozone.moderation.defs#modEventLabel') {
       eventView.event = {
         ...eventView.event,

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

@@ -0,0 +1,131 @@
+import {
+  TestNetwork,
+  RecordRef,
+  SeedClient,
+  basicSeed,
+  ModeratorClient,
+} from '@atproto/dev-env'
+import {
+  REASONAPPEAL,
+  REASONOTHER,
+  REASONSPAM,
+} from '../src/lexicon/types/com/atproto/moderation/defs'
+import {
+  REVIEWCLOSED,
+  REVIEWESCALATED,
+  REVIEWOPEN,
+  SubjectStatusView,
+} from '../src/lexicon/types/tools/ozone/moderation/defs'
+import { isRepoRef } from '../src/lexicon/types/com/atproto/admin/defs'
+import { ComAtprotoRepoStrongRef } from '@atproto/api'
+
+describe('moderation', () => {
+  let network: TestNetwork
+  let sc: SeedClient
+  let modClient: ModeratorClient
+
+  const repoSubject = (did: string) => ({
+    $type: 'com.atproto.admin.defs#repoRef',
+    did,
+  })
+
+  const recordSubject = (ref: RecordRef) => ({
+    $type: 'com.atproto.repo.strongRef',
+    uri: ref.uriStr,
+    cid: ref.cidStr,
+  })
+
+  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.', async () => {
+    const postOne = sc.posts[sc.dids.bob][0].ref
+    const postTwo = sc.posts[sc.dids.bob][1].ref
+    await Promise.all([
+      sc.createReport({
+        reasonType: REASONSPAM,
+        subject: repoSubject(sc.dids.bob),
+        reportedBy: sc.dids.alice,
+      }),
+      sc.createReport({
+        reasonType: REASONOTHER,
+        reason: 'defamation',
+        subject: recordSubject(postOne),
+        reportedBy: sc.dids.carol,
+      }),
+      sc.createReport({
+        reasonType: REASONOTHER,
+        reason: 'defamation',
+        subject: recordSubject(postTwo),
+        reportedBy: sc.dids.carol,
+      }),
+    ])
+
+    await modClient.emitEvent({
+      event: {
+        $type: 'tools.ozone.moderation.defs#modEventReport',
+        reportType: REASONAPPEAL,
+      },
+      subject: recordSubject(postTwo),
+    })
+
+    const { subjectStatuses: statusesBefore } = await modClient.queryStatuses({
+      subject: sc.dids.bob,
+      includeAllUserRecords: true,
+    })
+
+    await modClient.performTakedown({
+      subject: repoSubject(sc.dids.bob),
+      acknowledgeAccountSubjects: true,
+    })
+
+    const { subjectStatuses: statusesAfter } = await modClient.queryStatuses({
+      subject: sc.dids.bob,
+      includeAllUserRecords: true,
+    })
+
+    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)
+        }
+      })
+
+      return states
+    }
+
+    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)
+
+    // 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)
+  })
+})