@atproto/bsky 0.0.14 → 0.0.16

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

@@ -1,3 +1,4 @@
+import { mapDefined } from '@atproto/common'
 import { Server } from '../../../../lexicon'
 import AppContext from '../../../../context'
 import { FeedGenInfo, FeedService } from '../../../../services/feed'
@@ -60,7 +61,7 @@ const hydration = async (state: SkeletonState, ctx: Context) => {
 
 const presentation = (state: HydrationState, ctx: Context) => {
   const { feedService } = ctx
-  const feeds = state.generators.map((gen) =>
+  const feeds = mapDefined(state.generators, (gen) =>
     feedService.views.formatFeedGeneratorView(gen, state.profiles),
   )
   return { feeds }

package/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 }
 }
 

package/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 }
 }
@@ -255,11 +241,15 @@ const getThreadData = async (
       .orderBy('sortAt', 'desc')
       .execute(),
   ])
-  const parentsByUri = parents.reduce((acc, parent) => {
-    return Object.assign(acc, { [parent.postUri]: parent })
+  // prevent self-referential loops
+  const includedPosts = new Set<string>([uri])
+  const parentsByUri = parents.reduce((acc, post) => {
+    return Object.assign(acc, { [post.uri]: post })
   }, {} as Record<string, FeedRow>)
   const childrenByParentUri = children.reduce((acc, child) => {
     if (!child.replyParent) return acc
+    if (includedPosts.has(child.uri)) return acc
+    includedPosts.add(child.uri)
     acc[child.replyParent] ??= []
     acc[child.replyParent].push(child)
     return acc
@@ -269,7 +259,12 @@ const getThreadData = async (
   return {
     post,
     parent: post.replyParent
-      ? getParentData(parentsByUri, post.replyParent, parentHeight)
+      ? getParentData(
+          parentsByUri,
+          includedPosts,
+          post.replyParent,
+          parentHeight,
+        )
       : undefined,
     replies: getChildrenData(childrenByParentUri, uri, depth),
   }
@@ -277,16 +272,19 @@ const getThreadData = async (
 
 const getParentData = (
   postsByUri: Record<string, FeedRow>,
+  includedPosts: Set<string>,
   uri: string,
   depth: number,
 ): PostThread | ParentNotFoundError | undefined => {
   if (depth < 1) return undefined
+  if (includedPosts.has(uri)) return undefined
+  includedPosts.add(uri)
   const post = postsByUri[uri]
   if (!post) return new ParentNotFoundError(uri)
   return {
     post,
     parent: post.replyParent
-      ? getParentData(postsByUri, post.replyParent, depth - 1)
+      ? getParentData(postsByUri, includedPosts, post.replyParent, depth - 1)
       : undefined,
     replies: [],
   }
@@ -305,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}`)
@@ -352,7 +328,4 @@ type SkeletonState = {
   threadData: PostThread
 }
 
-type HydrationState = SkeletonState &
-  FeedHydrationState & {
-    viewerCanReply: boolean
-  }
+type HydrationState = SkeletonState & FeedHydrationState

package/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,18 +34,18 @@ 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 }
@@ -50,32 +53,32 @@ const hydration = async (state: SkeletonState, ctx: Context) => {
 
 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

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

@@ -1,3 +1,4 @@
+import { mapDefined } from '@atproto/common'
 import { Server } from '../../../../lexicon'
 import AppContext from '../../../../context'
 
@@ -23,7 +24,7 @@ export default function (server: Server, ctx: AppContext) {
       const creators = genList.map((gen) => gen.creator)
       const profiles = await actorService.views.profilesBasic(creators, viewer)
 
-      const feedViews = genList.map((gen) =>
+      const feedViews = mapDefined(genList, (gen) =>
         feedService.views.formatFeedGeneratorView(gen, profiles),
       )
 

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

@@ -146,9 +146,7 @@ const noBlocksOrMutes = (state: HydrationState): 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 }
 }
 

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

@@ -0,0 +1,130 @@
+import AppContext from '../../../../context'
+import { Server } from '../../../../lexicon'
+import { InvalidRequestError } from '@atproto/xrpc-server'
+import AtpAgent from '@atproto/api'
+import { mapDefined } from '@atproto/common'
+import { QueryParams } from '../../../../lexicon/types/app/bsky/feed/searchPosts'
+import { Database } from '../../../../db'
+import {
+  FeedHydrationState,
+  FeedRow,
+  FeedService,
+} from '../../../../services/feed'
+import { ActorService } from '../../../../services/actor'
+import { createPipeline } from '../../../../pipeline'
+
+export default function (server: Server, ctx: AppContext) {
+  const searchPosts = createPipeline(
+    skeleton,
+    hydration,
+    noBlocks,
+    presentation,
+  )
+  server.app.bsky.feed.searchPosts({
+    auth: ctx.authOptionalVerifier,
+    handler: async ({ auth, params }) => {
+      const viewer = auth.credentials.did
+      const db = ctx.db.getReplica('search')
+      const feedService = ctx.services.feed(db)
+      const actorService = ctx.services.actor(db)
+      const searchAgent = ctx.searchAgent
+      if (!searchAgent) {
+        throw new InvalidRequestError('Search not available')
+      }
+
+      const results = await searchPosts(
+        { ...params, viewer },
+        { db, feedService, actorService, searchAgent },
+      )
+
+      return {
+        encoding: 'application/json',
+        body: results,
+      }
+    },
+  })
+}
+
+const skeleton = async (
+  params: Params,
+  ctx: Context,
+): Promise<SkeletonState> => {
+  const res = await ctx.searchAgent.api.app.bsky.unspecced.searchPostsSkeleton({
+    q: params.q,
+    cursor: params.cursor,
+    limit: params.limit,
+  })
+  const postUris = res.data.posts.map((a) => a.uri)
+  const feedItems = await ctx.feedService.postUrisToFeedItems(postUris)
+  return {
+    params,
+    feedItems,
+    cursor: res.data.cursor,
+    hitsTotal: res.data.hitsTotal,
+  }
+}
+
+const hydration = async (
+  state: SkeletonState,
+  ctx: Context,
+): Promise<HydrationState> => {
+  const { feedService } = ctx
+  const { params, feedItems } = state
+  const refs = feedService.feedItemRefs(feedItems)
+  const hydrated = await feedService.feedHydration({
+    ...refs,
+    viewer: params.viewer,
+  })
+  return { ...state, ...hydrated }
+}
+
+const noBlocks = (state: HydrationState): HydrationState => {
+  const { viewer } = state.params
+  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 { feedItems, profiles, params } = state
+  const actors = actorService.views.profileBasicPresentation(
+    Object.keys(profiles),
+    state,
+    params.viewer,
+  )
+
+  const postViews = mapDefined(feedItems, (item) =>
+    feedService.views.formatPostView(
+      item.postUri,
+      actors,
+      state.posts,
+      state.threadgates,
+      state.embeds,
+      state.labels,
+      state.lists,
+      params.viewer,
+    ),
+  )
+  return { posts: postViews, cursor: state.cursor, hitsTotal: state.hitsTotal }
+}
+
+type Context = {
+  db: Database
+  feedService: FeedService
+  actorService: ActorService
+  searchAgent: AtpAgent
+}
+
+type Params = QueryParams & { viewer: string | null }
+
+type SkeletonState = {
+  params: Params
+  feedItems: FeedRow[]
+  hitsTotal?: number
+  cursor?: string
+}
+
+type HydrationState = SkeletonState & FeedHydrationState

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) {