@atproto/bsky 0.0.15 → 0.0.17

package/src/api/app/bsky/feed/searchPosts.ts

@@ -2,11 +2,14 @@ import AppContext from '../../../../context'
 import { Server } from '../../../../lexicon'
 import { InvalidRequestError } from '@atproto/xrpc-server'
 import AtpAgent from '@atproto/api'
-import { AtUri } from '@atproto/syntax'
 import { mapDefined } from '@atproto/common'
 import { QueryParams } from '../../../../lexicon/types/app/bsky/feed/searchPosts'
 import { Database } from '../../../../db'
-import { FeedHydrationState, FeedService } from '../../../../services/feed'
+import {
+  FeedHydrationState,
+  FeedRow,
+  FeedService,
+} from '../../../../services/feed'
 import { ActorService } from '../../../../services/actor'
 import { createPipeline } from '../../../../pipeline'
 
@@ -51,9 +54,11 @@ const skeleton = async (
     cursor: params.cursor,
     limit: params.limit,
   })
+  const postUris = res.data.posts.map((a) => a.uri)
+  const feedItems = await ctx.feedService.postUrisToFeedItems(postUris)
   return {
     params,
-    postUris: res.data.posts.map((a) => a.uri),
+    feedItems,
     cursor: res.data.cursor,
     hitsTotal: res.data.hitsTotal,
   }
@@ -64,12 +69,10 @@ const hydration = async (
   ctx: Context,
 ): Promise<HydrationState> => {
   const { feedService } = ctx
-  const { params, postUris } = state
-  const uris = new Set<string>(postUris)
-  const dids = new Set<string>(postUris.map((uri) => new AtUri(uri).hostname))
+  const { params, feedItems } = state
+  const refs = feedService.feedItemRefs(feedItems)
   const hydrated = await feedService.feedHydration({
-    uris,
-    dids,
+    ...refs,
     viewer: params.viewer,
   })
   return { ...state, ...hydrated }
@@ -77,32 +80,32 @@ const hydration = async (
 
 const noBlocks = (state: HydrationState): HydrationState => {
   const { viewer } = state.params
-  state.postUris = state.postUris.filter((uri) => {
-    const post = state.posts[uri]
-    if (!viewer || !post) return true
-    return !state.bam.block([viewer, post.creator])
+  state.feedItems = state.feedItems.filter((item) => {
+    if (!viewer) return true
+    return !state.bam.block([viewer, item.postAuthorDid])
   })
   return state
 }
 
 const presentation = (state: HydrationState, ctx: Context) => {
   const { feedService, actorService } = ctx
-  const { postUris, profiles, params } = state
+  const { feedItems, profiles, params } = state
   const actors = actorService.views.profileBasicPresentation(
     Object.keys(profiles),
     state,
-    { viewer: params.viewer },
+    params.viewer,
   )
 
-  const postViews = mapDefined(postUris, (uri) =>
+  const postViews = mapDefined(feedItems, (item) =>
     feedService.views.formatPostView(
-      uri,
+      item.postUri,
       actors,
       state.posts,
       state.threadgates,
       state.embeds,
       state.labels,
       state.lists,
+      params.viewer,
     ),
   )
   return { posts: postViews, cursor: state.cursor, hitsTotal: state.hitsTotal }
@@ -119,7 +122,7 @@ type Params = QueryParams & { viewer: string | null }
 
 type SkeletonState = {
   params: Params
-  postUris: string[]
+  feedItems: FeedRow[]
   hitsTotal?: number
   cursor?: string
 }

package/src/api/app/bsky/graph/getList.ts

@@ -91,17 +91,20 @@ const presentation = (state: HydrationState, ctx: Context) => {
   const actors = actorService.views.profilePresentation(
     Object.keys(profileState.profiles),
     profileState,
-    { viewer: params.viewer },
+    params.viewer,
   )
   const creator = actors[list.creator]
   if (!creator) {
     throw new InvalidRequestError(`Actor not found: ${list.handle}`)
   }
   const listView = graphService.formatListView(list, actors)
+  if (!listView) {
+    throw new InvalidRequestError('List not found')
+  }
   const items = mapDefined(listItems, (item) => {
     const subject = actors[item.did]
     if (!subject) return
-    return { subject }
+    return { uri: item.uri, subject }
   })
   return { list: listView, items, cursor }
 }
@@ -119,7 +122,7 @@ type Params = QueryParams & {
 type SkeletonState = {
   params: Params
   list: Actor & ListInfo
-  listItems: (Actor & { cid: string; sortAt: string })[]
+  listItems: (Actor & { uri: string; cid: string; sortAt: string })[]
   cursor?: string
 }
 

package/src/api/app/bsky/graph/getListBlocks.ts

@@ -1,3 +1,4 @@
+import { mapDefined } from '@atproto/common'
 import { Server } from '../../../../lexicon'
 import { QueryParams } from '../../../../lexicon/types/app/bsky/graph/getListBlocks'
 import { paginate, TimeCidKeyset } from '../../../../db/pagination'
@@ -87,9 +88,9 @@ const presentation = (state: HydrationState, ctx: Context) => {
   const actors = actorService.views.profilePresentation(
     Object.keys(profileState.profiles),
     profileState,
-    { viewer: params.viewer },
+    params.viewer,
   )
-  const lists = listInfos.map((list) =>
+  const lists = mapDefined(listInfos, (list) =>
     graphService.formatListView(list, actors),
   )
   return { lists, cursor }

package/src/api/app/bsky/graph/getListMutes.ts

@@ -1,3 +1,4 @@
+import { mapDefined } from '@atproto/common'
 import { Server } from '../../../../lexicon'
 import { paginate, TimeCidKeyset } from '../../../../db/pagination'
 import AppContext from '../../../../context'
@@ -34,7 +35,7 @@ export default function (server: Server, ctx: AppContext) {
       const actorService = ctx.services.actor(db)
       const profiles = await actorService.views.profiles(listsRes, requester)
 
-      const lists = listsRes.map((row) =>
+      const lists = mapDefined(listsRes, (row) =>
         graphService.formatListView(row, profiles),
       )
 

package/src/api/app/bsky/graph/getLists.ts

@@ -1,3 +1,4 @@
+import { mapDefined } from '@atproto/common'
 import { InvalidRequestError } from '@atproto/xrpc-server'
 import { Server } from '../../../../lexicon'
 import { paginate, TimeCidKeyset } from '../../../../db/pagination'
@@ -39,7 +40,7 @@ export default function (server: Server, ctx: AppContext) {
         throw new InvalidRequestError(`Actor not found: ${actor}`)
       }
 
-      const lists = listsRes.map((row) =>
+      const lists = mapDefined(listsRes, (row) =>
         graphService.formatListView(row, profiles),
       )
 

package/src/api/app/bsky/unspecced/getPopularFeedGenerators.ts

@@ -57,7 +57,9 @@ export default function (server: Server, ctx: AppContext) {
         const gen = genInfos[row.uri]
         if (!gen) continue
         const view = feedService.views.formatFeedGeneratorView(gen, profiles)
-        genViews.push(view)
+        if (view) {
+          genViews.push(view)
+        }
       }
 
       return {

package/src/api/blob-resolver.ts

@@ -6,11 +6,11 @@ import { CID } from 'multiformats/cid'
 import { ensureValidDid } from '@atproto/syntax'
 import { forwardStreamErrors, VerifyCidTransform } from '@atproto/common'
 import { IdResolver, DidNotFoundError } from '@atproto/identity'
-import { TAKEDOWN } from '../lexicon/types/com/atproto/admin/defs'
 import AppContext from '../context'
 import { httpLogger as log } from '../logger'
 import { retryHttp } from '../util/retry'
 import { Database } from '../db'
+import { sql } from 'kysely'
 
 // Resolve and verify blob from its origin host
 
@@ -84,19 +84,14 @@ export async function resolveBlob(
   idResolver: IdResolver,
 ) {
   const cidStr = cid.toString()
+
   const [{ pds }, takedown] = await Promise.all([
     idResolver.did.resolveAtprotoData(did), // @TODO cache did info
     db.db
-      .selectFrom('moderation_action_subject_blob')
-      .select('actionId')
-      .innerJoin(
-        'moderation_action',
-        'moderation_action.id',
-        'moderation_action_subject_blob.actionId',
-      )
-      .where('cid', '=', cidStr)
-      .where('action', '=', TAKEDOWN)
-      .where('reversedAt', 'is', null)
+      .selectFrom('moderation_subject_status')
+      .select('id')
+      .where('blobCids', '@>', sql`CAST(${JSON.stringify([cidStr])} AS JSONB)`)
+      .where('takendown', 'is', true)
       .executeTakeFirst(),
   ])
   if (takedown) {

package/src/api/com/atproto/admin/emitModerationEvent.ts

@@ -0,0 +1,220 @@
+import { CID } from 'multiformats/cid'
+import { AtUri } from '@atproto/syntax'
+import {
+  AuthRequiredError,
+  InvalidRequestError,
+  UpstreamFailureError,
+} from '@atproto/xrpc-server'
+import { Server } from '../../../../lexicon'
+import AppContext from '../../../../context'
+import { getSubject } from '../moderation/util'
+import {
+  isModEventLabel,
+  isModEventReverseTakedown,
+  isModEventTakedown,
+} from '../../../../lexicon/types/com/atproto/admin/defs'
+import { TakedownSubjects } from '../../../../services/moderation'
+import { retryHttp } from '../../../../util/retry'
+
+export default function (server: Server, ctx: AppContext) {
+  server.com.atproto.admin.emitModerationEvent({
+    auth: ctx.roleVerifier,
+    handler: async ({ input, auth }) => {
+      const access = auth.credentials
+      const db = ctx.db.getPrimary()
+      const moderationService = ctx.services.moderation(db)
+      const { subject, createdBy, subjectBlobCids, event } = input.body
+      const isTakedownEvent = isModEventTakedown(event)
+      const isReverseTakedownEvent = isModEventReverseTakedown(event)
+      const isLabelEvent = isModEventLabel(event)
+
+      // apply access rules
+
+      // if less than moderator access then can not takedown an account
+      if (!access.moderator && isTakedownEvent && 'did' in subject) {
+        throw new AuthRequiredError(
+          'Must be a full moderator to perform an account takedown',
+        )
+      }
+      // if less than moderator access then can only take ack and escalation actions
+      if (!access.moderator && (isTakedownEvent || isReverseTakedownEvent)) {
+        throw new AuthRequiredError(
+          'Must be a full moderator to take this type of action',
+        )
+      }
+      // if less than moderator access then can not apply labels
+      if (!access.moderator && isLabelEvent) {
+        throw new AuthRequiredError('Must be a full moderator to label content')
+      }
+
+      if (isLabelEvent) {
+        validateLabels([
+          ...(event.createLabelVals ?? []),
+          ...(event.negateLabelVals ?? []),
+        ])
+      }
+
+      const subjectInfo = getSubject(subject)
+
+      if (isTakedownEvent || isReverseTakedownEvent) {
+        const isSubjectTakendown = await moderationService.isSubjectTakendown(
+          subjectInfo,
+        )
+
+        if (isSubjectTakendown && isTakedownEvent) {
+          throw new InvalidRequestError(`Subject is already taken down`)
+        }
+
+        if (!isSubjectTakendown && isReverseTakedownEvent) {
+          throw new InvalidRequestError(`Subject is not taken down`)
+        }
+      }
+
+      const { result: moderationEvent, takenDown } = await db.transaction(
+        async (dbTxn) => {
+          const moderationTxn = ctx.services.moderation(dbTxn)
+          const labelTxn = ctx.services.label(dbTxn)
+
+          const result = await moderationTxn.logEvent({
+            event,
+            subject: subjectInfo,
+            subjectBlobCids:
+              subjectBlobCids?.map((cid) => CID.parse(cid)) ?? [],
+            createdBy,
+          })
+
+          let takenDown: TakedownSubjects | undefined
+
+          if (
+            result.subjectType === 'com.atproto.admin.defs#repoRef' &&
+            result.subjectDid
+          ) {
+            // No credentials to revoke on appview
+            if (isTakedownEvent) {
+              takenDown = await moderationTxn.takedownRepo({
+                takedownId: result.id,
+                did: result.subjectDid,
+              })
+            }
+
+            if (isReverseTakedownEvent) {
+              await moderationTxn.reverseTakedownRepo({
+                did: result.subjectDid,
+              })
+              takenDown = {
+                subjects: [
+                  {
+                    $type: 'com.atproto.admin.defs#repoRef',
+                    did: result.subjectDid,
+                  },
+                ],
+                did: result.subjectDid,
+              }
+            }
+          }
+
+          if (
+            result.subjectType === 'com.atproto.repo.strongRef' &&
+            result.subjectUri
+          ) {
+            const blobCids = subjectBlobCids?.map((cid) => CID.parse(cid)) ?? []
+            if (isTakedownEvent) {
+              takenDown = await moderationTxn.takedownRecord({
+                takedownId: result.id,
+                uri: new AtUri(result.subjectUri),
+                // TODO: I think this will always be available for strongRefs?
+                cid: CID.parse(result.subjectCid as string),
+                blobCids,
+              })
+            }
+
+            if (isReverseTakedownEvent) {
+              await moderationTxn.reverseTakedownRecord({
+                uri: new AtUri(result.subjectUri),
+              })
+              takenDown = {
+                did: result.subjectDid,
+                subjects: [
+                  {
+                    $type: 'com.atproto.repo.strongRef',
+                    uri: result.subjectUri,
+                    cid: result.subjectCid ?? '',
+                  },
+                  ...blobCids.map((cid) => ({
+                    $type: 'com.atproto.admin.defs#repoBlobRef',
+                    did: result.subjectDid,
+                    cid: cid.toString(),
+                    recordUri: result.subjectUri,
+                  })),
+                ],
+              }
+            }
+          }
+
+          if (isLabelEvent) {
+            await labelTxn.formatAndCreate(
+              ctx.cfg.labelerDid,
+              result.subjectUri ?? result.subjectDid,
+              result.subjectCid,
+              {
+                create: result.createLabelVals?.length
+                  ? result.createLabelVals.split(' ')
+                  : undefined,
+                negate: result.negateLabelVals?.length
+                  ? result.negateLabelVals.split(' ')
+                  : undefined,
+              },
+            )
+          }
+
+          return { result, takenDown }
+        },
+      )
+
+      if (takenDown && ctx.moderationPushAgent) {
+        const { did, subjects } = takenDown
+        if (did && subjects.length > 0) {
+          const agent = ctx.moderationPushAgent
+          const results = await Promise.allSettled(
+            subjects.map((subject) =>
+              retryHttp(() =>
+                agent.api.com.atproto.admin.updateSubjectStatus({
+                  subject,
+                  takedown: isTakedownEvent
+                    ? {
+                        applied: true,
+                        ref: moderationEvent.id.toString(),
+                      }
+                    : {
+                        applied: false,
+                      },
+                }),
+              ),
+            ),
+          )
+          const hadFailure = results.some((r) => r.status === 'rejected')
+          if (hadFailure) {
+            throw new UpstreamFailureError('failed to apply action on PDS')
+          }
+        }
+      }
+
+      return {
+        encoding: 'application/json',
+        body: await moderationService.views.event(moderationEvent),
+      }
+    },
+  })
+}
+
+const validateLabels = (labels: string[]) => {
+  for (const label of labels) {
+    for (const char of badChars) {
+      if (label.includes(char)) {
+        throw new InvalidRequestError(`Invalid label: ${label}`)
+      }
+    }
+  }
+}
+
+const badChars = [' ', ',', ';', `'`, `"`]

package/src/api/com/atproto/admin/{getModerationActions.ts → getModerationEvent.ts}

@@ -2,23 +2,17 @@ import { Server } from '../../../../lexicon'
 import AppContext from '../../../../context'
 
 export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.admin.getModerationActions({
+  server.com.atproto.admin.getModerationEvent({
     auth: ctx.roleVerifier,
     handler: async ({ params }) => {
-      const { subject, limit = 50, cursor } = params
+      const { id } = params
       const db = ctx.db.getPrimary()
       const moderationService = ctx.services.moderation(db)
-      const results = await moderationService.getActions({
-        subject,
-        limit,
-        cursor,
-      })
+      const event = await moderationService.getEventOrThrow(id)
+      const eventDetail = await moderationService.views.eventDetail(event)
       return {
         encoding: 'application/json',
-        body: {
-          cursor: results.at(-1)?.id.toString() ?? undefined,
-          actions: await moderationService.views.action(results),
-        },
+        body: eventDetail,
       }
     },
   })

package/src/api/com/atproto/admin/getRecord.ts

@@ -18,6 +18,7 @@ export default function (server: Server, ctx: AppContext) {
       if (!result) {
         throw new InvalidRequestError('Record not found', 'RecordNotFound')
       }
+
       const [record, accountInfo] = await Promise.all([
         ctx.services.moderation(db).views.recordDetail(result),
         getPdsAccountInfo(ctx, result.did),

package/src/api/com/atproto/admin/{getModerationReports.ts → queryModerationEvents.ts}

@@ -1,39 +1,36 @@
 import { Server } from '../../../../lexicon'
 import AppContext from '../../../../context'
+import { getEventType } from '../moderation/util'
 
 export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.admin.getModerationReports({
+  server.com.atproto.admin.queryModerationEvents({
     auth: ctx.roleVerifier,
     handler: async ({ params }) => {
       const {
         subject,
-        resolved,
-        actionType,
         limit = 50,
         cursor,
-        ignoreSubjects,
-        reverse = false,
-        reporters = [],
-        actionedBy,
+        sortDirection = 'desc',
+        types,
+        includeAllUserRecords = false,
+        createdBy,
       } = params
       const db = ctx.db.getPrimary()
       const moderationService = ctx.services.moderation(db)
-      const results = await moderationService.getReports({
+      const results = await moderationService.getEvents({
+        types: types?.length ? types.map(getEventType) : [],
         subject,
-        resolved,
-        actionType,
+        createdBy,
         limit,
         cursor,
-        ignoreSubjects,
-        reverse,
-        reporters,
-        actionedBy,
+        sortDirection,
+        includeAllUserRecords,
       })
       return {
         encoding: 'application/json',
         body: {
-          cursor: results.at(-1)?.id.toString() ?? undefined,
-          reports: await moderationService.views.report(results),
+          cursor: results.cursor,
+          events: await moderationService.views.event(results.events),
         },
       }
     },

package/src/api/com/atproto/admin/queryModerationStatuses.ts

@@ -0,0 +1,55 @@
+import { Server } from '../../../../lexicon'
+import AppContext from '../../../../context'
+import { getReviewState } from '../moderation/util'
+
+export default function (server: Server, ctx: AppContext) {
+  server.com.atproto.admin.queryModerationStatuses({
+    auth: ctx.roleVerifier,
+    handler: async ({ params }) => {
+      const {
+        subject,
+        takendown,
+        reviewState,
+        reviewedAfter,
+        reviewedBefore,
+        reportedAfter,
+        reportedBefore,
+        ignoreSubjects,
+        lastReviewedBy,
+        sortDirection = 'desc',
+        sortField = 'lastReportedAt',
+        includeMuted = false,
+        limit = 50,
+        cursor,
+      } = params
+      const db = ctx.db.getPrimary()
+      const moderationService = ctx.services.moderation(db)
+      const results = await moderationService.getSubjectStatuses({
+        reviewState: getReviewState(reviewState),
+        subject,
+        takendown,
+        reviewedAfter,
+        reviewedBefore,
+        reportedAfter,
+        reportedBefore,
+        includeMuted,
+        ignoreSubjects,
+        sortDirection,
+        lastReviewedBy,
+        sortField,
+        limit,
+        cursor,
+      })
+      const subjectStatuses = moderationService.views.subjectStatus(
+        results.statuses,
+      )
+      return {
+        encoding: 'application/json',
+        body: {
+          cursor: results.cursor,
+          subjectStatuses,
+        },
+      }
+    },
+  })
+}

package/src/api/com/atproto/moderation/createReport.ts

@@ -22,15 +22,17 @@ export default function (server: Server, ctx: AppContext) {
         }
       }
 
-      const moderationService = ctx.services.moderation(db)
-
-      const report = await moderationService.report({
-        reasonType: getReasonType(reasonType),
-        reason,
-        subject: getSubject(subject),
-        reportedBy: requester || ctx.cfg.serverDid,
+      const report = await db.transaction(async (dbTxn) => {
+        const moderationTxn = ctx.services.moderation(dbTxn)
+        return moderationTxn.report({
+          reasonType: getReasonType(reasonType),
+          reason,
+          subject: getSubject(subject),
+          reportedBy: requester || ctx.cfg.serverDid,
+        })
       })
 
+      const moderationService = ctx.services.moderation(db)
       return {
         encoding: 'application/json',
         body: moderationService.views.reportPublic(report),