@atproto/pds 0.5.12 → 0.5.14

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

@@ -1,143 +0,0 @@
-import { parseCid } from '@atproto/lex-data'
-import { InvalidRecordKeyError } from '@atproto/syntax'
-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,
-  PreparedCreate,
-  prepareCreate,
-  prepareDelete,
-} from '../../../../repo/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(com.atproto.repo.createRecord, {
-    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 requires the request body
-      },
-    }),
-    rateLimit: [
-      {
-        name: 'repo-write-hour',
-        calcKey: ({ auth }) => auth.credentials.did,
-        calcPoints: () => 3,
-      },
-      {
-        name: 'repo-write-day',
-        calcKey: ({ auth }) => auth.credentials.did,
-        calcPoints: () => 3,
-      },
-    ],
-    opts: {
-      jsonLimit: 1_000_000,
-    },
-    handler: async ({ input, auth }) => {
-      const { repo, collection, rkey, record, swapCommit, validate } =
-        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 (auth.credentials.type === 'oauth') {
-        auth.credentials.permissions.assertRepo({
-          action: 'create',
-          collection,
-        })
-      }
-
-      const swapCommitCid = swapCommit ? parseCid(swapCommit) : undefined
-
-      let write: PreparedCreate
-      try {
-        write = await prepareCreate({
-          did,
-          collection,
-          record,
-          rkey,
-          validate,
-        })
-      } catch (err) {
-        if (err instanceof InvalidRecordError) {
-          throw new InvalidRequestError(err.message)
-        }
-        if (err instanceof InvalidRecordKeyError) {
-          throw new InvalidRequestError(err.message)
-        }
-        throw err
-      }
-
-      const commit = await ctx.actorStore.transact(did, async (actorTxn) => {
-        const backlinkConflicts =
-          validate !== false
-            ? await actorTxn.record.getBacklinkConflicts(
-                write.uri,
-                write.record,
-              )
-            : []
-        const backlinkDeletions = backlinkConflicts.map((uri) =>
-          prepareDelete({
-            did: uri.did,
-            collection: uri.collectionSafe,
-            rkey: uri.rkeySafe,
-          }),
-        )
-        const writes = [...backlinkDeletions, write]
-        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.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: {
-          uri: write.uri.toString(),
-          cid: write.cid.toString(),
-          commit: {
-            cid: commit.cid.toString(),
-            rev: commit.rev,
-          },
-          validationStatus: write.validationStatus,
-        },
-      }
-    },
-  })
-}

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

@@ -1,122 +0,0 @@
-import { parseCid } from '@atproto/lex-data'
-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,
-  BadRecordSwapError,
-  prepareDelete,
-} from '../../../../repo/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(com.atproto.repo.deleteRecord, {
-    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 requires the request body
-      },
-    }),
-    rateLimit: [
-      {
-        name: 'repo-write-hour',
-        calcKey: ({ auth }) => auth.credentials.did,
-        calcPoints: () => 1,
-      },
-      {
-        name: 'repo-write-day',
-        calcKey: ({ auth }) => auth.credentials.did,
-        calcPoints: () => 1,
-      },
-    ],
-    handler: async ({ input: { body }, auth }) => {
-      const { repo, collection, rkey, swapCommit, swapRecord } = body
-
-      const account = await ctx.authVerifier.findAccount(repo, {
-        checkDeactivated: true,
-        checkTakedown: true,
-      })
-
-      const did = account.did
-      if (did !== auth.credentials.did) {
-        throw new AuthRequiredError()
-      }
-
-      // We can't compute permissions based on the request payload ("input") in
-      // the 'auth' phase, so we do it here.
-      if (auth.credentials.type === 'oauth') {
-        auth.credentials.permissions.assertRepo({
-          action: 'delete',
-          collection,
-        })
-      }
-
-      const swapCommitCid = swapCommit ? parseCid(swapCommit) : undefined
-      const swapRecordCid = swapRecord ? parseCid(swapRecord) : undefined
-
-      const write = prepareDelete({
-        did,
-        collection,
-        rkey,
-        swapCid: swapRecordCid,
-      })
-      const commit = await ctx.actorStore.transact(did, async (actorTxn) => {
-        const record = await actorTxn.record.getRecord(write.uri, null, true)
-        if (!record) {
-          return null // No-op if record already doesn't exist
-        }
-
-        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.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: commit
-            ? {
-                cid: commit.cid.toString(),
-                rev: commit.rev,
-              }
-            : undefined,
-        },
-      }
-    },
-  })
-}

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

@@ -1,43 +0,0 @@
-import * as id from '@atproto/identity'
-import { HandleString, INVALID_HANDLE } from '@atproto/syntax'
-import { InvalidRequestError, Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { com } from '../../../../lexicons/index.js'
-import { assertRepoAvailability } from '../sync/util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(
-    com.atproto.repo.describeRepo,
-    async ({ params }): Promise<com.atproto.repo.describeRepo.$Output> => {
-      const { repo } = params
-
-      const account = await assertRepoAvailability(ctx, repo, false)
-
-      let didDoc: id.DidDocument
-      try {
-        didDoc = await ctx.idResolver.did.ensureResolve(account.did)
-      } catch (err) {
-        throw new InvalidRequestError(`Could not resolve DID: ${err}`)
-      }
-
-      const handle = id.getHandle(didDoc)
-      const handleIsCorrect = handle === account.handle
-
-      const collections = await ctx.actorStore.read(account.did, (store) =>
-        store.record.listCollections(),
-      )
-
-      return {
-        encoding: 'application/json' as const,
-        body: {
-          handle: (account.handle ?? INVALID_HANDLE) as HandleString,
-          did: account.did,
-          // @ts-expect-error https://github.com/bluesky-social/atproto/pull/4406
-          didDoc,
-          collections,
-          handleIsCorrect,
-        },
-      }
-    },
-  )
-}

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

@@ -1,40 +0,0 @@
-import { atUri } from '@atproto/lex'
-import { InvalidRequestError, Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { com } from '../../../../lexicons/index.js'
-import { pipethrough } from '../../../../pipethrough.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(com.atproto.repo.getRecord, async ({ req, params }) => {
-    const { repo, collection, rkey, cid } = params
-    const did = await ctx.accountManager.getDidForActor(repo)
-
-    // fetch from pds if available, if not then fetch from appview
-    if (did) {
-      const uri = atUri(did, collection, rkey)
-      const record = await ctx.actorStore.read(did, (store) =>
-        store.record.getRecord(uri, cid ?? null),
-      )
-      if (!record || record.takedownRef !== null) {
-        throw new InvalidRequestError(
-          `Could not locate record: ${uri}`,
-          'RecordNotFound',
-        )
-      }
-      return {
-        encoding: 'application/json' as const,
-        body: {
-          uri,
-          cid: record.cid,
-          value: record.value,
-        },
-      }
-    }
-
-    if (!ctx.cfg.bskyAppView) {
-      throw new InvalidRequestError(`Could not locate record`)
-    }
-
-    return pipethrough(ctx, req)
-  })
-}

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

@@ -1,101 +0,0 @@
-import { TID } from '@atproto/common'
-import { LexMap, enumBlobRefs } from '@atproto/lex-data'
-import {
-  BlockMap,
-  WriteOpAction,
-  getAndParseRecord,
-  readCarStream,
-  verifyDiff,
-} from '@atproto/repo'
-import { AtUri } from '@atproto/syntax'
-import { InvalidRequestError, Server } from '@atproto/xrpc-server'
-import { ACCESS_FULL } from '../../../../auth-scope.js'
-import { AppContext } from '../../../../context.js'
-import { com } from '../../../../lexicons/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(com.atproto.repo.importRepo, {
-    opts: {
-      blobLimit: ctx.cfg.service.maxImportSize,
-    },
-    auth: ctx.authVerifier.authorization({
-      checkTakedown: true,
-      scopes: ACCESS_FULL,
-      authorize: (permissions) => {
-        permissions.assertAccount({ attr: 'repo', action: 'manage' })
-      },
-    }),
-    handler: async ({ input, auth }) => {
-      if (!ctx.cfg.service.acceptingImports) {
-        throw new InvalidRequestError('Service is not accepting repo imports')
-      }
-
-      const { did } = auth.credentials
-
-      // @NOTE process as much as we can before the transaction, in particular
-      // the reading of the body stream.
-      const { roots, blocks } = await readCarStream(input.body)
-      if (roots.length !== 1) {
-        await blocks.dump()
-        throw new InvalidRequestError('expected one root')
-      }
-
-      const blockMap = new BlockMap()
-      for await (const block of blocks) {
-        blockMap.set(block.cid, block.bytes)
-      }
-
-      await ctx.actorStore.transact(did, async (store) => {
-        const now = new Date().toISOString()
-        const rev = TID.nextStr()
-        const did = store.repo.did
-
-        const currRepo = await store.repo.maybeLoadRepo()
-        const diff = await verifyDiff(
-          currRepo,
-          blockMap,
-          roots[0],
-          undefined,
-          undefined,
-          { ensureLeaves: false },
-        )
-        diff.commit.rev = rev
-        await store.repo.storage.applyCommit(diff.commit, currRepo === null)
-
-        // @NOTE There is no point in performing the following concurrently
-        // since better-sqlite3 is synchronous.
-        for (const write of diff.writes) {
-          const uri = AtUri.make(did, write.collection, write.rkey)
-          if (write.action === WriteOpAction.Delete) {
-            await store.record.deleteRecord(uri)
-          } else {
-            let parsedRecord: LexMap
-            try {
-              // @NOTE getAndParseRecord returns a promise for historical
-              // reasons but it's internal processing is actually synchronous.
-              const parsed = await getAndParseRecord(blockMap, write.cid)
-              parsedRecord = parsed.record
-            } catch {
-              throw new InvalidRequestError(
-                `Could not parse record at '${write.collection}/${write.rkey}'`,
-              )
-            }
-
-            await store.record.indexRecord(
-              uri,
-              write.cid,
-              parsedRecord,
-              write.action,
-              rev,
-              now,
-            )
-            const recordBlobs = Array.from(
-              enumBlobRefs(parsedRecord, { allowLegacy: true, strict: false }),
-            )
-            await store.repo.blob.insertBlobs(uri.toString(), recordBlobs)
-          }
-        }
-      })
-    },
-  })
-}

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

@@ -1,25 +0,0 @@
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import applyWrites from './applyWrites.js'
-import createRecord from './createRecord.js'
-import deleteRecord from './deleteRecord.js'
-import describeRepo from './describeRepo.js'
-import getRecord from './getRecord.js'
-import importRepo from './importRepo.js'
-import listMissingBlobs from './listMissingBlobs.js'
-import listRecords from './listRecords.js'
-import putRecord from './putRecord.js'
-import uploadBlob from './uploadBlob.js'
-
-export default function (server: Server, ctx: AppContext) {
-  applyWrites(server, ctx)
-  createRecord(server, ctx)
-  deleteRecord(server, ctx)
-  describeRepo(server, ctx)
-  getRecord(server, ctx)
-  listRecords(server, ctx)
-  putRecord(server, ctx)
-  uploadBlob(server, ctx)
-  listMissingBlobs(server, ctx)
-  importRepo(server, ctx)
-}

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

@@ -1,29 +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.repo.listMissingBlobs, {
-    auth: ctx.authVerifier.authorization({
-      authorize: () => {
-        // always allow
-      },
-    }),
-    handler: async ({ auth, params }) => {
-      const { did } = auth.credentials
-      const { limit, cursor } = params
-
-      const blobs = await ctx.actorStore.read(did, (store) =>
-        store.repo.blob.listMissingBlobs({ limit, cursor }),
-      )
-
-      return {
-        encoding: 'application/json' as const,
-        body: {
-          blobs,
-          cursor: blobs.at(-1)?.cid,
-        },
-      }
-    },
-  })
-}

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

@@ -1,36 +0,0 @@
-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.repo.listRecords, async ({ params }) => {
-    const { repo, collection, limit = 50, cursor, reverse = false } = params
-
-    const did = await ctx.accountManager.getDidForActor(repo)
-    if (!did) {
-      throw new InvalidRequestError(`Could not find repo: ${repo}`)
-    }
-
-    const records = await ctx.actorStore.read(did, (store) =>
-      store.record.listRecordsForCollection({
-        collection,
-        limit,
-        reverse,
-        cursor,
-      }),
-    )
-
-    const lastRecord = records.at(-1)
-    const lastUri = lastRecord && new AtUri(lastRecord?.uri)
-
-    return {
-      encoding: 'application/json' as const,
-      body: {
-        records,
-        // Paginate with `before` by default, paginate with `after` when using `reverse`.
-        cursor: lastUri?.rkey,
-      },
-    }
-  })
-}