@atproto/pds 0.5.1 → 0.5.3

package/src/api/com/atproto/identity/updateHandle.ts

@@ -1,97 +1,66 @@
 import { DAY, MINUTE } from '@atproto/common'
-import { InvalidRequestError, Server } from '@atproto/xrpc-server'
+import { MethodRateLimit, Server } from '@atproto/xrpc-server'
+import { AccessOutput, OAuthOutput } from '../../../../auth-output.js'
 import { AppContext } from '../../../../context.js'
 import { com } from '../../../../lexicons/index.js'
-import { httpLogger } from '../../../../logger.js'
 
 export default function (server: Server, ctx: AppContext) {
-  server.add(com.atproto.identity.updateHandle, {
-    auth: ctx.authVerifier.authorization({
-      checkTakedown: true,
-      authorize: (permissions) => {
-        permissions.assertIdentity({ attr: 'handle' })
-      },
-    }),
-    rateLimit: [
-      {
-        durationMs: 5 * MINUTE,
-        points: 10,
-        calcKey: ({ auth }) => auth.credentials.did,
-      },
-      {
-        durationMs: DAY,
-        points: 50,
-        calcKey: ({ auth }) => auth.credentials.did,
-      },
-    ],
-    handler: async ({ auth, input, req }) => {
-      const requester = auth.credentials.did
+  const { entrywayClient } = ctx
+
+  const auth = ctx.authVerifier.authorization({
+    checkTakedown: true,
+    authorize: (permissions) => {
+      permissions.assertIdentity({ attr: 'handle' })
+    },
+  })
 
-      if (ctx.entrywayClient) {
+  const rateLimit: MethodRateLimit<AccessOutput | OAuthOutput> = [
+    {
+      durationMs: 5 * MINUTE,
+      points: 10,
+      calcKey: ({ auth }) => auth.credentials.did,
+    },
+    {
+      durationMs: DAY,
+      points: 50,
+      calcKey: ({ auth }) => auth.credentials.did,
+    },
+  ]
+
+  if (entrywayClient) {
+    server.add(com.atproto.identity.updateHandle, {
+      auth,
+      rateLimit,
+      handler: async ({ auth, input, req }) => {
         const { headers } = await ctx.entrywayAuthHeaders(
           req,
           auth.credentials.did,
           com.atproto.identity.updateHandle.$lxm,
         )
-        // the full flow is:
+
+        // The full flow is:
         // -> entryway(identity.updateHandle) [update handle, submit plc op]
         // -> pds(admin.updateAccountHandle)  [track handle, sequence handle update]
-        await ctx.entrywayClient.xrpc(com.atproto.identity.updateHandle, {
+        await entrywayClient.xrpc(com.atproto.identity.updateHandle, {
           headers,
           body: {
             handle: input.body.handle,
             // @ts-expect-error "did" is not in the schema
-            did: requester,
+            did: auth.credentials.did,
           },
         })
-        return
-      }
-
-      const handle = await ctx.accountManager.normalizeAndValidateHandle(
-        input.body.handle,
-        { did: requester },
-      )
-
-      // Pessimistic check to handle spam: also enforced by updateHandle() and the db.
-      const account = await ctx.accountManager.getAccount(handle, {
-        includeDeactivated: true,
-      })
-
-      if (!account) {
-        if (requester.startsWith('did:plc:')) {
-          await ctx.plcClient.updateHandle(
-            requester,
-            ctx.plcRotationKey,
-            handle,
-          )
-        } else {
-          const resolved = await ctx.idResolver.did.resolveAtprotoData(
-            requester,
-            true,
-          )
-          if (resolved.handle !== handle) {
-            throw new InvalidRequestError(
-              'DID is not properly configured for handle',
-            )
-          }
-        }
-        await ctx.accountManager.updateHandle(requester, handle)
-      } else {
-        // if we found an account with matching handle, check if it is the same as requester
-        // if so emit an identity event, otherwise error.
-        if (account.did !== requester) {
-          throw new InvalidRequestError(`Handle already taken: ${handle}`)
-        }
-      }
-
-      try {
-        await ctx.sequencer.sequenceIdentityEvt(requester, handle)
-      } catch (err) {
-        httpLogger.error(
-          { err, did: requester, handle },
-          'failed to sequence handle update',
+      },
+    })
+  } else {
+    server.add(com.atproto.identity.updateHandle, {
+      auth,
+      rateLimit,
+      handler: async ({ auth, input }) => {
+        await ctx.accountManager.updateHandle(
+          auth.credentials.did,
+          input.body.handle,
         )
-      }
-    },
-  })
+      },
+    })
+  }
 }

package/src/api/com/atproto/repo/getRecord.ts

@@ -1,4 +1,4 @@
-import { AtUri } from '@atproto/syntax'
+import { atUri } from '@atproto/lex'
 import { InvalidRequestError, Server } from '@atproto/xrpc-server'
 import { AppContext } from '../../../../context.js'
 import { com } from '../../../../lexicons/index.js'
@@ -11,7 +11,7 @@ export default function (server: Server, ctx: AppContext) {
 
     // fetch from pds if available, if not then fetch from appview
     if (did) {
-      const uri = AtUri.make(did, collection, rkey)
+      const uri = atUri(did, collection, rkey)
       const record = await ctx.actorStore.read(did, (store) =>
         store.record.getRecord(uri, cid ?? null),
       )
@@ -24,7 +24,7 @@ export default function (server: Server, ctx: AppContext) {
       return {
         encoding: 'application/json' as const,
         body: {
-          uri: uri.toString(),
+          uri,
           cid: record.cid,
           value: record.value,
         },

package/src/api/com/atproto/repo/putRecord.ts

@@ -1,3 +1,4 @@
+import { atUri } from '@atproto/lex'
 import {
   LegacyBlobRef,
   LexMap,
@@ -5,7 +6,6 @@ import {
   isLegacyBlobRef,
   parseCid,
 } from '@atproto/lex-data'
-import { AtUri } from '@atproto/syntax'
 import {
   AuthRequiredError,
   InvalidRequestError,
@@ -90,7 +90,7 @@ export default function (server: Server, ctx: AppContext) {
         })
       }
 
-      const uri = AtUri.make(did, collection, rkey)
+      const uri = atUri(did, collection, rkey)
       const swapCommitCid = swapCommit ? parseCid(swapCommit) : undefined
       const swapRecordCid =
         typeof swapRecord === 'string' ? parseCid(swapRecord) : swapRecord

package/src/api/com/atproto/sync/getRepo.ts

@@ -1,5 +1,5 @@
 import stream from 'node:stream'
-import { byteIterableToStream } from '@atproto/common'
+import { byteIterableToStream, coalesceByteStream } from '@atproto/common'
 import { InvalidRequestError, Server } from '@atproto/xrpc-server'
 import {
   RepoRootNotFoundError,
@@ -11,6 +11,8 @@ import { AppContext } from '../../../../context.js'
 import { com } from '../../../../lexicons/index.js'
 import { assertRepoAvailability } from './util.js'
 
+const CAR_STREAM_CHUNK_SIZE = 64 * 1024
+
 export default function (server: Server, ctx: AppContext) {
   server.add(com.atproto.sync.getRepo, {
     auth: ctx.authVerifier.authorizationOrAdminTokenOptional({
@@ -19,7 +21,7 @@ export default function (server: Server, ctx: AppContext) {
         // always allow
       },
     }),
-    handler: async ({ params, auth }) => {
+    handler: async ({ req, params, auth }) => {
       const { did, since } = params
       await assertRepoAvailability(ctx, did, isUserOrAdmin(auth, did))
 
@@ -27,7 +29,15 @@ export default function (server: Server, ctx: AppContext) {
 
       return {
         encoding: 'application/vnd.ipld.car' as const,
-        body: carStream,
+        // @NOTE If the client asked for compression (via "accept-encoding"), we
+        // coalesce the CAR stream into larger chunks to improve compression
+        // efficiency. See https://github.com/bluesky-social/atproto/pull/5078
+        //
+        // @TODO This would be better handled by xrpc-server and/or the
+        // compression middleware instead of manually coalescing the stream.
+        body: req.headers['accept-encoding']
+          ? coalesceByteStream(carStream, CAR_STREAM_CHUNK_SIZE)
+          : carStream,
       }
     },
   })
@@ -39,11 +49,14 @@ export const getCarStream = async (
   since?: string,
 ): Promise<stream.Readable> => {
   const actorDb = await ctx.actorStore.openDb(did)
-  let carStream: stream.Readable
   try {
     const storage = new SqlRepoReader(actorDb)
     const carIter = await storage.getCarStream(since)
-    carStream = byteIterableToStream(carIter)
+    const carStream = byteIterableToStream(carIter)
+    const closeDb = () => actorDb.close()
+    carStream.on('error', closeDb)
+    carStream.on('close', closeDb)
+    return carStream
   } catch (err) {
     await actorDb.close()
     if (err instanceof RepoRootNotFoundError) {
@@ -51,8 +64,4 @@ export const getCarStream = async (
     }
     throw err
   }
-  const closeDb = () => actorDb.close()
-  carStream.on('error', closeDb)
-  carStream.on('close', closeDb)
-  return carStream
 }

package/src/context.ts

@@ -267,25 +267,28 @@ export class AppContext {
       backgroundQueue,
     })
 
+    const plcRotationKey =
+      secrets.plcRotationKey.provider === 'kms'
+        ? await KmsKeypair.load({
+            keyId: secrets.plcRotationKey.keyId,
+          })
+        : await crypto.Secp256k1Keypair.import(
+            secrets.plcRotationKey.privateKeyHex,
+          )
+
     const accountManager = new AccountManager(
       idResolver,
       jwtSecretKey,
       mailer,
+      sequencer,
+      plcClient,
+      plcRotationKey,
       cfg.service.did,
       cfg.identity.serviceHandleDomains,
       cfg.db,
     )
     await accountManager.migrateOrThrow()
 
-    const plcRotationKey =
-      secrets.plcRotationKey.provider === 'kms'
-        ? await KmsKeypair.load({
-            keyId: secrets.plcRotationKey.keyId,
-          })
-        : await crypto.Secp256k1Keypair.import(
-            secrets.plcRotationKey.privateKeyHex,
-          )
-
     const localViewer = LocalViewer.creator(
       accountManager,
       imageUrlBuilder,

package/tests/_puppeteer.ts

@@ -85,6 +85,8 @@ export class PageHelper implements AsyncDisposable {
   async typeIn(selector: string, text: string) {
     const elementHandle = await this.getVisibleElement(selector)
     elementHandle.focus()
+    await elementHandle.click({ clickCount: 3 }) // Select all existing text
+    await elementHandle.press('Backspace') // Clear the input
     await elementHandle.type(text)
     return elementHandle
   }
@@ -93,16 +95,20 @@ export class PageHelper implements AsyncDisposable {
     return this.typeIn(`input[name=${JSON.stringify(name)}]`, text)
   }
 
-  async ensureTextVisibility(text: string, tag = 'p') {
+  async ensureTextVisibility(text: string, tag = 'p', timeout = 5_000) {
     await this.page.waitForSelector(
       `${tag}::-p-text(${JSON.stringify(text)})`,
       {
         visible: true,
-        timeout: 5_000,
+        timeout,
       },
     )
   }
 
+  async ensureNotification(text: string) {
+    return this.ensureTextVisibility(text, 'div')
+  }
+
   protected async getVisibleElement(selector: string) {
     const elementHandle = await this.page.waitForSelector(selector, {
       visible: true,