@atproto/bsky 0.0.43 → 0.0.44

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/bsky",
-  "version": "0.0.43",
+  "version": "0.0.44",
   "license": "MIT",
   "description": "Reference implementation of app.bsky App View (Bluesky API)",
   "keywords": [
@@ -46,7 +46,7 @@
     "@atproto/lexicon": "^0.4.0",
     "@atproto/repo": "^0.4.0",
     "@atproto/syntax": "^0.3.0",
-    "@atproto/xrpc-server": "^0.5.0"
+    "@atproto/xrpc-server": "^0.5.1"
   },
   "devDependencies": {
     "@bufbuild/buf": "^1.28.1",
@@ -63,7 +63,7 @@
     "ts-node": "^10.8.2",
     "@atproto/api": "^0.12.2",
     "@atproto/lex-cli": "^0.4.0",
-    "@atproto/pds": "^0.4.11",
+    "@atproto/pds": "^0.4.13",
     "@atproto/xrpc": "^0.5.0"
   },
   "scripts": {

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

@@ -15,7 +15,7 @@ import { Views } from '../../../../views'
 import { DataPlaneClient } from '../../../../data-plane'
 import { parseString } from '../../../../hydration/util'
 import { Actor } from '../../../../hydration/actor'
-import { FeedItem } from '../../../../hydration/feed'
+import { FeedItem, Post } from '../../../../hydration/feed'
 import { FeedType } from '../../../../proto/bsky_pb'
 
 export default function (server: Server, ctx: AppContext) {
@@ -77,7 +77,7 @@ export const skeleton = async (inputs: {
     throw new InvalidRequestError('Profile not found')
   }
   if (clearlyBadCursor(params.cursor)) {
-    return { actor, items: [] }
+    return { actor, filter: params.filter, items: [] }
   }
   const res = await ctx.dataplane.getAuthorFeed({
     actorDid: did,
@@ -87,6 +87,7 @@ export const skeleton = async (inputs: {
   })
   return {
     actor,
+    filter: params.filter,
     items: res.items.map((item) => ({
       post: { uri: item.uri, cid: item.cid || undefined },
       repost: item.repost
@@ -129,14 +130,30 @@ const noBlocksOrMutedReposts = (inputs: {
       'BlockedByActor',
     )
   }
-  skeleton.items = skeleton.items.filter((item) => {
+
+  const checkBlocksAndMutes = (item: FeedItem) => {
     const bam = ctx.views.feedItemBlocksAndMutes(item, hydration)
     return (
       !bam.authorBlocked &&
       !bam.originatorBlocked &&
-      !(bam.authorMuted && !bam.originatorMuted)
+      (!bam.authorMuted || bam.originatorMuted) // repost of muted content
     )
-  })
+  }
+
+  if (skeleton.filter === 'posts_and_author_threads') {
+    // ensure replies are only included if the feed contains all
+    // replies up to the thread root (i.e. a complete self-thread.)
+    const selfThread = new SelfThreadTracker(skeleton.items, hydration)
+    skeleton.items = skeleton.items.filter((item) => {
+      return (
+        checkBlocksAndMutes(item) &&
+        (item.repost || selfThread.ok(item.post.uri))
+      )
+    })
+  } else {
+    skeleton.items = skeleton.items.filter(checkBlocksAndMutes)
+  }
+
   return skeleton
 }
 
@@ -165,5 +182,63 @@ type Params = QueryParams & {
 type Skeleton = {
   actor: Actor
   items: FeedItem[]
+  filter: QueryParams['filter']
   cursor?: string
 }
+
+class SelfThreadTracker {
+  feedUris = new Set<string>()
+  cache = new Map<string, boolean>()
+
+  constructor(
+    items: FeedItem[],
+    private hydration: HydrationState,
+  ) {
+    items.forEach((item) => {
+      if (!item.repost) {
+        this.feedUris.add(item.post.uri)
+      }
+    })
+  }
+
+  ok(uri: string, loop = new Set<string>()) {
+    // if we've already checked this uri, pull from the cache
+    if (this.cache.has(uri)) {
+      return this.cache.get(uri) ?? false
+    }
+    // loop detection
+    if (loop.has(uri)) {
+      this.cache.set(uri, false)
+      return false
+    } else {
+      loop.add(uri)
+    }
+    // cache through the result
+    const result = this._ok(uri, loop)
+    this.cache.set(uri, result)
+    return result
+  }
+
+  private _ok(uri: string, loop: Set<string>): boolean {
+    // must be in the feed to be in a self-thread
+    if (!this.feedUris.has(uri)) {
+      return false
+    }
+    // must be hydratable to be part of self-thread
+    const post = this.hydration.posts?.get(uri)
+    if (!post) {
+      return false
+    }
+    // root posts (no parent) are trivial case of self-thread
+    const parentUri = getParentUri(post)
+    if (parentUri === null) {
+      return true
+    }
+    // recurse w/ cache: this post is in a self-thread if its parent is.
+    return this.ok(parentUri, loop)
+  }
+}
+
+function getParentUri(post: Post) {
+  return post.record.reply?.parent.uri ?? null
+}

package/src/api/app/bsky/notification/registerPush.ts

@@ -24,8 +24,8 @@ export default function (server: Server, ctx: AppContext) {
           platform === 'ios'
             ? AppPlatform.IOS
             : platform === 'android'
-            ? AppPlatform.ANDROID
-            : AppPlatform.WEB,
+              ? AppPlatform.ANDROID
+              : AppPlatform.WEB,
         appId,
       })
     },

package/src/auth-verifier.ts

@@ -64,7 +64,10 @@ export class AuthVerifier {
   public modServiceDid: string
   private adminPasses: Set<string>
 
-  constructor(public dataplane: DataPlaneClient, opts: AuthVerifierOpts) {
+  constructor(
+    public dataplane: DataPlaneClient,
+    opts: AuthVerifierOpts,
+  ) {
     this.ownDid = opts.ownDid
     this.modServiceDid = opts.modServiceDid
     this.adminPasses = new Set(opts.adminPasses)

package/src/cache/read-through.ts

@@ -14,7 +14,10 @@ export type CacheOptions<T> = {
 }
 
 export class ReadThroughCache<T> {
-  constructor(public redis: Redis, public opts: CacheOptions<T>) {}
+  constructor(
+    public redis: Redis,
+    public opts: CacheOptions<T>,
+  ) {}
 
   private async _fetchMany(keys: string[]): Promise<Record<string, T | null>> {
     let result: Record<string, T | null> = {}
@@ -142,10 +145,13 @@ export class ReadThroughCache<T> {
 }
 
 const removeNulls = <T>(obj: Record<string, T | null>): Record<string, T> => {
-  return Object.entries(obj).reduce((acc, [key, val]) => {
-    if (val !== null) {
-      acc[key] = val
-    }
-    return acc
-  }, {} as Record<string, T>)
+  return Object.entries(obj).reduce(
+    (acc, [key, val]) => {
+      if (val !== null) {
+        acc[key] = val
+      }
+      return acc
+    },
+    {} as Record<string, T>,
+  )
 }

package/src/data-plane/server/db/pagination.ts

@@ -23,7 +23,10 @@ export type LabeledResult = {
  *                     ↳ SQL Condition
  */
 export abstract class GenericKeyset<R, LR extends LabeledResult> {
-  constructor(public primary: DbRef, public secondary: DbRef) {}
+  constructor(
+    public primary: DbRef,
+    public secondary: DbRef,
+  ) {}
   abstract labelResult(result: R): LR
   abstract labeledResultToCursor(labeled: LR): Cursor
   abstract cursorToLabeledResult(cursor: Cursor): LR

package/src/data-plane/server/index.ts

@@ -9,7 +9,10 @@ import { IdResolver, MemoryCache } from '@atproto/identity'
 export { RepoSubscription } from './subscription'
 
 export class DataPlaneServer {
-  constructor(public server: http.Server, public idResolver: IdResolver) {}
+  constructor(
+    public server: http.Server,
+    public idResolver: IdResolver,
+  ) {}
 
   static async create(db: Database, port: number, plcUrl?: string) {
     const app = express()

package/src/data-plane/server/indexing/index.ts

@@ -206,13 +206,16 @@ export class IndexingService {
       .where('did', '=', did)
       .select(['uri', 'cid'])
       .execute()
-    return res.reduce((acc, cur) => {
-      acc[cur.uri] = {
-        uri: new AtUri(cur.uri),
-        cid: CID.parse(cur.cid),
-      }
-      return acc
-    }, {} as Record<string, { uri: AtUri; cid: CID }>)
+    return res.reduce(
+      (acc, cur) => {
+        acc[cur.uri] = {
+          uri: new AtUri(cur.uri),
+          cid: CID.parse(cur.cid),
+        }
+        return acc
+      },
+      {} as Record<string, { uri: AtUri; cid: CID }>,
+    )
   }
 
   async setCommitLastSeen(

package/src/data-plane/server/subscription/index.ts

@@ -134,9 +134,8 @@ export class RepoSubscription {
         return
       }
       if (msg.rebase) {
-        const needsReindex = await this.indexingSvc.checkCommitNeedsIndexing(
-          root,
-        )
+        const needsReindex =
+          await this.indexingSvc.checkCommitNeedsIndexing(root)
         if (needsReindex) {
           await this.indexingSvc.indexRepo(msg.repo, rootCid.toString())
         }

package/src/data-plane/server/subscription/util.ts

@@ -88,7 +88,10 @@ export class ConsecutiveList<T> {
 
 export class ConsecutiveItem<T> {
   isComplete = false
-  constructor(private consecutive: ConsecutiveList<T>, public value: T) {}
+  constructor(
+    private consecutive: ConsecutiveList<T>,
+    public value: T,
+  ) {}
 
   complete() {
     this.isComplete = true

package/src/hydration/actor.ts

@@ -61,13 +61,16 @@ export class ActorHydrator {
     const res = handles.length
       ? await this.dataplane.getDidsByHandles({ handles })
       : { dids: [] }
-    const didByHandle = handles.reduce((acc, cur, i) => {
-      const did = res.dids[i]
-      if (did && did.length > 0) {
-        return acc.set(cur, did)
-      }
-      return acc
-    }, new Map() as Map<string, string>)
+    const didByHandle = handles.reduce(
+      (acc, cur, i) => {
+        const did = res.dids[i]
+        if (did && did.length > 0) {
+          return acc.set(cur, did)
+        }
+        return acc
+      },
+      new Map() as Map<string, string>,
+    )
     return handleOrDids.map((id) =>
       id.startsWith('did:') ? id : didByHandle.get(id),
     )

package/src/hydration/graph.ts

@@ -28,11 +28,14 @@ export type Block = RecordInfo<BlockRecord>
 export type RelationshipPair = [didA: string, didB: string]
 
 const dedupePairs = (pairs: RelationshipPair[]): RelationshipPair[] => {
-  const mapped = pairs.reduce((acc, cur) => {
-    const sorted = ([...cur] as RelationshipPair).sort()
-    acc[sorted.join('-')] = sorted
-    return acc
-  }, {} as Record<string, RelationshipPair>)
+  const mapped = pairs.reduce(
+    (acc, cur) => {
+      const sorted = ([...cur] as RelationshipPair).sort()
+      acc[sorted.join('-')] = sorted
+      return acc
+    },
+    {} as Record<string, RelationshipPair>,
+  )
   return Object.values(mapped)
 }
 

package/src/image/server.ts

@@ -29,7 +29,10 @@ export class ImageProcessingServer {
   app: Express = express()
   uriBuilder: ImageUriBuilder
 
-  constructor(public cfg: ServerConfig, public cache: BlobCache) {
+  constructor(
+    public cfg: ServerConfig,
+    public cache: BlobCache,
+  ) {
     this.uriBuilder = new ImageUriBuilder('')
     this.app.get('*', this.handler.bind(this))
     this.app.use(errorMiddleware)

package/src/lexicon/lexicons.ts

@@ -1067,6 +1067,8 @@ export const schemaDict = {
               },
               reason: {
                 type: 'string',
+                maxGraphemes: 2000,
+                maxLength: 20000,
                 description:
                   'Additional context about the content and violation.',
               },
@@ -2438,9 +2440,11 @@ export const schemaDict = {
         properties: {
           privacyPolicy: {
             type: 'string',
+            format: 'uri',
           },
           termsOfService: {
             type: 'string',
+            format: 'uri',
           },
         },
       },
@@ -3052,7 +3056,8 @@ export const schemaDict = {
             commit: {
               type: 'string',
               format: 'cid',
-              description: 'An optional past commit CID.',
+              description:
+                'DEPRECATED: referenced a repo commit by CID, and retrieved record as of that commit',
             },
           },
         },
@@ -3621,6 +3626,7 @@ export const schemaDict = {
           },
           avatar: {
             type: 'string',
+            format: 'uri',
           },
           associated: {
             type: 'ref',
@@ -3663,6 +3669,7 @@ export const schemaDict = {
           },
           avatar: {
             type: 'string',
+            format: 'uri',
           },
           associated: {
             type: 'ref',
@@ -3709,9 +3716,11 @@ export const schemaDict = {
           },
           avatar: {
             type: 'string',
+            format: 'uri',
           },
           banner: {
             type: 'string',
+            format: 'uri',
           },
           followersCount: {
             type: 'integer',
@@ -4388,6 +4397,7 @@ export const schemaDict = {
           },
           thumb: {
             type: 'string',
+            format: 'uri',
           },
         },
       },
@@ -4468,11 +4478,13 @@ export const schemaDict = {
         properties: {
           thumb: {
             type: 'string',
+            format: 'uri',
             description:
               'Fully-qualified URL where a thumbnail of the image can be fetched. For example, CDN location provided by the App View.',
           },
           fullsize: {
             type: 'string',
+            format: 'uri',
             description:
               'Fully-qualified URL where a large version of the image can be fetched. May or may not be the exact original blob. For example, CDN location provided by the App View.',
           },
@@ -4886,6 +4898,7 @@ export const schemaDict = {
           },
           avatar: {
             type: 'string',
+            format: 'uri',
           },
           likeCount: {
             type: 'integer',
@@ -6201,6 +6214,7 @@ export const schemaDict = {
           },
           avatar: {
             type: 'string',
+            format: 'uri',
           },
           labels: {
             type: 'array',
@@ -6258,6 +6272,7 @@ export const schemaDict = {
           },
           avatar: {
             type: 'string',
+            format: 'uri',
           },
           labels: {
             type: 'array',

package/src/lexicon/types/com/atproto/sync/getRecord.ts

@@ -15,7 +15,7 @@ export interface QueryParams {
   collection: string
   /** Record Key */
   rkey: string
-  /** An optional past commit CID. */
+  /** DEPRECATED: referenced a repo commit by CID, and retrieved record as of that commit */
   commit?: string
 }
 

package/tests/_util.ts

@@ -178,16 +178,16 @@ export const stripViewerFromPost = (postUnknown: unknown): PostView => {
     post.embed && isViewRecord(post.embed.record)
       ? post.embed.record // Record from record embed
       : post.embed?.['record'] && isViewRecord(post.embed['record']['record'])
-      ? post.embed['record']['record'] // Record from record-with-media embed
-      : undefined
+        ? post.embed['record']['record'] // Record from record-with-media embed
+        : undefined
   if (recordEmbed) {
     recordEmbed.author = stripViewer(recordEmbed.author)
     recordEmbed.embeds?.forEach((deepEmbed) => {
       const deepRecordEmbed = isViewRecord(deepEmbed.record)
         ? deepEmbed.record // Record from record embed
         : deepEmbed['record'] && isViewRecord(deepEmbed['record']['record'])
-        ? deepEmbed['record']['record'] // Record from record-with-media embed
-        : undefined
+          ? deepEmbed['record']['record'] // Record from record-with-media embed
+          : undefined
       if (deepRecordEmbed) {
         deepRecordEmbed.author = stripViewer(deepRecordEmbed.author)
       }

package/tests/views/author-feed.test.ts

@@ -1,9 +1,10 @@
-import AtpAgent from '@atproto/api'
+import AtpAgent, { AtUri } from '@atproto/api'
 import { TestNetwork, SeedClient, authorFeedSeed } from '@atproto/dev-env'
 import { forSnapshot, paginateAll, stripViewerFromPost } from '../_util'
-import { isRecord } from '../../src/lexicon/types/app/bsky/feed/post'
+import { ReplyRef, isRecord } from '../../src/lexicon/types/app/bsky/feed/post'
 import { isView as isEmbedRecordWithMedia } from '../../src/lexicon/types/app/bsky/embed/recordWithMedia'
 import { isView as isImageEmbed } from '../../src/lexicon/types/app/bsky/embed/images'
+import { isPostView } from '../../src/lexicon/types/app/bsky/feed/defs'
 
 describe('pds author feed views', () => {
   let network: TestNetwork
@@ -282,13 +283,48 @@ describe('pds author feed views', () => {
       filter: 'posts_and_author_threads',
     })
 
-    expect(eveFeed.feed.length).toEqual(7)
+    expect(eveFeed.feed.length).toEqual(6)
     expect(
       eveFeed.feed.some(({ post }) => {
-        return (
+        const replyByEve =
           isRecord(post.record) && post.record.reply && post.author.did === eve
-        )
+        return replyByEve
+      }),
+    ).toBeTruthy()
+    // does not include eve's replies to fred, even within her own thread.
+    expect(
+      eveFeed.feed.every(({ post, reply }) => {
+        if (!post || !isRecord(post.record) || !post.record.reply) {
+          return true // not a reply
+        }
+        const replyToEve = isReplyTo(post.record.reply, eve)
+        const replyToReplyByEve =
+          reply &&
+          isPostView(reply.parent) &&
+          isRecord(reply.parent.record) &&
+          (!reply.parent.record.reply ||
+            isReplyTo(reply.parent.record.reply, eve))
+        return replyToEve && replyToReplyByEve
+      }),
+    ).toBeTruthy()
+    // reposts are preserved
+    expect(
+      eveFeed.feed.some(({ post, reason }) => {
+        const repostOfOther =
+          reason && isRecord(post.record) && post.author.did !== eve
+        return repostOfOther
       }),
     ).toBeTruthy()
   })
 })
+
+function isReplyTo(reply: ReplyRef, did: string) {
+  return (
+    getDidFromUri(reply.root.uri) === did &&
+    getDidFromUri(reply.parent.uri) === did
+  )
+}
+
+function getDidFromUri(uri: string) {
+  return new AtUri(uri).hostname
+}