@atproto/bsky 0.0.156 → 0.0.157

package/src/proto/bsync_pb.ts

@@ -736,14 +736,14 @@ export class Operation extends Message<Operation> {
   actorDid = ''
 
   /**
-   * @generated from field: string collection = 3;
+   * @generated from field: string namespace = 3;
    */
-  collection = ''
+  namespace = ''
 
   /**
-   * @generated from field: string rkey = 4;
+   * @generated from field: string key = 4;
    */
-  rkey = ''
+  key = ''
 
   /**
    * @generated from field: bsync.Method method = 5;
@@ -765,8 +765,8 @@ export class Operation extends Message<Operation> {
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: 'id', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
     { no: 2, name: 'actor_did', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
-    { no: 3, name: 'collection', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
-    { no: 4, name: 'rkey', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: 'namespace', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+    { no: 4, name: 'key', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
     { no: 5, name: 'method', kind: 'enum', T: proto3.getEnumType(Method) },
     { no: 6, name: 'payload', kind: 'scalar', T: 12 /* ScalarType.BYTES */ },
   ])
@@ -805,19 +805,19 @@ export class Operation extends Message<Operation> {
  */
 export class PutOperationRequest extends Message<PutOperationRequest> {
   /**
-   * @generated from field: string collection = 1;
+   * @generated from field: string actor_did = 1;
    */
-  collection = ''
+  actorDid = ''
 
   /**
-   * @generated from field: string actor_did = 2;
+   * @generated from field: string namespace = 2;
    */
-  actorDid = ''
+  namespace = ''
 
   /**
-   * @generated from field: string rkey = 3;
+   * @generated from field: string key = 3;
    */
-  rkey = ''
+  key = ''
 
   /**
    * @generated from field: bsync.Method method = 4;
@@ -837,9 +837,9 @@ export class PutOperationRequest extends Message<PutOperationRequest> {
   static readonly runtime: typeof proto3 = proto3
   static readonly typeName = 'bsync.PutOperationRequest'
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: 'collection', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
-    { no: 2, name: 'actor_did', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
-    { no: 3, name: 'rkey', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+    { no: 1, name: 'actor_did', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: 'namespace', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: 'key', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
     { no: 4, name: 'method', kind: 'enum', T: proto3.getEnumType(Method) },
     { no: 5, name: 'payload', kind: 'scalar', T: 12 /* ScalarType.BYTES */ },
   ])

package/src/stash.ts

@@ -0,0 +1,75 @@
+import { LexValue, stringifyLex } from '@atproto/lexicon'
+import { BsyncClient } from './bsync'
+import { lexicons } from './lexicon/lexicons'
+import { Method } from './proto/bsync_pb'
+
+export const createStashClient = (bsyncClient: BsyncClient): StashClient => {
+  return new StashClient(bsyncClient)
+}
+
+// An abstraction over the BsyncClient, that uses the bsync `PutOperation` RPC
+// to store private data, which can be indexed by the dataplane and queried by the appview.
+export class StashClient {
+  constructor(private readonly bsyncClient: BsyncClient) {}
+
+  create(input: CreateInput) {
+    this.validateLexicon(input.namespace, input.payload)
+    return this.putOperation(Method.CREATE, input)
+  }
+
+  update(input: UpdateInput) {
+    this.validateLexicon(input.namespace, input.payload)
+    return this.putOperation(Method.UPDATE, input)
+  }
+
+  delete(input: DeleteInput) {
+    return this.putOperation(Method.DELETE, { ...input, payload: undefined })
+  }
+
+  private validateLexicon(namespace: string, payload: LexValue) {
+    const result = lexicons.validate(namespace, payload)
+    if (!result.success) {
+      throw result.error
+    }
+  }
+
+  private async putOperation(method: Method, input: PutOperationInput) {
+    const { actorDid, namespace, key, payload } = input
+    await this.bsyncClient.putOperation({
+      actorDid,
+      namespace,
+      key,
+      method,
+      payload: payload
+        ? Buffer.from(
+            stringifyLex({
+              $type: namespace,
+              ...payload,
+            }),
+          )
+        : undefined,
+    })
+  }
+}
+
+type PutOperationInput = {
+  actorDid: string
+  namespace: string
+  key: string
+  payload: LexValue | undefined
+}
+
+type CreateInput = {
+  actorDid: string
+  namespace: string
+  key: string
+  payload: LexValue
+}
+
+type UpdateInput = CreateInput
+
+type DeleteInput = {
+  actorDid: string
+  namespace: string
+  key: string
+}

package/tests/stash.test.ts

@@ -0,0 +1,156 @@
+import { TestNetwork } from '@atproto/dev-env'
+import { ProfileAssociatedChat } from '../dist/lexicon/types/app/bsky/actor/defs'
+import { StashClient } from '../dist/stash'
+
+type Database = TestNetwork['bsky']['db']
+
+describe('private data', () => {
+  let network: TestNetwork
+  let stashClient: StashClient
+  let db: Database
+
+  const actorDid = 'did:plc:example'
+  // This lexicon has nothing special other than being simple, convenient to use in a test.
+  const namespace = 'app.bsky.actor.defs#profileAssociatedChat'
+  const key = 'self'
+
+  const validPayload0: ProfileAssociatedChat = { allowIncoming: 'all' }
+  const validPayload1: ProfileAssociatedChat = { allowIncoming: 'following' }
+  const invalidPayload: ProfileAssociatedChat = {
+    invalid: 'all',
+  } as unknown as ProfileAssociatedChat
+
+  beforeAll(async () => {
+    network = await TestNetwork.create({
+      dbPostgresSchema: 'bsky_private_data',
+    })
+    db = network.bsky.db
+    stashClient = network.bsky.ctx.stashClient
+  })
+
+  afterEach(async () => {
+    await clearPrivateData(db)
+  })
+
+  afterAll(async () => {
+    await network.close()
+  })
+
+  describe('create', () => {
+    it('creates entry', async () => {
+      await stashClient.create({
+        actorDid,
+        namespace,
+        key,
+        payload: validPayload0,
+      })
+      await network.processAll()
+
+      const dbResult = await db.db
+        .selectFrom('private_data')
+        .selectAll()
+        .where('actorDid', '=', actorDid)
+        .where('namespace', '=', namespace)
+        .where('key', '=', key)
+        .executeTakeFirstOrThrow()
+      expect(dbResult).toStrictEqual({
+        actorDid,
+        namespace,
+        key,
+        payload: JSON.stringify({ $type: namespace, ...validPayload0 }),
+        indexedAt: expect.any(String),
+        updatedAt: expect.any(String),
+      })
+    })
+
+    it('validates lexicon', async () => {
+      expect(() =>
+        stashClient.create({
+          actorDid,
+          namespace,
+          key,
+          payload: invalidPayload,
+        }),
+      ).toThrow('Object must have the property "allowIncoming"')
+    })
+  })
+
+  describe('update', () => {
+    it('updates entry', async () => {
+      await stashClient.create({
+        actorDid,
+        namespace,
+        key,
+        payload: validPayload0,
+      })
+      await network.processAll()
+
+      await stashClient.update({
+        actorDid,
+        namespace,
+        key,
+        payload: validPayload1,
+      })
+      await network.processAll()
+
+      const dbResult = await db.db
+        .selectFrom('private_data')
+        .selectAll()
+        .where('actorDid', '=', actorDid)
+        .where('namespace', '=', namespace)
+        .where('key', '=', key)
+        .executeTakeFirstOrThrow()
+      expect(dbResult).toStrictEqual({
+        actorDid,
+        namespace,
+        key,
+        payload: JSON.stringify({ $type: namespace, ...validPayload1 }),
+        indexedAt: expect.any(String),
+        updatedAt: expect.any(String),
+      })
+    })
+
+    it('validates lexicon', async () => {
+      expect(() =>
+        stashClient.update({
+          actorDid,
+          namespace,
+          key,
+          payload: invalidPayload,
+        }),
+      ).toThrow('Object must have the property "allowIncoming"')
+    })
+  })
+
+  describe('delete', () => {
+    it('deletes entry', async () => {
+      await stashClient.create({
+        actorDid,
+        namespace,
+        key,
+        payload: validPayload0,
+      })
+      await network.processAll()
+
+      await stashClient.delete({
+        actorDid,
+        namespace,
+        key,
+      })
+      await network.processAll()
+
+      const dbResult = await db.db
+        .selectFrom('private_data')
+        .selectAll()
+        .where('actorDid', '=', actorDid)
+        .where('namespace', '=', namespace)
+        .where('key', '=', key)
+        .executeTakeFirst()
+      expect(dbResult).toBe(undefined)
+    })
+  })
+})
+
+const clearPrivateData = async (db: Database) => {
+  await db.db.deleteFrom('private_data').execute()
+}

package/tests/views/notifications.test.ts

@@ -2,11 +2,22 @@ import { AtpAgent } from '@atproto/api'
 import { SeedClient, TestNetwork, basicSeed } from '@atproto/dev-env'
 import { delayCursor } from '../../src/api/app/bsky/notification/listNotifications'
 import { ids } from '../../src/lexicon/lexicons'
+import {
+  ChatPreference,
+  FilterablePreference,
+  Preference,
+  Preferences,
+} from '../../src/lexicon/types/app/bsky/notification/defs'
 import { Notification } from '../../src/lexicon/types/app/bsky/notification/listNotifications'
+import { InputSchema } from '../../src/lexicon/types/app/bsky/notification/putPreferencesV2'
 import { forSnapshot, paginateAll } from '../_util'
 
+type Database = TestNetwork['bsky']['db']
+
 describe('notification views', () => {
   let network: TestNetwork
+  let db: Database
+
   let agent: AtpAgent
   let sc: SeedClient
 
@@ -19,6 +30,7 @@ describe('notification views', () => {
     network = await TestNetwork.create({
       dbPostgresSchema: 'bsky_views_notifications',
     })
+    db = network.bsky.db
     agent = network.bsky.getClient()
     sc = network.getSeedClient()
     await basicSeed(sc)
@@ -905,4 +917,213 @@ describe('notification views', () => {
       })
     })
   })
+
+  describe('preferences v2', () => {
+    beforeEach(async () => {
+      await clearPrivateData(db)
+    })
+
+    // Defaults
+    const fp: FilterablePreference = {
+      filter: 'all',
+      list: true,
+      push: true,
+    }
+    const p: Preference = {
+      list: true,
+      push: true,
+    }
+    const cp: ChatPreference = {
+      filter: 'all',
+      push: true,
+    }
+
+    it('gets preferences filling up with the defaults', async () => {
+      const actorDid = sc.dids.carol
+
+      const getAndAssert = async (
+        expectedApi: Preferences,
+        expectedDb: Preferences | undefined,
+      ) => {
+        const { data } = await agent.app.bsky.notification.getPreferences(
+          {},
+          {
+            headers: await network.serviceHeaders(
+              actorDid,
+              ids.AppBskyNotificationGetPreferences,
+            ),
+          },
+        )
+        expect(data.preferences).toStrictEqual(expectedApi)
+
+        const dbResult = await db.db
+          .selectFrom('private_data')
+          .selectAll()
+          .where('actorDid', '=', actorDid)
+          .where('namespace', '=', 'app.bsky.notification.defs#preferences')
+          .where('key', '=', 'self')
+          .executeTakeFirst()
+        if (dbResult === undefined) {
+          expect(dbResult).toBe(expectedDb)
+        } else {
+          expect(dbResult).toStrictEqual({
+            actorDid: actorDid,
+            namespace: 'app.bsky.notification.defs#preferences',
+            key: 'self',
+            indexedAt: expect.any(String),
+            payload: expect.anything(), // Better to compare payload parsed.
+            updatedAt: expect.any(String),
+          })
+          expect(JSON.parse(dbResult.payload)).toStrictEqual({
+            $type: 'app.bsky.notification.defs#preferences',
+            ...expectedDb,
+          })
+        }
+      }
+
+      const expectedApi0: Preferences = {
+        chat: cp,
+        follow: fp,
+        like: fp,
+        likeViaRepost: fp,
+        mention: fp,
+        quote: fp,
+        reply: fp,
+        repost: fp,
+        repostViaRepost: fp,
+        starterpackJoined: p,
+        subscribedPost: p,
+        unverified: p,
+        verified: p,
+      }
+      // The user has no preferences set yet, so nothing stored.
+      const expectedDb0 = undefined
+      await getAndAssert(expectedApi0, expectedDb0)
+
+      await agent.app.bsky.notification.putPreferencesV2(
+        { verified: { list: false, push: false } },
+        {
+          encoding: 'application/json',
+          headers: await network.serviceHeaders(
+            actorDid,
+            ids.AppBskyNotificationPutPreferencesV2,
+          ),
+        },
+      )
+      await network.processAll()
+
+      const expectedApi1: Preferences = {
+        chat: cp,
+        follow: fp,
+        like: fp,
+        likeViaRepost: fp,
+        mention: fp,
+        quote: fp,
+        reply: fp,
+        repost: fp,
+        repostViaRepost: fp,
+        starterpackJoined: p,
+        subscribedPost: p,
+        unverified: p,
+        verified: { list: false, push: false },
+      }
+      // Stored all the defaults.
+      const expectedDb1 = expectedApi1
+      await getAndAssert(expectedApi1, expectedDb1)
+    })
+
+    it('stores the preferences setting the defaults', async () => {
+      const actorDid = sc.dids.carol
+
+      const putAndAssert = async (
+        input: InputSchema,
+        expected: Preferences,
+      ) => {
+        const { data } = await agent.app.bsky.notification.putPreferencesV2(
+          input,
+          {
+            encoding: 'application/json',
+            headers: await network.serviceHeaders(
+              actorDid,
+              ids.AppBskyNotificationPutPreferencesV2,
+            ),
+          },
+        )
+        await network.processAll()
+        expect(data.preferences).toStrictEqual(expected)
+
+        const dbResult = await db.db
+          .selectFrom('private_data')
+          .selectAll()
+          .where('actorDid', '=', actorDid)
+          .where('namespace', '=', 'app.bsky.notification.defs#preferences')
+          .where('key', '=', 'self')
+          .executeTakeFirstOrThrow()
+        expect(dbResult).toStrictEqual({
+          actorDid: actorDid,
+          namespace: 'app.bsky.notification.defs#preferences',
+          key: 'self',
+          indexedAt: expect.any(String),
+          payload: expect.anything(), // Better to compare payload parsed.
+          updatedAt: expect.any(String),
+        })
+        expect(JSON.parse(dbResult.payload)).toStrictEqual({
+          $type: 'app.bsky.notification.defs#preferences',
+          ...expected,
+        })
+      }
+
+      const input0 = {
+        chat: {
+          push: false,
+          filter: 'accepted',
+        },
+      }
+      const expected0: Preferences = {
+        chat: input0.chat,
+        follow: fp,
+        like: fp,
+        likeViaRepost: fp,
+        mention: fp,
+        quote: fp,
+        reply: fp,
+        repost: fp,
+        repostViaRepost: fp,
+        starterpackJoined: p,
+        subscribedPost: p,
+        unverified: p,
+        verified: p,
+      }
+      await putAndAssert(input0, expected0)
+
+      const input1 = {
+        mention: {
+          list: false,
+          push: false,
+          filter: 'follows',
+        },
+      }
+      const expected1: Preferences = {
+        // Kept from the previous call.
+        chat: input0.chat,
+        follow: fp,
+        like: fp,
+        likeViaRepost: fp,
+        mention: input1.mention,
+        quote: fp,
+        reply: fp,
+        repost: fp,
+        repostViaRepost: fp,
+        starterpackJoined: p,
+        subscribedPost: p,
+        unverified: p,
+        verified: p,
+      }
+      await putAndAssert(input1, expected1)
+    })
+  })
 })
+
+const clearPrivateData = async (db: Database) => {
+  await db.db.deleteFrom('private_data').execute()
+}