@atproto/bsky 0.0.56 → 0.0.58

package/src/proto/bsky_pb.ts

@@ -3760,6 +3760,11 @@ export class ActorInfo extends Message<ActorInfo> {
    */
   allowIncomingChatsFrom = ''
 
+  /**
+   * @generated from field: string upstream_status = 9;
+   */
+  upstreamStatus = ''
+
   constructor(data?: PartialMessage<ActorInfo>) {
     super()
     proto3.util.initPartial(data, this)
@@ -3786,6 +3791,12 @@ export class ActorInfo extends Message<ActorInfo> {
       kind: 'scalar',
       T: 9 /* ScalarType.STRING */,
     },
+    {
+      no: 9,
+      name: 'upstream_status',
+      kind: 'scalar',
+      T: 9 /* ScalarType.STRING */,
+    },
   ])
 
   static fromBinary(
@@ -10007,6 +10018,132 @@ export class PingResponse extends Message<PingResponse> {
   }
 }
 
+/**
+ * @generated from message bsky.UpdateActorUpstreamStatusRequest
+ */
+export class UpdateActorUpstreamStatusRequest extends Message<UpdateActorUpstreamStatusRequest> {
+  /**
+   * @generated from field: string actor_did = 1;
+   */
+  actorDid = ''
+
+  /**
+   * @generated from field: bool active = 2;
+   */
+  active = false
+
+  /**
+   * @generated from field: string upstream_status = 3;
+   */
+  upstreamStatus = ''
+
+  constructor(data?: PartialMessage<UpdateActorUpstreamStatusRequest>) {
+    super()
+    proto3.util.initPartial(data, this)
+  }
+
+  static readonly runtime: typeof proto3 = proto3
+  static readonly typeName = 'bsky.UpdateActorUpstreamStatusRequest'
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: 'actor_did', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: 'active', kind: 'scalar', T: 8 /* ScalarType.BOOL */ },
+    {
+      no: 3,
+      name: 'upstream_status',
+      kind: 'scalar',
+      T: 9 /* ScalarType.STRING */,
+    },
+  ])
+
+  static fromBinary(
+    bytes: Uint8Array,
+    options?: Partial<BinaryReadOptions>,
+  ): UpdateActorUpstreamStatusRequest {
+    return new UpdateActorUpstreamStatusRequest().fromBinary(bytes, options)
+  }
+
+  static fromJson(
+    jsonValue: JsonValue,
+    options?: Partial<JsonReadOptions>,
+  ): UpdateActorUpstreamStatusRequest {
+    return new UpdateActorUpstreamStatusRequest().fromJson(jsonValue, options)
+  }
+
+  static fromJsonString(
+    jsonString: string,
+    options?: Partial<JsonReadOptions>,
+  ): UpdateActorUpstreamStatusRequest {
+    return new UpdateActorUpstreamStatusRequest().fromJsonString(
+      jsonString,
+      options,
+    )
+  }
+
+  static equals(
+    a:
+      | UpdateActorUpstreamStatusRequest
+      | PlainMessage<UpdateActorUpstreamStatusRequest>
+      | undefined,
+    b:
+      | UpdateActorUpstreamStatusRequest
+      | PlainMessage<UpdateActorUpstreamStatusRequest>
+      | undefined,
+  ): boolean {
+    return proto3.util.equals(UpdateActorUpstreamStatusRequest, a, b)
+  }
+}
+
+/**
+ * @generated from message bsky.UpdateActorUpstreamStatusResponse
+ */
+export class UpdateActorUpstreamStatusResponse extends Message<UpdateActorUpstreamStatusResponse> {
+  constructor(data?: PartialMessage<UpdateActorUpstreamStatusResponse>) {
+    super()
+    proto3.util.initPartial(data, this)
+  }
+
+  static readonly runtime: typeof proto3 = proto3
+  static readonly typeName = 'bsky.UpdateActorUpstreamStatusResponse'
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [])
+
+  static fromBinary(
+    bytes: Uint8Array,
+    options?: Partial<BinaryReadOptions>,
+  ): UpdateActorUpstreamStatusResponse {
+    return new UpdateActorUpstreamStatusResponse().fromBinary(bytes, options)
+  }
+
+  static fromJson(
+    jsonValue: JsonValue,
+    options?: Partial<JsonReadOptions>,
+  ): UpdateActorUpstreamStatusResponse {
+    return new UpdateActorUpstreamStatusResponse().fromJson(jsonValue, options)
+  }
+
+  static fromJsonString(
+    jsonString: string,
+    options?: Partial<JsonReadOptions>,
+  ): UpdateActorUpstreamStatusResponse {
+    return new UpdateActorUpstreamStatusResponse().fromJsonString(
+      jsonString,
+      options,
+    )
+  }
+
+  static equals(
+    a:
+      | UpdateActorUpstreamStatusResponse
+      | PlainMessage<UpdateActorUpstreamStatusResponse>
+      | undefined,
+    b:
+      | UpdateActorUpstreamStatusResponse
+      | PlainMessage<UpdateActorUpstreamStatusResponse>
+      | undefined,
+  ): boolean {
+    return proto3.util.equals(UpdateActorUpstreamStatusResponse, a, b)
+  }
+}
+
 /**
  * @generated from message bsky.TakedownActorRequest
  */

package/src/views/index.ts

@@ -63,8 +63,21 @@ export class Views {
   // Actor
   // ------------
 
+  actorIsNoHosted(did: string, state: HydrationState): boolean {
+    return (
+      this.actorIsDeactivated(did, state) || this.actorIsTakendown(did, state)
+    )
+  }
+
+  actorIsDeactivated(did: string, state: HydrationState): boolean {
+    if (state.actors?.get(did)?.upstreamStatus === 'deactivated') return true
+    return false
+  }
+
   actorIsTakendown(did: string, state: HydrationState): boolean {
     if (state.actors?.get(did)?.takedownRef) return true
+    if (state.actors?.get(did)?.upstreamStatus === 'takendown') return true
+    if (state.actors?.get(did)?.upstreamStatus === 'suspended') return true
     if (state.labels?.get(did)?.isTakendown) return true
     return false
   }

package/tests/data-plane/db.test.ts

@@ -64,7 +64,7 @@ describe('db', () => {
 
       const row = await db.db
         .selectFrom('actor')
-        .selectAll()
+        .select(['did', 'handle', 'indexedAt'])
         .where('did', '=', 'x')
         .executeTakeFirst()
 
@@ -72,7 +72,6 @@ describe('db', () => {
         did: 'x',
         handle: 'x',
         indexedAt: 'bad-date',
-        takedownRef: null,
       })
     })
 

package/tests/data-plane/indexing.test.ts

@@ -614,14 +614,14 @@ describe('indexing', () => {
     })
   })
 
-  describe('tombstoneActor', () => {
+  describe('deleteActor', () => {
     it('does not unindex actor when they are still being hosted by their pds', async () => {
       const { data: profileBefore } = await agent.api.app.bsky.actor.getProfile(
         { actor: sc.dids.alice },
         { headers: await network.serviceHeaders(sc.dids.bob) },
       )
       // Attempt indexing tombstone
-      await network.bsky.sub.indexingSvc.tombstoneActor(sc.dids.alice)
+      await network.bsky.sub.indexingSvc.deleteActor(sc.dids.alice)
       const { data: profileAfter } = await agent.api.app.bsky.actor.getProfile(
         { actor: sc.dids.alice },
         { headers: await network.serviceHeaders(sc.dids.bob) },
@@ -648,7 +648,7 @@ describe('indexing', () => {
       })
       await network.pds.ctx.backgroundQueue.processAll()
       // Index tombstone
-      await network.bsky.sub.indexingSvc.tombstoneActor(alice)
+      await network.bsky.sub.indexingSvc.deleteActor(alice)
       const getProfileAfter = agent.api.app.bsky.actor.getProfile(
         { actor: alice },
         { headers: await network.serviceHeaders(sc.dids.bob) },

package/tests/data-plane/subscription/repo.test.ts

@@ -86,7 +86,7 @@ describe('sync', () => {
       const evt = cborDecode(seqEvt.event) as sequencer.CommitEvt
       evt.blocks = new Uint8Array() // bad blocks
       seqEvt.event = cborEncode(evt)
-      await network.pds.ctx.sequencer.sequenceEvt(seqEvt)
+      return await network.pds.ctx.sequencer.sequenceEvt(seqEvt)
     }
     // create account and index the initial commit event
     await sc.createAccount('jack', {

package/tests/views/account-deactivation.test.ts

@@ -0,0 +1,76 @@
+import AtpAgent from '@atproto/api'
+import { TestNetwork, SeedClient, basicSeed } from '@atproto/dev-env'
+
+describe('bsky account deactivation', () => {
+  let network: TestNetwork
+  let agent: AtpAgent
+  let sc: SeedClient
+
+  let alice: string
+
+  beforeAll(async () => {
+    network = await TestNetwork.create({
+      dbPostgresSchema: 'bsky_views_account_deactivation',
+    })
+    agent = network.bsky.getClient()
+    sc = network.getSeedClient()
+    await basicSeed(sc)
+    alice = sc.dids.alice
+    const pdsAgent = network.pds.getClient()
+    await pdsAgent.com.atproto.server.deactivateAccount(
+      {},
+      { encoding: 'application/json', headers: sc.getHeaders(alice) },
+    )
+    await network.processAll()
+  })
+
+  afterAll(async () => {
+    await network.close()
+  })
+
+  it('does not return deactivated profiles', async () => {
+    const attempt = agent.api.app.bsky.actor.getProfile({
+      actor: alice,
+    })
+    await expect(attempt).rejects.toThrow('Account is deactivated')
+    const res = await agent.api.app.bsky.actor.getProfiles({
+      actors: [sc.dids.alice, sc.dids.bob, sc.dids.carol],
+    })
+    expect(res.data.profiles.length).toBe(2)
+    expect(res.data.profiles.some((p) => p.did === alice)).toBe(false)
+  })
+
+  it('does not return deactivated accounts in follows', async () => {
+    const follows = await agent.api.app.bsky.graph.getFollows({
+      actor: sc.dids.bob,
+    })
+    expect(follows.data.follows.some((f) => f.did === alice)).toBe(false)
+    const followers = await agent.api.app.bsky.graph.getFollowers({
+      actor: sc.dids.bob,
+    })
+    expect(followers.data.followers.some((f) => f.did === alice)).toBe(false)
+  })
+
+  it('does not return posts from deactivated accounts', async () => {
+    const uris = [
+      sc.posts[sc.dids.alice][0].ref.uriStr,
+      sc.posts[sc.dids.alice][1].ref.uriStr,
+      sc.posts[sc.dids.bob][0].ref.uriStr,
+      sc.posts[sc.dids.carol][0].ref.uriStr,
+      sc.posts[sc.dids.dan][1].ref.uriStr,
+      sc.replies[sc.dids.alice][0].ref.uriStr,
+    ]
+    const res = await agent.api.app.bsky.feed.getPosts({ uris })
+
+    expect(res.data.posts.length).toBe(3)
+    expect(res.data.posts.some((p) => p.author.did === alice)).toBe(false)
+  })
+
+  it('does not return posts from deactivated in timelines', async () => {
+    const res = await agent.api.app.bsky.feed.getTimeline(
+      {},
+      { headers: await network.serviceHeaders(sc.dids.bob) },
+    )
+    expect(res.data.feed.some((p) => p.post.author.did === alice)).toBe(false)
+  })
+})