@atproto/pds 0.5.12 → 0.5.15

package/tests/rate-limits.test.ts

@@ -1,70 +0,0 @@
-import { AtpAgent } from '@atproto/api'
-import { randomStr } from '@atproto/crypto'
-import { SeedClient, TestNetworkNoAppView } from '@atproto/dev-env'
-import userSeed from './seeds/basic.js'
-
-describe('rate limits', () => {
-  let network: TestNetworkNoAppView
-  let agent: AtpAgent
-  let sc: SeedClient
-  let alice: string
-  let bob: string
-
-  beforeAll(async () => {
-    network = await TestNetworkNoAppView.create({
-      dbPostgresSchema: 'rate_limits',
-      pds: {
-        redisScratchAddress: process.env.REDIS_HOST,
-        redisScratchPassword: process.env.REDIS_PASSWORD,
-        rateLimitsEnabled: true,
-      },
-    })
-    agent = network.pds.getAgent()
-    sc = network.getSeedClient()
-    await userSeed(sc)
-    alice = sc.dids.alice
-    bob = sc.dids.bob
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  it('rate limits by ip', async () => {
-    const attempt = () =>
-      agent.api.com.atproto.server.resetPassword({
-        token: randomStr(4, 'base32'),
-        password: 'asdf1234',
-      })
-    for (let i = 0; i < 50; i++) {
-      try {
-        await attempt()
-      } catch (err) {
-        // do nothing
-      }
-    }
-    await expect(attempt).rejects.toThrow('Rate Limit Exceeded')
-  })
-
-  it('rate limits by a custom key', async () => {
-    const attempt = () =>
-      agent.api.com.atproto.server.createSession({
-        identifier: sc.accounts[alice].handle,
-        password: 'asdf1234',
-      })
-    for (let i = 0; i < 30; i++) {
-      try {
-        await attempt()
-      } catch (err) {
-        // do nothing
-      }
-    }
-    await expect(attempt).rejects.toThrow('Rate Limit Exceeded')
-
-    // does not rate limit for another key
-    await agent.api.com.atproto.server.createSession({
-      identifier: sc.accounts[bob].handle,
-      password: sc.accounts[bob].password,
-    })
-  })
-})

package/tests/recovery.test.ts

@@ -1,180 +0,0 @@
-import fs from 'node:fs/promises'
-import * as ui8 from 'uint8arrays'
-import AtpAgent from '@atproto/api'
-import { renameIfExists, rmIfExists } from '@atproto/common'
-import { SeedClient, TestNetworkNoAppView, basicSeed } from '@atproto/dev-env'
-// import package to avoid type errors from circular dep with dev-env
-import { type AppContext, scripts } from '@atproto/pds'
-import { verifyRepoCar } from '@atproto/repo'
-import { DidString } from '@atproto/syntax'
-
-describe('recovery', () => {
-  let network: TestNetworkNoAppView
-  let ctx: AppContext
-  let sc: SeedClient
-  let agent: AtpAgent
-  let alice: DidString
-  let bob: DidString
-  let elli: DidString
-
-  beforeAll(async () => {
-    network = await TestNetworkNoAppView.create({
-      dbPostgresSchema: 'recovery',
-    })
-    ctx = network.pds.ctx
-    sc = network.getSeedClient()
-    agent = network.pds.getAgent()
-    await basicSeed(sc)
-    alice = sc.dids.alice
-    bob = sc.dids.bob
-    await network.processAll()
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  const getStats = (did: string) => {
-    return ctx.actorStore.read(did, async (store) => {
-      const recordCount = await store.record.recordCount()
-      const root = await store.repo.storage.getRootDetailed()
-      return {
-        recordCount,
-        rev: root.rev,
-        commit: root.cid,
-      }
-    })
-  }
-
-  const getRev = (did: string) => {
-    return ctx.actorStore.read(did, async (store) => {
-      const root = await store.repo.storage.getRootDetailed()
-      return root.rev
-    })
-  }
-
-  const getCar = async (did: string, since?: string) => {
-    const res = await agent.api.com.atproto.sync.getRepo({
-      did,
-      since,
-    })
-    return res.data
-  }
-
-  const backup = async (dids: string[]) => {
-    for (const did of dids) {
-      const { dbLocation, keyLocation } = await ctx.actorStore.getLocation(did)
-      await fs.copyFile(dbLocation, `${dbLocation}-backup`)
-      await fs.copyFile(keyLocation, `${keyLocation}-backup`)
-    }
-  }
-
-  const restore = async (dids: string[]) => {
-    for (const did of dids) {
-      const { dbLocation, keyLocation } = await ctx.actorStore.getLocation(did)
-      await rmIfExists(dbLocation)
-      await rmIfExists(keyLocation)
-      await renameIfExists(`${dbLocation}-backup`, dbLocation)
-      await renameIfExists(`${keyLocation}-backup`, keyLocation)
-    }
-  }
-
-  it('recovers repos based on the sequencer ', async () => {
-    // backup alice & bob
-    await backup([alice, bob])
-
-    // grab rev times from intermediate repo states
-    // process a bunch of record creates, updates, and delets for alice
-    const startRev = await getRev(alice)
-    let middleRev = ''
-    for (let i = 0; i < 100; i++) {
-      if (i === 0) {
-        middleRev = await getRev(alice)
-      }
-      const ref = await sc.post(alice, `post-${i}`)
-      if (i % 20 === 0) {
-        await sc.updateProfile(alice, { displayName: `name-${i}` })
-      }
-      if (i % 10 === 0) {
-        await sc.deletePost(alice, ref.ref.uri)
-      } else {
-        await sc.like(alice, ref.ref)
-      }
-    }
-
-    // delete bob's account
-    const deleteToken = await ctx.accountManager.createEmailToken(
-      bob,
-      'delete_account',
-    )
-    await agent.com.atproto.server.deleteAccount({
-      token: deleteToken,
-      did: bob,
-      password: sc.accounts[bob].password,
-    })
-
-    // create a new account (elli)
-    await sc.createAccount('elli', {
-      handle: 'elli.test',
-      password: 'elli-pass',
-      email: 'elli@test.com',
-    })
-    elli = sc.dids.elli
-    for (let i = 0; i < 10; i++) {
-      await sc.post(elli, `post-${i}`)
-    }
-    // get some stats & snapshots from before we do a recovery
-    const endRev = await getRev(alice)
-    const startCarBefore = await getCar(alice, startRev)
-    const middleCarBefore = await getCar(alice, middleRev)
-    const endCarBefore = await getCar(alice, endRev)
-    const aliceStatsBefore = await getStats(alice)
-    const elliCarBefore = await getCar(elli)
-    const elliStatsBefore = await getStats(elli)
-
-    // "restore" all 3 accounts to their backedup state, effectively rolling back the previous mutations
-    // deleting alice's mutations, restoring bob's account, and deleting elli's account
-    await restore([alice, bob, elli])
-
-    // run recovery operation
-    await scripts['sequencer-recovery'](network.pds.ctx, ['0', '10', 'true'])
-
-    // ensure alice's CAR is exactly the same as before the loss, including intermediate states based on tracked revs
-    const startCarAfter = await getCar(alice, startRev)
-    const middleCarAfter = await getCar(alice, middleRev)
-    const endCarAfter = await getCar(alice, endRev)
-    const aliceStatsAfter = await getStats(alice)
-    expect(ui8.equals(startCarAfter, startCarBefore)).toBe(true)
-    expect(ui8.equals(middleCarAfter, middleCarBefore)).toBe(true)
-    expect(ui8.equals(endCarAfter, endCarBefore)).toBe(true)
-    expect(aliceStatsAfter).toMatchObject(aliceStatsBefore)
-
-    // ensure bob's account is re-deleted
-    const attempt = getCar(bob)
-    await expect(attempt).rejects.toThrow(/Could not find repo for DID/)
-    const bobExists = await ctx.actorStore.exists(bob)
-    expect(bobExists).toBe(false)
-
-    // ensure elli's CAR is exactly the same as before the loss
-    // this involves creating a new signing key for her and updating her DID document
-    const elliCarAfter = await getCar(elli)
-    const elliStatsAfter = await getStats(elli)
-    expect(ui8.equals(elliCarAfter, elliCarBefore)).toBe(true)
-    expect(elliStatsAfter).toMatchObject(elliStatsBefore)
-    // it creates a new keypair for elli
-    const elliKey = await ctx.actorStore.keypair(elli)
-    expect(elliKey.did()).toBeDefined()
-  })
-
-  it('rotates keys for users', async () => {
-    await scripts['rotate-keys'](network.pds.ctx, [elli])
-    const elliKey = await ctx.actorStore.keypair(elli)
-
-    const plcData = await ctx.plcClient.getDocumentData(elli)
-    expect(plcData.verificationMethods['atproto']).toEqual(elliKey.did())
-
-    // it correctly resigned elli's repo
-    const elliCar = await getCar(elli)
-    await verifyRepoCar(elliCar, elli, elliKey.did())
-  })
-})

package/tests/seeds/basic.ts

@@ -1,165 +0,0 @@
-import { EXAMPLE_LABELER, SeedClient, TestBsky } from '@atproto/dev-env'
-import { app, com } from '../../src/lexicons/index.js'
-import usersSeed from './users.js'
-
-export default async function basicSeed(
-  sc: SeedClient,
-  opts?: { inviteCode?: string; addModLabels?: TestBsky },
-) {
-  await usersSeed(sc, opts)
-
-  const alice = sc.dids.alice
-  const bob = sc.dids.bob
-  const carol = sc.dids.carol
-  const dan = sc.dids.dan
-  const createdAtMicroseconds = () => ({
-    createdAt: new Date().toISOString().replace('Z', '000Z'), // microseconds
-  })
-  const createdAtTimezone = () => ({
-    createdAt: new Date().toISOString().replace('Z', '+00:00'), // iso timezone format
-  })
-
-  await sc.follow(alice, bob)
-  await sc.follow(alice, carol)
-  await sc.follow(alice, dan)
-  await sc.follow(carol, alice)
-  await sc.follow(bob, alice)
-  await sc.follow(bob, carol, createdAtMicroseconds())
-  await sc.follow(dan, bob, createdAtTimezone())
-  await sc.post(alice, posts.alice[0], undefined, undefined, undefined, {
-    labels: com.atproto.label.defs.selfLabels.$build({
-      values: [{ val: 'self-label' }],
-    }),
-  })
-  await sc.post(bob, posts.bob[0], undefined, undefined, undefined, {
-    langs: ['en-US', 'i-klingon'],
-  })
-  const img1 = await sc.uploadFile(
-    carol,
-    '../dev-env/assets/key-landscape-small.jpg',
-    'image/jpeg',
-  )
-  const img2 = await sc.uploadFile(
-    carol,
-    '../dev-env/assets/key-alt.jpg',
-    'image/jpeg',
-  )
-  await sc.post(
-    carol,
-    posts.carol[0],
-    undefined,
-    [img1, img2], // Contains both images and a quote
-    sc.posts[bob][0].ref,
-  )
-  await sc.post(dan, posts.dan[0])
-  await sc.post(
-    dan,
-    posts.dan[1],
-    [
-      {
-        index: { byteStart: 0, byteEnd: 18 },
-        features: [app.bsky.richtext.facet.mention.$build({ did: alice })],
-      },
-    ],
-    undefined,
-    sc.posts[carol][0].ref, // This post contains an images embed
-  )
-  await sc.post(
-    alice,
-    posts.alice[1],
-    undefined,
-    undefined,
-    undefined,
-    createdAtMicroseconds(),
-  )
-  await sc.post(
-    bob,
-    posts.bob[1],
-    undefined,
-    undefined,
-    undefined,
-    createdAtTimezone(),
-  )
-  await sc.post(
-    alice,
-    posts.alice[2],
-    undefined,
-    undefined,
-    sc.posts[dan][1].ref, // This post contains a record embed which contains an images embed
-  )
-  await sc.like(bob, sc.posts[alice][1].ref)
-  await sc.like(bob, sc.posts[alice][2].ref)
-  await sc.like(carol, sc.posts[alice][1].ref)
-  await sc.like(carol, sc.posts[alice][2].ref)
-  await sc.like(dan, sc.posts[alice][1].ref)
-  await sc.like(alice, sc.posts[carol][0].ref, createdAtMicroseconds())
-  await sc.like(bob, sc.posts[carol][0].ref, createdAtTimezone())
-
-  const replyImg = await sc.uploadFile(
-    bob,
-    '../dev-env/assets/key-landscape-small.jpg',
-    'image/jpeg',
-  )
-  // must ensure ordering of replies in indexing
-  await sc.network.processAll()
-  await sc.reply(
-    bob,
-    sc.posts[alice][1].ref,
-    sc.posts[alice][1].ref,
-    replies.bob[0],
-    undefined,
-    [replyImg],
-  )
-  await sc.reply(
-    carol,
-    sc.posts[alice][1].ref,
-    sc.posts[alice][1].ref,
-    replies.carol[0],
-  )
-  await sc.network.processAll()
-  const alicesReplyToBob = await sc.reply(
-    alice,
-    sc.posts[alice][1].ref,
-    sc.replies[bob][0].ref,
-    replies.alice[0],
-  )
-  await sc.repost(carol, sc.posts[dan][1].ref)
-  await sc.repost(dan, sc.posts[alice][1].ref)
-  await sc.repost(dan, alicesReplyToBob.ref)
-
-  if (opts?.addModLabels) {
-    await createLabel(opts.addModLabels, { did: dan, val: 'repo-action-label' })
-  }
-
-  return sc
-}
-
-export const posts = {
-  alice: ['hey there', 'again', 'yoohoo label_me'],
-  bob: ['bob back at it again!', 'bobby boy here', 'yoohoo'],
-  carol: ['hi im carol'],
-  dan: ['dan here!', '@alice.bluesky.xyz is the best'],
-}
-
-export const replies = {
-  alice: ['thanks bob'],
-  bob: ['hear that label_me label_me_2'],
-  carol: ['of course'],
-}
-
-const createLabel = async (
-  bsky: TestBsky,
-  opts: { did: string; val: string },
-) => {
-  await bsky.db.db
-    .insertInto('label')
-    .values({
-      uri: opts.did,
-      cid: '',
-      val: opts.val,
-      cts: new Date().toISOString(),
-      neg: false,
-      src: EXAMPLE_LABELER,
-    })
-    .execute()
-}

package/tests/seeds/follows.ts

@@ -1,57 +0,0 @@
-import { SeedClient } from '@atproto/dev-env'
-
-export default async (sc: SeedClient) => {
-  await sc.createAccount('alice', users.alice)
-  await sc.createAccount('bob', users.bob)
-  await sc.createAccount('carol', users.carol)
-  await sc.createAccount('dan', users.dan)
-  await sc.createAccount('eve', users.eve)
-  for (const name in sc.dids) {
-    await sc.createProfile(sc.dids[name], `display-${name}`, `descript-${name}`)
-  }
-  const alice = sc.dids.alice
-  const bob = sc.dids.bob
-  const carol = sc.dids.carol
-  const dan = sc.dids.dan
-  const eve = sc.dids.eve
-  await sc.follow(alice, bob)
-  await sc.follow(alice, carol)
-  await sc.follow(alice, dan)
-  await sc.follow(alice, eve)
-  await sc.follow(carol, alice)
-  await sc.follow(bob, alice)
-  await sc.follow(bob, carol)
-  await sc.follow(dan, alice)
-  await sc.follow(dan, bob)
-  await sc.follow(dan, eve)
-  await sc.follow(eve, alice)
-  await sc.follow(eve, carol)
-}
-
-const users = {
-  alice: {
-    email: 'alice@test.com',
-    handle: 'alice.test',
-    password: 'alice-pass',
-  },
-  bob: {
-    email: 'bob@test.com',
-    handle: 'bob.test',
-    password: 'bob-pass',
-  },
-  carol: {
-    email: 'carol@test.com',
-    handle: 'carol.test',
-    password: 'carol-pass',
-  },
-  dan: {
-    email: 'dan@test.com',
-    handle: 'dan.test',
-    password: 'dan-pass',
-  },
-  eve: {
-    email: 'eve@test.com',
-    handle: 'eve.test',
-    password: 'eve-pass',
-  },
-} as const

package/tests/seeds/likes.ts

@@ -1,14 +0,0 @@
-import { SeedClient } from '@atproto/dev-env'
-import basicSeed from './basic.js'
-
-export default async (sc: SeedClient) => {
-  await basicSeed(sc)
-  await sc.createAccount('eve', {
-    email: 'eve@test.com',
-    handle: 'eve.test',
-    password: 'eve-pass',
-  })
-  await sc.like(sc.dids.eve, sc.posts[sc.dids.alice][1].ref)
-  await sc.like(sc.dids.carol, sc.replies[sc.dids.bob][0].ref)
-  return sc
-}

package/tests/seeds/reposts.ts

@@ -1,18 +0,0 @@
-import { SeedClient } from '@atproto/dev-env'
-import basicSeed from './basic.js'
-
-export default async (sc: SeedClient) => {
-  await basicSeed(sc)
-  await sc.createAccount('eve', {
-    email: 'eve@test.com',
-    handle: 'eve.test',
-    password: 'eve-pass',
-  })
-  await sc.repost(sc.dids.bob, sc.posts[sc.dids.alice][2].ref)
-  await sc.repost(sc.dids.carol, sc.posts[sc.dids.alice][2].ref)
-  await sc.repost(sc.dids.dan, sc.posts[sc.dids.alice][2].ref)
-  await sc.repost(sc.dids.eve, sc.posts[sc.dids.alice][2].ref)
-  await sc.repost(sc.dids.dan, sc.replies[sc.dids.bob][0].ref)
-  await sc.repost(sc.dids.eve, sc.replies[sc.dids.bob][0].ref)
-  return sc
-}

package/tests/seeds/thread.ts

@@ -1,40 +0,0 @@
-import { RecordRef, SeedClient } from '@atproto/dev-env'
-
-export default async (sc: SeedClient, did, threads: Item[]) => {
-  const refByItemId: Record<string, RecordRef> = {}
-  const rootByItemId: Record<string, RecordRef> = {}
-  await walk(threads, async (item, _depth, parent) => {
-    if (parent !== undefined) {
-      const parentRef = refByItemId[parent.id]
-      const rootRef = rootByItemId[parent.id]
-      const { ref } = await sc.reply(did, rootRef, parentRef, String(item.id))
-      refByItemId[item.id] = ref
-      rootByItemId[item.id] = rootRef
-    } else {
-      const { ref } = await sc.post(did, String(item.id))
-      refByItemId[item.id] = ref
-      rootByItemId[item.id] = ref
-    }
-  })
-}
-
-export function item(id: number, children: Item[] = []) {
-  return { id, children }
-}
-
-export async function walk(
-  items: Item[],
-  cb: (item: Item, depth: number, parent?: Item) => Promise<void>,
-  depth = 0,
-  parent?: Item,
-) {
-  for (const item of items) {
-    await cb(item, depth, parent)
-    await walk(item.children, cb, depth + 1, item)
-  }
-}
-
-export interface Item {
-  id: number
-  children: Item[]
-}