@atproto/bsky 0.0.250 → 0.0.253

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

@@ -1,128 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it, vitest } from 'vitest'
-import { AtpAgent, ids } from '@atproto/api'
-import { cborDecode, cborEncode } from '@atproto/common'
-import { SeedClient, TestNetwork, basicSeed } from '@atproto/dev-env'
-import { sequencer } from '@atproto/pds'
-import type { DidString } from '@atproto/syntax'
-import { DatabaseSchemaType } from '../../src/data-plane/server/db/database-schema.js'
-import { forSnapshot } from '../_util.js'
-
-type Database = TestNetwork['bsky']['db']
-
-describe('sync', () => {
-  let network: TestNetwork
-  let pdsAgent: AtpAgent
-  let sc: SeedClient
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'bsky_subscription_repo',
-    })
-    pdsAgent = network.pds.getAgent()
-    sc = network.getSeedClient()
-    await basicSeed(sc)
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  it('indexes permit history being replayed.', async () => {
-    const { db } = network.bsky
-
-    // Generate some modifications and dupes
-    const { alice, bob, carol, dan } = sc.dids
-    await sc.follow(alice, bob)
-    await sc.follow(carol, alice)
-    await sc.follow(bob, alice)
-    await sc.follow(dan, bob)
-    await sc.like(dan, sc.posts[alice][1].ref) // Identical
-    await sc.like(alice, sc.posts[carol][0].ref) // Identical
-    await updateProfile(pdsAgent, alice, { displayName: 'ali!' })
-    await updateProfile(pdsAgent, bob, { displayName: 'robert!' })
-
-    await network.processAll()
-
-    // Table comparator
-    const getTableDump = async () => {
-      const [actor, post, profile, like, follow, dupes] = await Promise.all([
-        dumpTable(db, 'actor', ['did']),
-        dumpTable(db, 'post', ['uri']),
-        dumpTable(db, 'profile', ['uri']),
-        dumpTable(db, 'like', ['creator', 'subject']),
-        dumpTable(db, 'follow', ['creator', 'subjectDid']),
-        dumpTable(db, 'duplicate_record', ['uri']),
-      ])
-      return { actor, post, profile, like, follow, dupes }
-    }
-
-    // Mark originals
-    const originalTableDump = await getTableDump()
-
-    // Reprocess repos via sync subscription, on top of existing indices
-    await network.bsky.sub.restart()
-    await network.processAll()
-
-    // Permissive of indexedAt times changing
-    expect(forSnapshot(await getTableDump())).toEqual(
-      forSnapshot(originalTableDump),
-    )
-  })
-
-  it('indexes actor when commit is unprocessable.', async () => {
-    // mock sequencing to create an unprocessable commit event
-    using _ = vitest
-      .spyOn(network.pds.ctx.sequencer, 'sequenceCommit')
-      .mockImplementation(async function (
-        this: typeof network.pds.ctx.sequencer,
-        did,
-        commitData,
-      ) {
-        const seqEvt = await sequencer.formatSeqCommit(did, commitData)
-        const evt = cborDecode(seqEvt.event) as sequencer.CommitEvt
-        evt.blocks = new Uint8Array() // bad blocks
-        seqEvt.event = cborEncode(evt)
-        await this.sequenceEvts([seqEvt])
-      })
-
-    // create account and index the initial commit event
-    await sc.createAccount('jack', {
-      handle: 'jack.test',
-      email: 'jack@test.com',
-      password: 'password',
-    })
-    await network.processAll()
-    // confirm jack was indexed as an actor despite the bad event
-    const actors = await dumpTable(network.bsky.db, 'actor', ['did'])
-    expect(actors.map((a) => a.handle)).toContain('jack.test')
-  })
-
-  async function updateProfile(
-    agent: AtpAgent,
-    did: DidString,
-    record: Record<string, unknown>,
-  ) {
-    return await agent.api.com.atproto.repo.putRecord(
-      {
-        repo: did,
-        collection: ids.AppBskyActorProfile,
-        rkey: 'self',
-        record,
-      },
-      { headers: sc.getHeaders(did), encoding: 'application/json' },
-    )
-  }
-})
-
-async function dumpTable<T extends keyof DatabaseSchemaType>(
-  db: Database,
-  tableName: T,
-  pkeys: (keyof DatabaseSchemaType[T] & string)[],
-) {
-  const { ref, table } = db.db.dynamic
-  let builder = db.db.selectFrom(table(tableName).as('t')).selectAll()
-  pkeys.forEach((key) => {
-    builder = builder.orderBy(ref(key))
-  })
-  return await builder.execute()
-}

package/tests/data-plane/thread-mutes.test.ts

@@ -1,175 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it } from 'vitest'
-import { AtpAgent, ids } from '@atproto/api'
-import { RecordRef, SeedClient, TestNetwork, usersSeed } from '@atproto/dev-env'
-import type { DidString } from '@atproto/syntax'
-
-describe('thread mutes', () => {
-  let network: TestNetwork
-  let agent: AtpAgent
-  let sc: SeedClient
-
-  let alice: DidString
-  let bob: DidString
-
-  let rootPost: RecordRef
-  let replyPost: RecordRef
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'bsky_thread_mutes',
-    })
-    sc = network.getSeedClient()
-    agent = network.bsky.getAgent()
-    await usersSeed(sc)
-    alice = sc.dids.alice
-    bob = sc.dids.bob
-    rootPost = (await sc.post(alice, 'root post')).ref
-    replyPost = (await sc.reply(alice, rootPost, rootPost, 'first reply')).ref
-    await network.processAll()
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  it('mutes threads', async () => {
-    await agent.api.app.bsky.graph.muteThread(
-      { root: rootPost.uriStr },
-      {
-        encoding: 'application/json',
-        headers: await network.serviceHeaders(
-          alice,
-          ids.AppBskyGraphMuteThread,
-        ),
-      },
-    )
-    await network.processAll()
-  })
-
-  it('notes that threads are muted in viewer state', async () => {
-    const res = await agent.api.app.bsky.feed.getPosts(
-      {
-        uris: [rootPost.uriStr, replyPost.uriStr],
-      },
-      {
-        headers: await network.serviceHeaders(alice, ids.AppBskyFeedGetPosts),
-      },
-    )
-    expect(res.data.posts[0].viewer?.threadMuted).toBe(true)
-    expect(res.data.posts[1].viewer?.threadMuted).toBe(true)
-  })
-
-  it('prevents notifs from replies', async () => {
-    await sc.reply(bob, rootPost, rootPost, 'reply')
-    await sc.reply(bob, rootPost, replyPost, 'reply')
-    await network.processAll()
-
-    const notifsRes = await agent.api.app.bsky.notification.listNotifications(
-      {},
-      {
-        headers: await network.serviceHeaders(
-          alice,
-          ids.AppBskyNotificationListNotifications,
-        ),
-      },
-    )
-    expect(notifsRes.data.notifications.length).toBe(0)
-  })
-
-  it('prevents notifs from quote posts', async () => {
-    await sc.post(bob, 'quote', undefined, undefined, rootPost)
-    await sc.post(bob, 'quote', undefined, undefined, replyPost)
-    await network.processAll()
-
-    const notifsRes = await agent.api.app.bsky.notification.listNotifications(
-      {},
-      {
-        headers: await network.serviceHeaders(
-          alice,
-          ids.AppBskyNotificationListNotifications,
-        ),
-      },
-    )
-    expect(notifsRes.data.notifications.length).toBe(0)
-  })
-
-  it('prevents notifs from likes', async () => {
-    await sc.like(bob, rootPost)
-    await sc.like(bob, replyPost)
-    await network.processAll()
-
-    const notifsRes = await agent.api.app.bsky.notification.listNotifications(
-      {},
-      {
-        headers: await network.serviceHeaders(
-          alice,
-          ids.AppBskyNotificationListNotifications,
-        ),
-      },
-    )
-    expect(notifsRes.data.notifications.length).toBe(0)
-  })
-
-  it('prevents notifs from reposts', async () => {
-    await sc.repost(bob, rootPost)
-    await sc.repost(bob, replyPost)
-    await network.processAll()
-
-    const notifsRes = await agent.api.app.bsky.notification.listNotifications(
-      {},
-      {
-        headers: await network.serviceHeaders(
-          alice,
-          ids.AppBskyNotificationListNotifications,
-        ),
-      },
-    )
-    expect(notifsRes.data.notifications.length).toBe(0)
-  })
-
-  it('unmutes threads', async () => {
-    await agent.api.app.bsky.graph.unmuteThread(
-      { root: rootPost.uriStr },
-      {
-        encoding: 'application/json',
-        headers: await network.serviceHeaders(
-          alice,
-          ids.AppBskyGraphUnmuteThread,
-        ),
-      },
-    )
-    await network.processAll()
-  })
-
-  it('no longer notes that threads are muted in viewer state after unmuting', async () => {
-    const res = await agent.api.app.bsky.feed.getPosts(
-      {
-        uris: [rootPost.uriStr, replyPost.uriStr],
-      },
-      {
-        headers: await network.serviceHeaders(alice, ids.AppBskyFeedGetPosts),
-      },
-    )
-    expect(res.data.posts[0].viewer?.threadMuted).toBe(false)
-    expect(res.data.posts[1].viewer?.threadMuted).toBe(false)
-  })
-
-  it('sends notifications after unmuting', async () => {
-    await sc.reply(bob, rootPost, rootPost, 'new reply')
-    await sc.reply(bob, rootPost, replyPost, 'new reply')
-    await sc.like(bob, rootPost)
-    await sc.repost(bob, replyPost)
-    await network.processAll()
-
-    const notifsRes = await agent.api.app.bsky.notification.listNotifications(
-      {},
-      {
-        headers: await network.serviceHeaders(
-          alice,
-          ids.AppBskyNotificationListNotifications,
-        ),
-      },
-    )
-    expect(notifsRes.data.notifications.length).toBe(4)
-  })
-})

package/tests/entryway-auth.test.ts

@@ -1,177 +0,0 @@
-import assert from 'node:assert'
-import * as nodeCrypto from 'node:crypto'
-import * as jose from 'jose'
-import KeyEncoderModule from 'key-encoder'
-import * as ui8 from 'uint8arrays'
-import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest'
-import { AtUri, AtpAgent } from '@atproto/api'
-import { MINUTE } from '@atproto/common'
-import * as crypto from '@atproto/crypto'
-import { SeedClient, TestNetwork, basicSeed } from '@atproto/dev-env'
-
-// key-encoder is CJS with exports.default; Node ESM interop wraps it as { default: Class }
-const KeyEncoder = ((m) => m.default ?? m)(KeyEncoderModule)
-
-const keyEncoder = new KeyEncoder('secp256k1')
-
-const derivePrivKey = async (
-  keypair: crypto.ExportableKeypair,
-): Promise<nodeCrypto.KeyObject> => {
-  const privKeyRaw = await keypair.export()
-  const privKeyEncoded = keyEncoder.encodePrivate(
-    ui8.toString(privKeyRaw, 'hex'),
-    'raw',
-    'pem',
-  )
-  return nodeCrypto.createPrivateKey(privKeyEncoded)
-}
-
-// @NOTE temporary measure, see note on entrywaySession in bsky/src/auth-verifier.ts
-describe('entryway auth', () => {
-  let network: TestNetwork
-  let agent: AtpAgent
-  let sc: SeedClient
-  let alice: string
-  let jwtPrivKey: nodeCrypto.KeyObject
-
-  beforeAll(async () => {
-    const keypair = await crypto.Secp256k1Keypair.create({ exportable: true })
-    jwtPrivKey = await derivePrivKey(keypair)
-    const entrywayJwtPublicKeyHex = ui8.toString(
-      keypair.publicKeyBytes(),
-      'hex',
-    )
-
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'bsky_entryway_auth',
-      bsky: {
-        entrywayJwtPublicKeyHex,
-      },
-    })
-    agent = network.bsky.getAgent()
-    sc = network.getSeedClient()
-    await basicSeed(sc)
-
-    alice = sc.dids.alice
-  })
-
-  beforeEach(async () => network.processAll())
-  afterAll(async () => network?.close())
-
-  it('works', async () => {
-    const signer = new jose.SignJWT({ scope: 'com.atproto.access' })
-      .setSubject(alice)
-      .setIssuedAt()
-      .setExpirationTime('60mins')
-      .setAudience('did:web:fake.server.bsky.network')
-      .setProtectedHeader({
-        typ: 'at+jwt', // https://www.rfc-editor.org/rfc/rfc9068.html
-        alg: 'ES256K',
-      })
-    const token = await signer.sign(jwtPrivKey)
-    const res = await agent.app.bsky.actor.getProfile(
-      { actor: sc.dids.bob },
-      { headers: { authorization: `Bearer ${token}` } },
-    )
-    expect(res.data.did).toEqual(sc.dids.bob)
-    // ensure this request is personalized for alice
-    const followingUri = res.data.viewer?.following
-    assert(followingUri)
-    const parsed = new AtUri(followingUri)
-    expect(parsed.hostname).toEqual(alice)
-  })
-
-  it('does not work on bad scopes', async () => {
-    const signer = new jose.SignJWT({ scope: 'com.atproto.refresh' })
-      .setSubject(alice)
-      .setIssuedAt()
-      .setExpirationTime('60mins')
-      .setAudience('did:web:fake.server.bsky.network')
-      .setProtectedHeader({
-        typ: 'at+jwt', // https://www.rfc-editor.org/rfc/rfc9068.html
-        alg: 'ES256K',
-      })
-    const token = await signer.sign(jwtPrivKey)
-    const attempt = agent.app.bsky.actor.getProfile(
-      { actor: sc.dids.bob },
-      { headers: { authorization: `Bearer ${token}` } },
-    )
-    await expect(attempt).rejects.toThrow('Bad token scope')
-  })
-
-  it('does not work on expired tokens', async () => {
-    const time = Math.floor((Date.now() - 5 * MINUTE) / 1000)
-    const signer = new jose.SignJWT({ scope: 'com.atproto.access' })
-      .setSubject(alice)
-      .setIssuedAt()
-      .setExpirationTime(time)
-      .setAudience('did:web:fake.server.bsky.network')
-      .setProtectedHeader({
-        typ: 'at+jwt', // https://www.rfc-editor.org/rfc/rfc9068.html
-        alg: 'ES256K',
-      })
-    const token = await signer.sign(jwtPrivKey)
-    const attempt = agent.app.bsky.actor.getProfile(
-      { actor: sc.dids.bob },
-      { headers: { authorization: `Bearer ${token}` } },
-    )
-    await expect(attempt).rejects.toThrow('Token has expired')
-  })
-
-  it('does not work on bad auds', async () => {
-    const signer = new jose.SignJWT({ scope: 'com.atproto.access' })
-      .setSubject(alice)
-      .setIssuedAt()
-      .setExpirationTime('60mins')
-      .setAudience('did:web:my.personal.pds.com')
-      .setProtectedHeader({
-        typ: 'at+jwt', // https://www.rfc-editor.org/rfc/rfc9068.html
-        alg: 'ES256K',
-      })
-    const token = await signer.sign(jwtPrivKey)
-    const attempt = agent.app.bsky.actor.getProfile(
-      { actor: sc.dids.bob },
-      { headers: { authorization: `Bearer ${token}` } },
-    )
-    await expect(attempt).rejects.toThrow('Bad token aud')
-  })
-
-  it('does not work with bad signatures', async () => {
-    const fakeKey = await crypto.Secp256k1Keypair.create({ exportable: true })
-    const fakeJwtKey = await derivePrivKey(fakeKey)
-    const signer = new jose.SignJWT({ scope: 'com.atproto.access' })
-      .setSubject(alice)
-      .setIssuedAt()
-      .setExpirationTime('60mins')
-      .setAudience('did:web:my.personal.pds.com')
-      .setProtectedHeader({
-        typ: 'at+jwt', // https://www.rfc-editor.org/rfc/rfc9068.html
-        alg: 'ES256K',
-      })
-    const token = await signer.sign(fakeJwtKey)
-    const attempt = agent.app.bsky.actor.getProfile(
-      { actor: sc.dids.bob },
-      { headers: { authorization: `Bearer ${token}` } },
-    )
-    await expect(attempt).rejects.toThrow('Token could not be verified')
-  })
-
-  it('does not work on flexible aud routes', async () => {
-    const signer = new jose.SignJWT({ scope: 'com.atproto.access' })
-      .setSubject(alice)
-      .setIssuedAt()
-      .setExpirationTime('60mins')
-      .setAudience('did:web:fake.server.bsky.network')
-      .setProtectedHeader({
-        typ: 'at+jwt', // https://www.rfc-editor.org/rfc/rfc9068.html
-        alg: 'ES256K',
-      })
-    const token = await signer.sign(jwtPrivKey)
-    const feedUri = AtUri.make(alice, 'app.bsky.feed.generator', 'fake-feed')
-    const attempt = agent.app.bsky.feed.getFeed(
-      { feed: feedUri.toString() },
-      { headers: { authorization: `Bearer ${token}` } },
-    )
-    await expect(attempt).rejects.toThrow('Malformed token')
-  })
-})