@atproto/pds 0.5.12 → 0.5.14

package/tests/handles.test.ts

@@ -1,274 +0,0 @@
-import { jest } from '@jest/globals'
-import { type AtpAgent } from '@atproto/api'
-import { type SeedClient } from '@atproto/dev-env'
-import { AtIdentifierString, DidString } from '@atproto/syntax'
-import { type AppContext } from '../src/index.js'
-
-// outside of suite so they can be used in mock
-let alice: DidString
-let bob: DidString
-
-jest.unstable_mockModule('node:dns/promises', () => {
-  return {
-    resolveTxt: (domain: string) => {
-      if (domain === '_atproto.alice.external') {
-        return [[`did=${alice}`]]
-      }
-      if (domain === '_atproto.bob.external') {
-        return [[`did=${bob}`]]
-      }
-      return []
-    },
-  }
-})
-
-// Dynamic imports so jest.unstable_mockModule() registers before these modules
-// load node:dns/promises. Static imports link the full dep graph before any code
-// evaluates, which would bypass the mock. Remove once migrated to vitest.
-const { IdResolver } = await import('@atproto/identity')
-const { TestNetworkNoAppView } = await import('@atproto/dev-env')
-const { default: basicSeed } = await import('./seeds/basic.js')
-
-describe('handles', () => {
-  let network: InstanceType<typeof TestNetworkNoAppView>
-  let agent: AtpAgent
-  let sc: SeedClient
-  let ctx: AppContext
-  let idResolver: InstanceType<typeof IdResolver>
-
-  const newHandle = 'alice2.test'
-
-  const tryHandle = async (handle: string) => {
-    await agent.com.atproto.identity.updateHandle(
-      { handle },
-      { headers: sc.getHeaders(alice), encoding: 'application/json' },
-    )
-  }
-
-  beforeAll(async () => {
-    network = await TestNetworkNoAppView.create({
-      dbPostgresSchema: 'handles',
-    })
-    // @ts-expect-error Error due to circular dependency with the dev-env package
-    ctx = network.pds.ctx
-    idResolver = new IdResolver({ plcUrl: ctx.cfg.identity.plcUrl })
-    agent = network.pds.getAgent()
-    sc = network.getSeedClient()
-    await basicSeed(sc)
-    alice = sc.dids.alice
-    bob = sc.dids.bob
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  const getHandleFromDb = async (
-    did: AtIdentifierString,
-  ): Promise<string | undefined> => {
-    const res = await ctx.accountManager.getAccount(did)
-    return res?.handle ?? undefined
-  }
-
-  it('resolves handles', async () => {
-    const res = await agent.api.com.atproto.identity.resolveHandle({
-      handle: 'alice.test',
-    })
-    expect(res.data.did).toBe(alice)
-  })
-
-  it('resolves non-normalize handles', async () => {
-    const res = await agent.api.com.atproto.identity.resolveHandle({
-      handle: 'aLicE.tEst',
-    })
-    expect(res.data.did).toBe(alice)
-  })
-
-  it('allows a user to change their handle', async () => {
-    await agent.api.com.atproto.identity.updateHandle(
-      { handle: newHandle },
-      { headers: sc.getHeaders(alice), encoding: 'application/json' },
-    )
-    const attemptOld = agent.api.com.atproto.identity.resolveHandle({
-      handle: 'alice.test',
-    })
-    await expect(attemptOld).rejects.toThrow('Unable to resolve handle')
-    const attemptNew = await agent.api.com.atproto.identity.resolveHandle({
-      handle: newHandle,
-    })
-    expect(attemptNew.data.did).toBe(alice)
-  })
-
-  it('updates their did document', async () => {
-    const data = await idResolver.did.resolveAtprotoData(alice)
-    expect(data.handle).toBe(newHandle)
-  })
-
-  it('allows a user to login with their new handle', async () => {
-    const res = await agent.api.com.atproto.server.createSession({
-      identifier: newHandle,
-      password: sc.accounts[alice].password,
-    })
-    sc.accounts[alice].accessJwt = res.data.accessJwt
-    sc.accounts[alice].refreshJwt = res.data.refreshJwt
-  })
-
-  it('does not allow taking a handle that already exists', async () => {
-    const attempt = agent.api.com.atproto.identity.updateHandle(
-      { handle: 'Bob.test' },
-      { headers: sc.getHeaders(alice), encoding: 'application/json' },
-    )
-    await expect(attempt).rejects.toThrow('Handle already taken: bob.test')
-  })
-
-  it('handle updates are idempotent', async () => {
-    await agent.api.com.atproto.identity.updateHandle(
-      { handle: 'Bob.test' },
-      { headers: sc.getHeaders(bob), encoding: 'application/json' },
-    )
-  })
-
-  it('if handle update fails, it does not update their did document', async () => {
-    const data = await idResolver.did.resolveAtprotoData(alice)
-    expect(data.handle).toBe(newHandle)
-  })
-
-  it('disallows handles that do not resolve to a DID', async () => {
-    await expect(tryHandle('john.bsky.io')).rejects.toThrow(
-      'External handle did not resolve to DID',
-    )
-  })
-
-  it('validates input through lexicon schema', async () => {
-    for (const invalidHandle of [
-      'did:john',
-      'jo_hn.test',
-      'jo!hn.test',
-      'jo%hn.test',
-      'jo&hn.test',
-      'jo*hn.test',
-      'jo|hn.test',
-      'jo:hn.test',
-      'jo/hn.test',
-    ]) {
-      await expect(tryHandle(invalidHandle)).rejects.toMatchObject({
-        error: 'InvalidRequest',
-        message: expect.stringContaining('handle'),
-      })
-    }
-  })
-
-  it('applies PDS specific handle length constraints', async () => {
-    await expect(tryHandle('j.test')).rejects.toMatchObject({
-      error: 'InvalidHandle',
-      message: 'Handle too short',
-    })
-    await expect(
-      tryHandle('jayromy-johnber12345678910.test'),
-    ).rejects.toMatchObject({
-      error: 'InvalidHandle',
-      message: 'Handle too long',
-    })
-  })
-
-  it('disallows reserved handles', async () => {
-    await expect(tryHandle('about.test')).rejects.toMatchObject({
-      error: 'HandleNotAvailable',
-      message: 'Reserved handle',
-    })
-    await expect(tryHandle('atp.test')).rejects.toMatchObject({
-      error: 'HandleNotAvailable',
-      message: 'Reserved handle',
-    })
-  })
-
-  it('allows updating to a dns handles', async () => {
-    await agent.api.com.atproto.identity.updateHandle(
-      {
-        handle: 'alice.external',
-      },
-      { headers: sc.getHeaders(alice), encoding: 'application/json' },
-    )
-    const dbHandle = await getHandleFromDb(alice)
-    expect(dbHandle).toBe('alice.external')
-
-    const data = await idResolver.did.resolveAtprotoData(alice)
-    expect(data.handle).toBe('alice.external')
-  })
-
-  it('does not allow updating to an invalid dns handle', async () => {
-    const attempt = agent.api.com.atproto.identity.updateHandle(
-      {
-        handle: 'bob.external',
-      },
-      { headers: sc.getHeaders(alice), encoding: 'application/json' },
-    )
-    await expect(attempt).rejects.toThrow(
-      'External handle did not resolve to DID',
-    )
-
-    const attempt2 = agent.api.com.atproto.identity.updateHandle(
-      {
-        handle: 'noexist.external',
-      },
-      { headers: sc.getHeaders(alice), encoding: 'application/json' },
-    )
-    await expect(attempt2).rejects.toThrow(
-      'External handle did not resolve to DID',
-    )
-
-    const dbHandle = await getHandleFromDb(alice)
-    expect(dbHandle).toBe('alice.external')
-  })
-
-  it('allows admin overrules of service domains', async () => {
-    await agent.api.com.atproto.admin.updateAccountHandle(
-      {
-        did: bob,
-        handle: 'bob-alt.test',
-      },
-      {
-        headers: network.pds.adminAuthHeaders(),
-        encoding: 'application/json',
-      },
-    )
-
-    const dbHandle = await getHandleFromDb(bob)
-    expect(dbHandle).toBe('bob-alt.test')
-  })
-
-  it('allows admin override of reserved domains', async () => {
-    await agent.api.com.atproto.admin.updateAccountHandle(
-      {
-        did: bob,
-        handle: 'dril.test',
-      },
-      {
-        headers: network.pds.adminAuthHeaders(),
-        encoding: 'application/json',
-      },
-    )
-
-    const dbHandle = await getHandleFromDb(bob)
-    expect(dbHandle).toBe('dril.test')
-  })
-
-  it('requires admin auth', async () => {
-    const attempt = agent.api.com.atproto.admin.updateAccountHandle(
-      {
-        did: bob,
-        handle: 'bob-alt.test',
-      },
-      {
-        headers: sc.getHeaders(bob),
-        encoding: 'application/json',
-      },
-    )
-    await expect(attempt).rejects.toThrow('Authentication Required')
-    const attempt2 = agent.api.com.atproto.admin.updateAccountHandle({
-      did: bob,
-      handle: 'bob-alt.test',
-    })
-    await expect(attempt2).rejects.toThrow('Authentication Required')
-  })
-})

package/tests/invite-codes.test.ts

@@ -1,367 +0,0 @@
-import { AtpAgent, ComAtprotoServerCreateAccount } from '@atproto/api'
-import { DAY } from '@atproto/common'
-import * as crypto from '@atproto/crypto'
-import { TestNetworkNoAppView } from '@atproto/dev-env'
-import { toDatetimeString } from '@atproto/lex'
-import { genInvCodes } from '../src/api/com/atproto/server/util.js'
-import { AppContext } from '../src/index.js'
-
-describe('account', () => {
-  let network: TestNetworkNoAppView
-  let ctx: AppContext
-  let agent: AtpAgent
-
-  beforeAll(async () => {
-    network = await TestNetworkNoAppView.create({
-      dbPostgresSchema: 'invite_codes',
-      pds: {
-        inviteRequired: true,
-        inviteInterval: DAY,
-        inviteEpoch: Date.now() - 3 * DAY,
-      },
-    })
-    // @ts-expect-error Error due to circular dependency with the dev-env package
-    ctx = network.pds.ctx
-    agent = network.pds.getAgent()
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  it('describes the fact that invites are required', async () => {
-    const res = await agent.api.com.atproto.server.describeServer({})
-    expect(res.data.inviteCodeRequired).toBe(true)
-  })
-
-  it('succeeds with a valid code', async () => {
-    const code = await createInviteCode(network, agent, 1)
-    await createAccountWithInvite(agent, code)
-  })
-
-  it('fails on bad invite code', async () => {
-    const promise = createAccountWithInvite(agent, 'fake-invite')
-    await expect(promise).rejects.toThrow(
-      ComAtprotoServerCreateAccount.InvalidInviteCodeError,
-    )
-  })
-
-  it('fails on invite code from takendown account', async () => {
-    const account = await makeLoggedInAccount(network, agent)
-    // assign an invite code to the user
-    const code = await createInviteCode(network, agent, 1, account.did)
-    // takedown the user's account
-    const subject = {
-      $type: 'com.atproto.admin.defs#repoRef',
-      did: account.did,
-    }
-    await agent.api.com.atproto.admin.updateSubjectStatus(
-      {
-        subject,
-        takedown: { applied: true },
-      },
-      {
-        encoding: 'application/json',
-        headers: network.pds.adminAuthHeaders(),
-      },
-    )
-    // attempt to create account with the previously generated invite code
-    const promise = createAccountWithInvite(agent, code)
-    await expect(promise).rejects.toThrow(
-      ComAtprotoServerCreateAccount.InvalidInviteCodeError,
-    )
-
-    // double check that reversing the takedown action makes the invite code valid again
-    await agent.api.com.atproto.admin.updateSubjectStatus(
-      {
-        subject,
-        takedown: { applied: false },
-      },
-      {
-        encoding: 'application/json',
-        headers: network.pds.adminAuthHeaders(),
-      },
-    )
-    // attempt to create account with the previously generated invite code
-    await createAccountWithInvite(agent, code)
-  })
-
-  it('fails on used up invite code', async () => {
-    const code = await createInviteCode(network, agent, 2)
-    await createAccountsWithInvite(agent, code, 2)
-    const promise = createAccountWithInvite(agent, code)
-    await expect(promise).rejects.toThrow(
-      ComAtprotoServerCreateAccount.InvalidInviteCodeError,
-    )
-  })
-
-  it('handles racing invite code uses', async () => {
-    const inviteCode = await createInviteCode(network, agent, 1)
-    const COUNT = 10
-
-    let successes = 0
-    let failures = 0
-    const promises: Promise<unknown>[] = []
-    for (let i = 0; i < COUNT; i++) {
-      const attempt = async () => {
-        try {
-          await createAccountWithInvite(agent, inviteCode)
-          successes++
-        } catch (err) {
-          failures++
-        }
-      }
-      promises.push(attempt())
-    }
-    await Promise.all(promises)
-    expect(successes).toBe(1)
-    expect(failures).toBe(9)
-  })
-
-  it('allow users to get available user invites', async () => {
-    const account = await makeLoggedInAccount(network, agent)
-
-    // no codes available yet
-    const res1 = await account.com.atproto.server.getAccountInviteCodes()
-    expect(res1.data.codes.length).toBe(0)
-
-    // next, pretend account was made 2 days in the past
-    const twoDaysAgo = new Date(Date.now() - 2 * DAY).toISOString()
-    await ctx.accountManager.db.db
-      .updateTable('actor')
-      .set({ createdAt: twoDaysAgo })
-      .where('did', '=', account.accountDid)
-      .execute()
-    const res2 = await account.com.atproto.server.getAccountInviteCodes()
-    expect(res2.data.codes.length).toBe(2)
-
-    // use both invites and confirm we can't get any more
-    for (const code of res2.data.codes) {
-      await createAccountWithInvite(agent, code.code)
-    }
-
-    const res3 = await account.com.atproto.server.getAccountInviteCodes()
-    expect(res3.data.codes.length).toBe(2)
-  })
-
-  it('admin gifted codes to not impact a users available codes', async () => {
-    const account = await makeLoggedInAccount(network, agent)
-
-    // again, pretend account was made 2 days ago
-    const twoDaysAgo = new Date(Date.now() - 2 * DAY).toISOString()
-    await ctx.accountManager.db.db
-      .updateTable('actor')
-      .set({ createdAt: twoDaysAgo })
-      .where('did', '=', account.accountDid)
-      .execute()
-
-    await createInviteCode(network, agent, 1, account.accountDid)
-    await createInviteCode(network, agent, 1, account.accountDid)
-    await createInviteCode(network, agent, 1, account.accountDid)
-
-    const res = await account.com.atproto.server.getAccountInviteCodes()
-    expect(res.data.codes.length).toBe(5)
-
-    const fromAdmin = res.data.codes.filter(
-      (code) => code.createdBy === 'admin',
-    )
-    expect(fromAdmin.length).toBe(3)
-
-    const fromSelf = res.data.codes.filter(
-      (code) => code.createdBy === account.accountDid,
-    )
-    expect(fromSelf.length).toBe(2)
-  })
-
-  it('creates invites based on epoch', async () => {
-    const account = await makeLoggedInAccount(network, agent)
-
-    // first, pretend account was made 2 days ago & get those two codes
-    const twoDaysAgo = toDatetimeString(new Date(Date.now() - 2 * DAY))
-    await ctx.accountManager.db.db
-      .updateTable('actor')
-      .set({ createdAt: twoDaysAgo })
-      .where('did', '=', account.accountDid)
-      .execute()
-
-    const res1 = await account.com.atproto.server.getAccountInviteCodes()
-    expect(res1.data.codes.length).toBe(2)
-
-    // then pretend account was made ever so slightly over 10 days ago
-    const tenDaysAgo = new Date(Date.now() - 10.01 * DAY).toISOString()
-    await ctx.accountManager.db.db
-      .updateTable('actor')
-      .set({ createdAt: tenDaysAgo })
-      .where('did', '=', account.accountDid)
-      .execute()
-
-    // we have a 3 day epoch so should still get 3 code
-    const res2 = await account.com.atproto.server.getAccountInviteCodes()
-    expect(res2.data.codes.length).toBe(3)
-
-    // use up these codes
-    for (const code of res2.data.codes) {
-      await createAccountWithInvite(agent, code.code)
-    }
-
-    // we pad their account with some additional unused codes from the past which should not allow them to generate anymore
-    const inviteRows = genInvCodes(ctx.cfg, 10).map((code) => ({
-      code: code,
-      availableUses: 1,
-      disabled: 0 as const,
-      forAccount: account.accountDid,
-      createdBy: account.accountDid,
-      createdAt: toDatetimeString(new Date(Date.now() - 5 * DAY)),
-    }))
-    await ctx.accountManager.db.db
-      .insertInto('invite_code')
-      .values(inviteRows)
-      .execute()
-    const res3 = await account.com.atproto.server.getAccountInviteCodes({
-      includeUsed: false,
-    })
-    expect(res3.data.codes.length).toBe(10)
-
-    // no we use the codes which should still not allow them to generate anymore
-    await ctx.accountManager.db.db
-      .insertInto('invite_code_use')
-      .values(
-        inviteRows.map((row) => ({
-          code: row.code,
-          usedBy: 'did:example:test' as const,
-          usedAt: toDatetimeString(new Date()),
-        })),
-      )
-      .execute()
-
-    const res4 = await account.com.atproto.server.getAccountInviteCodes({
-      includeUsed: false,
-    })
-    expect(res4.data.codes.length).toBe(0)
-  })
-
-  it('prevents use of disabled codes', async () => {
-    const first = await createInviteCode(network, agent, 1)
-    const account = await makeLoggedInAccount(network, agent)
-    const second = await createInviteCode(network, agent, 1, account.accountDid)
-
-    // disabled first by code & second by did
-    await agent.api.com.atproto.admin.disableInviteCodes(
-      {
-        codes: [first],
-        accounts: [account.accountDid],
-      },
-      {
-        headers: network.pds.adminAuthHeaders(),
-        encoding: 'application/json',
-      },
-    )
-
-    await expect(createAccountWithInvite(agent, first)).rejects.toThrow(
-      ComAtprotoServerCreateAccount.InvalidInviteCodeError,
-    )
-    await expect(createAccountWithInvite(agent, second)).rejects.toThrow(
-      ComAtprotoServerCreateAccount.InvalidInviteCodeError,
-    )
-  })
-
-  it('does not allow disabling all admin codes', async () => {
-    const attempt = agent.api.com.atproto.admin.disableInviteCodes(
-      {
-        accounts: ['admin'],
-      },
-      {
-        headers: network.pds.adminAuthHeaders(),
-        encoding: 'application/json',
-      },
-    )
-    await expect(attempt).rejects.toThrow('cannot disable admin invite codes')
-  })
-
-  it('creates many invite codes', async () => {
-    const accounts = ['did:example:one', 'did:example:two', 'did:example:three']
-    const res = await agent.api.com.atproto.server.createInviteCodes(
-      {
-        useCount: 2,
-        codeCount: 2,
-        forAccounts: accounts,
-      },
-      {
-        headers: network.pds.adminAuthHeaders(),
-        encoding: 'application/json',
-      },
-    )
-    expect(res.data.codes.length).toBe(3)
-    const fromDb = await ctx.accountManager.db.db
-      .selectFrom('invite_code')
-      .selectAll()
-      .where('forAccount', 'in', accounts)
-      .execute()
-    expect(fromDb.length).toBe(6)
-    const dbCodesByUser = {}
-    for (const row of fromDb) {
-      expect(row.disabled).toBe(0)
-      expect(row.availableUses).toBe(2)
-      dbCodesByUser[row.forAccount] ??= []
-      dbCodesByUser[row.forAccount].push(row.code)
-    }
-    for (const { account, codes } of res.data.codes) {
-      expect(codes.length).toBe(2)
-      expect(codes.sort()).toEqual(dbCodesByUser[account].sort())
-    }
-  })
-})
-
-const createInviteCode = async (
-  network: TestNetworkNoAppView,
-  agent: AtpAgent,
-  uses: number,
-  forAccount?: string,
-): Promise<string> => {
-  const res = await agent.api.com.atproto.server.createInviteCode(
-    { useCount: uses, forAccount },
-    {
-      headers: network.pds.adminAuthHeaders(),
-      encoding: 'application/json',
-    },
-  )
-  return res.data.code
-}
-
-const createAccountWithInvite = async (agent: AtpAgent, code: string) => {
-  const name = crypto.randomStr(5, 'base32')
-  const res = await agent.api.com.atproto.server.createAccount({
-    email: `${name}@test.com`,
-    handle: `${name}.test`,
-    password: name,
-    inviteCode: code,
-  })
-  return {
-    ...res.data,
-    password: name,
-  }
-}
-
-const createAccountsWithInvite = async (
-  agent: AtpAgent,
-  code: string,
-  count = 0,
-) => {
-  for (let i = 0; i < count; i++) {
-    await createAccountWithInvite(agent, code)
-  }
-}
-
-const makeLoggedInAccount = async (
-  network: TestNetworkNoAppView,
-  inviterAgent: AtpAgent,
-) => {
-  const code = await createInviteCode(network, inviterAgent, 1)
-  const account = await createAccountWithInvite(inviterAgent, code)
-  const agent = network.pds.getAgent()
-  await agent.login({
-    identifier: account.handle,
-    password: account.password,
-  })
-  return agent
-}