@atproto/pds 0.5.12 → 0.5.15

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

@@ -1,22 +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.admin.deleteAccount, {
-    auth: ctx.authVerifier.adminToken,
-    handler: async ({ input }) => {
-      const { did } = input.body
-
-      // @NOTE Order matters here: first "unlink" the account by removing it
-      // from the account manager database ("source of truth"), then notify the
-      // sequencer, and finally cleanup files from the file system.
-      await ctx.accountManager.deleteAccount(did)
-      try {
-        await ctx.sequencer.sequenceAccountDeletion(did)
-      } finally {
-        await ctx.actorStore.destroy(did)
-      }
-    },
-  })
-}

package/src/api/com/atproto/admin/disableAccountInvites.ts

@@ -1,18 +0,0 @@
-import { InvalidRequestError, 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.admin.disableAccountInvites, {
-    auth: ctx.authVerifier.moderator,
-    handler: async ({ input }) => {
-      if (ctx.cfg.entryway) {
-        throw new InvalidRequestError(
-          'Account invites are managed by the entryway service',
-        )
-      }
-      const { account } = input.body
-      await ctx.accountManager.setAccountInvitesDisabled(account, true)
-    },
-  })
-}

package/src/api/com/atproto/admin/disableInviteCodes.ts

@@ -1,21 +0,0 @@
-import { InvalidRequestError, 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.admin.disableInviteCodes, {
-    auth: ctx.authVerifier.moderator,
-    handler: async ({ input }) => {
-      if (ctx.cfg.entryway) {
-        throw new InvalidRequestError(
-          'Account invites are managed by the entryway service',
-        )
-      }
-      const { codes = [], accounts = [] } = input.body
-      if (accounts.includes('admin')) {
-        throw new InvalidRequestError('cannot disable admin invite codes')
-      }
-      await ctx.accountManager.disableInviteCodes({ codes, accounts })
-    },
-  })
-}

package/src/api/com/atproto/admin/enableAccountInvites.ts

@@ -1,18 +0,0 @@
-import { InvalidRequestError, 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.admin.enableAccountInvites, {
-    auth: ctx.authVerifier.moderator,
-    handler: async ({ input }) => {
-      if (ctx.cfg.entryway) {
-        throw new InvalidRequestError(
-          'Account invites are managed by the entryway service',
-        )
-      }
-      const { account } = input.body
-      await ctx.accountManager.setAccountInvitesDisabled(account, false)
-    },
-  })
-}

package/src/api/com/atproto/admin/getAccountInfo.ts

@@ -1,32 +0,0 @@
-import { InvalidRequestError, Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { com } from '../../../../lexicons/index.js'
-import { formatAccountInfo } from './util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(com.atproto.admin.getAccountInfo, {
-    auth: ctx.authVerifier.moderator,
-    handler: async ({ params }) => {
-      const [account, invites, invitedBy] = await Promise.all([
-        ctx.accountManager.getAccount(params.did, {
-          includeDeactivated: true,
-          includeTakenDown: true,
-        }),
-        ctx.accountManager.getAccountInvitesCodes(params.did),
-        ctx.accountManager.getInvitedByForAccounts([params.did]),
-      ])
-      if (!account) {
-        throw new InvalidRequestError('Account not found', 'NotFound')
-      }
-      const managesOwnInvites = !ctx.cfg.entryway
-      return {
-        encoding: 'application/json' as const,
-        body: formatAccountInfo(account, {
-          managesOwnInvites,
-          invitedBy,
-          invites,
-        }),
-      }
-    },
-  })
-}

package/src/api/com/atproto/admin/getAccountInfos.ts

@@ -1,34 +0,0 @@
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { com } from '../../../../lexicons/index.js'
-import { formatAccountInfo } from './util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(com.atproto.admin.getAccountInfos, {
-    auth: ctx.authVerifier.moderator,
-    handler: async ({ params }) => {
-      const [accounts, invites, invitedBy] = await Promise.all([
-        ctx.accountManager.getAccounts(params.dids, {
-          includeDeactivated: true,
-          includeTakenDown: true,
-        }),
-        ctx.accountManager.getAccountsInvitesCodes(params.dids),
-        ctx.accountManager.getInvitedByForAccounts(params.dids),
-      ])
-
-      const managesOwnInvites = !ctx.cfg.entryway
-      const infos = Array.from(accounts.values()).map((account) => {
-        return formatAccountInfo(account, {
-          managesOwnInvites,
-          invitedBy,
-          invites,
-        })
-      })
-
-      return {
-        encoding: 'application/json' as const,
-        body: { infos },
-      }
-    },
-  })
-}

package/src/api/com/atproto/admin/getInviteCodes.ts

@@ -1,126 +0,0 @@
-import { InvalidRequestError, Server } from '@atproto/xrpc-server'
-import {
-  CodeDetail,
-  selectInviteCodesQb,
-} from '../../../../account-manager/helpers/invite.js'
-import { AppContext } from '../../../../context.js'
-import {
-  Cursor,
-  GenericKeyset,
-  LabeledResult,
-  paginate,
-} from '../../../../db/pagination.js'
-import { com } from '../../../../lexicons/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  if (ctx.cfg.entryway) {
-    server.add(com.atproto.admin.getInviteCodes, () => {
-      throw new InvalidRequestError(
-        'Account invites are managed by the entryway service',
-      )
-    })
-    return
-  }
-
-  server.add(com.atproto.admin.getInviteCodes, {
-    auth: ctx.authVerifier.moderator,
-    handler: async ({
-      params,
-    }): Promise<com.atproto.admin.getInviteCodes.$Output> => {
-      const { sort, limit, cursor } = params
-      const db = ctx.accountManager.db
-      const keyset = createKeyset(ctx, sort)
-
-      const builder = selectInviteCodesQb(db)
-
-      const res = await paginate(builder, {
-        limit,
-        cursor,
-        keyset,
-      }).execute()
-
-      const codes = res.map((row) => row.code)
-      const uses = await ctx.accountManager.getInviteCodesUses(codes)
-
-      const resultCursor = keyset.packFromResult(res)
-      const codeDetails = res.map(
-        ({ disabled, createdAt, ...row }): CodeDetail => ({
-          ...row,
-          createdAt,
-          disabled: disabled === 1,
-          uses: uses[row.code] ?? [],
-        }),
-      )
-
-      return {
-        encoding: 'application/json' as const,
-        body: {
-          cursor: resultCursor,
-          codes: codeDetails,
-        },
-      }
-    },
-  })
-}
-
-function createKeyset(ctx: AppContext, sort?: string): GenericKeyset<any, any> {
-  const { ref } = ctx.accountManager.db.db.dynamic
-
-  if (sort === 'recent') {
-    return new TimeCodeKeyset(ref('createdAt'), ref('code'))
-  }
-
-  if (sort === 'usage') {
-    return new UseCodeKeyset(ref('uses'), ref('code'))
-  }
-
-  throw new InvalidRequestError(`unknown sort method: ${sort}`)
-}
-
-type TimeCodeResult = { createdAt: string; code: string }
-
-export class TimeCodeKeyset extends GenericKeyset<TimeCodeResult, Cursor> {
-  labelResult(result: TimeCodeResult): Cursor {
-    return { primary: result.createdAt, secondary: result.code }
-  }
-  labeledResultToCursor(labeled: Cursor) {
-    return {
-      primary: new Date(labeled.primary).getTime().toString(),
-      secondary: labeled.secondary,
-    }
-  }
-  cursorToLabeledResult(cursor: Cursor) {
-    const primaryDate = new Date(parseInt(cursor.primary, 10))
-    if (isNaN(primaryDate.getTime())) {
-      throw new InvalidRequestError('Malformed cursor')
-    }
-    return {
-      primary: primaryDate.toISOString(),
-      secondary: cursor.secondary,
-    }
-  }
-}
-
-type UseCodeResult = { uses: number; code: string }
-
-export class UseCodeKeyset extends GenericKeyset<UseCodeResult, LabeledResult> {
-  labelResult(result: UseCodeResult): LabeledResult {
-    return { primary: result.uses, secondary: result.code }
-  }
-  labeledResultToCursor(labeled: Cursor) {
-    return {
-      primary: labeled.primary.toString(),
-      secondary: labeled.secondary,
-    }
-  }
-  cursorToLabeledResult(cursor: Cursor) {
-    const primaryCode = parseInt(cursor.primary, 10)
-    if (isNaN(primaryCode)) {
-      throw new InvalidRequestError('Malformed cursor')
-    }
-    return {
-      primary: primaryCode,
-      secondary: cursor.secondary,
-    }
-  }
-}

package/src/api/com/atproto/admin/getSubjectStatus.ts

@@ -1,76 +0,0 @@
-import { parseCid } from '@atproto/lex-data'
-import { AtUri } from '@atproto/syntax'
-import { InvalidRequestError, 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.admin.getSubjectStatus, {
-    auth: ctx.authVerifier.moderator,
-    handler: async ({ params }) => {
-      const { did, uri, blob } = params
-      let body: com.atproto.admin.getSubjectStatus.$OutputBody | null = null
-      if (blob) {
-        if (!did) {
-          throw new InvalidRequestError(
-            'Must provide a did to request blob state',
-          )
-        }
-        const takedown = await ctx.actorStore.read(did, (store) =>
-          store.repo.blob.getBlobTakedownStatus(parseCid(blob)),
-        )
-        if (takedown) {
-          body = {
-            subject: {
-              $type: 'com.atproto.admin.defs#repoBlobRef',
-              did: did,
-              cid: blob,
-            },
-            takedown,
-          }
-        }
-      } else if (uri) {
-        const parsedUri = new AtUri(uri)
-        const [takedown, cid] = await ctx.actorStore.read(
-          parsedUri.hostname,
-          (store) =>
-            Promise.all([
-              store.record.getRecordTakedownStatus(parsedUri),
-              store.record.getCurrentRecordCid(parsedUri),
-            ]),
-        )
-        if (cid && takedown) {
-          body = {
-            subject: {
-              $type: 'com.atproto.repo.strongRef',
-              uri: parsedUri.toString(),
-              cid: cid.toString(),
-            },
-            takedown,
-          }
-        }
-      } else if (did) {
-        const status = await ctx.accountManager.getAccountAdminStatus(did)
-        if (status) {
-          body = {
-            subject: {
-              $type: 'com.atproto.admin.defs#repoRef',
-              did: did,
-            },
-            takedown: status.takedown,
-            deactivated: status.deactivated,
-          }
-        }
-      } else {
-        throw new InvalidRequestError('No provided subject')
-      }
-      if (body === null) {
-        throw new InvalidRequestError('Subject not found', 'NotFound')
-      }
-      return {
-        encoding: 'application/json' as const,
-        body,
-      }
-    },
-  })
-}

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

@@ -1,31 +0,0 @@
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import deleteAccount from './deleteAccount.js'
-import disableAccountInvites from './disableAccountInvites.js'
-import disableInviteCodes from './disableInviteCodes.js'
-import enableAccountInvites from './enableAccountInvites.js'
-import getAccountInfo from './getAccountInfo.js'
-import getAccountInfos from './getAccountInfos.js'
-import getInviteCodes from './getInviteCodes.js'
-import getSubjectStatus from './getSubjectStatus.js'
-import sendEmail from './sendEmail.js'
-import updateAccountEmail from './updateAccountEmail.js'
-import updateAccountHandle from './updateAccountHandle.js'
-import updateAccountPassword from './updateAccountPassword.js'
-import updateSubjectStatus from './updateSubjectStatus.js'
-
-export default function (server: Server, ctx: AppContext) {
-  updateSubjectStatus(server, ctx)
-  getSubjectStatus(server, ctx)
-  getAccountInfo(server, ctx)
-  getAccountInfos(server, ctx)
-  enableAccountInvites(server, ctx)
-  disableAccountInvites(server, ctx)
-  disableInviteCodes(server, ctx)
-  getInviteCodes(server, ctx)
-  updateAccountHandle(server, ctx)
-  updateAccountEmail(server, ctx)
-  updateAccountPassword(server, ctx)
-  sendEmail(server, ctx)
-  deleteAccount(server, ctx)
-}

package/src/api/com/atproto/admin/sendEmail.ts

@@ -1,47 +0,0 @@
-import { InvalidRequestError, 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.admin.sendEmail, {
-    auth: ctx.authVerifier.moderator,
-    handler: async ({ input: { body }, req }) => {
-      const { content, recipientDid, subject = 'Message via your PDS' } = body
-
-      const account = await ctx.accountManager.getAccount(recipientDid, {
-        includeDeactivated: true,
-        includeTakenDown: true,
-      })
-      if (!account) {
-        throw new InvalidRequestError('Recipient not found')
-      }
-
-      if (ctx.entrywayClient) {
-        const { headers } = await ctx.entrywayAuthHeaders(
-          req,
-          recipientDid,
-          com.atproto.admin.sendEmail.$lxm,
-        )
-
-        return ctx.entrywayClient.xrpc(com.atproto.admin.sendEmail, {
-          headers,
-          body,
-        })
-      }
-
-      if (!account.email) {
-        throw new InvalidRequestError('account does not have an email address')
-      }
-
-      await ctx.moderationMailer.send(
-        { content },
-        { subject, to: account.email },
-      )
-
-      return {
-        encoding: 'application/json' as const,
-        body: { sent: true },
-      }
-    },
-  })
-}

package/src/api/com/atproto/admin/updateAccountEmail.ts

@@ -1,32 +0,0 @@
-import { InvalidRequestError, 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.admin.updateAccountEmail, {
-    auth: ctx.authVerifier.adminToken,
-    handler: async ({ input: { body }, req }) => {
-      const account = await ctx.accountManager.getAccount(body.account, {
-        includeDeactivated: true,
-        includeTakenDown: true,
-      })
-      if (!account) {
-        throw new InvalidRequestError(`Account does not exist: ${body.account}`)
-      }
-
-      if (ctx.entrywayClient) {
-        const { headers } = ctx.entrywayPassthruHeaders(req)
-        await ctx.entrywayClient.xrpc(com.atproto.admin.updateAccountEmail, {
-          headers,
-          body,
-        })
-        return
-      }
-
-      await ctx.accountManager.updateAccountEmail({
-        did: account.did,
-        email: body.email,
-      })
-    },
-  })
-}

package/src/api/com/atproto/admin/updateAccountHandle.ts

@@ -1,47 +0,0 @@
-import { InvalidRequestError, Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { com } from '../../../../lexicons/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  const { entrywayClient } = ctx
-
-  if (entrywayClient) {
-    server.add(com.atproto.admin.updateAccountHandle, {
-      auth: ctx.authVerifier.adminToken,
-      handler: async ({ input: { body } }) => {
-        const { did, handle } = await ctx.accountManager.validateHandleUpdate(
-          body.did,
-          body.handle,
-          { allowAnyValid: true },
-        )
-
-        // the pds defers to the entryway for updating the handle in the user's
-        // did doc. here was just check that the handle is already
-        // bidirectionally confirmed.
-        //
-        // -> entryway(identity.updateHandle) [update handle, submit plc op]
-        // -> pds(admin.updateAccountHandle)  [track handle, sequence handle update]
-        //
-        // @TODO if handle is taken according to this PDS, should we force-update?
-        const doc = await ctx.idResolver.did
-          .resolveAtprotoData(did, true)
-          .catch(() => undefined)
-
-        if (!doc || doc.handle !== handle) {
-          throw new InvalidRequestError('Handle does not match DID doc')
-        }
-
-        await ctx.accountManager.updateAccountHandle(did, handle)
-      },
-    })
-  } else {
-    server.add(com.atproto.admin.updateAccountHandle, {
-      auth: ctx.authVerifier.adminToken,
-      handler: async ({ input: { body } }) => {
-        await ctx.accountManager.updateHandle(body.did, body.handle, {
-          allowAnyValid: true,
-        })
-      },
-    })
-  }
-}

package/src/api/com/atproto/admin/updateAccountPassword.ts

@@ -1,34 +0,0 @@
-import { InvalidRequestError, Server } from '@atproto/xrpc-server'
-import { NEW_PASSWORD_MAX_LENGTH } from '../../../../account-manager/helpers/scrypt.js'
-import { AppContext } from '../../../../context.js'
-import { com } from '../../../../lexicons/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  const { entrywayClient } = ctx
-
-  if (entrywayClient) {
-    server.add(com.atproto.admin.updateAccountPassword, {
-      auth: ctx.authVerifier.adminToken,
-      handler: async ({ input: { body }, req }) => {
-        const { headers } = ctx.entrywayPassthruHeaders(req)
-        await entrywayClient.xrpc(com.atproto.admin.updateAccountPassword, {
-          body,
-          headers,
-        })
-      },
-    })
-  } else {
-    server.add(com.atproto.admin.updateAccountPassword, {
-      auth: ctx.authVerifier.adminToken,
-      handler: async ({ input: { body } }) => {
-        const { did, password } = body
-
-        if (password.length > NEW_PASSWORD_MAX_LENGTH) {
-          throw new InvalidRequestError('Invalid password length.')
-        }
-
-        await ctx.accountManager.updateAccountPassword({ did, password })
-      },
-    })
-  }
-}

package/src/api/com/atproto/admin/updateSubjectStatus.ts

@@ -1,68 +0,0 @@
-import { parseCid } from '@atproto/lex-data'
-import { AtUri } from '@atproto/syntax'
-import { InvalidRequestError, 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.admin.updateSubjectStatus, {
-    auth: ctx.authVerifier.moderator,
-    handler: async ({ input }) => {
-      const { subject, takedown, deactivated } = input.body
-
-      if (takedown?.applied && deactivated != null && !deactivated.applied) {
-        throw new InvalidRequestError(
-          `Cannot activate and takedown an account at the same time`,
-        )
-      }
-
-      if (takedown) {
-        if (com.atproto.admin.defs.repoRef.$isTypeOf(subject)) {
-          await ctx.accountManager.takedownAccount(subject.did, takedown)
-        } else if (com.atproto.repo.strongRef.$isTypeOf(subject)) {
-          const uri = new AtUri(subject.uri)
-          await ctx.actorStore.transact(uri.hostname, async (store) => {
-            await store.record.updateRecordTakedownStatus(uri, takedown)
-          })
-        } else if (com.atproto.admin.defs.repoBlobRef.$isTypeOf(subject)) {
-          await ctx.actorStore.transact(subject.did, async (store) => {
-            await store.repo.blob.updateBlobTakedownStatus(
-              parseCid(subject.cid),
-              takedown,
-            )
-          })
-        } else {
-          throw new InvalidRequestError(`Invalid subject (${subject.$type})`)
-        }
-      }
-
-      if (deactivated) {
-        if (com.atproto.admin.defs.repoRef.$isTypeOf(subject)) {
-          if (deactivated.applied) {
-            await ctx.accountManager.deactivateAccount(subject.did)
-          } else {
-            await ctx.accountManager.activateAccount(subject.did)
-          }
-        }
-      }
-
-      // @NOTE accountManager will sequence an account status when updating the
-      // status, so we don't *need* to sequence the account status here.
-      // However, this endpoint historically has always sequenced the account
-      // status.
-      if (!takedown && !deactivated) {
-        if (com.atproto.admin.defs.repoRef.$isTypeOf(subject)) {
-          await ctx.accountManager.sequenceAccountStatus(subject.did)
-        }
-      }
-
-      return {
-        encoding: 'application/json' as const,
-        body: {
-          subject,
-          takedown,
-        },
-      }
-    },
-  })
-}

package/src/api/com/atproto/admin/util.ts

@@ -1,66 +0,0 @@
-import express from 'express'
-import { l } from '@atproto/lex'
-import { INVALID_HANDLE } from '@atproto/syntax'
-import { ActorAccount } from '../../../../account-manager/helpers/account.js'
-import { CodeDetail } from '../../../../account-manager/helpers/invite.js'
-import { com } from '../../../../lexicons/index.js'
-
-// Output designed to passed as second arg to AtpAgent methods.
-// The encoding field here is a quirk of the AtpAgent.
-export function authPassthru(
-  req: express.Request,
-  withEncoding?: false,
-): { headers: { authorization: string }; encoding: undefined } | undefined
-
-export function authPassthru(
-  req: express.Request,
-  withEncoding: true,
-):
-  | { headers: { authorization: string }; encoding: 'application/json' }
-  | undefined
-
-export function authPassthru(req: express.Request, withEncoding?: boolean) {
-  if (req.headers.authorization) {
-    return {
-      headers: { authorization: req.headers.authorization },
-      encoding: withEncoding ? 'application/json' : undefined,
-    }
-  }
-}
-
-export function formatAccountInfo(
-  account: ActorAccount,
-  {
-    managesOwnInvites,
-    invitedBy,
-    invites,
-  }: {
-    managesOwnInvites: boolean
-    invites: Map<string, CodeDetail[]> | CodeDetail[]
-    invitedBy: Record<string, CodeDetail>
-  },
-): com.atproto.admin.defs.AccountView {
-  let invitesResults: CodeDetail[] | undefined
-  if (managesOwnInvites) {
-    if (Array.isArray(invites)) {
-      invitesResults = invites
-    } else {
-      invitesResults = invites.get(account.did) || []
-    }
-  }
-  return {
-    did: account.did as l.DidString,
-    handle: (account.handle ?? INVALID_HANDLE) as l.HandleString,
-    email: account.email ?? undefined,
-    indexedAt: account.createdAt as l.DatetimeString,
-    emailConfirmedAt:
-      (account.emailConfirmedAt as l.DatetimeString | undefined) ?? undefined,
-    invitedBy: managesOwnInvites ? invitedBy[account.did] : undefined,
-    invites: invitesResults,
-    invitesDisabled: managesOwnInvites
-      ? account.invitesDisabled === 1
-      : undefined,
-    deactivatedAt:
-      (account.deactivatedAt as l.DatetimeString | undefined) ?? undefined,
-  }
-}