@atproto/pds 0.4.103 → 0.4.105

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

@@ -1,4 +1,3 @@
-import assert from 'node:assert'
 import { InvalidRequestError } from '@atproto/xrpc-server'
 import { AuthScope } from '../../../../auth-verifier'
 import { AppContext } from '../../../../context'
@@ -8,14 +7,13 @@ import { ids } from '../../../../lexicon/lexicons'
 export default function (server: Server, ctx: AppContext) {
   server.com.atproto.identity.requestPlcOperationSignature({
     auth: ctx.authVerifier.accessFull({ additional: [AuthScope.Takendown] }),
-    handler: async ({ auth }) => {
+    handler: async ({ auth, req }) => {
       if (ctx.entrywayAgent) {
-        assert(ctx.cfg.entryway)
         await ctx.entrywayAgent.com.atproto.identity.requestPlcOperationSignature(
           undefined,
-          await ctx.serviceAuthHeaders(
+          await ctx.entrywayAuthHeaders(
+            req,
             auth.credentials.did,
-            ctx.cfg.entryway.did,
             ids.ComAtprotoIdentityRequestPlcOperationSignature,
           ),
         )

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

@@ -1,20 +1,11 @@
-import * as ident from '@atproto/syntax'
 import { InvalidRequestError } from '@atproto/xrpc-server'
 import { AppContext } from '../../../../context'
+import { baseNormalizeAndValidate } from '../../../../handle'
 import { Server } from '../../../../lexicon'
 
 export default function (server: Server, ctx: AppContext) {
   server.com.atproto.identity.resolveHandle(async ({ params }) => {
-    let handle: string
-    try {
-      handle = ident.normalizeAndEnsureValidHandle(params.handle)
-    } catch (err) {
-      if (err instanceof ident.InvalidHandleError) {
-        throw new InvalidRequestError(err.message, 'InvalidHandle')
-      } else {
-        throw err
-      }
-    }
+    const handle = baseNormalizeAndValidate(params.handle)
 
     let did: string | undefined
     const user = await ctx.accountManager.getAccount(handle)

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

@@ -1,4 +1,3 @@
-import assert from 'node:assert'
 import * as plc from '@did-plc/lib'
 import { check } from '@atproto/common'
 import { InvalidRequestError } from '@atproto/xrpc-server'
@@ -10,15 +9,14 @@ import { resultPassthru } from '../../../proxy'
 export default function (server: Server, ctx: AppContext) {
   server.com.atproto.identity.signPlcOperation({
     auth: ctx.authVerifier.accessFull(),
-    handler: async ({ auth, input }) => {
+    handler: async ({ auth, input, req }) => {
       if (ctx.entrywayAgent) {
-        assert(ctx.cfg.entryway)
         return resultPassthru(
           await ctx.entrywayAgent.com.atproto.identity.signPlcOperation(
             input.body,
-            await ctx.serviceAuthHeaders(
+            await ctx.entrywayAuthHeaders(
+              req,
               auth.credentials.did,
-              ctx.cfg.entryway.did,
               ids.ComAtprotoIdentitySignPlcOperation,
             ),
           ),

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

@@ -1,8 +1,6 @@
-import assert from 'node:assert'
 import { DAY, MINUTE } from '@atproto/common'
 import { InvalidRequestError } from '@atproto/xrpc-server'
 import { AppContext } from '../../../../context'
-import { normalizeAndValidateHandle } from '../../../../handle'
 import { Server } from '../../../../lexicon'
 import { ids } from '../../../../lexicon/lexicons'
 import { httpLogger } from '../../../../logger'
@@ -22,32 +20,29 @@ export default function (server: Server, ctx: AppContext) {
         calcKey: ({ auth }) => auth.credentials.did,
       },
     ],
-    handler: async ({ auth, input }) => {
+    handler: async ({ auth, input, req }) => {
       const requester = auth.credentials.did
 
       if (ctx.entrywayAgent) {
-        assert(ctx.cfg.entryway)
-
         // the full flow is:
         // -> entryway(identity.updateHandle) [update handle, submit plc op]
         // -> pds(admin.updateAccountHandle)  [track handle, sequence handle update]
         await ctx.entrywayAgent.com.atproto.identity.updateHandle(
           // @ts-expect-error "did" is not in the schema
           { did: requester, handle: input.body.handle },
-          await ctx.serviceAuthHeaders(
+          await ctx.entrywayAuthHeaders(
+            req,
             auth.credentials.did,
-            ctx.cfg.entryway.did,
             ids.ComAtprotoIdentityUpdateHandle,
           ),
         )
         return
       }
 
-      const handle = await normalizeAndValidateHandle({
-        ctx,
-        handle: input.body.handle,
-        did: requester,
-      })
+      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, {
@@ -82,7 +77,6 @@ export default function (server: Server, ctx: AppContext) {
       }
 
       try {
-        await ctx.sequencer.sequenceHandleUpdate(requester, handle)
         await ctx.sequencer.sequenceIdentityEvt(requester, handle)
       } catch (err) {
         httpLogger.error(

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

@@ -12,6 +12,7 @@ import {
   isDelete,
   isUpdate,
 } from '../../../../lexicon/types/com/atproto/repo/applyWrites'
+import { dbLogger } from '../../../../logger'
 import {
   BadCommitSwapError,
   InvalidRecordError,
@@ -119,19 +120,28 @@ export default function (server: Server, ctx: AppContext) {
       const swapCommitCid = swapCommit ? CID.parse(swapCommit) : undefined
 
       const commit = await ctx.actorStore.transact(did, async (actorTxn) => {
-        try {
-          return await actorTxn.repo.processWrites(writes, swapCommitCid)
-        } catch (err) {
-          if (err instanceof BadCommitSwapError) {
-            throw new InvalidRequestError(err.message, 'InvalidSwap')
-          } else {
-            throw err
-          }
-        }
+        const commit = await actorTxn.repo
+          .processWrites(writes, swapCommitCid)
+          .catch((err) => {
+            if (err instanceof BadCommitSwapError) {
+              throw new InvalidRequestError(err.message, 'InvalidSwap')
+            } else {
+              throw err
+            }
+          })
+
+        await ctx.sequencer.sequenceCommit(did, commit)
+        return commit
       })
 
-      await ctx.sequencer.sequenceCommit(did, commit)
-      await ctx.accountManager.updateRepoRoot(did, commit.cid, commit.rev)
+      await ctx.accountManager
+        .updateRepoRoot(did, commit.cid, commit.rev)
+        .catch((err) => {
+          dbLogger.error(
+            { err, did, cid: commit.cid, rev: commit.rev },
+            'failed to update account root',
+          )
+        })
 
       return {
         encoding: 'application/json',

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

@@ -3,6 +3,7 @@ import { InvalidRecordKeyError } from '@atproto/syntax'
 import { AuthRequiredError, InvalidRequestError } from '@atproto/xrpc-server'
 import { AppContext } from '../../../../context'
 import { Server } from '../../../../lexicon'
+import { dbLogger } from '../../../../logger'
 import {
   BadCommitSwapError,
   InvalidRecordError,
@@ -82,22 +83,26 @@ export default function (server: Server, ctx: AppContext) {
           }),
         )
         const writes = [...backlinkDeletions, write]
-        try {
-          const commit = await actorTxn.repo.processWrites(
-            writes,
-            swapCommitCid,
-          )
-          return commit
-        } catch (err) {
-          if (err instanceof BadCommitSwapError) {
-            throw new InvalidRequestError(err.message, 'InvalidSwap')
-          }
-          throw err
-        }
+        const commit = await actorTxn.repo
+          .processWrites(writes, swapCommitCid)
+          .catch((err) => {
+            if (err instanceof BadCommitSwapError) {
+              throw new InvalidRequestError(err.message, 'InvalidSwap')
+            }
+            throw err
+          })
+        await ctx.sequencer.sequenceCommit(did, commit)
+        return commit
       })
 
-      await ctx.sequencer.sequenceCommit(did, commit)
-      await ctx.accountManager.updateRepoRoot(did, commit.cid, commit.rev)
+      await ctx.accountManager
+        .updateRepoRoot(did, commit.cid, commit.rev)
+        .catch((err) => {
+          dbLogger.error(
+            { err, did, cid: commit.cid, rev: commit.rev },
+            'failed to update account root',
+          )
+        })
 
       return {
         encoding: 'application/json',

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

@@ -2,6 +2,7 @@ import { CID } from 'multiformats/cid'
 import { AuthRequiredError, InvalidRequestError } from '@atproto/xrpc-server'
 import { AppContext } from '../../../../context'
 import { Server } from '../../../../lexicon'
+import { dbLogger } from '../../../../logger'
 import {
   BadCommitSwapError,
   BadRecordSwapError,
@@ -56,24 +57,35 @@ export default function (server: Server, ctx: AppContext) {
         if (!record) {
           return null // No-op if record already doesn't exist
         }
-        try {
-          return await actorTxn.repo.processWrites([write], swapCommitCid)
-        } catch (err) {
-          if (
-            err instanceof BadCommitSwapError ||
-            err instanceof BadRecordSwapError
-          ) {
-            throw new InvalidRequestError(err.message, 'InvalidSwap')
-          } else {
-            throw err
-          }
-        }
+
+        const commit = await actorTxn.repo
+          .processWrites([write], swapCommitCid)
+          .catch((err) => {
+            if (
+              err instanceof BadCommitSwapError ||
+              err instanceof BadRecordSwapError
+            ) {
+              throw new InvalidRequestError(err.message, 'InvalidSwap')
+            } else {
+              throw err
+            }
+          })
+
+        await ctx.sequencer.sequenceCommit(did, commit)
+        return commit
       })
 
       if (commit !== null) {
-        await ctx.sequencer.sequenceCommit(did, commit)
-        await ctx.accountManager.updateRepoRoot(did, commit.cid, commit.rev)
+        await ctx.accountManager
+          .updateRepoRoot(did, commit.cid, commit.rev)
+          .catch((err) => {
+            dbLogger.error(
+              { err, did, cid: commit.cid, rev: commit.rev },
+              'failed to update account root',
+            )
+          })
       }
+
       return {
         encoding: 'application/json',
         body: {

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

@@ -5,15 +5,7 @@ import { Server } from '../../../../lexicon'
 
 export default function (server: Server, ctx: AppContext) {
   server.com.atproto.repo.listRecords(async ({ params }) => {
-    const {
-      repo,
-      collection,
-      limit = 50,
-      cursor,
-      rkeyStart,
-      rkeyEnd,
-      reverse = false,
-    } = params
+    const { repo, collection, limit = 50, cursor, reverse = false } = params
 
     const did = await ctx.accountManager.getDidForActor(repo)
     if (!did) {
@@ -26,8 +18,6 @@ export default function (server: Server, ctx: AppContext) {
         limit,
         reverse,
         cursor,
-        rkeyStart,
-        rkeyEnd,
       }),
     )
 

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

@@ -7,10 +7,10 @@ import { AppContext } from '../../../../context'
 import { Server } from '../../../../lexicon'
 import { ids } from '../../../../lexicon/lexicons'
 import { Record as ProfileRecord } from '../../../../lexicon/types/app/bsky/actor/profile'
+import { dbLogger } from '../../../../logger'
 import {
   BadCommitSwapError,
   BadRecordSwapError,
-  CommitDataWithOps,
   InvalidRecordError,
   PreparedCreate,
   PreparedUpdate,
@@ -104,26 +104,34 @@ export default function (server: Server, ctx: AppContext) {
             }
           }
 
-          let commit: CommitDataWithOps
-          try {
-            commit = await actorTxn.repo.processWrites([write], swapCommitCid)
-          } catch (err) {
-            if (
-              err instanceof BadCommitSwapError ||
-              err instanceof BadRecordSwapError
-            ) {
-              throw new InvalidRequestError(err.message, 'InvalidSwap')
-            } else {
-              throw err
-            }
-          }
+          const commit = await actorTxn.repo
+            .processWrites([write], swapCommitCid)
+            .catch((err) => {
+              if (
+                err instanceof BadCommitSwapError ||
+                err instanceof BadRecordSwapError
+              ) {
+                throw new InvalidRequestError(err.message, 'InvalidSwap')
+              } else {
+                throw err
+              }
+            })
+
+          await ctx.sequencer.sequenceCommit(did, commit)
+
           return { commit, write }
         },
       )
 
       if (commit !== null) {
-        await ctx.sequencer.sequenceCommit(did, commit)
-        await ctx.accountManager.updateRepoRoot(did, commit.cid, commit.rev)
+        await ctx.accountManager
+          .updateRepoRoot(did, commit.cid, commit.rev)
+          .catch((err) => {
+            dbLogger.error(
+              { err, did, cid: commit.cid, rev: commit.rev },
+              'failed to update account root',
+            )
+          })
       }
 
       return {

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

@@ -1,9 +1,7 @@
-import { CidSet } from '@atproto/repo'
 import { INVALID_HANDLE } from '@atproto/syntax'
 import { InvalidRequestError } from '@atproto/xrpc-server'
 import { AppContext } from '../../../../context'
 import { Server } from '../../../../lexicon'
-import { authPassthru } from '../../../proxy'
 import { assertValidDidDocumentForService } from './util'
 
 export default function (server: Server, ctx: AppContext) {
@@ -14,7 +12,7 @@ export default function (server: Server, ctx: AppContext) {
       if (ctx.entrywayAgent) {
         await ctx.entrywayAgent.com.atproto.server.activateAccount(
           undefined,
-          authPassthru(req),
+          ctx.entrywayPassthruHeaders(req),
         )
         return
       }
@@ -32,22 +30,9 @@ export default function (server: Server, ctx: AppContext) {
 
       await ctx.accountManager.activateAccount(requester)
 
-      const commitData = await ctx.actorStore.read(requester, async (store) => {
-        const root = await store.repo.storage.getRootDetailed()
-        const blocks = await store.repo.storage.getBlocks([root.cid])
-        return {
-          cid: root.cid,
-          rev: root.rev,
-          since: null,
-          prev: null,
-          newBlocks: blocks.blocks,
-          relevantBlocks: blocks.blocks,
-          removedCids: new CidSet(),
-          ops: [],
-          blobs: new CidSet(),
-          prevData: null,
-        }
-      })
+      const syncData = await ctx.actorStore.read(requester, (store) =>
+        store.repo.getSyncEventData(),
+      )
 
       // @NOTE: we're over-emitting for now for backwards compatibility, can reduce this in the future
       const status = await ctx.accountManager.getAccountStatus(requester)
@@ -56,7 +41,7 @@ export default function (server: Server, ctx: AppContext) {
         requester,
         account.handle ?? INVALID_HANDLE,
       )
-      await ctx.sequencer.sequenceCommit(requester, commitData)
+      await ctx.sequencer.sequenceSyncEvt(requester, syncData)
     },
   })
 }

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

@@ -1,4 +1,3 @@
-import assert from 'node:assert'
 import { InvalidRequestError } from '@atproto/xrpc-server'
 import { AppContext } from '../../../../context'
 import { Server } from '../../../../lexicon'
@@ -7,7 +6,7 @@ import { ids } from '../../../../lexicon/lexicons'
 export default function (server: Server, ctx: AppContext) {
   server.com.atproto.server.confirmEmail({
     auth: ctx.authVerifier.accessStandard({ checkTakedown: true }),
-    handler: async ({ auth, input }) => {
+    handler: async ({ auth, input, req }) => {
       const did = auth.credentials.did
 
       const user = await ctx.accountManager.getAccount(did, {
@@ -18,12 +17,11 @@ export default function (server: Server, ctx: AppContext) {
       }
 
       if (ctx.entrywayAgent) {
-        assert(ctx.cfg.entryway)
         await ctx.entrywayAgent.com.atproto.server.confirmEmail(
           input.body,
-          await ctx.serviceAuthHeaders(
+          await ctx.entrywayAuthHeaders(
+            req,
             auth.credentials.did,
-            ctx.cfg.entryway.did,
             ids.ComAtprotoServerConfirmEmail,
           ),
         )

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

@@ -5,12 +5,9 @@ import { DidDocument, MINUTE, check } from '@atproto/common'
 import { ExportableKeypair, Keypair, Secp256k1Keypair } from '@atproto/crypto'
 import { AtprotoData, ensureAtpDocument } from '@atproto/identity'
 import { AuthRequiredError, InvalidRequestError } from '@atproto/xrpc-server'
-import { AccountStatus } from '../../../../account-manager'
+import { AccountStatus } from '../../../../account-manager/account-manager'
 import { AppContext } from '../../../../context'
-import {
-  baseNormalizeAndValidate,
-  normalizeAndValidateHandle,
-} from '../../../../handle'
+import { baseNormalizeAndValidate } from '../../../../handle'
 import { Server } from '../../../../lexicon'
 import { InputSchema as CreateAccountInput } from '../../../../lexicon/types/com/atproto/server/createAccount'
 import { safeResolveDidDoc } from './util'
@@ -23,6 +20,9 @@ export default function (server: Server, ctx: AppContext) {
     },
     auth: ctx.authVerifier.userServiceAuthOptional,
     handler: async ({ input, auth, req }) => {
+      // @NOTE Until this code and the OAuthStore's `createAccount` are
+      // refactored together, any change made here must be reflected over there.
+
       const requester = auth.credentials?.did ?? null
       const {
         did,
@@ -60,7 +60,7 @@ export default function (server: Server, ctx: AppContext) {
 
         didDoc = await safeResolveDidDoc(ctx, did, true)
 
-        creds = await ctx.accountManager.createAccount({
+        creds = await ctx.accountManager.createAccountAndSession({
           did,
           handle,
           email,
@@ -183,11 +183,10 @@ const validateInputsForLocalPds = async (
   }
 
   // normalize & ensure valid handle
-  const handle = await normalizeAndValidateHandle({
-    ctx,
-    handle: input.handle,
-    did: input.did,
-  })
+  const handle = await ctx.accountManager.normalizeAndValidateHandle(
+    input.handle,
+    { did: input.did },
+  )
 
   // check that the invite code still has uses
   if (ctx.cfg.invites.required && inviteCode) {

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

@@ -1,4 +1,3 @@
-import assert from 'node:assert'
 import { AppContext } from '../../../../context'
 import { Server } from '../../../../lexicon'
 import { ids } from '../../../../lexicon/lexicons'
@@ -9,16 +8,14 @@ export default function (server: Server, ctx: AppContext) {
     auth: ctx.authVerifier.accessFull({
       checkTakedown: true,
     }),
-    handler: async ({ auth, input }) => {
+    handler: async ({ auth, input, req }) => {
       if (ctx.entrywayAgent) {
-        assert(ctx.cfg.entryway)
-
         return resultPassthru(
           await ctx.entrywayAgent.com.atproto.server.createAppPassword(
             input.body,
-            await ctx.serviceAuthHeaders(
+            await ctx.entrywayAuthHeaders(
+              req,
               auth.credentials.did,
-              ctx.cfg.entryway.did,
               ids.ComAtprotoServerCreateAppPassword,
             ),
           ),

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

@@ -1,10 +1,10 @@
 import { DAY, MINUTE } from '@atproto/common'
 import { INVALID_HANDLE } from '@atproto/syntax'
 import { AuthRequiredError } from '@atproto/xrpc-server'
-import { formatAccountStatus } from '../../../../account-manager'
+import { formatAccountStatus } from '../../../../account-manager/account-manager'
 import { AppContext } from '../../../../context'
 import { Server } from '../../../../lexicon'
-import { authPassthru, resultPassthru } from '../../../proxy'
+import { resultPassthru } from '../../../proxy'
 import { didDocForSession } from './util'
 
 export default function (server: Server, ctx: AppContext) {
@@ -26,7 +26,7 @@ export default function (server: Server, ctx: AppContext) {
         return resultPassthru(
           await ctx.entrywayAgent.com.atproto.server.createSession(
             input.body,
-            authPassthru(req, true),
+            ctx.entrywayPassthruHeaders(req),
           ),
         )
       }

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

@@ -1,7 +1,6 @@
 import { AuthScope } from '../../../../auth-verifier'
 import { AppContext } from '../../../../context'
 import { Server } from '../../../../lexicon'
-import { authPassthru } from '../../../proxy'
 
 export default function (server: Server, ctx: AppContext) {
   server.com.atproto.server.deactivateAccount({
@@ -11,7 +10,7 @@ export default function (server: Server, ctx: AppContext) {
       if (ctx.entrywayAgent) {
         await ctx.entrywayAgent.com.atproto.server.deactivateAccount(
           input.body,
-          authPassthru(req),
+          ctx.entrywayPassthruHeaders(req),
         )
         return
       }

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

@@ -1,9 +1,8 @@
 import { MINUTE } from '@atproto/common'
 import { AuthRequiredError, InvalidRequestError } from '@atproto/xrpc-server'
-import { AccountStatus } from '../../../../account-manager'
+import { AccountStatus } from '../../../../account-manager/account-manager'
 import { AppContext } from '../../../../context'
 import { Server } from '../../../../lexicon'
-import { authPassthru } from '../../../proxy'
 
 export default function (server: Server, ctx: AppContext) {
   server.com.atproto.server.deleteAccount({
@@ -25,7 +24,7 @@ export default function (server: Server, ctx: AppContext) {
       if (ctx.entrywayAgent) {
         await ctx.entrywayAgent.com.atproto.server.deleteAccount(
           input.body,
-          authPassthru(req, true),
+          ctx.entrywayPassthruHeaders(req),
         )
         return
       }
@@ -49,8 +48,7 @@ export default function (server: Server, ctx: AppContext) {
         did,
         AccountStatus.Deleted,
       )
-      const tombstoneSeq = await ctx.sequencer.sequenceTombstone(did)
-      await ctx.sequencer.deleteAllForUser(did, [accountSeq, tombstoneSeq])
+      await ctx.sequencer.deleteAllForUser(did, [accountSeq])
     },
   })
 }

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

@@ -1,14 +1,13 @@
 import { AppContext } from '../../../../context'
 import { Server } from '../../../../lexicon'
-import { authPassthru } from '../../../proxy'
 
 export default function (server: Server, ctx: AppContext) {
   const { entrywayAgent } = ctx
   if (entrywayAgent) {
-    server.com.atproto.server.deleteSession(async (reqCtx) => {
+    server.com.atproto.server.deleteSession(async ({ req }) => {
       await entrywayAgent.com.atproto.server.deleteSession(
         undefined,
-        authPassthru(reqCtx.req),
+        ctx.entrywayPassthruHeaders(req),
       )
     })
   } else {

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

@@ -1,4 +1,3 @@
-import assert from 'node:assert'
 import { InvalidRequestError } from '@atproto/xrpc-server'
 import { CodeDetail } from '../../../../account-manager/helpers/invite'
 import { AppContext } from '../../../../context'
@@ -10,15 +9,14 @@ import { genInvCodes } from './util'
 export default function (server: Server, ctx: AppContext) {
   server.com.atproto.server.getAccountInviteCodes({
     auth: ctx.authVerifier.accessFull({ checkTakedown: true }),
-    handler: async ({ params, auth }) => {
+    handler: async ({ params, auth, req }) => {
       if (ctx.entrywayAgent) {
-        assert(ctx.cfg.entryway)
         return resultPassthru(
           await ctx.entrywayAgent.com.atproto.server.getAccountInviteCodes(
             params,
-            await ctx.serviceAuthHeaders(
+            await ctx.entrywayAuthHeaders(
+              req,
               auth.credentials.did,
-              ctx.cfg.entryway.did,
               ids.ComAtprotoServerGetAccountInviteCodes,
             ),
           ),