@atproto/pds 0.5.12 → 0.5.15

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

@@ -1,50 +0,0 @@
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { com } from '../../../../lexicons/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(com.atproto.identity.getRecommendedDidCredentials, {
-    auth: ctx.authVerifier.authorization({
-      authorize: () => {
-        // always allow
-      },
-    }),
-    handler: async ({ auth }) => {
-      const requester = auth.credentials.did
-      const signingKey = await ctx.actorStore.keypair(requester)
-      const verificationMethods = {
-        atproto: signingKey.did(),
-      }
-      const account = await ctx.accountManager.getAccount(requester, {
-        includeDeactivated: true,
-      })
-      const alsoKnownAs = account?.handle
-        ? [`at://${account.handle}`]
-        : undefined
-
-      const plcRotationKey =
-        ctx.cfg.entryway?.plcRotationKey ?? ctx.plcRotationKey.did()
-      const rotationKeys = [plcRotationKey]
-      if (ctx.cfg.identity.recoveryDidKey) {
-        rotationKeys.unshift(ctx.cfg.identity.recoveryDidKey)
-      }
-
-      const services = {
-        atproto_pds: {
-          type: 'AtprotoPersonalDataServer',
-          endpoint: ctx.cfg.service.publicUrl,
-        },
-      }
-
-      return {
-        encoding: 'application/json' as const,
-        body: {
-          alsoKnownAs,
-          verificationMethods,
-          rotationKeys,
-          services,
-        },
-      }
-    },
-  })
-}

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

@@ -1,17 +0,0 @@
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import getRecommendedDidCredentials from './getRecommendedDidCredentials.js'
-import requestPlcOperationSignature from './requestPlcOperationSignature.js'
-import resolveHandle from './resolveHandle.js'
-import signPlcOperation from './signPlcOperation.js'
-import submitPlcOperation from './submitPlcOperation.js'
-import updateHandle from './updateHandle.js'
-
-export default function (server: Server, ctx: AppContext) {
-  resolveHandle(server, ctx)
-  updateHandle(server, ctx)
-  getRecommendedDidCredentials(server, ctx)
-  requestPlcOperationSignature(server, ctx)
-  signPlcOperation(server, ctx)
-  submitPlcOperation(server, ctx)
-}

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

@@ -1,59 +0,0 @@
-import { InvalidRequestError, Server } from '@atproto/xrpc-server'
-import { ACCESS_FULL, AuthScope } from '../../../../auth-scope.js'
-import { AppContext } from '../../../../context.js'
-import { com } from '../../../../lexicons/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  const { entrywayClient } = ctx
-
-  const auth = ctx.authVerifier.authorization({
-    // @NOTE Reflect any change in signPlcOperation
-    scopes: ACCESS_FULL,
-    additional: [AuthScope.Takendown],
-    authorize: (permissions) => {
-      permissions.assertIdentity({ attr: '*' })
-    },
-  })
-
-  if (entrywayClient) {
-    // @TODO we should have a higher level way of defining these "passthrough"
-    // handlers
-    server.add(com.atproto.identity.requestPlcOperationSignature, {
-      auth,
-      handler: async ({ auth, req }) => {
-        const { headers } = await ctx.entrywayAuthHeaders(
-          req,
-          auth.credentials.did,
-          com.atproto.identity.requestPlcOperationSignature.$lxm,
-        )
-        await entrywayClient.xrpc(
-          com.atproto.identity.requestPlcOperationSignature,
-          { headers },
-        )
-      },
-    })
-  } else {
-    server.add(com.atproto.identity.requestPlcOperationSignature, {
-      auth,
-      handler: async ({ auth }) => {
-        const did = auth.credentials.did
-        const account = await ctx.accountManager.getAccount(did, {
-          includeDeactivated: true,
-          includeTakenDown: true,
-        })
-        if (!account) {
-          throw new InvalidRequestError('account not found')
-        } else if (!account.email) {
-          throw new InvalidRequestError(
-            'account does not have an email address',
-          )
-        }
-        const token = await ctx.accountManager.createEmailToken(
-          did,
-          'plc_operation',
-        )
-        await ctx.mailer.sendPlcOperation({ token }, { to: account.email })
-      },
-    })
-  }
-}

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

@@ -1,50 +0,0 @@
-import { isDidString } from '@atproto/lex'
-import { DidString } from '@atproto/syntax'
-import { InvalidRequestError, Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { baseNormalizeAndValidate } from '../../../../handle/index.js'
-import { com } from '../../../../lexicons/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(com.atproto.identity.resolveHandle, async ({ params }) => {
-    const handle = baseNormalizeAndValidate(params.handle)
-
-    const user = await ctx.accountManager.getAccount(handle)
-    if (user) {
-      return {
-        encoding: 'application/json' as const,
-        body: { did: user.did as DidString },
-      }
-    }
-
-    const supportedHandle = ctx.cfg.identity.serviceHandleDomains.some(
-      (host) => handle.endsWith(host) || handle === host.slice(1),
-    )
-    // this should be in our DB & we couldn't find it, so fail
-    if (supportedHandle) {
-      throw new InvalidRequestError('Unable to resolve handle')
-    }
-
-    const did: DidString = ctx.bskyAppView
-      ? await ctx.bskyAppView.client
-          .call(com.atproto.identity.resolveHandle, { handle })
-          .then((r) => r.did, throwInvalidRequestError)
-      : await ctx.idResolver.handle
-          .resolve(handle)
-          .then(
-            (v) => (v && isDidString(v) ? v : throwInvalidRequestError()),
-            throwInvalidRequestError,
-          )
-
-    return {
-      encoding: 'application/json' as const,
-      body: { did },
-    }
-  })
-}
-
-function throwInvalidRequestError(cause?: unknown): never {
-  throw new InvalidRequestError('Unable to resolve handle', undefined, {
-    cause,
-  })
-}

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

@@ -1,85 +0,0 @@
-import * as plc from '@did-plc/lib'
-import { check } from '@atproto/common'
-import { InvalidRequestError, Server } from '@atproto/xrpc-server'
-import { ACCESS_FULL, AuthScope } from '../../../../auth-scope.js'
-import { AppContext } from '../../../../context.js'
-import { com } from '../../../../lexicons/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  const { entrywayClient } = ctx
-
-  const auth = ctx.authVerifier.authorization({
-    // @NOTE Should match auth rules from requestPlcOperationSignature
-    scopes: ACCESS_FULL,
-    additional: [AuthScope.Takendown],
-    authorize: (permissions) => {
-      permissions.assertIdentity({ attr: '*' })
-    },
-  })
-
-  if (entrywayClient) {
-    server.add(com.atproto.identity.signPlcOperation, {
-      auth,
-      handler: async ({ auth, input: { body }, req }) => {
-        const { headers } = await ctx.entrywayAuthHeaders(
-          req,
-          auth.credentials.did,
-          com.atproto.identity.signPlcOperation.$lxm,
-        )
-
-        return entrywayClient.xrpc(com.atproto.identity.signPlcOperation, {
-          headers,
-          body,
-        })
-      },
-    })
-  } else {
-    server.add(com.atproto.identity.signPlcOperation, {
-      auth,
-      handler: async ({ auth, input }) => {
-        const did = auth.credentials.did
-        const { token } = input.body
-        if (!token) {
-          throw new InvalidRequestError(
-            'email confirmation token required to sign PLC operations',
-          )
-        }
-        await ctx.accountManager.assertValidEmailTokenAndCleanup(
-          did,
-          'plc_operation',
-          token,
-        )
-
-        const lastOp = await ctx.plcClient.getLastOp(did)
-        if (check.is(lastOp, plc.def.tombstone)) {
-          throw new InvalidRequestError('Did is tombstoned')
-        }
-        const operation = await plc.createUpdateOp(
-          lastOp,
-          ctx.plcRotationKey,
-          (lastOp) => ({
-            ...lastOp,
-            rotationKeys: input.body.rotationKeys ?? lastOp.rotationKeys,
-            alsoKnownAs: input.body.alsoKnownAs ?? lastOp.alsoKnownAs,
-            verificationMethods:
-              // @TODO: actually validate instead of type casting
-              (input.body.verificationMethods as
-                | undefined
-                | Record<string, string>) ?? lastOp.verificationMethods,
-            services:
-              // @TODO: actually validate instead of type casting
-              (input.body.services as
-                | undefined
-                | Record<string, { type: string; endpoint: string }>) ??
-              lastOp.services,
-          }),
-        )
-
-        return {
-          encoding: 'application/json' as const,
-          body: { operation },
-        }
-      },
-    })
-  }
-}

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

@@ -1,65 +0,0 @@
-import * as plc from '@did-plc/lib'
-import { check } from '@atproto/common'
-import { InvalidRequestError, Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { com } from '../../../../lexicons/index.js'
-import { httpLogger as log } from '../../../../logger.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(com.atproto.identity.submitPlcOperation, {
-    auth: ctx.authVerifier.authorization({
-      authorize: (permissions) => {
-        permissions.assertIdentity({ attr: '*' })
-      },
-    }),
-    handler: async ({ auth, input }) => {
-      const requester = auth.credentials.did
-      const op = input.body.operation
-
-      if (!check.is(op, plc.def.operation)) {
-        throw new InvalidRequestError('Invalid operation')
-      }
-
-      const rotationKey =
-        ctx.cfg.entryway?.plcRotationKey ?? ctx.plcRotationKey.did()
-      if (!op.rotationKeys.includes(rotationKey)) {
-        throw new InvalidRequestError(
-          "Rotation keys do not include server's rotation key",
-        )
-      }
-      if (op.services['atproto_pds']?.type !== 'AtprotoPersonalDataServer') {
-        throw new InvalidRequestError('Incorrect type on atproto_pds service')
-      }
-      if (op.services['atproto_pds']?.endpoint !== ctx.cfg.service.publicUrl) {
-        throw new InvalidRequestError(
-          'Incorrect endpoint on atproto_pds service',
-        )
-      }
-      const signingKey = await ctx.actorStore.keypair(requester)
-      if (op.verificationMethods['atproto'] !== signingKey.did()) {
-        throw new InvalidRequestError('Incorrect signing key')
-      }
-      const account = await ctx.accountManager.getAccount(requester, {
-        includeDeactivated: true,
-      })
-      if (
-        account?.handle &&
-        op.alsoKnownAs.at(0) !== `at://${account.handle}`
-      ) {
-        throw new InvalidRequestError('Incorrect handle in alsoKnownAs')
-      }
-
-      await ctx.plcClient.sendOperation(requester, op)
-      await ctx.sequencer.sequenceIdentity(requester)
-
-      try {
-        await ctx.idResolver.did.resolve(requester, true)
-      } catch (err) {
-        log.error(
-          { err, did: requester },
-          'failed to refresh did after plc update',
-        )
-      }
-    },
-  })
-}

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

@@ -1,66 +0,0 @@
-import { DAY, MINUTE } from '@atproto/common'
-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'
-
-export default function (server: Server, ctx: AppContext) {
-  const { entrywayClient } = ctx
-
-  const auth = ctx.authVerifier.authorization({
-    checkTakedown: true,
-    authorize: (permissions) => {
-      permissions.assertIdentity({ attr: 'handle' })
-    },
-  })
-
-  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:
-        // -> entryway(identity.updateHandle) [update handle, submit plc op]
-        // -> pds(admin.updateAccountHandle)  [track handle, sequence handle update]
-        await entrywayClient.xrpc(com.atproto.identity.updateHandle, {
-          headers,
-          body: {
-            handle: input.body.handle,
-            // @ts-expect-error "did" is not in the schema
-            did: auth.credentials.did,
-          },
-        })
-      },
-    })
-  } 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/index.ts

@@ -1,19 +0,0 @@
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../context.js'
-import admin from './admin/index.js'
-import identity from './identity/index.js'
-import moderation from './moderation/index.js'
-import repo from './repo/index.js'
-import serverMethods from './server/index.js'
-import sync from './sync/index.js'
-import temp from './temp/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  admin(server, ctx)
-  identity(server, ctx)
-  moderation(server, ctx)
-  repo(server, ctx)
-  serverMethods(server, ctx)
-  sync(server, ctx)
-  temp(server, ctx)
-}

package/src/api/com/atproto/moderation/createReport.ts

@@ -1,41 +0,0 @@
-import { xrpc } from '@atproto/lex'
-import { Server } from '@atproto/xrpc-server'
-import { AuthScope } from '../../../../auth-scope.js'
-import { AppContext } from '../../../../context.js'
-import { com } from '../../../../lexicons/index.js'
-import { computeProxyTo, parseProxyInfo } from '../../../../pipethrough.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(com.atproto.moderation.createReport, {
-    auth: ctx.authVerifier.authorization({
-      additional: [AuthScope.Takendown],
-      authorize: (permissions, { req }) => {
-        const lxm = com.atproto.moderation.createReport.$lxm
-        const aud = computeProxyTo(ctx, req, lxm)
-        permissions.assertRpc({ aud, lxm })
-      },
-    }),
-    handler: async ({ auth, params, input: { body }, req }) => {
-      const { url, did: aud } = await parseProxyInfo(
-        ctx,
-        req,
-        com.atproto.moderation.createReport.$lxm,
-      )
-
-      const { headers } = await ctx.serviceAuthHeaders(
-        auth.credentials.did,
-        aud,
-        com.atproto.moderation.createReport.$lxm,
-      )
-
-      return xrpc(url, com.atproto.moderation.createReport, {
-        validateRequest: ctx.cfg.service.devMode,
-        validateResponse: ctx.cfg.service.devMode,
-        strictResponseProcessing: ctx.cfg.service.devMode,
-        headers,
-        params,
-        body,
-      })
-    },
-  })
-}

package/src/api/com/atproto/moderation/index.ts

@@ -1,7 +0,0 @@
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import createReport from './createReport.js'
-
-export default function (server: Server, ctx: AppContext) {
-  createReport(server, ctx)
-}

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

@@ -1,226 +0,0 @@
-import { parseCid } from '@atproto/lex-data'
-import { WriteOpAction } from '@atproto/repo'
-import {
-  AuthRequiredError,
-  InvalidRequestError,
-  Server,
-} from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { com } from '../../../../lexicons/index.js'
-import { dbLogger } from '../../../../logger.js'
-import {
-  BadCommitSwapError,
-  InvalidRecordError,
-  PreparedWrite,
-  prepareCreate,
-  prepareDelete,
-  prepareUpdate,
-} from '../../../../repo/index.js'
-
-const ratelimitPoints = ({
-  input,
-}: {
-  input: com.atproto.repo.applyWrites.$Input
-}) => {
-  let points = 0
-  for (const op of input.body.writes) {
-    if (com.atproto.repo.applyWrites.create.$isTypeOf(op)) {
-      points += 3
-    } else if (com.atproto.repo.applyWrites.update.$isTypeOf(op)) {
-      points += 2
-    } else {
-      points += 1
-    }
-  }
-  return points
-}
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(com.atproto.repo.applyWrites, {
-    auth: ctx.authVerifier.authorization({
-      // @NOTE the "checkTakedown" and "checkDeactivated" checks are typically
-      // performed during auth. However, since this method's "repo" parameter
-      // can be a handle, we will need to fetch the account again to ensure that
-      // the handle matches the DID from the request's credentials. In order to
-      // avoid fetching the account twice (during auth, and then again in the
-      // controller), the checks are disabled here:
-
-      // checkTakedown: true,
-      // checkDeactivated: true,
-      authorize: () => {
-        // Performed in the handler as it is based on the request body
-      },
-    }),
-
-    rateLimit: [
-      {
-        name: 'repo-write-hour',
-        calcKey: ({ auth }) => auth.credentials.did,
-        calcPoints: ratelimitPoints,
-      },
-      {
-        name: 'repo-write-day',
-        calcKey: ({ auth }) => auth.credentials.did,
-        calcPoints: ratelimitPoints,
-      },
-    ],
-
-    opts: {
-      jsonLimit: 1_000_000,
-    },
-
-    handler: async ({ input, auth }) => {
-      const { repo, validate, swapCommit, writes } = input.body
-
-      const account = await ctx.authVerifier.findAccount(repo, {
-        checkDeactivated: true,
-        checkTakedown: true,
-      })
-
-      const did = account.did
-      if (did !== auth.credentials.did) {
-        throw new AuthRequiredError()
-      }
-
-      if (writes.length > 200) {
-        throw new InvalidRequestError('Too many writes. Max: 200')
-      }
-
-      // Verify permission of every unique "action" / "collection" pair
-      if (auth.credentials.type === 'oauth') {
-        // @NOTE Unlike "importRepo", we do not require "action" = "*" here.
-        for (const [action, collections] of [
-          [
-            'create',
-            new Set(
-              writes
-                .filter((v) => com.atproto.repo.applyWrites.create.$isTypeOf(v))
-                .map((w) => w.collection),
-            ),
-          ],
-          [
-            'update',
-            new Set(
-              writes
-                .filter((v) => com.atproto.repo.applyWrites.update.$isTypeOf(v))
-                .map((w) => w.collection),
-            ),
-          ],
-          [
-            'delete',
-            new Set(
-              writes
-                .filter((v) => com.atproto.repo.applyWrites.delete.$isTypeOf(v))
-                .map((w) => w.collection),
-            ),
-          ],
-        ] as const) {
-          for (const collection of collections) {
-            auth.credentials.permissions.assertRepo({ action, collection })
-          }
-        }
-      }
-
-      // @NOTE should preserve order of ts.writes for final use in response
-      let preparedWrites: PreparedWrite[]
-      try {
-        preparedWrites = await Promise.all(
-          writes.map(async (write, i) => {
-            if (com.atproto.repo.applyWrites.create.$isTypeOf(write)) {
-              return prepareCreate({
-                did,
-                collection: write.collection,
-                record: write.value,
-                rkey: write.rkey,
-                validate,
-                validationPath: ['writes', i, 'record'],
-              })
-            } else if (com.atproto.repo.applyWrites.update.$isTypeOf(write)) {
-              return prepareUpdate({
-                did,
-                collection: write.collection,
-                record: write.value,
-                rkey: write.rkey,
-                validate,
-                validationPath: ['writes', i, 'record'],
-              })
-            } else if (com.atproto.repo.applyWrites.delete.$isTypeOf(write)) {
-              return prepareDelete({
-                did,
-                collection: write.collection,
-                rkey: write.rkey,
-              })
-            } else {
-              throw new InvalidRequestError(
-                `Action not supported: ${write['$type']}`,
-              )
-            }
-          }),
-        )
-      } catch (err) {
-        if (err instanceof InvalidRecordError) {
-          throw new InvalidRequestError(err.message)
-        }
-        throw err
-      }
-
-      const swapCommitCid = swapCommit ? parseCid(swapCommit) : undefined
-
-      const commit = await ctx.actorStore.transact(did, async (actorTxn) => {
-        const commit = await actorTxn.repo
-          .processWrites(preparedWrites, 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.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' as const,
-        body: {
-          commit: {
-            cid: commit.cid.toString(),
-            rev: commit.rev,
-          },
-          results: preparedWrites.map(writeToOutputResult),
-        },
-      }
-    },
-  })
-}
-
-const writeToOutputResult = (write: PreparedWrite) => {
-  switch (write.action) {
-    case WriteOpAction.Create:
-      return com.atproto.repo.applyWrites.createResult.$build({
-        cid: write.cid.toString(),
-        uri: write.uri.toString(),
-        validationStatus: write.validationStatus,
-      })
-    case WriteOpAction.Update:
-      return com.atproto.repo.applyWrites.updateResult.$build({
-        cid: write.cid.toString(),
-        uri: write.uri.toString(),
-        validationStatus: write.validationStatus,
-      })
-    case WriteOpAction.Delete:
-      return com.atproto.repo.applyWrites.deleteResult.$build({})
-    default:
-      throw new Error(`Unrecognized action: ${write}`)
-  }
-}