Put canReply state on post viewer state instead of thread viewer state (

#1882)

* switch canReply from thread to post view

* tweaks & fix up tests

* update snaps

* fix more snaps

* hydrate feed items for getPosts & searchPosts

* fix another snapshot

* getPosts test

* canReply -> blockedByGate & DRY up code

* blockedByGate -> excludedByGate

* replyDisabled

lexicons/app/bsky/feed/defs.json

@@ -38,7 +38,8 @@
       "type": "object",
       "properties": {
         "repost": { "type": "string", "format": "at-uri" },
-        "like": { "type": "string", "format": "at-uri" }
+        "like": { "type": "string", "format": "at-uri" },
+        "replyDisabled": { "type": "boolean" }
       }
     },
     "feedViewPost": {
@@ -87,8 +88,7 @@
             "type": "union",
             "refs": ["#threadViewPost", "#notFoundPost", "#blockedPost"]
           }
-        },
-        "viewer": { "type": "ref", "ref": "#viewerThreadState" }
+        }
       }
     },
     "notFoundPost": {
@@ -116,12 +116,6 @@
         "viewer": { "type": "ref", "ref": "app.bsky.actor.defs#viewerState" }
       }
     },
-    "viewerThreadState": {
-      "type": "object",
-      "properties": {
-        "canReply": { "type": "boolean" }
-      }
-    },
     "generatorView": {
       "type": "object",
       "required": ["uri", "cid", "did", "creator", "displayName", "indexedAt"],

packages/api/src/client/lexicons.ts

@@ -4892,6 +4892,9 @@ export const schemaDict = {
             type: 'string',
             format: 'at-uri',
           },
+          replyDisabled: {
+            type: 'boolean',
+          },
         },
       },
       feedViewPost: {
@@ -4975,10 +4978,6 @@ export const schemaDict = {
               ],
             },
           },
-          viewer: {
-            type: 'ref',
-            ref: 'lex:app.bsky.feed.defs#viewerThreadState',
-          },
         },
       },
       notFoundPost: {
@@ -5027,14 +5026,6 @@ export const schemaDict = {
           },
         },
       },
-      viewerThreadState: {
-        type: 'object',
-        properties: {
-          canReply: {
-            type: 'boolean',
-          },
-        },
-      },
       generatorView: {
         type: 'object',
         required: ['uri', 'cid', 'did', 'creator', 'displayName', 'indexedAt'],

packages/api/src/client/types/app/bsky/feed/defs.ts

@@ -48,6 +48,7 @@ export function validatePostView(v: unknown): ValidationResult {
 export interface ViewerState {
   repost?: string
   like?: string
+  replyDisabled?: boolean
   [k: string]: unknown
 }
 
@@ -137,7 +138,6 @@ export interface ThreadViewPost {
     | BlockedPost
     | { $type: string; [k: string]: unknown }
   )[]
-  viewer?: ViewerThreadState
   [k: string]: unknown
 }
 
@@ -208,23 +208,6 @@ export function validateBlockedAuthor(v: unknown): ValidationResult {
   return lexicons.validate('app.bsky.feed.defs#blockedAuthor', v)
 }
 
-export interface ViewerThreadState {
-  canReply?: boolean
-  [k: string]: unknown
-}
-
-export function isViewerThreadState(v: unknown): v is ViewerThreadState {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'app.bsky.feed.defs#viewerThreadState'
-  )
-}
-
-export function validateViewerThreadState(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.feed.defs#viewerThreadState', v)
-}
-
 export interface GeneratorView {
   uri: string
   cid: string

packages/bsky/src/api/app/bsky/feed/getActorLikes.ts

@@ -107,9 +107,7 @@ const noPostBlocks = (state: HydrationState) => {
 const presentation = (state: HydrationState, ctx: Context) => {
   const { feedService } = ctx
   const { feedItems, cursor, params } = state
-  const feed = feedService.views.formatFeed(feedItems, state, {
-    viewer: params.viewer,
-  })
+  const feed = feedService.views.formatFeed(feedItems, state, params.viewer)
   return { feed, cursor }
 }
 

packages/bsky/src/api/app/bsky/feed/getAuthorFeed.ts

@@ -147,9 +147,7 @@ const noBlocksOrMutedReposts = (state: HydrationState) => {
 const presentation = (state: HydrationState, ctx: Context) => {
   const { feedService } = ctx
   const { feedItems, cursor, params } = state
-  const feed = feedService.views.formatFeed(feedItems, state, {
-    viewer: params.viewer,
-  })
+  const feed = feedService.views.formatFeed(feedItems, state, params.viewer)
   return { feed, cursor }
 }
 

packages/bsky/src/api/app/bsky/feed/getFeed.ts

@@ -113,9 +113,7 @@ const noBlocksOrMutes = (state: HydrationState) => {
 const presentation = (state: HydrationState, ctx: Context) => {
   const { feedService } = ctx
   const { feedItems, cursor, passthrough, params } = state
-  const feed = feedService.views.formatFeed(feedItems, state, {
-    viewer: params.viewer,
-  })
+  const feed = feedService.views.formatFeed(feedItems, state, params.viewer)
   return {
     feed,
     cursor,

packages/bsky/src/api/app/bsky/feed/getListFeed.ts

@@ -105,9 +105,7 @@ const noBlocksOrMutes = (state: HydrationState) => {
 const presentation = (state: HydrationState, ctx: Context) => {
   const { feedService } = ctx
   const { feedItems, cursor, params } = state
-  const feed = feedService.views.formatFeed(feedItems, state, {
-    viewer: params.viewer,
-  })
+  const feed = feedService.views.formatFeed(feedItems, state, params.viewer)
   return { feed, cursor }
 }
 

packages/bsky/src/api/app/bsky/feed/getPostThread.ts

@@ -6,27 +6,21 @@ import {
   NotFoundPost,
   ThreadViewPost,
   isNotFoundPost,
-  isThreadViewPost,
 } from '../../../../lexicon/types/app/bsky/feed/defs'
-import { Record as PostRecord } from '../../../../lexicon/types/app/bsky/feed/post'
-import { Record as ThreadgateRecord } from '../../../../lexicon/types/app/bsky/feed/threadgate'
 import { QueryParams } from '../../../../lexicon/types/app/bsky/feed/getPostThread'
 import AppContext from '../../../../context'
 import {
   FeedService,
   FeedRow,
   FeedHydrationState,
-  PostInfo,
 } from '../../../../services/feed'
 import {
   getAncestorsAndSelfQb,
   getDescendentsQb,
 } from '../../../../services/util/post'
 import { Database } from '../../../../db'
-import DatabaseSchema from '../../../../db/database-schema'
 import { setRepoRev } from '../../../util'
 import { ActorInfoMap, ActorService } from '../../../../services/actor'
-import { violatesThreadGate } from '../../../../services/feed/util'
 import { createPipeline, noRules } from '../../../../pipeline'
 
 export default function (server: Server, ctx: AppContext) {
@@ -80,21 +74,7 @@ const hydration = async (state: SkeletonState, ctx: Context) => {
   } = state
   const relevant = getRelevantIds(threadData)
   const hydrated = await feedService.feedHydration({ ...relevant, viewer })
-  // check root reply interaction rules
-  const anchorPostUri = threadData.post.postUri
-  const rootUri = threadData.post.replyRoot || anchorPostUri
-  const anchor = hydrated.posts[anchorPostUri]
-  const root = hydrated.posts[rootUri]
-  const gate = hydrated.threadgates[rootUri]?.record
-  const viewerCanReply = await checkViewerCanReply(
-    ctx.db.db,
-    anchor ?? null,
-    viewer,
-    new AtUri(rootUri).host,
-    (root?.record ?? null) as PostRecord | null,
-    gate ?? null,
-  )
-  return { ...state, ...hydrated, viewerCanReply }
+  return { ...state, ...hydrated }
 }
 
 const presentation = (state: HydrationState, ctx: Context) => {
@@ -103,16 +83,19 @@ const presentation = (state: HydrationState, ctx: Context) => {
   const actors = actorService.views.profileBasicPresentation(
     Object.keys(profiles),
     state,
-    { viewer: params.viewer },
+    params.viewer,
+  )
+  const thread = composeThread(
+    state.threadData,
+    actors,
+    state,
+    ctx,
+    params.viewer,
   )
-  const thread = composeThread(state.threadData, actors, state, ctx)
   if (isNotFoundPost(thread)) {
     // @TODO technically this could be returned as a NotFoundPost based on lexicon
     throw new InvalidRequestError(`Post not found: ${params.uri}`, 'NotFound')
   }
-  if (isThreadViewPost(thread) && params.viewer) {
-    thread.viewer = { canReply: state.viewerCanReply }
-  }
   return { thread }
 }
 
@@ -121,6 +104,7 @@ const composeThread = (
   actors: ActorInfoMap,
   state: HydrationState,
   ctx: Context,
+  viewer: string | null,
 ) => {
   const { feedService } = ctx
   const { posts, threadgates, embeds, blocks, labels, lists } = state
@@ -133,6 +117,7 @@ const composeThread = (
     embeds,
     labels,
     lists,
+    viewer,
   )
 
   // replies that are invalid due to reply-gating:
@@ -179,14 +164,14 @@ const composeThread = (
         notFound: true,
       }
     } else {
-      parent = composeThread(threadData.parent, actors, state, ctx)
+      parent = composeThread(threadData.parent, actors, state, ctx, viewer)
     }
   }
 
   let replies: (ThreadViewPost | NotFoundPost | BlockedPost)[] | undefined
   if (threadData.replies && !badReply) {
     replies = threadData.replies.flatMap((reply) => {
-      const thread = composeThread(reply, actors, state, ctx)
+      const thread = composeThread(reply, actors, state, ctx, viewer)
       // e.g. don't bother including #postNotFound reply placeholders for takedowns. either way matches api contract.
       const skip = []
       return isNotFoundPost(thread) ? skip : thread
@@ -223,6 +208,7 @@ const getRelevantIds = (
   if (thread.post.replyRoot) {
     // ensure root is included for checking interactions
     uris.add(thread.post.replyRoot)
+    dids.add(new AtUri(thread.post.replyRoot).hostname)
   }
   return { dids, uris }
 }
@@ -317,28 +303,6 @@ const getChildrenData = (
   }))
 }
 
-const checkViewerCanReply = async (
-  db: DatabaseSchema,
-  anchor: PostInfo | null,
-  viewer: string | null,
-  owner: string,
-  root: PostRecord | null,
-  threadgate: ThreadgateRecord | null,
-) => {
-  if (!viewer) return false
-  // @TODO re-enable invalidReplyRoot check
-  // if (anchor?.invalidReplyRoot || anchor?.violatesThreadGate) return false
-  if (anchor?.violatesThreadGate) return false
-  const viewerViolatesThreadGate = await violatesThreadGate(
-    db,
-    viewer,
-    owner,
-    root,
-    threadgate,
-  )
-  return !viewerViolatesThreadGate
-}
-
 class ParentNotFoundError extends Error {
   constructor(public uri: string) {
     super(`Parent not found: ${uri}`)
@@ -364,7 +328,4 @@ type SkeletonState = {
   threadData: PostThread
 }
 
-type HydrationState = SkeletonState &
-  FeedHydrationState & {
-    viewerCanReply: boolean
-  }
+type HydrationState = SkeletonState & FeedHydrationState

packages/bsky/src/api/app/bsky/feed/getPosts.ts

@@ -1,10 +1,13 @@
 import { dedupeStrs } from '@atproto/common'
-import { AtUri } from '@atproto/syntax'
 import { Server } from '../../../../lexicon'
 import { QueryParams } from '../../../../lexicon/types/app/bsky/feed/getPosts'
 import AppContext from '../../../../context'
 import { Database } from '../../../../db'
-import { FeedHydrationState, FeedService } from '../../../../services/feed'
+import {
+  FeedHydrationState,
+  FeedRow,
+  FeedService,
+} from '../../../../services/feed'
 import { createPipeline } from '../../../../pipeline'
 import { ActorService } from '../../../../services/actor'
 
@@ -31,51 +34,51 @@ export default function (server: Server, ctx: AppContext) {
   })
 }
 
-const skeleton = async (params: Params) => {
-  return { params, postUris: dedupeStrs(params.uris) }
+const skeleton = async (params: Params, ctx: Context) => {
+  const deduped = dedupeStrs(params.uris)
+  const feedItems = await ctx.feedService.postUrisToFeedItems(deduped)
+  return { params, feedItems }
 }
 
 const hydration = async (state: SkeletonState, ctx: Context) => {
   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 }
 }
 
 const noBlocks = (state: 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 SKIP = []
   const actors = actorService.views.profileBasicPresentation(
     Object.keys(profiles),
     state,
-    { viewer: params.viewer },
+    params.viewer,
   )
-  const postViews = postUris.flatMap((uri) => {
+  const postViews = feedItems.flatMap((item) => {
     const postView = feedService.views.formatPostView(
-      uri,
+      item.postUri,
       actors,
       state.posts,
       state.threadgates,
       state.embeds,
       state.labels,
       state.lists,
+      params.viewer,
     )
     return postView ?? SKIP
   })
@@ -92,7 +95,7 @@ type Params = QueryParams & { viewer: string | null }
 
 type SkeletonState = {
   params: Params
-  postUris: string[]
+  feedItems: FeedRow[]
 }
 
 type HydrationState = SkeletonState & FeedHydrationState