@atproto/pds 0.4.216 → 0.4.218

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

@@ -1,12 +1,11 @@
 import { DAY, MINUTE } 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'
 import { httpLogger } from '../../../../logger'
 
 export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.identity.updateHandle({
+  server.add(com.atproto.identity.updateHandle, {
     auth: ctx.authVerifier.authorization({
       checkTakedown: true,
       authorize: (permissions) => {
@@ -28,19 +27,23 @@ export default function (server: Server, ctx: AppContext) {
     handler: async ({ auth, input, req }) => {
       const requester = auth.credentials.did
 
-      if (ctx.entrywayAgent) {
+      if (ctx.entrywayClient) {
+        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 ctx.entrywayAgent.com.atproto.identity.updateHandle(
-          // @ts-expect-error "did" is not in the schema
-          { did: requester, handle: input.body.handle },
-          await ctx.entrywayAuthHeaders(
-            req,
-            auth.credentials.did,
-            ids.ComAtprotoIdentityUpdateHandle,
-          ),
-        )
+        await ctx.entrywayClient.xrpc(com.atproto.identity.updateHandle, {
+          headers,
+          body: {
+            handle: input.body.handle,
+            // @ts-expect-error "did" is not in the schema
+            did: requester,
+          },
+        })
         return
       }
 

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

@@ -1,5 +1,5 @@
+import { Server } from '@atproto/xrpc-server'
 import { AppContext } from '../../../context'
-import { Server } from '../../../lexicon'
 import admin from './admin'
 import identity from './identity'
 import moderation from './moderation'

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

@@ -1,41 +1,41 @@
-import { AtpAgent } from '@atproto/api'
+import { xrpc } from '@atproto/lex'
+import { Server } from '@atproto/xrpc-server'
 import { AuthScope } from '../../../../auth-scope'
 import { AppContext } from '../../../../context'
-import { Server } from '../../../../lexicon'
-import { ids } from '../../../../lexicon/lexicons'
+import { com } from '../../../../lexicons/index.js'
 import { computeProxyTo, parseProxyInfo } from '../../../../pipethrough'
 
 export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.moderation.createReport({
+  server.add(com.atproto.moderation.createReport, {
     auth: ctx.authVerifier.authorization({
       additional: [AuthScope.Takendown],
       authorize: (permissions, { req }) => {
-        const lxm = ids.ComAtprotoModerationCreateReport
+        const lxm = com.atproto.moderation.createReport.$lxm
         const aud = computeProxyTo(ctx, req, lxm)
         permissions.assertRpc({ aud, lxm })
       },
     }),
-    handler: async ({ auth, input, req }) => {
+    handler: async ({ auth, params, input: { body }, req }) => {
       const { url, did: aud } = await parseProxyInfo(
         ctx,
         req,
-        ids.ComAtprotoModerationCreateReport,
+        com.atproto.moderation.createReport.$lxm,
       )
-      const agent = new AtpAgent({ service: url })
-      const serviceAuth = await ctx.serviceAuthHeaders(
+
+      const { headers } = await ctx.serviceAuthHeaders(
         auth.credentials.did,
         aud,
-        ids.ComAtprotoModerationCreateReport,
+        com.atproto.moderation.createReport.$lxm,
       )
-      const res = await agent.com.atproto.moderation.createReport(input.body, {
-        ...serviceAuth,
-        encoding: 'application/json',
-      })
 
-      return {
-        encoding: 'application/json',
-        body: res.data,
-      }
+      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,5 +1,5 @@
+import { Server } from '@atproto/xrpc-server'
 import { AppContext } from '../../../../context'
-import { Server } from '../../../../lexicon'
 import createReport from './createReport'
 
 export default function (server: Server, ctx: AppContext) {

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

@@ -1,17 +1,12 @@
-import { CID } from 'multiformats/cid'
+import { parseCid } from '@atproto/lex-data'
 import { WriteOpAction } from '@atproto/repo'
-import { AuthRequiredError, InvalidRequestError } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context'
-import { Server } from '../../../../lexicon'
 import {
-  CreateResult,
-  DeleteResult,
-  HandlerInput,
-  UpdateResult,
-  isCreate,
-  isDelete,
-  isUpdate,
-} from '../../../../lexicon/types/com/atproto/repo/applyWrites'
+  AuthRequiredError,
+  InvalidRequestError,
+  Server,
+} from '@atproto/xrpc-server'
+import { AppContext } from '../../../../context'
+import { com } from '../../../../lexicons/index.js'
 import { dbLogger } from '../../../../logger'
 import {
   BadCommitSwapError,
@@ -22,12 +17,16 @@ import {
   prepareUpdate,
 } from '../../../../repo'
 
-const ratelimitPoints = ({ input }: { input: HandlerInput }) => {
+const ratelimitPoints = ({
+  input,
+}: {
+  input: com.atproto.repo.applyWrites.$Input
+}) => {
   let points = 0
   for (const op of input.body.writes) {
-    if (isCreate(op)) {
+    if (com.atproto.repo.applyWrites.create.$isTypeOf(op)) {
       points += 3
-    } else if (isUpdate(op)) {
+    } else if (com.atproto.repo.applyWrites.update.$isTypeOf(op)) {
       points += 2
     } else {
       points += 1
@@ -37,7 +36,7 @@ const ratelimitPoints = ({ input }: { input: HandlerInput }) => {
 }
 
 export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.repo.applyWrites({
+  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
@@ -87,9 +86,30 @@ export default function (server: Server, ctx: AppContext) {
       if (auth.credentials.type === 'oauth') {
         // @NOTE Unlike "importRepo", we do not require "action" = "*" here.
         for (const [action, collections] of [
-          ['create', new Set(writes.filter(isCreate).map((w) => w.collection))],
-          ['update', new Set(writes.filter(isUpdate).map((w) => w.collection))],
-          ['delete', new Set(writes.filter(isDelete).map((w) => w.collection))],
+          [
+            '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 })
@@ -101,24 +121,26 @@ export default function (server: Server, ctx: AppContext) {
       let preparedWrites: PreparedWrite[]
       try {
         preparedWrites = await Promise.all(
-          writes.map(async (write) => {
-            if (isCreate(write)) {
+          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 (isUpdate(write)) {
+            } 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 (isDelete(write)) {
+            } else if (com.atproto.repo.applyWrites.delete.$isTypeOf(write)) {
               return prepareDelete({
                 did,
                 collection: write.collection,
@@ -138,7 +160,7 @@ export default function (server: Server, ctx: AppContext) {
         throw err
       }
 
-      const swapCommitCid = swapCommit ? CID.parse(swapCommit) : undefined
+      const swapCommitCid = swapCommit ? parseCid(swapCommit) : undefined
 
       const commit = await ctx.actorStore.transact(did, async (actorTxn) => {
         const commit = await actorTxn.repo
@@ -165,7 +187,7 @@ export default function (server: Server, ctx: AppContext) {
         })
 
       return {
-        encoding: 'application/json',
+        encoding: 'application/json' as const,
         body: {
           commit: {
             cid: commit.cid.toString(),
@@ -181,23 +203,19 @@ export default function (server: Server, ctx: AppContext) {
 const writeToOutputResult = (write: PreparedWrite) => {
   switch (write.action) {
     case WriteOpAction.Create:
-      return {
-        $type: 'com.atproto.repo.applyWrites#createResult',
+      return com.atproto.repo.applyWrites.createResult.$build({
         cid: write.cid.toString(),
         uri: write.uri.toString(),
         validationStatus: write.validationStatus,
-      } satisfies CreateResult
+      })
     case WriteOpAction.Update:
-      return {
-        $type: 'com.atproto.repo.applyWrites#updateResult',
+      return com.atproto.repo.applyWrites.updateResult.$build({
         cid: write.cid.toString(),
         uri: write.uri.toString(),
         validationStatus: write.validationStatus,
-      } satisfies UpdateResult
+      })
     case WriteOpAction.Delete:
-      return {
-        $type: 'com.atproto.repo.applyWrites#deleteResult',
-      } satisfies DeleteResult
+      return com.atproto.repo.applyWrites.deleteResult.$build({})
     default:
       throw new Error(`Unrecognized action: ${write}`)
   }

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

@@ -1,8 +1,12 @@
-import { CID } from 'multiformats/cid'
+import { parseCid } from '@atproto/lex-data'
 import { InvalidRecordKeyError } from '@atproto/syntax'
-import { AuthRequiredError, InvalidRequestError } from '@atproto/xrpc-server'
+import {
+  AuthRequiredError,
+  InvalidRequestError,
+  Server,
+} from '@atproto/xrpc-server'
 import { AppContext } from '../../../../context'
-import { Server } from '../../../../lexicon'
+import { com } from '../../../../lexicons/index.js'
 import { dbLogger } from '../../../../logger'
 import {
   BadCommitSwapError,
@@ -13,7 +17,7 @@ import {
 } from '../../../../repo'
 
 export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.repo.createRecord({
+  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
@@ -61,7 +65,7 @@ export default function (server: Server, ctx: AppContext) {
         })
       }
 
-      const swapCommitCid = swapCommit ? CID.parse(swapCommit) : undefined
+      const swapCommitCid = swapCommit ? parseCid(swapCommit) : undefined
 
       let write: PreparedCreate
       try {
@@ -92,9 +96,9 @@ export default function (server: Server, ctx: AppContext) {
             : []
         const backlinkDeletions = backlinkConflicts.map((uri) =>
           prepareDelete({
-            did: uri.hostname,
-            collection: uri.collection,
-            rkey: uri.rkey,
+            did: uri.did,
+            collection: uri.collectionSafe,
+            rkey: uri.rkeySafe,
           }),
         )
         const writes = [...backlinkDeletions, write]
@@ -120,7 +124,7 @@ export default function (server: Server, ctx: AppContext) {
         })
 
       return {
-        encoding: 'application/json',
+        encoding: 'application/json' as const,
         body: {
           uri: write.uri.toString(),
           cid: write.cid.toString(),

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

@@ -1,7 +1,11 @@
-import { CID } from 'multiformats/cid'
-import { AuthRequiredError, InvalidRequestError } from '@atproto/xrpc-server'
+import { parseCid } from '@atproto/lex-data'
+import {
+  AuthRequiredError,
+  InvalidRequestError,
+  Server,
+} from '@atproto/xrpc-server'
 import { AppContext } from '../../../../context'
-import { Server } from '../../../../lexicon'
+import { com } from '../../../../lexicons/index.js'
 import { dbLogger } from '../../../../logger'
 import {
   BadCommitSwapError,
@@ -10,7 +14,7 @@ import {
 } from '../../../../repo'
 
 export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.repo.deleteRecord({
+  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
@@ -37,8 +41,8 @@ export default function (server: Server, ctx: AppContext) {
         calcPoints: () => 1,
       },
     ],
-    handler: async ({ input, auth }) => {
-      const { repo, collection, rkey, swapCommit, swapRecord } = input.body
+    handler: async ({ input: { body }, auth }) => {
+      const { repo, collection, rkey, swapCommit, swapRecord } = body
 
       const account = await ctx.authVerifier.findAccount(repo, {
         checkDeactivated: true,
@@ -59,8 +63,8 @@ export default function (server: Server, ctx: AppContext) {
         })
       }
 
-      const swapCommitCid = swapCommit ? CID.parse(swapCommit) : undefined
-      const swapRecordCid = swapRecord ? CID.parse(swapRecord) : undefined
+      const swapCommitCid = swapCommit ? parseCid(swapCommit) : undefined
+      const swapRecordCid = swapRecord ? parseCid(swapRecord) : undefined
 
       const write = prepareDelete({
         did,
@@ -103,7 +107,7 @@ export default function (server: Server, ctx: AppContext) {
       }
 
       return {
-        encoding: 'application/json',
+        encoding: 'application/json' as const,
         body: {
           commit: commit
             ? {

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

@@ -1,39 +1,43 @@
 import * as id from '@atproto/identity'
-import { INVALID_HANDLE } from '@atproto/syntax'
-import { InvalidRequestError } from '@atproto/xrpc-server'
+import { HandleString, INVALID_HANDLE } from '@atproto/syntax'
+import { InvalidRequestError, Server } from '@atproto/xrpc-server'
 import { AppContext } from '../../../../context'
-import { Server } from '../../../../lexicon'
+import { com } from '../../../../lexicons/index.js'
 import { assertRepoAvailability } from '../sync/util'
 
 export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.repo.describeRepo(async ({ params }) => {
-    const { repo } = params
+  server.add(
+    com.atproto.repo.describeRepo,
+    async ({ params }): Promise<com.atproto.repo.describeRepo.$Output> => {
+      const { repo } = params
 
-    const account = await assertRepoAvailability(ctx, repo, false)
+      const account = await assertRepoAvailability(ctx, repo, false)
 
-    let didDoc
-    try {
-      didDoc = await ctx.idResolver.did.ensureResolve(account.did)
-    } catch (err) {
-      throw new InvalidRequestError(`Could not resolve DID: ${err}`)
-    }
+      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 handle = id.getHandle(didDoc)
+      const handleIsCorrect = handle === account.handle
 
-    const collections = await ctx.actorStore.read(account.did, (store) =>
-      store.record.listCollections(),
-    )
+      const collections = await ctx.actorStore.read(account.did, (store) =>
+        store.record.listCollections(),
+      )
 
-    return {
-      encoding: 'application/json',
-      body: {
-        handle: account.handle ?? INVALID_HANDLE,
-        did: account.did,
-        didDoc,
-        collections,
-        handleIsCorrect,
-      },
-    }
-  })
+      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,11 +1,11 @@
 import { AtUri } from '@atproto/syntax'
-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'
 import { pipethrough } from '../../../../pipethrough'
 
 export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.repo.getRecord(async ({ req, params }) => {
+  server.add(com.atproto.repo.getRecord, async ({ req, params }) => {
     const { repo, collection, rkey, cid } = params
     const did = await ctx.accountManager.getDidForActor(repo)
 
@@ -22,7 +22,7 @@ export default function (server: Server, ctx: AppContext) {
         )
       }
       return {
-        encoding: 'application/json',
+        encoding: 'application/json' as const,
         body: {
           uri: uri.toString(),
           cid: record.cid,

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

@@ -1,6 +1,5 @@
-import { CID } from 'multiformats/cid'
 import { TID } from '@atproto/common'
-import { BlobRef, LexValue, RepoRecord } from '@atproto/lexicon'
+import { LexMap, enumBlobRefs } from '@atproto/lex-data'
 import {
   BlockMap,
   WriteOpAction,
@@ -9,13 +8,13 @@ import {
   verifyDiff,
 } from '@atproto/repo'
 import { AtUri } from '@atproto/syntax'
-import { InvalidRequestError } from '@atproto/xrpc-server'
+import { InvalidRequestError, Server } from '@atproto/xrpc-server'
 import { ACCESS_FULL } from '../../../../auth-scope'
 import { AppContext } from '../../../../context'
-import { Server } from '../../../../lexicon'
+import { com } from '../../../../lexicons/index.js'
 
 export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.repo.importRepo({
+  server.add(com.atproto.repo.importRepo, {
     opts: {
       blobLimit: ctx.cfg.service.maxImportSize,
     },
@@ -70,7 +69,7 @@ export default function (server: Server, ctx: AppContext) {
           if (write.action === WriteOpAction.Delete) {
             await store.record.deleteRecord(uri)
           } else {
-            let parsedRecord: RepoRecord
+            let parsedRecord: LexMap
             try {
               // @NOTE getAndParseRecord returns a promise for historical
               // reasons but it's internal processing is actually synchronous.
@@ -90,7 +89,9 @@ export default function (server: Server, ctx: AppContext) {
               rev,
               now,
             )
-            const recordBlobs = findBlobRefs(parsedRecord)
+            const recordBlobs = Array.from(
+              enumBlobRefs(parsedRecord, { allowLegacy: true, strict: false }),
+            )
             await store.repo.blob.insertBlobs(uri.toString(), recordBlobs)
           }
         }
@@ -98,27 +99,3 @@ export default function (server: Server, ctx: AppContext) {
     },
   })
 }
-
-export const findBlobRefs = (val: LexValue, layer = 0): BlobRef[] => {
-  if (layer > 32) {
-    return []
-  }
-  // walk arrays
-  if (Array.isArray(val)) {
-    return val.flatMap((item) => findBlobRefs(item, layer + 1))
-  }
-  // objects
-  if (val && typeof val === 'object') {
-    // convert blobs, leaving the original encoding so that we don't change CIDs on re-encode
-    if (val instanceof BlobRef) {
-      return [val]
-    }
-    // retain cids & bytes
-    if (CID.asCID(val) || val instanceof Uint8Array) {
-      return []
-    }
-    return Object.values(val).flatMap((item) => findBlobRefs(item, layer + 1))
-  }
-  // pass through
-  return []
-}

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

@@ -1,5 +1,5 @@
+import { Server } from '@atproto/xrpc-server'
 import { AppContext } from '../../../../context'
-import { Server } from '../../../../lexicon'
 import applyWrites from './applyWrites'
 import createRecord from './createRecord'
 import deleteRecord from './deleteRecord'

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

@@ -1,8 +1,9 @@
+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.repo.listMissingBlobs({
+  server.add(com.atproto.repo.listMissingBlobs, {
     auth: ctx.authVerifier.authorization({
       authorize: () => {
         // always allow
@@ -17,7 +18,7 @@ export default function (server: Server, ctx: AppContext) {
       )
 
       return {
-        encoding: 'application/json',
+        encoding: 'application/json' as const,
         body: {
           blobs,
           cursor: blobs.at(-1)?.cid,

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

@@ -1,10 +1,10 @@
 import { AtUri } from '@atproto/syntax'
-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.repo.listRecords(async ({ params }) => {
+  server.add(com.atproto.repo.listRecords, async ({ params }) => {
     const { repo, collection, limit = 50, cursor, reverse = false } = params
 
     const did = await ctx.accountManager.getDidForActor(repo)
@@ -25,7 +25,7 @@ export default function (server: Server, ctx: AppContext) {
     const lastUri = lastRecord && new AtUri(lastRecord?.uri)
 
     return {
-      encoding: 'application/json',
+      encoding: 'application/json' as const,
       body: {
         records,
         // Paginate with `before` by default, paginate with `after` when using `reverse`.