@atproto/pds 0.5.12 → 0.5.15

package/tests/sync/sync.test.ts

@@ -1,316 +0,0 @@
-import assert from 'node:assert'
-import { TID } from '@atproto/common'
-import { Keypair, randomStr } from '@atproto/crypto'
-import { SeedClient, TestNetworkNoAppView } from '@atproto/dev-env'
-import { Client, isNsidString, isRecordKeyString } from '@atproto/lex'
-import { cidForLex } from '@atproto/lex-cbor'
-import { Cid } from '@atproto/lex-data'
-import * as repo from '@atproto/repo'
-import { MemoryBlockstore } from '@atproto/repo'
-import { AtUri, DidString, NsidString } from '@atproto/syntax'
-import { com } from '../../src/lexicons.js'
-
-describe('repo sync', () => {
-  let network: TestNetworkNoAppView
-  let client: Client
-  let sc: SeedClient
-  let did: DidString
-  let signingKey: Keypair
-
-  const repoData: repo.RepoContents = {}
-  const uris: AtUri[] = []
-  const storage = new MemoryBlockstore()
-  let currRoot: Cid | undefined
-  let currRev: string | undefined
-
-  beforeAll(async () => {
-    network = await TestNetworkNoAppView.create({
-      dbPostgresSchema: 'repo_sync',
-    })
-    client = network.pds.getClient()
-    sc = network.getSeedClient()
-    await sc.createAccount('alice', {
-      email: 'alice@test.com',
-      handle: 'alice.test',
-      password: 'alice-pass',
-    })
-    did = sc.dids.alice
-    signingKey = await network.pds.ctx.actorStore.keypair(did)
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  it('creates and syncs some records', async () => {
-    const ADD_COUNT = 10
-    for (let i = 0; i < ADD_COUNT; i++) {
-      const { obj, uri } = await makePost(sc, did)
-      if (!repoData[uri.collection]) {
-        repoData[uri.collection] = {}
-      }
-      repoData[uri.collection][uri.rkey] = obj
-      uris.push(uri)
-    }
-
-    const carRes = await client.call(com.atproto.sync.getRepo, { did })
-    const car = await repo.readCarWithRoot(carRes)
-    const synced = await repo.verifyRepo(
-      car.blocks,
-      car.root,
-      did,
-      signingKey.did(),
-    )
-    await storage.applyCommit(synced.commit)
-    expect(synced.creates.length).toBe(ADD_COUNT)
-    const loaded = await repo.Repo.load(storage, car.root)
-    const contents = await loaded.getContents()
-    expect(contents).toEqual(repoData)
-
-    currRoot = car.root
-    currRev = loaded.commit.rev
-  })
-
-  it('syncs creates and deletes', async () => {
-    const ADD_COUNT = 10
-    const DEL_COUNT = 4
-    for (let i = 0; i < ADD_COUNT; i++) {
-      const { obj, uri } = await makePost(sc, did)
-      if (!repoData[uri.collection]) {
-        repoData[uri.collection] = {}
-      }
-      repoData[uri.collection][uri.rkey] = obj
-      uris.push(uri)
-    }
-    // delete two that are already sync & two that have not been
-    for (let i = 0; i < DEL_COUNT; i++) {
-      const uri = uris[i * 5]
-      await sc.deletePost(did, uri)
-      delete repoData[uri.collection][uri.rkey]
-    }
-
-    const carRes = await client.call(com.atproto.sync.getRepo, { did })
-    const car = await repo.readCarWithRoot(carRes)
-    const currRepo = await repo.Repo.load(storage, currRoot)
-    const synced = await repo.verifyDiff(
-      currRepo,
-      car.blocks,
-      car.root,
-      did,
-      signingKey.did(),
-    )
-    expect(synced.writes.length).toBe(ADD_COUNT) // -2 because of dels of new records, +2 because of dels of old records
-    await storage.applyCommit(synced.commit)
-    const loaded = await repo.Repo.load(storage, car.root)
-    const contents = await loaded.getContents()
-    expect(contents).toEqual(repoData)
-
-    currRoot = car.root
-    currRev = loaded.commit.rev
-  })
-
-  it('syncs repo status', async () => {
-    const status = await client.call(com.atproto.sync.getRepoStatus, { did })
-    expect(status).toEqual({
-      did,
-      active: true,
-      rev: currRev,
-    })
-  })
-
-  it('syncs latest repo commit', async () => {
-    const commit = await client.call(com.atproto.sync.getLatestCommit, { did })
-    expect(commit.cid).toEqual(currRoot?.toString())
-  })
-
-  it('syncs `since` a given rev', async () => {
-    const repoBefore = await repo.Repo.load(storage, currRoot)
-
-    // add a post
-    const { obj, uri } = await makePost(sc, did)
-    if (!repoData[uri.collection]) {
-      repoData[uri.collection] = {}
-    }
-    repoData[uri.collection][uri.rkey] = obj
-    uris.push(uri)
-
-    const carRes = await client.call(com.atproto.sync.getRepo, {
-      did,
-      since: repoBefore.commit.rev,
-    })
-    const car = await repo.readCarWithRoot(carRes)
-    expect(car.blocks.size).toBeLessThan(10) // should only contain new blocks
-    const synced = await repo.verifyDiff(
-      repoBefore,
-      car.blocks,
-      car.root,
-      did,
-      signingKey.did(),
-    )
-    expect(synced.writes.length).toBe(1)
-    await storage.applyCommit(synced.commit)
-    const loaded = await repo.Repo.load(storage, car.root)
-    const contents = await loaded.getContents()
-    expect(contents).toEqual(repoData)
-
-    currRoot = car.root
-  })
-
-  it('sync a record proof', async () => {
-    const collection = Object.keys(repoData)[0] as NsidString
-    const rkey = Object.keys(repoData[collection])[0]
-    const car = await client.call(com.atproto.sync.getRecord, {
-      did,
-      collection,
-      rkey,
-    })
-    const records = await repo.verifyRecords(
-      new Uint8Array(car),
-      did,
-      signingKey.did(),
-    )
-    const claim = {
-      collection,
-      rkey,
-      cid: await cidForLex(repoData[collection][rkey]),
-    }
-    expect(records.length).toBe(1)
-    expect(await cidForLex(records[0].record)).toEqual(claim.cid)
-    const result = await repo.verifyProofs(
-      new Uint8Array(car),
-      [claim],
-      did,
-      signingKey.did(),
-    )
-    expect(result.verified.length).toBe(1)
-    expect(result.unverified.length).toBe(0)
-  })
-
-  it('sync a proof of non-existence', async () => {
-    const collection = Object.keys(repoData)[0]
-    assert(isNsidString(collection))
-    const rkey = TID.nextStr() // rkey that doesn't exist
-    const car = await client.call(com.atproto.sync.getRecord, {
-      did,
-      collection,
-      rkey,
-    })
-    const claim = {
-      collection,
-      rkey,
-      cid: null,
-    }
-    const result = await repo.verifyProofs(
-      new Uint8Array(car),
-      [claim],
-      did,
-      signingKey.did(),
-    )
-    expect(result.verified.length).toBe(1)
-    expect(result.unverified.length).toBe(0)
-  })
-
-  describe('repo takedown', () => {
-    beforeAll(async () => {
-      await client.call(
-        com.atproto.admin.updateSubjectStatus,
-        {
-          subject: {
-            $type: 'com.atproto.admin.defs#repoRef',
-            did,
-          },
-          takedown: { applied: true },
-        },
-        {
-          headers: network.pds.adminAuthHeaders(),
-        },
-      )
-    })
-
-    afterAll(async () => {
-      await client.call(
-        com.atproto.admin.updateSubjectStatus,
-        {
-          subject: {
-            $type: 'com.atproto.admin.defs#repoRef',
-            did,
-          },
-          takedown: { applied: false },
-        },
-        {
-          headers: network.pds.adminAuthHeaders(),
-        },
-      )
-    })
-
-    it('returns takendown status', async () => {
-      const res = await client.call(com.atproto.sync.getRepoStatus, { did })
-      expect(res).toEqual({
-        did,
-        active: false,
-        status: 'takendown',
-      })
-    })
-
-    it('lists as takendown in listRepos', async () => {
-      const res = await client.call(com.atproto.sync.listRepos)
-      const found = res.repos.find((r) => r.did === did)
-      expect(found?.active).toBe(false)
-      expect(found?.status).toBe('takendown')
-    })
-
-    it('does not sync repo unauthed', async () => {
-      const tryGetRepo = client.call(com.atproto.sync.getRepo, { did })
-      await expect(tryGetRepo).rejects.toThrow(/Repo has been takendown/)
-    })
-
-    it('syncs repo to owner or admin', async () => {
-      const tryGetRepoOwner = client.call(
-        com.atproto.sync.getRepo,
-        { did },
-        { headers: sc.getHeaders(did) },
-      )
-      await expect(tryGetRepoOwner).resolves.toBeDefined()
-      const tryGetRepoAdmin = client.call(
-        com.atproto.sync.getRepo,
-        { did },
-        { headers: network.pds.adminAuthHeaders() },
-      )
-      await expect(tryGetRepoAdmin).resolves.toBeDefined()
-    })
-
-    it('does not sync latest commit unauthed', async () => {
-      const tryGetLatest = client.call(com.atproto.sync.getLatestCommit, {
-        did,
-      })
-      await expect(tryGetLatest).rejects.toThrow(/Repo has been takendown/)
-    })
-
-    it('does not sync a record proof unauthed', async () => {
-      const collection = Object.keys(repoData)[0]
-      assert(isNsidString(collection))
-      const rkey = Object.keys(repoData[collection])[0]
-      assert(isRecordKeyString(rkey))
-      const tryGetRecord = client.call(com.atproto.sync.getRecord, {
-        did,
-        collection,
-        rkey,
-      })
-      await expect(tryGetRecord).rejects.toThrow(/Repo has been takendown/)
-    })
-  })
-})
-
-const makePost = async (sc: SeedClient, did: DidString) => {
-  const res = await sc.post(did, randomStr(32, 'base32'))
-  const uri = res.ref.uri
-  const data = await sc.client.call(com.atproto.repo.getRecord, {
-    repo: did as DidString,
-    collection: uri.collection as NsidString,
-    rkey: uri.rkey,
-  })
-  return {
-    uri,
-    obj: data.value,
-  }
-}

package/tests/takedown-appeal.test.ts

@@ -1,166 +0,0 @@
-import { AtpAgent, ComAtprotoModerationDefs } from '@atproto/api'
-import { SeedClient, TestNetwork } from '@atproto/dev-env'
-import type { DidString } from '@atproto/syntax'
-import { forSubjectStatusSnapshot } from './_util.js'
-
-describe('appeal account takedown', () => {
-  let network: TestNetwork
-  let agent: AtpAgent
-  let sc: SeedClient
-  let moderator: DidString
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'takedown_appeal',
-    })
-    sc = network.getSeedClient()
-    const modAccount = await sc.createAccount('moderator', {
-      handle: 'testmod.test',
-      email: 'testmod@test.com',
-      password: 'testmod-pass',
-    })
-    moderator = modAccount.did
-    await network.ozone.addModeratorDid(moderator)
-
-    agent = network.pds.getAgent()
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  it('actor takedown allows appeal request.', async () => {
-    const { data: account } = await agent.com.atproto.server.createAccount({
-      handle: 'jeff.test',
-      email: 'jeff@test.com',
-      password: 'password',
-    })
-    await network.processAll()
-
-    // Emit a takedown event
-    await network.ozone.getModClient().performTakedown({
-      subject: {
-        $type: 'com.atproto.admin.defs#repoRef',
-        did: account.did,
-      },
-    })
-
-    // Manually set the account as takendown at the PDS level
-    // since the takedown event only propagates when the daemon is running
-    await agent.com.atproto.admin.updateSubjectStatus(
-      {
-        subject: {
-          $type: 'com.atproto.admin.defs#repoRef',
-          did: account.did,
-        },
-        takedown: { applied: true },
-      },
-      {
-        encoding: 'application/json',
-        headers: { authorization: network.pds.adminAuth() },
-      },
-    )
-
-    await network.processAll()
-
-    // Verify user can not get session token without setting the optional param
-    await expect(
-      agent.com.atproto.server.createSession({
-        identifier: 'jeff.test',
-        password: 'password',
-      }),
-    ).rejects.toThrow('Account has been taken down')
-
-    const { data: auth } = await agent.com.atproto.server.createSession({
-      identifier: 'jeff.test',
-      password: 'password',
-      allowTakendown: true,
-    })
-
-    // send appeal event as the takendown account
-    await agent.com.atproto.moderation.createReport(
-      {
-        reasonType: ComAtprotoModerationDefs.REASONAPPEAL,
-        reason: 'I want my account back',
-        subject: { $type: 'com.atproto.admin.defs#repoRef', did: account.did },
-      },
-      {
-        headers: {
-          authorization: `Bearer ${auth.accessJwt}`,
-        },
-      },
-    )
-
-    // Verify that the appeal was created
-    const { data: result } = await agent.tools.ozone.moderation.queryStatuses(
-      {
-        subject: account.did,
-      },
-      { headers: sc.getHeaders(moderator) },
-    )
-
-    expect(result.subjectStatuses[0].appealed).toBe(true)
-    expect(
-      forSubjectStatusSnapshot(result.subjectStatuses[0]),
-    ).toMatchSnapshot()
-  })
-
-  it('takendown actor is not allowed to create reports.', async () => {
-    const { data: auth } = await agent.com.atproto.server.createSession({
-      identifier: 'jeff.test',
-      password: 'password',
-      allowTakendown: true,
-    })
-
-    // send appeal event as the takendown account
-    await expect(
-      agent.com.atproto.moderation.createReport(
-        {
-          reasonType: ComAtprotoModerationDefs.REASONRUDE,
-          reason: 'reporting others',
-          subject: {
-            $type: 'com.atproto.admin.defs#repoRef',
-            did: 'did:plc:test',
-          },
-        },
-        {
-          headers: {
-            authorization: `Bearer ${auth.accessJwt}`,
-          },
-        },
-      ),
-    ).rejects.toMatchObject({
-      error: 'AccountTakedown',
-      message: 'Report not accepted from takendown account',
-    })
-  })
-
-  it('takendown actor is not allowed to create records.', async () => {
-    const { data: auth } = await agent.com.atproto.server.createSession({
-      identifier: 'jeff.test',
-      password: 'password',
-      allowTakendown: true,
-    })
-
-    // send appeal event as the takendown account
-    await expect(
-      agent.com.atproto.repo.createRecord(
-        {
-          repo: auth.did,
-          collection: 'app.bsky.feed.post',
-          // rkey: 'self',
-          record: {
-            text: 'test',
-            createdAt: new Date().toISOString(),
-          },
-        },
-        {
-          headers: {
-            authorization: `Bearer ${auth.accessJwt}`,
-          },
-          encoding: 'application/json',
-        },
-      ),
-    ).rejects.toThrow('Bad token scope')
-  })
-})

package/tsconfig.build.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../tsconfig/node.json",
-  "compilerOptions": {
-    "rootDir": "./src",
-    "outDir": "./dist",
-    "noUnusedLocals": false,
-  },
-  "include": ["./src"],
-}