@atproto/pds 0.4.215 → 0.4.217

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

@@ -1,16 +1,22 @@
-import { INVALID_HANDLE } from '@atproto/syntax'
-import { AuthRequiredError, InvalidRequestError } from '@atproto/xrpc-server'
+import { DidString, HandleString, INVALID_HANDLE } from '@atproto/syntax'
+import {
+  AuthRequiredError,
+  InvalidRequestError,
+  Server,
+} from '@atproto/xrpc-server'
 import { formatAccountStatus } from '../../../../account-manager/account-manager'
 import { AppContext } from '../../../../context'
 import { softDeleted } from '../../../../db/util'
-import { Server } from '../../../../lexicon'
-import { resultPassthru } from '../../../proxy'
+import { com } from '../../../../lexicons/index.js'
 import { didDocForSession } from './util'
 
 export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.server.refreshSession({
+  server.add(com.atproto.server.refreshSession, {
     auth: ctx.authVerifier.refresh(),
-    handler: async ({ auth, req }) => {
+    handler: async ({
+      auth,
+      req,
+    }): Promise<com.atproto.server.refreshSession.$Output> => {
       const did = auth.credentials.did
       const user = await ctx.accountManager.getAccount(did, {
         includeDeactivated: true,
@@ -28,13 +34,11 @@ export default function (server: Server, ctx: AppContext) {
         )
       }
 
-      if (ctx.entrywayAgent) {
-        return resultPassthru(
-          await ctx.entrywayAgent.com.atproto.server.refreshSession(
-            undefined,
-            ctx.entrywayPassthruHeaders(req),
-          ),
-        )
+      if (ctx.entrywayClient) {
+        const { headers } = ctx.entrywayPassthruHeaders(req)
+        return ctx.entrywayClient.xrpc(com.atproto.server.refreshSession, {
+          headers,
+        })
       }
 
       const [didDoc, rotated] = await Promise.all([
@@ -48,14 +52,15 @@ export default function (server: Server, ctx: AppContext) {
       const { status, active } = formatAccountStatus(user)
 
       return {
-        encoding: 'application/json',
+        encoding: 'application/json' as const,
         body: {
           accessJwt: rotated.accessJwt,
           refreshJwt: rotated.refreshJwt,
 
-          did: user.did,
+          did: user.did as DidString,
+          // @ts-expect-error https://github.com/bluesky-social/atproto/pull/4406
           didDoc,
-          handle: user.handle ?? INVALID_HANDLE,
+          handle: (user.handle ?? INVALID_HANDLE) as HandleString,
           email: user.email ?? undefined,
           emailConfirmed: !!user.emailConfirmedAt,
           active,

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

@@ -1,12 +1,15 @@
 import { DAY, HOUR } from '@atproto/common'
-import { ForbiddenError, InvalidRequestError } from '@atproto/xrpc-server'
+import {
+  ForbiddenError,
+  InvalidRequestError,
+  Server,
+} from '@atproto/xrpc-server'
 import { ACCESS_FULL } from '../../../../auth-scope'
 import { AppContext } from '../../../../context'
-import { Server } from '../../../../lexicon'
-import { ids } from '../../../../lexicon/lexicons'
+import { com } from '../../../../lexicons/index.js'
 
 export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.server.requestAccountDelete({
+  server.add(com.atproto.server.requestAccountDelete, {
     rateLimit: [
       {
         durationMs: DAY,
@@ -38,15 +41,15 @@ export default function (server: Server, ctx: AppContext) {
         throw new InvalidRequestError('account not found')
       }
 
-      if (ctx.entrywayAgent) {
-        await ctx.entrywayAgent.com.atproto.server.requestAccountDelete(
-          undefined,
-          await ctx.entrywayAuthHeaders(
-            req,
-            auth.credentials.did,
-            ids.ComAtprotoServerRequestAccountDelete,
-          ),
+      if (ctx.entrywayClient) {
+        const { headers } = await ctx.entrywayAuthHeaders(
+          req,
+          auth.credentials.did,
+          com.atproto.server.requestAccountDelete.$lxm,
         )
+        await ctx.entrywayClient.xrpc(com.atproto.server.requestAccountDelete, {
+          headers,
+        })
         return
       }
 

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

@@ -1,11 +1,10 @@
 import { DAY, HOUR } from '@atproto/common'
-import { InvalidRequestError } from '@atproto/xrpc-server'
+import { InvalidRequestError, Server } from '@atproto/xrpc-server'
 import { AppContext } from '../../../../context'
-import { Server } from '../../../../lexicon'
-import { ids } from '../../../../lexicon/lexicons'
+import { com } from '../../../../lexicons/index.js'
 
 export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.server.requestEmailConfirmation({
+  server.add(com.atproto.server.requestEmailConfirmation, {
     rateLimit: [
       {
         durationMs: DAY,
@@ -34,15 +33,18 @@ export default function (server: Server, ctx: AppContext) {
         throw new InvalidRequestError('account not found')
       }
 
-      if (ctx.entrywayAgent) {
-        await ctx.entrywayAgent.com.atproto.server.requestEmailConfirmation(
-          undefined,
-          await ctx.entrywayAuthHeaders(
-            req,
-            auth.credentials.did,
-            ids.ComAtprotoServerRequestEmailConfirmation,
-          ),
+      if (ctx.entrywayClient) {
+        const { headers } = await ctx.entrywayAuthHeaders(
+          req,
+          auth.credentials.did,
+          com.atproto.server.requestEmailConfirmation.$lxm,
         )
+
+        await ctx.entrywayClient.xrpc(
+          com.atproto.server.requestEmailConfirmation,
+          { headers },
+        )
+
         return
       }
 

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

@@ -1,12 +1,12 @@
 import { DAY, HOUR } from '@atproto/common'
-import { InvalidRequestError } from '@atproto/xrpc-server'
+import { InvalidRequestError, Server } from '@atproto/xrpc-server'
 import { AppContext } from '../../../../context'
-import { Server } from '../../../../lexicon'
-import { ids } from '../../../../lexicon/lexicons'
-import { resultPassthru } from '../../../proxy'
+import { com } from '../../../../lexicons/index.js'
 
 export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.server.requestEmailUpdate({
+  const { entrywayClient } = ctx
+
+  server.add(com.atproto.server.requestEmailUpdate, {
     rateLimit: [
       {
         durationMs: DAY,
@@ -35,17 +35,15 @@ export default function (server: Server, ctx: AppContext) {
         throw new InvalidRequestError('account not found')
       }
 
-      if (ctx.entrywayAgent) {
-        return resultPassthru(
-          await ctx.entrywayAgent.com.atproto.server.requestEmailUpdate(
-            undefined,
-            await ctx.entrywayAuthHeaders(
-              req,
-              auth.credentials.did,
-              ids.ComAtprotoServerRequestEmailUpdate,
-            ),
-          ),
+      if (entrywayClient) {
+        const { headers } = await ctx.entrywayAuthHeaders(
+          req,
+          auth.credentials.did,
+          com.atproto.server.requestEmailUpdate.$lxm,
         )
+        return entrywayClient.xrpc(com.atproto.server.requestEmailUpdate, {
+          headers,
+        })
       }
 
       if (!account.email) {
@@ -62,7 +60,7 @@ export default function (server: Server, ctx: AppContext) {
       }
 
       return {
-        encoding: 'application/json',
+        encoding: 'application/json' as const,
         body: {
           tokenRequired,
         },

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

@@ -1,10 +1,12 @@
 import { DAY, HOUR } from '@atproto/common'
-import { InvalidRequestError } from '@atproto/xrpc-server'
+import { InvalidRequestError, Server } from '@atproto/xrpc-server'
 import { AppContext } from '../../../../context'
-import { Server } from '../../../../lexicon'
+import { com } from '../../../../lexicons/index.js'
 
 export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.server.requestPasswordReset({
+  const { entrywayClient } = ctx
+
+  server.add(com.atproto.server.requestPasswordReset, {
     rateLimit: [
       {
         durationMs: DAY,
@@ -15,33 +17,36 @@ export default function (server: Server, ctx: AppContext) {
         points: 15,
       },
     ],
-    handler: async ({ input, req }) => {
-      const email = input.body.email.toLowerCase()
+    handler: async ({ input: { body }, req }) => {
+      const email = body.email.toLowerCase()
 
       const account = await ctx.accountManager.getAccountByEmail(email, {
         includeDeactivated: true,
         includeTakenDown: true,
       })
 
-      if (!account?.email) {
-        if (ctx.entrywayAgent) {
-          await ctx.entrywayAgent.com.atproto.server.requestPasswordReset(
-            input.body,
-            ctx.entrywayPassthruHeaders(req),
-          )
-          return
-        }
-        throw new InvalidRequestError('account does not have an email address')
+      if (account?.email) {
+        const token = await ctx.accountManager.createEmailToken(
+          account.did,
+          'reset_password',
+        )
+        await ctx.mailer.sendResetPassword(
+          { handle: account.handle ?? account.email, token },
+          { to: account.email },
+        )
+        return
+      }
+
+      if (entrywayClient) {
+        const { headers } = ctx.entrywayPassthruHeaders(req)
+        await entrywayClient.xrpc(com.atproto.server.requestPasswordReset, {
+          headers,
+          body,
+        })
+        return
       }
 
-      const token = await ctx.accountManager.createEmailToken(
-        account.did,
-        'reset_password',
-      )
-      await ctx.mailer.sendResetPassword(
-        { handle: account.handle ?? account.email, token },
-        { to: account.email },
-      )
+      throw new InvalidRequestError('account does not have an email address')
     },
   })
 }

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

@@ -1,15 +1,14 @@
+import { Server } from '@atproto/xrpc-server'
 import { AppContext } from '../../../../context'
-import { Server } from '../../../../lexicon'
+import { com } from '../../../../lexicons/index.js'
 
 export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.server.reserveSigningKey({
+  server.add(com.atproto.server.reserveSigningKey, {
     handler: async ({ input }) => {
       const signingKey = await ctx.actorStore.reserveKeypair(input.body.did)
       return {
-        encoding: 'application/json',
-        body: {
-          signingKey,
-        },
+        encoding: 'application/json' as const,
+        body: { signingKey },
       }
     },
   })

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

@@ -1,33 +1,50 @@
 import { MINUTE } from '@atproto/common'
-import { InvalidRequestError } from '@atproto/xrpc-server'
+import {
+  InvalidRequestError,
+  MethodRateLimit,
+  Server,
+} from '@atproto/xrpc-server'
 import { NEW_PASSWORD_MAX_LENGTH } from '../../../../account-manager/helpers/scrypt'
 import { AppContext } from '../../../../context'
-import { Server } from '../../../../lexicon'
+import { com } from '../../../../lexicons/index.js'
 
 export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.server.resetPassword({
-    rateLimit: [
-      {
-        durationMs: 5 * MINUTE,
-        points: 50,
-      },
-    ],
-    handler: async ({ input, req }) => {
-      if (ctx.entrywayAgent) {
-        await ctx.entrywayAgent.com.atproto.server.resetPassword(
-          input.body,
-          ctx.entrywayPassthruHeaders(req),
-        )
-        return
-      }
+  const { entrywayClient } = ctx
+
+  const rateLimit: MethodRateLimit<
+    void,
+    com.atproto.server.resetPassword.$Params,
+    com.atproto.server.resetPassword.$Input
+  > = [
+    {
+      durationMs: 5 * MINUTE,
+      points: 50,
+    },
+  ]
 
-      const { token, password } = input.body
+  if (entrywayClient) {
+    server.add(com.atproto.server.resetPassword, {
+      rateLimit,
+      handler: async ({ input: { body }, req }) => {
+        const { headers } = ctx.entrywayPassthruHeaders(req)
+        await entrywayClient.xrpc(com.atproto.server.resetPassword, {
+          headers,
+          body,
+        })
+      },
+    })
+  } else {
+    server.add(com.atproto.server.resetPassword, {
+      rateLimit,
+      handler: async ({ input: { body } }) => {
+        const { token, password } = body
 
-      if (password.length > NEW_PASSWORD_MAX_LENGTH) {
-        throw new InvalidRequestError('Invalid password length.')
-      }
+        if (password.length > NEW_PASSWORD_MAX_LENGTH) {
+          throw new InvalidRequestError('Invalid password length.')
+        }
 
-      await ctx.accountManager.resetPassword({ token, password })
-    },
-  })
+        await ctx.accountManager.resetPassword({ token, password })
+      },
+    })
+  }
 }

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

@@ -1,34 +1,42 @@
-import { ForbiddenError } from '@atproto/xrpc-server'
+import { ForbiddenError, Server } from '@atproto/xrpc-server'
 import { AppContext } from '../../../../context'
-import { Server } from '../../../../lexicon'
-import { ids } from '../../../../lexicon/lexicons'
+import { com } from '../../../../lexicons/index.js'
 
 export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.server.revokeAppPassword({
-    auth: ctx.authVerifier.authorization({
-      authorize: () => {
-        throw new ForbiddenError(
-          'OAuth credentials are not supported for this endpoint',
-        )
-      },
-    }),
-    handler: async ({ auth, input, req }) => {
-      if (ctx.entrywayAgent) {
-        await ctx.entrywayAgent.com.atproto.server.revokeAppPassword(
-          input.body,
-          await ctx.entrywayAuthHeaders(
-            req,
-            auth.credentials.did,
-            ids.ComAtprotoServerRevokeAppPassword,
-          ),
-        )
-        return
-      }
+  const { entrywayClient } = ctx
 
-      const requester = auth.credentials.did
-      const { name } = input.body
-
-      await ctx.accountManager.revokeAppPassword(requester, name)
+  const auth = ctx.authVerifier.authorization({
+    authorize: () => {
+      throw new ForbiddenError(
+        'OAuth credentials are not supported for this endpoint',
+      )
     },
   })
+
+  if (entrywayClient) {
+    server.add(com.atproto.server.revokeAppPassword, {
+      auth,
+      handler: async ({ auth, input: { body }, req }) => {
+        const { headers } = await ctx.entrywayAuthHeaders(
+          req,
+          auth.credentials.did,
+          com.atproto.server.revokeAppPassword.$lxm,
+        )
+
+        await entrywayClient.xrpc(com.atproto.server.revokeAppPassword, {
+          headers,
+          body,
+        })
+      },
+    })
+  } else {
+    server.add(com.atproto.server.revokeAppPassword, {
+      auth,
+      handler: async ({ auth, input: { body } }) => {
+        const requester = auth.credentials.did
+
+        await ctx.accountManager.revokeAppPassword(requester, body.name)
+      },
+    })
+  }
 }

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

@@ -1,14 +1,17 @@
 import { isEmailValid } from '@hapi/address'
 import { isDisposableEmail } from 'disposable-email-domains-js'
-import { ForbiddenError, InvalidRequestError } from '@atproto/xrpc-server'
+import {
+  ForbiddenError,
+  InvalidRequestError,
+  Server,
+} from '@atproto/xrpc-server'
 import { UserAlreadyExistsError } from '../../../../account-manager/helpers/account'
 import { ACCESS_FULL } from '../../../../auth-scope'
 import { AppContext } from '../../../../context'
-import { Server } from '../../../../lexicon'
-import { ids } from '../../../../lexicon/lexicons'
+import { com } from '../../../../lexicons/index.js'
 
 export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.server.updateEmail({
+  server.add(com.atproto.server.updateEmail, {
     auth: ctx.authVerifier.authorization({
       checkTakedown: true,
       scopes: ACCESS_FULL,
@@ -18,9 +21,9 @@ export default function (server: Server, ctx: AppContext) {
         )
       },
     }),
-    handler: async ({ auth, input, req }) => {
+    handler: async ({ auth, input: { body }, req }) => {
       const did = auth.credentials.did
-      const { token, email } = input.body
+      const { token, email } = body
       if (!isEmailValid(email) || isDisposableEmail(email)) {
         throw new InvalidRequestError(
           'This email address is not supported, please use a different email.',
@@ -33,15 +36,18 @@ export default function (server: Server, ctx: AppContext) {
         throw new InvalidRequestError('account not found')
       }
 
-      if (ctx.entrywayAgent) {
-        await ctx.entrywayAgent.com.atproto.server.updateEmail(
-          input.body,
-          await ctx.entrywayAuthHeaders(
-            req,
-            auth.credentials.did,
-            ids.ComAtprotoServerUpdateEmail,
-          ),
+      if (ctx.entrywayClient) {
+        const { headers } = await ctx.entrywayAuthHeaders(
+          req,
+          auth.credentials.did,
+          com.atproto.server.updateEmail.$lxm,
         )
+
+        await ctx.entrywayClient.xrpc(com.atproto.server.updateEmail, {
+          headers,
+          body,
+        })
+
         return
       }
 

package/src/api/com/atproto/sync/deprecated/getCheckout.ts

@@ -1,11 +1,12 @@
+import { Server } from '@atproto/xrpc-server'
 import { isUserOrAdmin } from '../../../../../auth-verifier'
 import { AppContext } from '../../../../../context'
-import { Server } from '../../../../../lexicon'
+import { com } from '../../../../../lexicons/index.js'
 import { getCarStream } from '../getRepo'
 import { assertRepoAvailability } from '../util'
 
 export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.sync.getCheckout({
+  server.add(com.atproto.sync.getCheckout, {
     auth: ctx.authVerifier.authorizationOrAdminTokenOptional({
       authorize: () => {
         // always allow
@@ -18,7 +19,7 @@ export default function (server: Server, ctx: AppContext) {
       const carStream = await getCarStream(ctx, did)
 
       return {
-        encoding: 'application/vnd.ipld.car',
+        encoding: 'application/vnd.ipld.car' as const,
         body: carStream,
       }
     },

package/src/api/com/atproto/sync/deprecated/getHead.ts

@@ -1,11 +1,11 @@
-import { InvalidRequestError } from '@atproto/xrpc-server'
+import { InvalidRequestError, Server } from '@atproto/xrpc-server'
 import { isUserOrAdmin } from '../../../../../auth-verifier'
 import { AppContext } from '../../../../../context'
-import { Server } from '../../../../../lexicon'
+import { com } from '../../../../../lexicons/index.js'
 import { assertRepoAvailability } from '../util'
 
 export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.sync.getHead({
+  server.add(com.atproto.sync.getHead, {
     auth: ctx.authVerifier.authorizationOrAdminTokenOptional({
       authorize: () => {
         // always allow
@@ -25,7 +25,7 @@ export default function (server: Server, ctx: AppContext) {
         )
       }
       return {
-        encoding: 'application/json',
+        encoding: 'application/json' as const,
         body: { root: root.toString() },
       }
     },

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

@@ -1,14 +1,14 @@
-import { CID } from 'multiformats/cid'
+import { parseCid } from '@atproto/lex-data'
 import { BlobNotFoundError } from '@atproto/repo'
-import { InvalidRequestError } from '@atproto/xrpc-server'
+import { InvalidRequestError, Server } from '@atproto/xrpc-server'
 import { AuthScope } from '../../../../auth-scope'
 import { isUserOrAdmin } from '../../../../auth-verifier'
 import { AppContext } from '../../../../context'
-import { Server } from '../../../../lexicon'
+import { com } from '../../../../lexicons/index.js'
 import { assertRepoAvailability } from './util'
 
 export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.sync.getBlob({
+  server.add(com.atproto.sync.getBlob, {
     auth: ctx.authVerifier.authorizationOrAdminTokenOptional({
       additional: [AuthScope.Takendown],
       authorize: () => {
@@ -19,7 +19,7 @@ export default function (server: Server, ctx: AppContext) {
       const { did } = params
       await assertRepoAvailability(ctx, did, isUserOrAdmin(auth, did))
 
-      const cid = CID.parse(params.cid)
+      const cid = parseCid(params.cid)
       const found = await ctx.actorStore.read(params.did, async (store) => {
         try {
           return await store.repo.blob.getBlob(cid)
@@ -53,8 +53,7 @@ export default function (server: Server, ctx: AppContext) {
       res.setHeader('content-security-policy', `default-src 'none'; sandbox`)
 
       return {
-        // @TODO better codegen for */* mimetype
-        encoding: (found.mimeType || 'application/octet-stream') as '*/*',
+        encoding: found.mimeType || ('application/octet-stream' as const),
         body: found.stream,
       }
     },

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

@@ -1,14 +1,14 @@
-import { CID } from 'multiformats/cid'
 import { byteIterableToStream } from '@atproto/common'
+import { parseCid } from '@atproto/lex-data'
 import { blocksToCarStream } from '@atproto/repo'
-import { InvalidRequestError } from '@atproto/xrpc-server'
+import { InvalidRequestError, Server } from '@atproto/xrpc-server'
 import { isUserOrAdmin } from '../../../../auth-verifier'
 import { AppContext } from '../../../../context'
-import { Server } from '../../../../lexicon'
+import { com } from '../../../../lexicons/index.js'
 import { assertRepoAvailability } from './util'
 
 export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.sync.getBlocks({
+  server.add(com.atproto.sync.getBlocks, {
     auth: ctx.authVerifier.authorizationOrAdminTokenOptional({
       authorize: () => {
         // always allow
@@ -18,7 +18,7 @@ export default function (server: Server, ctx: AppContext) {
       const { did } = params
       await assertRepoAvailability(ctx, did, isUserOrAdmin(auth, did))
 
-      const cids = params.cids.map((c) => CID.parse(c))
+      const cids = params.cids.map(parseCid)
       const got = await ctx.actorStore.read(did, (store) =>
         store.repo.storage.getBlocks(cids),
       )
@@ -29,7 +29,7 @@ export default function (server: Server, ctx: AppContext) {
       const car = blocksToCarStream(null, got.blocks)
 
       return {
-        encoding: 'application/vnd.ipld.car',
+        encoding: 'application/vnd.ipld.car' as const,
         body: byteIterableToStream(car),
       }
     },

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

@@ -1,11 +1,11 @@
-import { InvalidRequestError } from '@atproto/xrpc-server'
+import { InvalidRequestError, Server } from '@atproto/xrpc-server'
 import { isUserOrAdmin } from '../../../../auth-verifier'
 import { AppContext } from '../../../../context'
-import { Server } from '../../../../lexicon'
+import { com } from '../../../../lexicons/index.js'
 import { assertRepoAvailability } from './util'
 
 export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.sync.getLatestCommit({
+  server.add(com.atproto.sync.getLatestCommit, {
     auth: ctx.authVerifier.authorizationOrAdminTokenOptional({
       authorize: () => {
         // always allow
@@ -25,7 +25,7 @@ export default function (server: Server, ctx: AppContext) {
         )
       }
       return {
-        encoding: 'application/json',
+        encoding: 'application/json' as const,
         body: { cid: root.cid.toString(), rev: root.rev },
       }
     },