@atproto/bsky 0.0.194 → 0.0.195

package/src/lexicon/types/com/atproto/lexicon/resolveLexicon.ts

@@ -0,0 +1,46 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import type * as ComAtprotoLexiconSchema from './schema.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'com.atproto.lexicon.resolveLexicon'
+
+export type QueryParams = {
+  /** The lexicon NSID to resolve. */
+  nsid: string
+}
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  /** The CID of the lexicon schema record. */
+  cid: string
+  schema: ComAtprotoLexiconSchema.Main
+  /** The AT-URI of the lexicon schema record. */
+  uri: string
+}
+
+export type HandlerInput = void
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+  error?: 'LexiconNotFound'
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess

package/src/views/index.ts

@@ -1246,13 +1246,11 @@ export class Views {
       above,
       below,
       branchingFactor,
-      prioritizeFollowedUsers,
       sort,
     }: {
       above: number
       below: number
       branchingFactor: number
-      prioritizeFollowedUsers: boolean
       sort: GetPostThreadV2QueryParams['sort']
     },
   ): { hasOtherReplies: boolean; thread: ThreadItem[] } {
@@ -1347,7 +1345,6 @@ export class Views {
                 below,
                 depth: 1,
                 branchingFactor,
-                prioritizeFollowedUsers,
               },
               state,
             )
@@ -1374,7 +1371,6 @@ export class Views {
       opDid,
       branchingFactor,
       sort,
-      prioritizeFollowedUsers,
       viewer: state.ctx?.viewer ?? null,
       threadTagsBumpDown: this.threadTagsBumpDown,
       threadTagsHide: this.threadTagsHide,
@@ -1513,7 +1509,6 @@ export class Views {
       below,
       depth,
       branchingFactor,
-      prioritizeFollowedUsers,
     }: {
       parentUri: string
       isOPThread: boolean
@@ -1523,7 +1518,6 @@ export class Views {
       below: number
       depth: number
       branchingFactor: number
-      prioritizeFollowedUsers: boolean
     },
     state: HydrationState,
   ): { replies: ThreadTreeVisible[] | undefined; hasOtherReplies: boolean } {
@@ -1547,7 +1541,7 @@ export class Views {
 
       // Hidden.
       const { isOther } = this.isOtherThreadPost(
-        { post, postView, prioritizeFollowedUsers, rootUri, uri },
+        { post, postView, rootUri, uri },
         state,
       )
       if (isOther) {
@@ -1570,7 +1564,6 @@ export class Views {
           below,
           depth: depth + 1,
           branchingFactor,
-          prioritizeFollowedUsers,
         },
         state,
       )
@@ -1699,11 +1692,9 @@ export class Views {
     {
       below,
       branchingFactor,
-      prioritizeFollowedUsers,
     }: {
       below: number
       branchingFactor: number
-      prioritizeFollowedUsers: boolean
     },
   ): ThreadOtherItem[] {
     const { anchor: anchorUri, uris } = skeleton
@@ -1738,7 +1729,6 @@ export class Views {
           childrenByParentUri,
           below,
           depth: 1,
-          prioritizeFollowedUsers,
         },
         state,
       ),
@@ -1747,7 +1737,6 @@ export class Views {
     return sortTrimFlattenThreadTree(anchorTree, {
       opDid,
       branchingFactor,
-      prioritizeFollowedUsers: false,
       viewer: state.ctx?.viewer ?? null,
       threadTagsBumpDown: this.threadTagsBumpDown,
       threadTagsHide: this.threadTagsHide,
@@ -1761,14 +1750,12 @@ export class Views {
       childrenByParentUri,
       below,
       depth,
-      prioritizeFollowedUsers,
     }: {
       parentUri: string
       rootUri: string
       childrenByParentUri: Record<string, string[]>
       below: number
       depth: number
-      prioritizeFollowedUsers: boolean
     },
     state: HydrationState,
   ): ThreadOtherPostNode[] | undefined {
@@ -1791,10 +1778,7 @@ export class Views {
 
       // Other posts to pull out
       const { isOther, hiddenByThreadgate, mutedByViewer } =
-        this.isOtherThreadPost(
-          { post, postView, rootUri, prioritizeFollowedUsers, uri },
-          state,
-        )
+        this.isOtherThreadPost({ post, postView, rootUri, uri }, state)
       if (isOther) {
         // Only show hidden anchor replies, not all hidden.
         if (depth > 1) {
@@ -1813,7 +1797,6 @@ export class Views {
           childrenByParentUri,
           below,
           depth: depth + 1,
-          prioritizeFollowedUsers,
         },
         state,
       )
@@ -1932,13 +1915,11 @@ export class Views {
     {
       post,
       postView,
-      prioritizeFollowedUsers,
       rootUri,
       uri,
     }: {
       post: Post
       postView: PostView
-      prioritizeFollowedUsers: boolean
       rootUri: string
       uri: string
     },
@@ -1952,8 +1933,7 @@ export class Views {
     const opDid = creatorFromUri(rootUri)
     const authorDid = creatorFromUri(uri)
 
-    const showBecauseFollowing =
-      prioritizeFollowedUsers && !!postView.author.viewer?.following
+    const showBecauseFollowing = !!postView.author.viewer?.following
     const hiddenByTag =
       authorDid !== opDid &&
       authorDid !== state.ctx?.viewer &&

package/src/views/threads-v2.ts

@@ -119,7 +119,6 @@ export function sortTrimFlattenThreadTree(
 type SortTrimFlattenOptions = {
   branchingFactor: GetPostThreadV2QueryParams['branchingFactor']
   opDid: string
-  prioritizeFollowedUsers: boolean
   sort?: GetPostThreadV2QueryParams['sort']
   viewer: HydrateCtx['viewer']
   threadTagsBumpDown: readonly string[]
@@ -182,13 +181,7 @@ function applyBumping(
     return null
   }
 
-  const {
-    opDid,
-    prioritizeFollowedUsers,
-    viewer,
-    threadTagsBumpDown,
-    threadTagsHide,
-  } = opts
+  const { opDid, viewer, threadTagsBumpDown, threadTagsHide } = opts
 
   type BumpDirection = 'up' | 'down'
   type BumpPredicateFn = (i: ThreadMaybeOtherPostNode) => boolean
@@ -227,10 +220,7 @@ function applyBumping(
     // Followers posts.
     [
       'up',
-      (i) =>
-        i.type === 'post' &&
-        prioritizeFollowedUsers &&
-        !!i.item.value.post.author.viewer?.following,
+      (i) => i.type === 'post' && !!i.item.value.post.author.viewer?.following,
     ],
     // Bump-down tags.
     [

package/tests/utils.test.ts

@@ -0,0 +1,45 @@
+import {
+  PostSearchQuery,
+  parsePostSearchQuery,
+} from '../src/data-plane/server/util'
+
+describe('parsePostSearchQuery', () => {
+  type TestCase = {
+    input: string
+    output: PostSearchQuery
+  }
+
+  const tests: TestCase[] = [
+    {
+      input: `bluesky `,
+      output: { q: `bluesky`, author: undefined },
+    },
+    {
+      input: ` bluesky  from:esb.lol`,
+      output: { q: `bluesky`, author: `esb.lol` },
+    },
+    {
+      input: `bluesky "from:esb.lol"`,
+      output: { q: `bluesky "from:esb.lol"`, author: undefined },
+    },
+    {
+      input: `bluesky mentions:@esb.lol `,
+      output: { q: `bluesky mentions:@esb.lol`, author: undefined },
+    },
+    {
+      input: `bluesky lang:"en"`,
+      output: { q: `bluesky lang:"en"`, author: undefined },
+    },
+    {
+      input: `bluesky "literal" "from:invalid" did:test:123 `,
+      output: {
+        q: `bluesky "literal" "from:invalid"`,
+        author: `did:test:123`,
+      },
+    },
+  ]
+
+  it.each(tests)(`'$input' -> '$output'`, ({ input, output }) => {
+    expect(parsePostSearchQuery(input)).toEqual(output)
+  })
+})

package/tests/views/post-search.test.ts

@@ -0,0 +1,221 @@
+import { AtpAgent } from '@atproto/api'
+import { QueryParams as SearchPostsQueryParams } from '@atproto/api/src/client/types/app/bsky/feed/searchPosts'
+import { SeedClient, TestNetwork, basicSeed } from '@atproto/dev-env'
+import { DatabaseSchema } from '../../src'
+import { ids } from '../../src/lexicon/lexicons'
+
+const TAG_HIDE = 'hide'
+
+describe('appview search', () => {
+  let network: TestNetwork
+  let agent: AtpAgent
+  let ozoneAgent: AtpAgent
+  let sc: SeedClient
+  let post0: Awaited<ReturnType<SeedClient['post']>>
+  let post1: Awaited<ReturnType<SeedClient['post']>>
+  let post2: Awaited<ReturnType<SeedClient['post']>>
+  let allResults: string[]
+  let nonTaggedResults: string[]
+
+  // account dids, for convenience
+  let alice: string
+  let bob: string
+  let carol: string
+
+  beforeAll(async () => {
+    network = await TestNetwork.create({
+      dbPostgresSchema: 'bsky_views_search',
+      bsky: {
+        searchTagsHide: new Set([TAG_HIDE]),
+      },
+    })
+    agent = network.bsky.getClient()
+    sc = network.getSeedClient()
+    ozoneAgent = network.ozone.getClient()
+    await basicSeed(sc)
+
+    alice = sc.dids.alice
+    bob = sc.dids.bob
+    carol = sc.dids.carol
+
+    post0 = await sc.post(alice, 'good doggo')
+    post1 = await sc.post(alice, 'bad doggo')
+    post2 = await sc.post(alice, 'cute doggo')
+    await network.processAll()
+
+    await createTag(network.bsky.db.db, {
+      uri: post1.ref.uriStr,
+      val: TAG_HIDE,
+    })
+
+    allResults = [post2.ref.uriStr, post1.ref.uriStr, post0.ref.uriStr]
+    nonTaggedResults = [post2.ref.uriStr, post0.ref.uriStr]
+  })
+
+  afterAll(async () => {
+    await deleteTags(network.bsky.db.db, {
+      uri: post1.ref.uriStr,
+    })
+
+    await network.close()
+  })
+
+  describe(`post search with 'top' sort`, () => {
+    type TestCase = {
+      name: string
+      viewer: () => string
+      queryParams: () => SearchPostsQueryParams
+      expectedPostUris: () => string[]
+    }
+
+    const tests: TestCase[] = [
+      // 'top' cases
+      {
+        name: `with 'top' sort, finds only non-tagged posts`,
+        viewer: () => carol,
+        queryParams: () => ({ q: 'doggo', sort: 'top' }),
+        expectedPostUris: () => nonTaggedResults,
+      },
+      {
+        name: `with 'top' sort, includes tagged posts from the viewer`,
+        viewer: () => alice,
+        queryParams: () => ({ q: 'doggo', sort: 'top' }),
+        expectedPostUris: () => allResults,
+      },
+      {
+        name: `with 'top' sort, finds only non-tagged posts, even specifying author`,
+        viewer: () => carol,
+        queryParams: () => ({ q: `doggo`, author: alice, sort: 'top' }),
+        expectedPostUris: () => nonTaggedResults,
+      },
+      {
+        name: `with 'top' sort, finds only non-tagged posts, even specifying from:`,
+        viewer: () => carol,
+        queryParams: () => ({
+          q: `doggo from:${sc.accounts[alice].handle}`,
+          sort: 'top',
+        }),
+        expectedPostUris: () => nonTaggedResults,
+      },
+      {
+        name: `with 'top' sort, finds only non-tagged posts, even specifying DID`,
+        viewer: () => carol,
+        queryParams: () => ({ q: `doggo ${alice}`, sort: 'top' }),
+        expectedPostUris: () => nonTaggedResults,
+      },
+      {
+        name: `with 'top' sort, finds no posts if specifying user who didn't post the term`,
+        viewer: () => carol,
+        queryParams: () => ({ q: `doggo ${bob}`, sort: 'top' }),
+        expectedPostUris: () => [],
+      },
+
+      // 'latest' cases
+      {
+        name: `with 'latest' sort, finds only non-tagged posts`,
+        viewer: () => carol,
+        queryParams: () => ({ q: 'doggo', sort: 'latest' }),
+        expectedPostUris: () => nonTaggedResults,
+      },
+      {
+        name: `with 'latest' sort, includes tagged posts from the viewer`,
+        viewer: () => alice,
+        queryParams: () => ({ q: 'doggo', sort: 'latest' }),
+        expectedPostUris: () => allResults,
+      },
+      {
+        name: `with 'latest' sort, finds all posts if specifying author`,
+        viewer: () => carol,
+        queryParams: () => ({
+          q: `doggo`,
+          author: alice,
+          sort: 'latest',
+        }),
+        expectedPostUris: () => allResults,
+      },
+      {
+        name: `with 'latest' sort, finds all posts if specifying from:`,
+        viewer: () => carol,
+        queryParams: () => ({
+          q: `doggo from:${sc.accounts[alice].handle}`,
+          sort: 'latest',
+        }),
+        expectedPostUris: () => allResults,
+      },
+      {
+        name: `with 'latest' sort, finds all posts if specifying DID`,
+        viewer: () => carol,
+        queryParams: () => ({ q: `doggo ${alice}`, sort: 'latest' }),
+        expectedPostUris: () => allResults,
+      },
+      {
+        name: `with 'latest' sort, finds no posts if specifying user who didn't post the term`,
+        viewer: () => carol,
+        queryParams: () => ({ q: `doggo ${bob}`, sort: 'latest' }),
+        expectedPostUris: () => [],
+      },
+    ]
+
+    it.each(tests)(
+      '$name',
+      async ({ viewer, queryParams, expectedPostUris }) => {
+        const res = await agent.app.bsky.feed.searchPosts(queryParams(), {
+          headers: await network.serviceHeaders(
+            viewer(),
+            ids.AppBskyFeedSearchPosts,
+          ),
+        })
+        expect(res.data.posts.map((p) => p.uri)).toStrictEqual(
+          expectedPostUris(),
+        )
+      },
+    )
+
+    it('mod service finds even tagged posts', async () => {
+      const resTop = await ozoneAgent.app.bsky.feed.searchPosts(
+        { q: 'doggo', sort: 'top' },
+        { headers: await network.ozone.modHeaders(ids.AppBskyFeedSearchPosts) },
+      )
+      const resLatest = await ozoneAgent.app.bsky.feed.searchPosts(
+        { q: 'doggo', sort: 'latest' },
+        { headers: await network.ozone.modHeaders(ids.AppBskyFeedSearchPosts) },
+      )
+
+      expect(resTop.data.posts.map((p) => p.uri)).toStrictEqual(allResults)
+      expect(resLatest.data.posts.map((p) => p.uri)).toStrictEqual(allResults)
+    })
+  })
+})
+
+const createTag = async (
+  db: DatabaseSchema,
+  opts: {
+    uri: string
+    val: string
+  },
+) => {
+  await db
+    .updateTable('record')
+    .set({
+      tags: JSON.stringify([opts.val]),
+    })
+    .where('uri', '=', opts.uri)
+    .returningAll()
+    .execute()
+}
+
+const deleteTags = async (
+  db: DatabaseSchema,
+  opts: {
+    uri: string
+  },
+) => {
+  await db
+    .updateTable('record')
+    .set({
+      tags: JSON.stringify([]),
+    })
+    .where('uri', '=', opts.uri)
+    .returningAll()
+    .execute()
+}

package/tests/views/thread-v2.test.ts

@@ -1108,16 +1108,11 @@ describe('appview thread views v2', () => {
           await network.processAll()
         })
 
-        const threadForPostAndViewer = async (
-          post: string,
-          viewer: string,
-          prioritizeFollowedUsers: boolean = false,
-        ) => {
+        const threadForPostAndViewer = async (post: string, viewer: string) => {
           const { data } = await agent.app.bsky.unspecced.getPostThreadV2(
             {
               anchor: post,
               sort: 'newest',
-              prioritizeFollowedUsers,
             },
             {
               headers: await network.serviceHeaders(
@@ -1133,13 +1128,10 @@ describe('appview thread views v2', () => {
           return t
         }
 
-        it('bumps up followed users if option is set', async () => {
-          const prioritizeFollowedUsers = true
-
+        it('bumps up followed users', async () => {
           const t1 = await threadForPostAndViewer(
             seed.root.ref.uriStr,
             seed.users.viewerF.did,
-            prioritizeFollowedUsers,
           )
           expect(t1).toEqual([
             expect.objectContaining({ uri: seed.root.ref.uriStr }), // root
@@ -1154,7 +1146,6 @@ describe('appview thread views v2', () => {
           const t2 = await threadForPostAndViewer(
             seed.root.ref.uriStr,
             seed.users.viewerNoF.did,
-            prioritizeFollowedUsers,
           )
           expect(t2).toEqual([
             expect.objectContaining({ uri: seed.root.ref.uriStr }), // root
@@ -1167,36 +1158,6 @@ describe('appview thread views v2', () => {
             expect.objectContaining({ uri: seed.r['0'].ref.uriStr }),
           ])
         })
-
-        it('does not prioritize followed users if option is not set', async () => {
-          const t1 = await threadForPostAndViewer(
-            seed.root.ref.uriStr,
-            seed.users.viewerF.did,
-          )
-          expect(t1).toHaveLength(7)
-          expect(t1[0].uri).toBe(seed.root.ref.uriStr) // root
-          expect(t1[1].uri).toBe(seed.r['3'].ref.uriStr) // op reply
-          expect(t1[2].uri).toBe(seed.r['4'].ref.uriStr) // viewer reply
-          // newest to oldest
-          expect(t1[3].uri).toBe(seed.r['5'].ref.uriStr)
-          expect(t1[4].uri).toBe(seed.r['2'].ref.uriStr)
-          expect(t1[5].uri).toBe(seed.r['1'].ref.uriStr)
-          expect(t1[6].uri).toBe(seed.r['0'].ref.uriStr)
-
-          const t2 = await threadForPostAndViewer(
-            seed.root.ref.uriStr,
-            seed.users.viewerNoF.did,
-          )
-          expect(t2).toHaveLength(7)
-          expect(t2[0].uri).toBe(seed.root.ref.uriStr) // root
-          expect(t2[1].uri).toBe(seed.r['3'].ref.uriStr) // op reply
-          expect(t2[2].uri).toBe(seed.r['5'].ref.uriStr) // viewer reply
-          // newest to oldest
-          expect(t2[3].uri).toBe(seed.r['4'].ref.uriStr)
-          expect(t2[4].uri).toBe(seed.r['2'].ref.uriStr)
-          expect(t2[5].uri).toBe(seed.r['1'].ref.uriStr)
-          expect(t2[6].uri).toBe(seed.r['0'].ref.uriStr)
-        })
       })
     })
   })
@@ -1960,14 +1921,11 @@ describe('appview thread views v2', () => {
     })
 
     describe('when prioritizing followed users', () => {
-      const prioritizeFollowedUsers = true
-
       it('considers tags for bumping down and hiding', async () => {
         const { data } = await agent.app.bsky.unspecced.getPostThreadV2(
           {
             anchor: seed.root.ref.uriStr,
             sort: 'newest',
-            prioritizeFollowedUsers,
           },
           {
             headers: await network.serviceHeaders(
@@ -2003,7 +1961,6 @@ describe('appview thread views v2', () => {
         const { data } = await agent.app.bsky.unspecced.getPostThreadOtherV2(
           {
             anchor: seed.root.ref.uriStr,
-            prioritizeFollowedUsers,
           },
           {
             headers: await network.serviceHeaders(
@@ -2021,70 +1978,6 @@ describe('appview thread views v2', () => {
         ])
       })
     })
-
-    describe('when not prioritizing followed users', () => {
-      const prioritizeFollowedUsers = false
-
-      it('considers tags for bumping down and hiding', async () => {
-        const { data } = await agent.app.bsky.unspecced.getPostThreadV2(
-          {
-            anchor: seed.root.ref.uriStr,
-            sort: 'newest',
-            prioritizeFollowedUsers,
-          },
-          {
-            headers: await network.serviceHeaders(
-              seed.users.viewer.did,
-              ids.AppBskyUnspeccedGetPostThreadV2,
-            ),
-          },
-        )
-        const { thread: t, hasOtherReplies } = data
-
-        expect(hasOtherReplies).toBe(true)
-        assertPosts(t)
-        expect(t).toEqual([
-          expect.objectContaining({ uri: seed.root.ref.uriStr }),
-          // OP (down overridden).
-          expect.objectContaining({ uri: seed.r['3'].ref.uriStr }),
-          // Viewer (hide overriden).
-          expect.objectContaining({ uri: seed.r['4'].ref.uriStr }),
-          // Following was hidden because not prioritizing.
-          // Not following.
-          expect.objectContaining({ uri: seed.r['0'].ref.uriStr }),
-          expect.objectContaining({ uri: seed.r['0.0'].ref.uriStr }),
-          expect.objectContaining({ uri: seed.r['0.1'].ref.uriStr }),
-          // Down.
-          expect.objectContaining({ uri: seed.r['1'].ref.uriStr }),
-          expect.objectContaining({ uri: seed.r['1.0'].ref.uriStr }),
-          expect.objectContaining({ uri: seed.r['1.1'].ref.uriStr }),
-        ])
-      })
-
-      it('finds the hidden by tag', async () => {
-        const { data } = await agent.app.bsky.unspecced.getPostThreadOtherV2(
-          {
-            anchor: seed.root.ref.uriStr,
-            prioritizeFollowedUsers,
-          },
-          {
-            headers: await network.serviceHeaders(
-              seed.users.viewer.did,
-              ids.AppBskyUnspeccedGetPostThreadOtherV2,
-            ),
-          },
-        )
-        const { thread: t } = data
-
-        assertHiddenPosts(t)
-        expect(t).toEqual([
-          // Following (hide).
-          expect.objectContaining({ uri: seed.r['5'].ref.uriStr }),
-          // Hide.
-          expect.objectContaining({ uri: seed.r['2'].ref.uriStr }),
-        ])
-      })
-    })
   })
 })