@atproto/pds 0.4.225 → 0.5.0

package/src/api/com/atproto/server/requestEmailUpdate.ts

@@ -1,70 +1,86 @@
 import { DAY, HOUR } from '@atproto/common'
-import { InvalidRequestError, Server } from '@atproto/xrpc-server'
+import {
+  ForbiddenError,
+  MethodAuthVerifier,
+  MethodRateLimit,
+  Server,
+} from '@atproto/xrpc-server'
+import { AccessOutput, OAuthOutput } from '../../../../auth-output.js'
+import { ACCESS_FULL } from '../../../../auth-scope.js'
 import { AppContext } from '../../../../context.js'
 import { com } from '../../../../lexicons/index.js'
 
+// Exposed as a utility to ensure auth in updateEmail and requestEmailUpdate
+// stay consistent.
+export function requestEmailUpdateAuth(
+  ctx: AppContext,
+): MethodAuthVerifier<AccessOutput | OAuthOutput> {
+  return ctx.authVerifier.authorization({
+    checkTakedown: true,
+    scopes: ACCESS_FULL,
+    authorize: () => {
+      throw new ForbiddenError(
+        'Use the account manager interface to update email address associated with an account',
+      )
+    },
+  })
+}
+
+const rateLimit: MethodRateLimit<AccessOutput | OAuthOutput> = [
+  {
+    durationMs: DAY,
+    points: 15,
+    calcKey: ({ auth }) => auth.credentials.did,
+  },
+  {
+    durationMs: HOUR,
+    points: 5,
+    calcKey: ({ auth }) => auth.credentials.did,
+  },
+]
+
 export default function (server: Server, ctx: AppContext) {
   const { entrywayClient } = ctx
 
-  server.add(com.atproto.server.requestEmailUpdate, {
-    rateLimit: [
-      {
-        durationMs: DAY,
-        points: 15,
-        calcKey: ({ auth }) => auth.credentials.did,
-      },
-      {
-        durationMs: HOUR,
-        points: 5,
-        calcKey: ({ auth }) => auth.credentials.did,
-      },
-    ],
-    auth: ctx.authVerifier.authorization({
-      checkTakedown: true,
-      authorize: (permissions) => {
-        permissions.assertAccount({ attr: 'email', action: 'manage' })
-      },
-    }),
-    handler: async ({ auth, req }) => {
-      const did = auth.credentials.did
-      const account = await ctx.accountManager.getAccount(did, {
-        includeDeactivated: true,
-        includeTakenDown: true,
-      })
-      if (!account) {
-        throw new InvalidRequestError('account not found')
-      }
+  const auth = requestEmailUpdateAuth(ctx)
 
-      if (entrywayClient) {
+  if (entrywayClient) {
+    server.add(com.atproto.server.requestEmailUpdate, {
+      rateLimit,
+      auth,
+      handler: async ({ auth, req }) => {
         const { headers } = await ctx.entrywayAuthHeaders(
           req,
           auth.credentials.did,
           com.atproto.server.requestEmailUpdate.$lxm,
         )
+
         return entrywayClient.xrpc(com.atproto.server.requestEmailUpdate, {
           headers,
         })
-      }
+      },
+    })
+  } else {
+    server.add(com.atproto.server.requestEmailUpdate, {
+      rateLimit,
+      auth,
+      handler: async ({ auth }) => {
+        const did = auth.credentials.did
 
-      if (!account.email) {
-        throw new InvalidRequestError('account does not have an email address')
-      }
+        // @TODO get the locale somehow (either by adding a field in the request
+        // body, or by using the `Accept-Language` header).
+        const locale = undefined
 
-      const tokenRequired = !!account.emailConfirmedAt
-      if (tokenRequired) {
-        const token = await ctx.accountManager.createEmailToken(
+        const { tokenRequired } = await ctx.accountManager.requestEmailUpdate(
           did,
-          'update_email',
+          { locale },
         )
-        await ctx.mailer.sendUpdateEmail({ token }, { to: account.email })
-      }
 
-      return {
-        encoding: 'application/json' as const,
-        body: {
-          tokenRequired,
-        },
-      }
-    },
-  })
+        return {
+          encoding: 'application/json' as const,
+          body: { tokenRequired },
+        }
+      },
+    })
+  }
 }

package/src/api/com/atproto/server/updateEmail.ts

@@ -1,82 +1,52 @@
-import { isEmailValid } from '@hapi/address'
-import { isDisposableEmail } from 'disposable-email-domains-js'
-import {
-  ForbiddenError,
-  InvalidRequestError,
-  Server,
-} from '@atproto/xrpc-server'
+import { InvalidRequestError, Server } from '@atproto/xrpc-server'
 import { UserAlreadyExistsError } from '../../../../account-manager/helpers/account.js'
-import { ACCESS_FULL } from '../../../../auth-scope.js'
 import { AppContext } from '../../../../context.js'
 import { com } from '../../../../lexicons/index.js'
+import { requestEmailUpdateAuth } from './requestEmailUpdate.js'
 
 export default function (server: Server, ctx: AppContext) {
-  server.add(com.atproto.server.updateEmail, {
-    auth: ctx.authVerifier.authorization({
-      checkTakedown: true,
-      scopes: ACCESS_FULL,
-      authorize: () => {
-        throw new ForbiddenError(
-          'OAuth credentials are not supported for this endpoint',
-        )
-      },
-    }),
-    handler: async ({ auth, input: { body }, req }) => {
-      const did = auth.credentials.did
-      const { token, email } = body
-      if (!isEmailValid(email) || isDisposableEmail(email)) {
-        throw new InvalidRequestError(
-          'This email address is not supported, please use a different email.',
-        )
-      }
-      const account = await ctx.accountManager.getAccount(did, {
-        includeDeactivated: true,
-      })
-      if (!account) {
-        throw new InvalidRequestError('account not found')
-      }
+  const { entrywayClient } = ctx
+
+  // @NOTE Ensure that both endpoints use the same authentication logic
+  const auth = requestEmailUpdateAuth(ctx)
 
-      if (ctx.entrywayClient) {
+  if (entrywayClient) {
+    server.add(com.atproto.server.updateEmail, {
+      auth,
+      handler: async ({ auth, input: { body }, req }) => {
         const { headers } = await ctx.entrywayAuthHeaders(
           req,
           auth.credentials.did,
           com.atproto.server.updateEmail.$lxm,
         )
 
-        await ctx.entrywayClient.xrpc(com.atproto.server.updateEmail, {
+        await entrywayClient.xrpc(com.atproto.server.updateEmail, {
           headers,
           body,
         })
+      },
+    })
+  } else {
+    server.add(com.atproto.server.updateEmail, {
+      auth,
+      handler: async ({ auth, input: { body } }) => {
+        const did = auth.credentials.did
+        const { token, email } = body
 
-        return
-      }
+        // @TODO get the locale somehow (either by adding a field in the request
+        // body, or by using the `Accept-Language` header).
+        const locale = undefined
 
-      // require valid token if account email is confirmed
-      if (account.emailConfirmedAt) {
-        if (!token) {
-          throw new InvalidRequestError(
-            'confirmation token required',
-            'TokenRequired',
-          )
-        }
-        await ctx.accountManager.assertValidEmailToken(
-          did,
-          'update_email',
-          token,
-        )
-      }
+        try {
+          await ctx.accountManager.updateEmail(did, email, token, { locale })
+        } catch (cause) {
+          if (cause instanceof UserAlreadyExistsError) {
+            throw new InvalidRequestError(cause.message, undefined, { cause })
+          }
 
-      try {
-        await ctx.accountManager.updateEmail({ did, email })
-      } catch (err) {
-        if (err instanceof UserAlreadyExistsError) {
-          throw new InvalidRequestError(
-            'This email address is already in use, please use a different email.',
-          )
-        } else {
-          throw err
+          throw cause
         }
-      }
-    },
-  })
+      },
+    })
+  }
 }

package/src/context.ts

@@ -270,6 +270,7 @@ export class AppContext {
     const accountManager = new AccountManager(
       idResolver,
       jwtSecretKey,
+      mailer,
       cfg.service.did,
       cfg.identity.serviceHandleDomains,
       cfg.db,

package/src/mailer/index.ts

@@ -39,14 +39,22 @@ export class ServerMailer {
     })
   }
 
-  async sendConfirmEmail(params: { token: string }, mailOpts: SendMailOptions) {
+  async sendConfirmEmail(
+    params: { token: string; locale?: string },
+    mailOpts: SendMailOptions,
+  ) {
+    // @TODO (later) handle locale in the template
     await this.sendTemplate('confirmEmail', params, {
       subject: 'Email Confirmation',
       ...mailOpts,
     })
   }
 
-  async sendUpdateEmail(params: { token: string }, mailOpts: SendMailOptions) {
+  async sendUpdateEmail(
+    params: { token: string; locale?: string },
+    mailOpts: SendMailOptions,
+  ) {
+    // @TODO (later) handle locale in the template
     await this.sendTemplate('updateEmail', params, {
       subject: 'Email Update Requested',
       ...mailOpts,

package/tests/account-manager.test.ts

@@ -108,12 +108,6 @@ describe('account manager', () => {
   })
 
   it('allows changing the password', async () => {
-    const sendResetPasswordMock = jest
-      .spyOn(network.pds.ctx.mailer, 'sendResetPassword')
-      .mockImplementation(async () => {
-        // noop
-      })
-
     await using page = await PageHelper.from(browser, { languages })
 
     await page.goto(new URL('/account', network.pds.url))
@@ -122,7 +116,11 @@ describe('account manager', () => {
 
     await page.clickOnText('Mot de passe', 'a')
 
-    expect(sendResetPasswordMock).toHaveBeenCalledTimes(0)
+    using sendResetPasswordMock = jest
+      .spyOn(network.pds.ctx.mailer, 'sendResetPassword')
+      .mockImplementation(async () => {
+        // noop
+      })
 
     await page.clickOnText('Envoyer le code')
 
@@ -145,7 +143,90 @@ describe('account manager', () => {
       'Réinitialisation du mot de passe réussie',
       'div',
     )
+  })
+
+  it('allows validating the email address', async () => {
+    await using page = await PageHelper.from(browser, { languages })
+
+    await page.goto(new URL('/account', network.pds.url))
+
+    await page.clickOnText('Vérifier maintenant', 'button')
+
+    using sendConfirmEmailMock = jest
+      .spyOn(network.pds.ctx.mailer, 'sendConfirmEmail')
+      .mockImplementation(async () => {
+        // noop
+      })
+
+    await page.clickOnText('Envoyer le code', 'button')
+
+    await page.waitForNetworkIdle()
+
+    expect(sendConfirmEmailMock).toHaveBeenCalledTimes(1)
+
+    const [params] = sendConfirmEmailMock.mock.lastCall!
+    expect(params).toEqual({
+      locale: 'fr',
+      token: expect.any(String),
+    })
+
+    await page.typeInInput('code', params.token)
+    await page.clickOnText('Soumettre')
+
+    await page.ensureTextVisibility('Adresse email vérifiée', 'div')
+  })
+
+  it('allows changing the email address', async () => {
+    await using page = await PageHelper.from(browser, { languages })
+
+    await page.goto(new URL('/account', network.pds.url))
+
+    await page.clickOnText('Email', 'a')
+
+    using sendUpdateEmailMock = jest
+      .spyOn(network.pds.ctx.mailer, 'sendUpdateEmail')
+      .mockImplementation(async () => {
+        // noop
+      })
+
+    using sendConfirmEmailMock = jest
+      .spyOn(network.pds.ctx.mailer, 'sendConfirmEmail')
+      .mockImplementation(async () => {
+        // noop
+      })
+
+    await page.clickOnText('Envoyer le code', 'button')
+
+    await page.waitForNetworkIdle()
+
+    expect(sendUpdateEmailMock).toHaveBeenCalledTimes(1)
+
+    const [updateParams] = sendUpdateEmailMock.mock.lastCall!
+    expect(updateParams).toEqual({
+      locale: 'fr',
+      token: expect.any(String),
+    })
+
+    await page.typeInInput('code', updateParams.token)
+    await page.typeInInput('email', 'bob-new-email@example.com')
+    await page.clickOnText('Soumettre')
+
+    await page.ensureTextVisibility(
+      "Modification de l'adresse email réussie",
+      'div',
+    )
+
+    expect(sendConfirmEmailMock).toHaveBeenCalledTimes(1)
+
+    const [confirmParams] = sendConfirmEmailMock.mock.lastCall!
+    expect(confirmParams).toEqual({
+      locale: 'fr',
+      token: expect.any(String),
+    })
+
+    await page.typeInInput('code', confirmParams.token)
+    await page.clickOnText('Soumettre')
 
-    sendResetPasswordMock.mockRestore()
+    await page.ensureTextVisibility('Adresse email vérifiée', 'div')
   })
 })

package/tests/server.test.ts

@@ -58,7 +58,7 @@ describe('server', () => {
 
   it('limits size of json input.', async () => {
     const res = await fetch(
-      `${network.pds.url}/xrpc/com.atproto.repo.createRecord`,
+      `${network.pds.url}/xrpc/com.atproto.identity.updateHandle`,
       {
         method: 'POST',
         body: '"' + 'x'.repeat(150 * 1024) + '"', // ~150kb