@atproto/pds 0.5.12 → 0.5.14

package/src/api/app/bsky/actor/putPreferences.ts

@@ -1,62 +0,0 @@
-import { InvalidRequestError, Server } from '@atproto/xrpc-server'
-import { AccountPreference } from '../../../../actor-store/preference/reader.js'
-import { isAccessFull } from '../../../../auth-scope.js'
-import { AppContext } from '../../../../context.js'
-import { app } from '../../../../lexicons/index.js'
-import {
-  bareDidFromProxyTo,
-  computeProxyTo,
-  pipethrough,
-} from '../../../../pipethrough.js'
-
-export default function (server: Server, ctx: AppContext) {
-  const { bskyAppView } = ctx
-  if (!bskyAppView) return
-
-  server.add(app.bsky.actor.putPreferences, {
-    auth: ctx.authVerifier.authorization({
-      checkTakedown: true,
-      authorize: (permissions, { req }) => {
-        const lxm = app.bsky.actor.putPreferences.$lxm
-        const aud = computeProxyTo(ctx, req, lxm)
-        permissions.assertRpc({ aud, lxm })
-      },
-    }),
-    handler: async ({ req, auth, input }) => {
-      const { did } = auth.credentials
-
-      // If the request has a proxy header different from the bsky app view,
-      // we need to proxy the request to the requested app view.
-      // @TODO This behavior should not be implemented as part of the XRPC framework
-      const lxm = app.bsky.actor.putPreferences.$lxm
-      const aud = computeProxyTo(ctx, req, lxm)
-      if (aud !== `${bskyAppView.did}#bsky_appview`) {
-        // Phase 1 of service auth updates: outbound JWT keeps bare-DID aud.
-        return pipethrough(ctx, req, {
-          iss: did,
-          aud: bareDidFromProxyTo(aud),
-          lxm,
-        })
-      }
-
-      const checkedPreferences: AccountPreference[] = []
-      for (const pref of input.body.preferences) {
-        if (typeof pref.$type === 'string') {
-          checkedPreferences.push(pref as AccountPreference)
-        } else {
-          throw new InvalidRequestError('Preference is missing a $type')
-        }
-      }
-
-      const hasAccessFull =
-        auth.credentials.type === 'access' &&
-        isAccessFull(auth.credentials.scope)
-
-      await ctx.actorStore.transact(did, async (actorTxn) => {
-        await actorTxn.pref.putPreferences(checkedPreferences, 'app.bsky', {
-          hasAccessFull,
-        })
-      })
-    },
-  })
-}

package/src/api/app/bsky/feed/getActorLikes.ts

@@ -1,63 +0,0 @@
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { app } from '../../../../lexicons/index.js'
-import { computeProxyTo } from '../../../../pipethrough.js'
-import {
-  MungeFn,
-  pipethroughReadAfterWrite,
-} from '../../../../read-after-write/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  if (!ctx.bskyAppView) return
-
-  server.add(app.bsky.feed.getActorLikes, {
-    auth: ctx.authVerifier.authorization({
-      authorize: (permissions, { req }) => {
-        const lxm = app.bsky.feed.getActorLikes.$lxm
-        const aud = computeProxyTo(ctx, req, lxm)
-        permissions.assertRpc({ aud, lxm })
-      },
-    }),
-    handler: async (reqCtx) => {
-      return pipethroughReadAfterWrite(
-        ctx,
-        reqCtx,
-        app.bsky.feed.getActorLikes,
-        getAuthorMunge,
-      )
-    },
-  })
-}
-
-const getAuthorMunge: MungeFn<app.bsky.feed.getActorLikes.$OutputBody> = async (
-  localViewer,
-  original,
-  local,
-  requester,
-) => {
-  const localProf = local.profile
-  let feed = original.feed
-  // first update any out of date profile pictures in feed
-  if (localProf) {
-    feed = feed.map((item) => {
-      if (item.post.author.did === requester) {
-        return {
-          ...item,
-          post: {
-            ...item.post,
-            author: localViewer.updateProfileViewBasic(
-              item.post.author,
-              localProf.record,
-            ),
-          },
-        }
-      } else {
-        return item
-      }
-    })
-  }
-  return {
-    ...original,
-    feed,
-  }
-}

package/src/api/app/bsky/feed/getAuthorFeed.ts

@@ -1,84 +0,0 @@
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { app } from '../../../../lexicons/index.js'
-import { computeProxyTo } from '../../../../pipethrough.js'
-import {
-  MungeFn,
-  pipethroughReadAfterWrite,
-} from '../../../../read-after-write/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  if (!ctx.bskyAppView) return
-
-  server.add(app.bsky.feed.getAuthorFeed, {
-    auth: ctx.authVerifier.authorization({
-      authorize: (permissions, { req }) => {
-        const lxm = app.bsky.feed.getAuthorFeed.$lxm
-        const aud = computeProxyTo(ctx, req, lxm)
-        permissions.assertRpc({ aud, lxm })
-      },
-    }),
-    handler: async (reqCtx) => {
-      return pipethroughReadAfterWrite(
-        ctx,
-        reqCtx,
-        app.bsky.feed.getAuthorFeed,
-        getAuthorMunge,
-      )
-    },
-  })
-}
-
-const getAuthorMunge: MungeFn<app.bsky.feed.getAuthorFeed.$OutputBody> = async (
-  localViewer,
-  original,
-  local,
-  requester,
-) => {
-  const localProf = local.profile
-  // only munge on own feed
-  if (!isUsersFeed(original, requester)) {
-    return original
-  }
-  let feed = original.feed
-  // first update any out of date profile pictures in feed
-  if (localProf) {
-    feed = feed.map((item) => {
-      if (item.post.author.did === requester) {
-        return {
-          ...item,
-          post: {
-            ...item.post,
-            author: localViewer.updateProfileViewBasic(
-              item.post.author,
-              localProf.record,
-            ),
-          },
-        }
-      } else {
-        return item
-      }
-    })
-  }
-  feed = await localViewer.formatAndInsertPostsInFeed(feed, local.posts)
-  return {
-    ...original,
-    feed,
-  }
-}
-
-const isUsersFeed = (
-  feed: app.bsky.feed.getAuthorFeed.$OutputBody,
-  requester: string,
-) => {
-  const first = feed.feed.at(0)
-  if (!first) return false
-  if (!first.reason && first.post.author.did === requester) return true
-  if (
-    first.reason &&
-    app.bsky.feed.defs.reasonRepost.$isTypeOf(first.reason) &&
-    first.reason.by.did === requester
-  )
-    return true
-  return false
-}

package/src/api/app/bsky/feed/getFeed.ts

@@ -1,47 +0,0 @@
-import { InvalidRequestError } from '@atproto/oauth-provider'
-import { AtUri } from '@atproto/syntax'
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { app, com } from '../../../../lexicons/index.js'
-import { computeProxyTo, pipethrough } from '../../../../pipethrough.js'
-
-export default function (server: Server, ctx: AppContext) {
-  const { bskyAppView } = ctx
-  if (!bskyAppView) return
-
-  server.add(app.bsky.feed.getFeed, {
-    auth: ctx.authVerifier.authorization({
-      authorize: (permissions, { req }) => {
-        const lxm = app.bsky.feed.getFeed.$lxm
-        const aud = computeProxyTo(ctx, req, lxm)
-        permissions.assertRpc({ aud, lxm })
-        permissions.assertRpc({ aud, lxm: app.bsky.feed.getFeedSkeleton.$lxm })
-      },
-    }),
-    handler: async ({ params, auth, req }) => {
-      const requester = auth.credentials.did
-
-      const feedUrl = new AtUri(params.feed)
-
-      const data = await bskyAppView.client.call(com.atproto.repo.getRecord, {
-        repo: feedUrl.host,
-        collection: feedUrl.collectionSafe,
-        rkey: feedUrl.rkeySafe,
-      })
-
-      const feedDid = data.value['did']
-      if (typeof feedDid !== 'string') {
-        throw new InvalidRequestError(
-          'could not resolve feed did',
-          'UnknownFeed',
-        )
-      }
-
-      return pipethrough(ctx, req, {
-        iss: requester,
-        aud: feedDid,
-        lxm: app.bsky.feed.getFeedSkeleton.$lxm,
-      })
-    },
-  })
-}

package/src/api/app/bsky/feed/getPostThread.ts

@@ -1,251 +0,0 @@
-import assert from 'node:assert'
-import { isHandleString, l } from '@atproto/lex'
-import { AtUri, AtUriString } from '@atproto/syntax'
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { app } from '../../../../lexicons/index.js'
-import {
-  PipethroughUpstreamError,
-  computeProxyTo,
-} from '../../../../pipethrough.js'
-import {
-  LocalViewer,
-  MungeFn,
-  RecordDescript,
-  formatMungedResponse,
-  getLocalLag,
-  pipethroughReadAfterWrite,
-} from '../../../../read-after-write/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  if (!ctx.bskyAppView) return
-
-  server.add(app.bsky.feed.getPostThread, {
-    auth: ctx.authVerifier.authorization({
-      authorize: (permissions, { req }) => {
-        const lxm = app.bsky.feed.getPostThread.$lxm
-        const aud = computeProxyTo(ctx, req, lxm)
-        permissions.assertRpc({ aud, lxm })
-      },
-    }),
-    opts: {
-      // @TODO remove after grace period has passed, behavior is non-standard.
-      // temporarily added for compat w/ previous version of xrpc-server to avoid breakage of a few specified parties.
-      paramsParseLoose: true,
-    },
-    handler: async (reqCtx) => {
-      try {
-        return await pipethroughReadAfterWrite(
-          ctx,
-          reqCtx,
-          app.bsky.feed.getPostThread,
-          getPostThreadMunge,
-        )
-      } catch (err) {
-        if (
-          err instanceof PipethroughUpstreamError &&
-          err.error === 'NotFound'
-        ) {
-          const { auth, params } = reqCtx
-          const requester = auth.credentials.did
-
-          const rev = err.headers?.['atproto-repo-rev']
-          if (!rev) throw err
-
-          const uri = new AtUri(params.uri)
-          if (
-            !uri.hostname.startsWith('did:') &&
-            isHandleString(uri.hostname)
-          ) {
-            const account = await ctx.accountManager.getAccount(uri.hostname)
-            if (account) {
-              uri.hostname = account.did
-            }
-          }
-          if (uri.hostname !== requester) throw err
-
-          const local = await ctx.actorStore.read(requester, (store) => {
-            const localViewer = ctx.localViewer(store)
-            return readAfterWriteNotFound(
-              ctx,
-              localViewer,
-              params,
-              requester,
-              rev,
-              uri,
-            )
-          })
-          if (local === null) {
-            throw err
-          } else {
-            return formatMungedResponse(local.data, local.lag)
-          }
-        } else {
-          throw err
-        }
-      }
-    },
-  })
-}
-
-// READ AFTER WRITE
-// ----------------
-
-const getPostThreadMunge: MungeFn<
-  app.bsky.feed.getPostThread.$OutputBody
-> = async (localViewer, original, local) => {
-  // @TODO if is NotFoundPost, handle similarly to error
-  // @NOTE not necessary right now as we never return those for the requested uri
-  if (!app.bsky.feed.defs.threadViewPost.$isTypeOf(original.thread)) {
-    return original
-  }
-  const thread = await addPostsToThread(
-    localViewer,
-    original.thread,
-    local.posts,
-  )
-  return {
-    ...original,
-    thread,
-  }
-}
-
-const addPostsToThread = async (
-  localViewer: LocalViewer,
-  original: l.$Typed<app.bsky.feed.defs.ThreadViewPost>,
-  posts: RecordDescript<app.bsky.feed.post.Main>[],
-) => {
-  const inThread = findPostsInThread(original, posts)
-  if (inThread.length === 0) return original
-  let thread: l.$Typed<app.bsky.feed.defs.ThreadViewPost> = original
-  for (const record of inThread) {
-    thread = await insertIntoThreadReplies(localViewer, thread, record)
-  }
-  return thread
-}
-
-const findPostsInThread = (
-  thread: app.bsky.feed.defs.ThreadViewPost,
-  posts: RecordDescript<app.bsky.feed.post.Main>[],
-): RecordDescript<app.bsky.feed.post.Main>[] => {
-  return posts.filter((post) => {
-    const rootUri = post.record.reply?.root.uri
-    if (!rootUri) return false
-    if (rootUri === thread.post.uri) return true
-    return (
-      (thread.post.record as app.bsky.feed.post.Main).reply?.root.uri ===
-      rootUri
-    )
-  })
-}
-
-const insertIntoThreadReplies = async (
-  localViewer: LocalViewer,
-  view: l.$Typed<app.bsky.feed.defs.ThreadViewPost>,
-  descript: RecordDescript<app.bsky.feed.post.Main>,
-): Promise<l.$Typed<app.bsky.feed.defs.ThreadViewPost>> => {
-  if (descript.record.reply?.parent.uri === view.post.uri) {
-    const postView = await threadPostView(localViewer, descript)
-    if (!postView) return view
-    const replies = [postView, ...(view.replies ?? [])]
-    return {
-      ...view,
-      replies,
-    }
-  }
-  if (!view.replies) return view
-  const replies = await Promise.all(
-    view.replies.map(async (reply) =>
-      app.bsky.feed.defs.threadViewPost.$isTypeOf(reply)
-        ? await insertIntoThreadReplies(localViewer, reply, descript)
-        : reply,
-    ),
-  )
-  return {
-    ...view,
-    replies,
-  }
-}
-
-const threadPostView = async (
-  localViewer: LocalViewer,
-  descript: RecordDescript<app.bsky.feed.post.Main>,
-): Promise<l.$Typed<app.bsky.feed.defs.ThreadViewPost> | null> => {
-  const postView = await localViewer.getPost(descript)
-  if (!postView) return null
-  return app.bsky.feed.defs.threadViewPost.$build({
-    post: postView,
-  })
-}
-
-// Read after write on error
-// ---------------------
-
-const readAfterWriteNotFound = async (
-  ctx: AppContext,
-  localViewer: LocalViewer,
-  params: app.bsky.feed.getPostThread.$Params,
-  requester: string,
-  rev: string,
-  resolvedUri: AtUri,
-): Promise<{
-  data: app.bsky.feed.getPostThread.$OutputBody
-  lag?: number
-} | null> => {
-  if (resolvedUri.hostname !== requester) {
-    return null
-  }
-  const local = await localViewer.getRecordsSinceRev(rev)
-  const found = local.posts.find(
-    (p) => p.uri.toString() === resolvedUri.toString(),
-  )
-  if (!found) return null
-  let thread = await threadPostView(localViewer, found)
-  if (!thread) return null
-  const rest = local.posts.filter(
-    (p) => p.uri.toString() !== resolvedUri.toString(),
-  )
-  thread = await addPostsToThread(localViewer, thread, rest)
-  const highestParent = getHighestParent(thread)
-  if (highestParent) {
-    try {
-      assert(ctx.bskyAppView)
-      const parentsRes = await ctx.bskyAppView.client.call(
-        app.bsky.feed.getPostThread,
-        { uri: highestParent, parentHeight: params.parentHeight, depth: 0 },
-        await ctx.appviewAuthHeaders(
-          requester,
-          app.bsky.feed.getPostThread.$lxm,
-        ),
-      )
-      thread.parent = parentsRes.thread
-    } catch (err) {
-      // do nothing
-    }
-  }
-  return {
-    data: {
-      thread,
-    },
-    lag: getLocalLag(local),
-  }
-}
-
-const getHighestParent = (
-  thread: app.bsky.feed.defs.ThreadViewPost,
-): AtUriString | undefined => {
-  while (
-    thread.parent &&
-    app.bsky.feed.defs.threadViewPost.$isTypeOf(thread.parent)
-  ) {
-    thread = thread.parent
-  }
-
-  // @NOTE we might get away with type casting here, but being safe to avoid
-  // potential issues
-  if (!app.bsky.feed.post.$matches(thread.post.record)) {
-    return undefined
-  }
-
-  return thread.post.record.reply?.parent.uri
-}

package/src/api/app/bsky/feed/getTimeline.ts

@@ -1,50 +0,0 @@
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { app } from '../../../../lexicons/index.js'
-import { computeProxyTo } from '../../../../pipethrough.js'
-import {
-  MungeFn,
-  pipethroughReadAfterWrite,
-} from '../../../../read-after-write/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  if (!ctx.bskyAppView) return
-
-  server.add(app.bsky.feed.getTimeline, {
-    auth: ctx.authVerifier.authorization({
-      authorize: (permissions, { req }) => {
-        const lxm = app.bsky.feed.getTimeline.$lxm
-        const aud = computeProxyTo(ctx, req, lxm)
-        permissions.assertRpc({ aud, lxm })
-      },
-    }),
-    opts: {
-      // @TODO remove after grace period has passed, behavior is non-standard.
-      // temporarily added for compat w/ previous version of xrpc-server to avoid breakage of a few specified parties.
-      paramsParseLoose: true,
-    },
-    handler: async (reqCtx) => {
-      return pipethroughReadAfterWrite(
-        ctx,
-        reqCtx,
-        app.bsky.feed.getTimeline,
-        getTimelineMunge,
-      )
-    },
-  })
-}
-
-const getTimelineMunge: MungeFn<app.bsky.feed.getTimeline.$OutputBody> = async (
-  localViewer,
-  original,
-  local,
-) => {
-  const feed = await localViewer.formatAndInsertPostsInFeed(
-    [...original.feed],
-    local.posts,
-  )
-  return {
-    ...original,
-    feed,
-  }
-}

package/src/api/app/bsky/feed/index.ts

@@ -1,15 +0,0 @@
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import getActorLikes from './getActorLikes.js'
-import getAuthorFeed from './getAuthorFeed.js'
-import getFeed from './getFeed.js'
-import getPostThread from './getPostThread.js'
-import getTimeline from './getTimeline.js'
-
-export default function (server: Server, ctx: AppContext) {
-  getActorLikes(server, ctx)
-  getAuthorFeed(server, ctx)
-  getFeed(server, ctx)
-  getPostThread(server, ctx)
-  getTimeline(server, ctx)
-}

package/src/api/app/bsky/index.ts

@@ -1,11 +0,0 @@
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../context.js'
-import actor from './actor/index.js'
-import feed from './feed/index.js'
-import notification from './notification/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  actor(server, ctx)
-  feed(server, ctx)
-  notification(server, ctx)
-}

package/src/api/app/bsky/notification/index.ts

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

package/src/api/app/bsky/notification/registerPush.ts

@@ -1,71 +0,0 @@
-import { getNotif } from '@atproto/identity'
-import { xrpc } from '@atproto/lex'
-import { InvalidRequestError, Server } from '@atproto/xrpc-server'
-import { AuthScope } from '../../../../auth-scope.js'
-import { AppContext } from '../../../../context.js'
-import { app } from '../../../../lexicons/index.js'
-import { getDidDoc } from '../util/resolver.js'
-
-export default function (server: Server, ctx: AppContext) {
-  const { bskyAppView } = ctx
-  if (!bskyAppView) return
-
-  server.add(app.bsky.notification.registerPush, {
-    auth: ctx.authVerifier.authorization({
-      additional: [AuthScope.SignupQueued],
-      authorize: () => {
-        // @NOTE this endpoint predates generic service proxying but we want to
-        // map the permission to the "RPC" scope for consistency. However, since
-        // the service info is only available in the request body, we can't
-        // assert permissions here.
-      },
-    }),
-    handler: async ({ auth, input: { body } }) => {
-      const { serviceDid } = body
-      const { did } = auth.credentials
-
-      if (auth.credentials.type === 'oauth') {
-        auth.credentials.permissions.assertRpc({
-          aud: `${serviceDid}#bsky_notif`,
-          lxm: app.bsky.notification.registerPush.$lxm,
-        })
-      }
-
-      const { headers } = await ctx.serviceAuthHeaders(
-        did,
-        serviceDid,
-        app.bsky.notification.registerPush.$lxm,
-      )
-
-      if (bskyAppView.did === serviceDid) {
-        await bskyAppView.client.call(
-          app.bsky.notification.registerPush,
-          body,
-          { headers },
-        )
-        return
-      }
-
-      const notifEndpoint = await getEndpoint(ctx, serviceDid)
-
-      await xrpc(notifEndpoint, app.bsky.notification.registerPush, {
-        validateRequest: ctx.cfg.service.devMode,
-        validateResponse: ctx.cfg.service.devMode,
-        strictResponseProcessing: ctx.cfg.service.devMode,
-        body,
-        headers,
-      })
-    },
-  })
-}
-
-const getEndpoint = async (ctx: AppContext, serviceDid: string) => {
-  const doc = await getDidDoc(ctx, serviceDid)
-  const notifEndpoint = getNotif(doc)
-  if (!notifEndpoint) {
-    throw new InvalidRequestError(
-      `invalid notification service details in did document: ${serviceDid}`,
-    )
-  }
-  return notifEndpoint
-}

package/src/api/app/bsky/util/resolver.ts

@@ -1,20 +0,0 @@
-import { DidDocument, PoorlyFormattedDidDocumentError } from '@atproto/identity'
-import { InvalidRequestError } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-
-// provides http-friendly errors during did resolution
-export const getDidDoc = async (ctx: AppContext, did: string) => {
-  let resolved: DidDocument | null
-  try {
-    resolved = await ctx.idResolver.did.resolve(did)
-  } catch (err) {
-    if (err instanceof PoorlyFormattedDidDocumentError) {
-      throw new InvalidRequestError(`invalid did document: ${did}`)
-    }
-    throw err
-  }
-  if (!resolved) {
-    throw new InvalidRequestError(`could not resolve did document: ${did}`)
-  }
-  return resolved
-}