@atproto/pds 0.5.12 → 0.5.14

package/tests/proxied/admin.test.ts

@@ -1,340 +0,0 @@
-import { AtpAgent } from '@atproto/api'
-import { SeedClient, TestNetwork } from '@atproto/dev-env'
-import type { DidString } from '@atproto/syntax'
-import { forSnapshot } from '../_util.js'
-import basicSeed from '../seeds/basic.js'
-
-describe('proxies admin requests', () => {
-  let network: TestNetwork
-  let agent: AtpAgent
-  let sc: SeedClient
-
-  let moderator: DidString
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'proxy_admin',
-      pds: {
-        inviteRequired: true,
-      },
-    })
-    agent = network.pds.getAgent()
-    sc = network.getSeedClient()
-    const { data: invite } =
-      await agent.api.com.atproto.server.createInviteCode(
-        { useCount: 10 },
-        {
-          encoding: 'application/json',
-          headers: network.pds.adminAuthHeaders(),
-        },
-      )
-    await basicSeed(sc, {
-      inviteCode: invite.code,
-      addModLabels: network.bsky,
-    })
-    const modAccount = await sc.createAccount('moderator', {
-      handle: 'testmod.test',
-      email: 'testmod@test.com',
-      password: 'testmod-pass',
-      inviteCode: invite.code,
-    })
-    moderator = modAccount.did
-    await network.ozone.addModeratorDid(moderator)
-
-    await network.processAll()
-  })
-
-  beforeAll(async () => {
-    const { data: invite } =
-      await agent.api.com.atproto.server.createInviteCode(
-        { useCount: 1, forAccount: sc.dids.alice },
-        {
-          headers: network.pds.adminAuthHeaders(),
-          encoding: 'application/json',
-        },
-      )
-    await agent.api.com.atproto.admin.disableAccountInvites(
-      { account: sc.dids.bob },
-      { headers: network.pds.adminAuthHeaders(), encoding: 'application/json' },
-    )
-    await sc.createAccount('eve', {
-      handle: 'eve.test',
-      email: 'eve@test.com',
-      password: 'password',
-      inviteCode: invite.code,
-    })
-  })
-
-  beforeEach(async () => {
-    await network.processAll()
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  it('creates reports of a repo.', async () => {
-    const { data: reportA } =
-      await agent.api.com.atproto.moderation.createReport(
-        {
-          reasonType: 'com.atproto.moderation.defs#reasonSpam',
-          subject: {
-            $type: 'com.atproto.admin.defs#repoRef',
-            did: sc.dids.bob,
-          },
-        },
-        {
-          headers: sc.getHeaders(sc.dids.alice),
-          encoding: 'application/json',
-        },
-      )
-    const { data: reportB } =
-      await agent.api.com.atproto.moderation.createReport(
-        {
-          reasonType: 'com.atproto.moderation.defs#reasonOther',
-          reason: 'impersonation',
-          subject: {
-            $type: 'com.atproto.admin.defs#repoRef',
-            did: sc.dids.bob,
-          },
-        },
-        {
-          headers: sc.getHeaders(sc.dids.carol),
-          encoding: 'application/json',
-        },
-      )
-    expect(forSnapshot([reportA, reportB])).toMatchSnapshot()
-  })
-
-  it('takes actions and resolves reports', async () => {
-    const post = sc.posts[sc.dids.bob][1]
-    const { data: actionA } = await agent.api.tools.ozone.moderation.emitEvent(
-      {
-        event: { $type: 'tools.ozone.moderation.defs#modEventAcknowledge' },
-        subject: {
-          $type: 'com.atproto.repo.strongRef',
-          uri: post.ref.uriStr,
-          cid: post.ref.cidStr,
-        },
-        createdBy: 'did:example:admin',
-        // @ts-expect-error
-        reason: 'Y',
-      },
-      {
-        headers: sc.getHeaders(moderator),
-        encoding: 'application/json',
-      },
-    )
-    expect(forSnapshot(actionA)).toMatchSnapshot()
-    const { data: actionB } = await agent.api.tools.ozone.moderation.emitEvent(
-      {
-        event: { $type: 'tools.ozone.moderation.defs#modEventAcknowledge' },
-        subject: {
-          $type: 'com.atproto.admin.defs#repoRef',
-          did: sc.dids.bob,
-        },
-        createdBy: 'did:example:admin',
-        // @ts-expect-error
-        reason: 'Y',
-      },
-      {
-        headers: sc.getHeaders(moderator),
-        encoding: 'application/json',
-      },
-    )
-    expect(forSnapshot(actionB)).toMatchSnapshot()
-  })
-
-  it('fetches moderation events.', async () => {
-    const { data: result } = await agent.api.tools.ozone.moderation.queryEvents(
-      {
-        subject: sc.posts[sc.dids.bob][1].ref.uriStr,
-      },
-      { headers: sc.getHeaders(moderator) },
-    )
-    expect(forSnapshot(result.events)).toMatchSnapshot()
-  })
-
-  it('fetches repo details.', async () => {
-    const { data: result } = await agent.api.tools.ozone.moderation.getRepo(
-      { did: sc.dids.eve },
-      { headers: sc.getHeaders(moderator) },
-    )
-    expect(forSnapshot(result)).toMatchSnapshot()
-  })
-
-  it('fetches record details.', async () => {
-    const post = sc.posts[sc.dids.bob][1]
-    const { data: result } = await agent.api.tools.ozone.moderation.getRecord(
-      { uri: post.ref.uriStr },
-      { headers: sc.getHeaders(moderator) },
-    )
-    expect(forSnapshot(result)).toMatchSnapshot()
-  })
-
-  it('fetches event details.', async () => {
-    const { data: result } = await agent.api.tools.ozone.moderation.getEvent(
-      { id: 2 },
-      { headers: sc.getHeaders(moderator) },
-    )
-    expect(forSnapshot(result)).toMatchSnapshot()
-  })
-
-  it('fetches a list of events.', async () => {
-    const { data: result } = await agent.api.tools.ozone.moderation.queryEvents(
-      { subject: sc.dids.bob },
-      { headers: sc.getHeaders(moderator) },
-    )
-    expect(forSnapshot(result.events)).toMatchSnapshot()
-  })
-
-  it('searches repos.', async () => {
-    const { data: result } = await agent.api.tools.ozone.moderation.searchRepos(
-      { term: 'alice' },
-      { headers: sc.getHeaders(moderator) },
-    )
-    expect(forSnapshot(result.repos)).toMatchSnapshot()
-  })
-
-  it('passes through errors.', async () => {
-    const tryGetRepo = agent.api.tools.ozone.moderation.getRepo(
-      { did: 'did:does:not:exist' },
-      { headers: sc.getHeaders(moderator) },
-    )
-    await expect(tryGetRepo).rejects.toThrow('Repo not found')
-    const tryGetRecord = agent.api.tools.ozone.moderation.getRecord(
-      { uri: 'at://did:does:not:exist/bad.collection.name/badrkey' },
-      { headers: sc.getHeaders(moderator) },
-    )
-    await expect(tryGetRecord).rejects.toThrow('Could not locate record')
-  })
-
-  it('takesdown and labels repos, and reverts.', async () => {
-    // takedown repo
-    await agent.api.tools.ozone.moderation.emitEvent(
-      {
-        event: { $type: 'tools.ozone.moderation.defs#modEventTakedown' },
-        subject: {
-          $type: 'com.atproto.admin.defs#repoRef',
-          did: sc.dids.alice,
-        },
-        createdBy: 'did:example:admin',
-        // @ts-expect-error
-        reason: 'Y',
-        createLabelVals: ['dogs'],
-        negateLabelVals: ['cats'],
-      },
-      {
-        headers: sc.getHeaders(moderator),
-        encoding: 'application/json',
-      },
-    )
-    await network.processAll()
-    // check profile and labels
-    const tryGetProfileAppview = agent.api.app.bsky.actor.getProfile(
-      { actor: sc.dids.alice },
-      {
-        headers: { ...sc.getHeaders(sc.dids.carol) },
-      },
-    )
-    await expect(tryGetProfileAppview).rejects.toThrow(
-      'Account has been suspended',
-    )
-    // reverse action
-    await agent.api.tools.ozone.moderation.emitEvent(
-      {
-        subject: {
-          $type: 'com.atproto.admin.defs#repoRef',
-          did: sc.dids.alice,
-        },
-        event: {
-          $type: 'tools.ozone.moderation.defs#modEventReverseTakedown',
-        },
-        createdBy: 'did:example:admin',
-        // @ts-expect-error
-        reason: 'X',
-      },
-      {
-        headers: sc.getHeaders(moderator),
-        encoding: 'application/json',
-      },
-    )
-    await network.processAll()
-    // check profile and labels
-    const { data: profileAppview } = await agent.api.app.bsky.actor.getProfile(
-      { actor: sc.dids.alice },
-      {
-        headers: { ...sc.getHeaders(sc.dids.carol) },
-      },
-    )
-    expect(profileAppview).toEqual(
-      expect.objectContaining({ did: sc.dids.alice, handle: 'alice.test' }),
-    )
-  })
-
-  it('takesdown and labels records, and reverts.', async () => {
-    const post = sc.posts[sc.dids.alice][0]
-    // takedown post
-    await agent.api.tools.ozone.moderation.emitEvent(
-      {
-        event: { $type: 'tools.ozone.moderation.defs#modEventTakedown' },
-        subject: {
-          $type: 'com.atproto.repo.strongRef',
-          uri: post.ref.uriStr,
-          cid: post.ref.cidStr,
-        },
-        createdBy: 'did:example:admin',
-        // @ts-expect-error
-        reason: 'Y',
-        createLabelVals: ['dogs'],
-        negateLabelVals: ['cats'],
-      },
-      {
-        headers: sc.getHeaders(moderator),
-        encoding: 'application/json',
-      },
-    )
-    await network.processAll()
-
-    // check takedown label has been created
-    const label = await network.ozone.ctx.db.db
-      .selectFrom('label')
-      .selectAll()
-      .where('val', '=', '!takedown')
-      .where('uri', '=', post.ref.uriStr)
-      .where('cid', '=', post.ref.cidStr)
-      .executeTakeFirst()
-    expect(label).toBeDefined()
-    expect(label?.neg).toBe(false)
-
-    // reverse action
-    await agent.api.tools.ozone.moderation.emitEvent(
-      {
-        subject: {
-          $type: 'com.atproto.repo.strongRef',
-          uri: post.ref.uriStr,
-          cid: post.ref.cidStr,
-        },
-        event: { $type: 'tools.ozone.moderation.defs#modEventReverseTakedown' },
-        createdBy: 'did:example:admin',
-        // @ts-expect-error
-        reason: 'X',
-      },
-      {
-        headers: sc.getHeaders(moderator),
-        encoding: 'application/json',
-      },
-    )
-    await network.processAll()
-
-    // check takedown label has been negated
-    const labelNeg = await network.ozone.ctx.db.db
-      .selectFrom('label')
-      .selectAll()
-      .where('val', '=', '!takedown')
-      .where('uri', '=', post.ref.uriStr)
-      .where('cid', '=', post.ref.cidStr)
-      .executeTakeFirst()
-    expect(labelNeg?.neg).toBe(true)
-  })
-})

package/tests/proxied/feedgen.test.ts

@@ -1,66 +0,0 @@
-import { AtUri, AtpAgent } from '@atproto/api'
-import { SeedClient, TestNetwork } from '@atproto/dev-env'
-import { InvalidRequestError } from '@atproto/xrpc-server'
-import { forSnapshot } from '../_util.js'
-import basicSeed from '../seeds/basic.js'
-
-describe('feedgen proxy view', () => {
-  let network: TestNetwork
-  let agent: AtpAgent
-  let sc: SeedClient
-  let feedUri: AtUri
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'proxy_feedgen',
-    })
-    agent = network.pds.getAgent()
-    sc = network.getSeedClient()
-    await basicSeed(sc, { addModLabels: network.bsky })
-
-    feedUri = AtUri.make(sc.dids.alice, 'app.bsky.feed.generator', 'mutuals')
-
-    const feedGen = await network.createFeedGen({
-      [feedUri.toString()]: ({ params }) => {
-        if (params.feed !== feedUri.toString()) {
-          throw new InvalidRequestError('Unknown feed')
-        }
-        return {
-          encoding: 'application/json',
-          body: {
-            feed: [
-              { post: sc.posts[sc.dids.alice][0].ref.uriStr },
-              { post: sc.posts[sc.dids.carol][0].ref.uriStr },
-            ],
-          },
-        }
-      },
-    })
-
-    // publish feed
-    await agent.api.app.bsky.feed.generator.create(
-      { repo: sc.dids.alice, rkey: feedUri.rkey },
-      {
-        did: feedGen.did,
-        displayName: 'Test feed',
-        createdAt: new Date().toISOString(),
-      },
-      sc.getHeaders(sc.dids.alice),
-    )
-    await network.processAll()
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  it('performs basic proxy of getFeed', async () => {
-    const { data: feed } = await agent.api.app.bsky.feed.getFeed(
-      { feed: feedUri.toString() },
-      {
-        headers: { ...sc.getHeaders(sc.dids.alice) },
-      },
-    )
-    expect(forSnapshot(feed)).toMatchSnapshot()
-  })
-})

package/tests/proxied/notif.test.ts

@@ -1,85 +0,0 @@
-import { AtpAgent } from '@atproto/api'
-import { SeedClient, TestNetworkNoAppView } from '@atproto/dev-env'
-import { createServer, verifyJwt } from '@atproto/xrpc-server'
-import { app } from '../../src/lexicons/index.js'
-import { startServer } from '../_util.js'
-import usersSeed from '../seeds/users.js'
-
-describe('notif service proxy', () => {
-  let network: TestNetworkNoAppView
-  let notifServer: AsyncDisposable & { port: number }
-  let notifDid: string
-  let agent: AtpAgent
-  let sc: SeedClient
-  const spy: { current: unknown } = { current: null }
-
-  beforeAll(async () => {
-    network = await TestNetworkNoAppView.create({
-      dbPostgresSchema: 'proxy_notifs',
-    })
-    const plc = network.plc.getClient()
-    agent = network.pds.getAgent()
-    sc = network.getSeedClient()
-    await usersSeed(sc)
-    await network.processAll()
-    // piggybacking existing plc did, turn it into a notif service
-    notifServer = await createMockNotifService(spy)
-    notifDid = sc.dids.dan
-    await plc.updateData(notifDid, network.pds.ctx.plcRotationKey, (x) => {
-      x.services['bsky_notif'] = {
-        type: 'BskyNotificationService',
-        endpoint: `http://localhost:${notifServer.port}`,
-      }
-      return x
-    })
-    await network.pds.ctx.idResolver.did.resolve(notifDid, true)
-  }, 20_000) // @NOTE seeding can take a while
-
-  afterAll(async () => {
-    await notifServer?.[Symbol.asyncDispose]()
-    await network?.close()
-  })
-
-  it('proxies to notif service.', async () => {
-    await agent.api.app.bsky.notification.registerPush(
-      {
-        serviceDid: notifDid,
-        token: 'tok1',
-        platform: 'web',
-        appId: 'app1',
-      },
-      {
-        headers: sc.getHeaders(sc.dids.bob),
-        encoding: 'application/json',
-      },
-    )
-    expect(spy.current?.['input']).toEqual({
-      serviceDid: notifDid,
-      token: 'tok1',
-      platform: 'web',
-      appId: 'app1',
-    })
-
-    const auth = await verifyJwt(
-      spy.current?.['jwt'] as string,
-      notifDid,
-      'app.bsky.notification.registerPush',
-      async (did) => {
-        const keypair = await network.pds.ctx.actorStore.keypair(did)
-        return keypair.did()
-      },
-    )
-    expect(auth.iss).toEqual(sc.dids.bob)
-  })
-})
-
-async function createMockNotifService(ref: { current: unknown }) {
-  const svc = createServer()
-  svc.add(app.bsky.notification.registerPush, ({ input, req }) => {
-    ref.current = {
-      input: input.body,
-      jwt: req.headers.authorization?.replace('Bearer ', ''),
-    }
-  })
-  return startServer(svc.router)
-}

package/tests/proxied/procedures.test.ts

@@ -1,175 +0,0 @@
-import { AtpAgent } from '@atproto/api'
-import { SeedClient, TestNetwork } from '@atproto/dev-env'
-import type { DidString } from '@atproto/syntax'
-import basicSeed from '../seeds/basic.js'
-
-describe('proxies appview procedures', () => {
-  let network: TestNetwork
-  let agent: AtpAgent
-  let sc: SeedClient
-
-  let alice: DidString
-  let bob: DidString
-  let carol: DidString
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'proxy_procedures',
-    })
-    agent = network.pds.getAgent()
-    sc = network.getSeedClient()
-    await basicSeed(sc, { addModLabels: network.bsky })
-    await network.processAll()
-    alice = sc.dids.alice
-    bob = sc.dids.bob
-    carol = sc.dids.carol
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  it('maintains muted actors.', async () => {
-    // mute actors
-    await agent.api.app.bsky.graph.muteActor(
-      { actor: bob },
-      {
-        headers: sc.getHeaders(alice),
-        encoding: 'application/json',
-      },
-    )
-    await agent.api.app.bsky.graph.muteActor(
-      { actor: carol },
-      {
-        headers: sc.getHeaders(alice),
-        encoding: 'application/json',
-      },
-    )
-    // check
-    const { data: result1 } = await agent.api.app.bsky.graph.getMutes(
-      {},
-      { headers: sc.getHeaders(alice) },
-    )
-    expect(result1.mutes.map((x) => x.handle)).toEqual([
-      'carol.test',
-      'bob.test',
-    ])
-    // unmute actors
-    await agent.api.app.bsky.graph.unmuteActor(
-      { actor: bob },
-      {
-        headers: sc.getHeaders(alice),
-        encoding: 'application/json',
-      },
-    )
-    // check
-    const { data: result2 } = await agent.api.app.bsky.graph.getMutes(
-      {},
-      { headers: sc.getHeaders(alice) },
-    )
-    expect(result2.mutes.map((x) => x.handle)).toEqual(['carol.test'])
-  })
-
-  it('maintains muted actor lists.', async () => {
-    // setup lists
-    const bobList = await agent.api.app.bsky.graph.list.create(
-      { repo: bob },
-      {
-        name: 'bob mutes',
-        purpose: 'app.bsky.graph.defs#modlist',
-        description: "bob's list of mutes",
-        createdAt: new Date().toISOString(),
-      },
-      sc.getHeaders(bob),
-    )
-    const carolList = await agent.api.app.bsky.graph.list.create(
-      { repo: carol },
-      {
-        name: 'carol mutes',
-        purpose: 'app.bsky.graph.defs#modlist',
-        description: "carol's list of mutes",
-        createdAt: new Date().toISOString(),
-      },
-      sc.getHeaders(carol),
-    )
-    await network.processAll()
-
-    // mute lists
-    await agent.api.app.bsky.graph.muteActorList(
-      { list: bobList.uri },
-      {
-        headers: sc.getHeaders(alice),
-        encoding: 'application/json',
-      },
-    )
-    await agent.api.app.bsky.graph.muteActorList(
-      { list: carolList.uri },
-      {
-        headers: sc.getHeaders(alice),
-        encoding: 'application/json',
-      },
-    )
-    await network.processAll()
-    // check
-    const { data: result1 } = await agent.api.app.bsky.graph.getListMutes(
-      {},
-      { headers: sc.getHeaders(alice) },
-    )
-    expect(result1.lists.map((x) => x.uri)).toEqual([
-      carolList.uri,
-      bobList.uri,
-    ])
-    // unmute lists
-    await agent.api.app.bsky.graph.unmuteActorList(
-      { list: bobList.uri },
-      {
-        headers: sc.getHeaders(alice),
-        encoding: 'application/json',
-      },
-    )
-    // check
-    const { data: result2 } = await agent.api.app.bsky.graph.getListMutes(
-      {},
-      { headers: sc.getHeaders(alice) },
-    )
-    expect(result2.lists.map((x) => x.uri)).toEqual([carolList.uri])
-  })
-
-  it('maintains notification last seen state.', async () => {
-    // check original notifs
-    const { data: result1 } =
-      await agent.api.app.bsky.notification.listNotifications(
-        {},
-        { headers: sc.getHeaders(alice) },
-      )
-    expect(result1.notifications.length).toBeGreaterThanOrEqual(5)
-    expect(
-      result1.notifications.every((n, i) => {
-        return (i === 0 && !n.isRead) || (i !== 0 && n.isRead)
-      }),
-    ).toBe(true)
-    // update last seen
-    const { indexedAt: lastSeenAt } = result1.notifications[2]
-    await agent.api.app.bsky.notification.updateSeen(
-      { seenAt: lastSeenAt },
-      {
-        headers: sc.getHeaders(alice),
-        encoding: 'application/json',
-      },
-    )
-    // check
-    const { data: result2 } =
-      await agent.api.app.bsky.notification.listNotifications(
-        {},
-        { headers: sc.getHeaders(alice) },
-      )
-    expect(result2.notifications.some((n) => n.isRead)).toBe(true)
-    expect(result2.notifications.some((n) => !n.isRead)).toBe(true)
-    expect(result2.notifications).toEqual(
-      result1.notifications.map((n) => ({
-        ...n,
-        isRead: n.indexedAt < lastSeenAt,
-      })),
-    )
-  })
-})