@atproto/bsky 0.0.250 → 0.0.253

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

@@ -1,147 +0,0 @@
-import { mapDefined } from '@atproto/common'
-import { AtUriString, DidString } from '@atproto/syntax'
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { DataPlaneClient } from '../../../../data-plane/index.js'
-import { FeedItem } from '../../../../hydration/feed.js'
-import {
-  HydrateCtx,
-  HydrationState,
-  Hydrator,
-  mergeStates,
-} from '../../../../hydration/hydrator.js'
-import { parseString } from '../../../../hydration/util.js'
-import { app } from '../../../../lexicons/index.js'
-import { createPipeline } from '../../../../pipeline.js'
-import { uriToDid } from '../../../../util/uris.js'
-import { Views } from '../../../../views/index.js'
-import { clearlyBadCursor, resHeaders } from '../../../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  const getListFeed = createPipeline(
-    skeleton,
-    hydration,
-    noBlocksOrMutes,
-    presentation,
-  )
-  server.add(app.bsky.feed.getListFeed, {
-    auth: ctx.authVerifier.standardOptional,
-    handler: async ({ params, auth, req }) => {
-      const viewer = auth.credentials.iss
-      const labelers = ctx.reqLabelers(req)
-      const hydrateCtx = await ctx.hydrator.createContext({ labelers, viewer })
-
-      const result = await getListFeed({ ...params, hydrateCtx }, ctx)
-
-      const repoRev = await ctx.hydrator.actor.getRepoRevSafe(viewer)
-
-      return {
-        encoding: 'application/json',
-        body: result,
-        headers: resHeaders({ labelers: hydrateCtx.labelers, repoRev }),
-      }
-    },
-  })
-}
-
-export const skeleton = async (inputs: {
-  ctx: Context
-  params: Params
-}): Promise<Skeleton> => {
-  const { ctx, params } = inputs
-  if (clearlyBadCursor(params.cursor)) {
-    return { items: [] }
-  }
-  const res = await ctx.dataplane.getListFeed({
-    listUri: params.list,
-    limit: params.limit,
-    cursor: params.cursor,
-  })
-  return {
-    items: res.items.map((item) => ({
-      post: { uri: item.uri as AtUriString, cid: item.cid || undefined },
-      repost: item.repost
-        ? { uri: item.repost as AtUriString, cid: item.repostCid || undefined }
-        : undefined,
-    })),
-    cursor: parseString(res.cursor),
-  }
-}
-
-const hydration = async (inputs: {
-  ctx: Context
-  params: Params
-  skeleton: Skeleton
-}): Promise<HydrationState> => {
-  const { ctx, params, skeleton } = inputs
-  const [feedItemsState, bidirectionalBlocks] = await Promise.all([
-    ctx.hydrator.hydrateFeedItems(skeleton.items, params.hydrateCtx),
-    getBlocks({ ctx, params, skeleton }),
-  ])
-  return mergeStates(feedItemsState, {
-    bidirectionalBlocks,
-  })
-}
-
-const noBlocksOrMutes = (inputs: {
-  ctx: Context
-  params: Params
-  skeleton: Skeleton
-  hydration: HydrationState
-}): Skeleton => {
-  const { ctx, params, skeleton, hydration } = inputs
-  skeleton.items = skeleton.items.filter((item) => {
-    const bam = ctx.views.feedItemBlocksAndMutes(item, hydration)
-    const creatorBlocks = hydration.bidirectionalBlocks?.get(
-      uriToDid(params.list),
-    )
-    return (
-      !bam.authorBlocked &&
-      !bam.authorMuted &&
-      !bam.originatorBlocked &&
-      !bam.originatorMuted &&
-      !bam.ancestorAuthorBlocked &&
-      !creatorBlocks?.get(uriToDid(item.post.uri))
-    )
-  })
-  return skeleton
-}
-
-const presentation = (inputs: {
-  ctx: Context
-  skeleton: Skeleton
-  hydration: HydrationState
-}) => {
-  const { ctx, skeleton, hydration } = inputs
-  const feed = mapDefined(skeleton.items, (item) =>
-    ctx.views.feedViewPost(item, hydration),
-  )
-  return { feed, cursor: skeleton.cursor }
-}
-
-const getBlocks = async (input: {
-  ctx: Context
-  skeleton: Skeleton
-  params: Params
-}) => {
-  const { ctx, skeleton, params } = input
-  const pairs: Map<DidString, DidString[]> = new Map()
-  pairs.set(
-    uriToDid(params.list),
-    skeleton.items.map((item) => uriToDid(item.post.uri)),
-  )
-  return await ctx.hydrator.hydrateBidirectionalBlocks(pairs, params.hydrateCtx)
-}
-
-type Context = {
-  hydrator: Hydrator
-  views: Views
-  dataplane: DataPlaneClient
-}
-
-type Params = app.bsky.feed.getListFeed.$Params & { hydrateCtx: HydrateCtx }
-
-type Skeleton = {
-  items: FeedItem[]
-  cursor?: string
-}

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

@@ -1,156 +0,0 @@
-import { AtUriString } from '@atproto/syntax'
-import { InvalidRequestError, Server } from '@atproto/xrpc-server'
-import { ServerConfig } from '../../../../config.js'
-import { AppContext } from '../../../../context.js'
-import {
-  Code,
-  DataPlaneClient,
-  isDataplaneError,
-} from '../../../../data-plane/index.js'
-import { HydrateCtx, Hydrator } from '../../../../hydration/hydrator.js'
-import { app } from '../../../../lexicons/index.js'
-import {
-  HydrationFnInput,
-  PresentationFnInput,
-  SkeletonFnInput,
-  createPipeline,
-  noRules,
-} from '../../../../pipeline.js'
-import { postUriToThreadgateUri } from '../../../../util/uris.js'
-import { Views } from '../../../../views/index.js'
-import { ATPROTO_REPO_REV, resHeaders } from '../../../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  const getPostThread = createPipeline(
-    skeleton,
-    hydration,
-    noRules, // handled in presentation: 3p block-violating replies are turned to #blockedPost, viewer blocks turned to #notFoundPost.
-    presentation,
-  )
-  server.add(app.bsky.feed.getPostThread, {
-    auth: ctx.authVerifier.optionalStandardOrRole,
-    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 ({ params, auth, req, res }) => {
-      const { viewer, includeTakedowns, include3pBlocks, skipViewerBlocks } =
-        ctx.authVerifier.parseCreds(auth)
-      const labelers = ctx.reqLabelers(req)
-      const hydrateCtx = await ctx.hydrator.createContext({
-        labelers,
-        viewer,
-        includeTakedowns,
-        include3pBlocks,
-        skipViewerBlocks,
-      })
-
-      let result: app.bsky.feed.getPostThread.$OutputBody
-      try {
-        result = await getPostThread({ ...params, hydrateCtx }, ctx)
-      } catch (err) {
-        const repoRev = await ctx.hydrator.actor.getRepoRevSafe(viewer)
-        if (repoRev) {
-          res.setHeader(ATPROTO_REPO_REV, repoRev)
-        }
-        throw err
-      }
-
-      const repoRev = await ctx.hydrator.actor.getRepoRevSafe(viewer)
-
-      return {
-        encoding: 'application/json',
-        body: result,
-        headers: resHeaders({
-          repoRev,
-          labelers: hydrateCtx.labelers,
-        }),
-      }
-    },
-  })
-}
-
-const skeleton = async (
-  inputs: SkeletonFnInput<Context, Params>,
-): Promise<Skeleton> => {
-  const { ctx, params } = inputs
-  const anchor = await ctx.hydrator.resolveUri(params.uri)
-  try {
-    const res = await ctx.dataplane.getThread({
-      postUri: anchor,
-      above: params.parentHeight,
-      below: getDepth(ctx, anchor, params),
-    })
-    return {
-      anchor,
-      uris: res.uris as AtUriString[],
-    }
-  } catch (err) {
-    if (isDataplaneError(err, Code.NotFound)) {
-      return {
-        anchor,
-        uris: [],
-      }
-    } else {
-      throw err
-    }
-  }
-}
-
-const hydration = async (
-  inputs: HydrationFnInput<Context, Params, Skeleton>,
-) => {
-  const { ctx, params, skeleton } = inputs
-  return ctx.hydrator.hydrateThreadPosts(
-    skeleton.uris.map((uri) => ({ uri })),
-    params.hydrateCtx,
-  )
-}
-
-const presentation = (
-  inputs: PresentationFnInput<Context, Params, Skeleton>,
-) => {
-  const { ctx, params, skeleton, hydration } = inputs
-  const thread = ctx.views.thread(skeleton, hydration, {
-    height: params.parentHeight!,
-    depth: getDepth(ctx, skeleton.anchor, params),
-  })
-  if (app.bsky.feed.defs.notFoundPost.$isTypeOf(thread)) {
-    // @TODO technically this could be returned as a NotFoundPost based on lexicon
-    throw new InvalidRequestError(
-      `Post not found: ${skeleton.anchor}`,
-      'NotFound',
-    )
-  }
-  const rootUri =
-    hydration.posts?.get(skeleton.anchor)?.record.reply?.root.uri ??
-    skeleton.anchor
-  const threadgate = ctx.views.threadgate(
-    postUriToThreadgateUri(rootUri),
-    hydration,
-  )
-  return { thread, threadgate }
-}
-
-type Context = {
-  dataplane: DataPlaneClient
-  hydrator: Hydrator
-  views: Views
-  cfg: ServerConfig
-}
-
-type Params = app.bsky.feed.getPostThread.$Params & { hydrateCtx: HydrateCtx }
-
-type Skeleton = {
-  anchor: AtUriString
-  uris: AtUriString[]
-}
-
-const getDepth = (ctx: Context, anchor: string, params: Params) => {
-  let maxDepth = ctx.cfg.maxThreadDepth
-  if (ctx.cfg.bigThreadUris.has(anchor) && ctx.cfg.bigThreadDepth) {
-    maxDepth = ctx.cfg.bigThreadDepth
-  }
-  return maxDepth ? Math.min(maxDepth, params.depth!) : params.depth!
-}

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

@@ -1,100 +0,0 @@
-import { dedupeStrs, mapDefined } from '@atproto/common'
-import { AtUriString } from '@atproto/syntax'
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import {
-  HydrateCtx,
-  HydrationState,
-  Hydrator,
-} from '../../../../hydration/hydrator.js'
-import { app } from '../../../../lexicons/index.js'
-import { createPipeline } from '../../../../pipeline.js'
-import { uriToDid as creatorFromUri } from '../../../../util/uris.js'
-import { Views } from '../../../../views/index.js'
-import { resHeaders } from '../../../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  const getPosts = createPipeline(skeleton, hydration, noBlocks, presentation)
-  server.add(app.bsky.feed.getPosts, {
-    auth: ctx.authVerifier.standardOptionalParameterized({
-      lxmCheck: (method) => {
-        if (!method) return false
-        return (
-          method === app.bsky.feed.getPosts.$lxm ||
-          method.startsWith('chat.bsky.')
-        )
-      },
-    }),
-    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 ({ params, auth, req }) => {
-      const viewer = auth.credentials.iss
-      const labelers = ctx.reqLabelers(req)
-      const hydrateCtx = await ctx.hydrator.createContext({ labelers, viewer })
-
-      const results = await getPosts({ ...params, hydrateCtx }, ctx)
-
-      return {
-        encoding: 'application/json',
-        body: results,
-        headers: resHeaders({ labelers: hydrateCtx.labelers }),
-      }
-    },
-  })
-}
-
-const skeleton = async (inputs: { params: Params }): Promise<Skeleton> => {
-  return { posts: dedupeStrs(inputs.params.uris) }
-}
-
-const hydration = async (inputs: {
-  ctx: Context
-  params: Params
-  skeleton: Skeleton
-}) => {
-  const { ctx, params, skeleton } = inputs
-  return ctx.hydrator.hydratePosts(
-    skeleton.posts.map((uri) => ({ uri })),
-    params.hydrateCtx,
-  )
-}
-
-const noBlocks = (inputs: {
-  ctx: Context
-  skeleton: Skeleton
-  hydration: HydrationState
-}) => {
-  const { ctx, skeleton, hydration } = inputs
-  skeleton.posts = skeleton.posts.filter((uri) => {
-    const creator = creatorFromUri(uri)
-    return !ctx.views.viewerBlockExists(creator, hydration)
-  })
-  return skeleton
-}
-
-const presentation = (inputs: {
-  ctx: Context
-  params: Params
-  skeleton: Skeleton
-  hydration: HydrationState
-}) => {
-  const { ctx, skeleton, hydration } = inputs
-  const posts = mapDefined(skeleton.posts, (uri) =>
-    ctx.views.post(uri, hydration),
-  )
-  return { posts }
-}
-
-type Context = {
-  hydrator: Hydrator
-  views: Views
-}
-
-type Params = app.bsky.feed.getPosts.$Params & { hydrateCtx: HydrateCtx }
-
-type Skeleton = {
-  posts: AtUriString[]
-}

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

@@ -1,122 +0,0 @@
-import { mapDefined } from '@atproto/common'
-import { AtUriString } from '@atproto/syntax'
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import {
-  HydrateCtx,
-  HydrationState,
-  Hydrator,
-} from '../../../../hydration/hydrator.js'
-import { parseString } from '../../../../hydration/util.js'
-import { app } from '../../../../lexicons/index.js'
-import { createPipeline } from '../../../../pipeline.js'
-import { uriToDid } from '../../../../util/uris.js'
-import { Views } from '../../../../views/index.js'
-import { clearlyBadCursor, resHeaders } from '../../../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  const getQuotes = createPipeline(
-    skeleton,
-    hydration,
-    noBlocksOrNeedsReview,
-    presentation,
-  )
-  server.add(app.bsky.feed.getQuotes, {
-    auth: ctx.authVerifier.standardOptional,
-    handler: async ({ params, auth, req }) => {
-      const { viewer, includeTakedowns, skipViewerBlocks } =
-        ctx.authVerifier.parseCreds(auth)
-      const labelers = ctx.reqLabelers(req)
-      const hydrateCtx = await ctx.hydrator.createContext({
-        labelers,
-        viewer,
-        includeTakedowns,
-        skipViewerBlocks,
-      })
-      const result = await getQuotes({ ...params, hydrateCtx }, ctx)
-      return {
-        encoding: 'application/json',
-        body: result,
-        headers: resHeaders({ labelers: hydrateCtx.labelers }),
-      }
-    },
-  })
-}
-
-const skeleton = async (inputs: {
-  ctx: Context
-  params: Params
-}): Promise<Skeleton> => {
-  const { ctx, params } = inputs
-  if (clearlyBadCursor(params.cursor)) {
-    return { uris: [] }
-  }
-  const quotesRes = await ctx.hydrator.dataplane.getQuotesBySubjectSorted({
-    subject: { uri: params.uri, cid: params.cid },
-    cursor: params.cursor,
-    limit: params.limit,
-  })
-  return {
-    uris: quotesRes.uris as AtUriString[],
-    cursor: parseString(quotesRes.cursor),
-  }
-}
-
-const hydration = async (inputs: {
-  ctx: Context
-  params: Params
-  skeleton: Skeleton
-}): Promise<HydrationState> => {
-  const { ctx, params, skeleton } = inputs
-  return await ctx.hydrator.hydratePosts(
-    skeleton.uris.map((uri) => ({ uri })),
-    params.hydrateCtx,
-  )
-}
-
-const noBlocksOrNeedsReview = (inputs: {
-  ctx: Context
-  skeleton: Skeleton
-  hydration: HydrationState
-}) => {
-  const { ctx, skeleton, hydration } = inputs
-  skeleton.uris = skeleton.uris.filter((uri) => {
-    const authorDid = uriToDid(uri)
-    return (
-      !ctx.views.viewerBlockExists(authorDid, hydration) &&
-      !hydration.postBlocks?.get(uri)?.embed &&
-      ctx.views.viewerSeesNeedsReview({ did: authorDid, uri }, hydration)
-    )
-  })
-  return skeleton
-}
-
-const presentation = (inputs: {
-  ctx: Context
-  params: Params
-  skeleton: Skeleton
-  hydration: HydrationState
-}) => {
-  const { ctx, params, skeleton, hydration } = inputs
-  const postViews = mapDefined(skeleton.uris, (uri) => {
-    return ctx.views.post(uri, hydration)
-  })
-  return {
-    posts: postViews,
-    cursor: skeleton.cursor,
-    uri: params.uri,
-    cid: params.cid,
-  }
-}
-
-type Context = {
-  hydrator: Hydrator
-  views: Views
-}
-
-type Params = app.bsky.feed.getQuotes.$Params & { hydrateCtx: HydrateCtx }
-
-type Skeleton = {
-  uris: AtUriString[]
-  cursor?: string
-}

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

@@ -1,121 +0,0 @@
-import { mapDefined } from '@atproto/common'
-import { AtUriString } from '@atproto/lex'
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import {
-  HydrateCtx,
-  HydrationState,
-  Hydrator,
-} from '../../../../hydration/hydrator.js'
-import { parseString } from '../../../../hydration/util.js'
-import { app } from '../../../../lexicons/index.js'
-import { createPipeline } from '../../../../pipeline.js'
-import { uriToDid as creatorFromUri } from '../../../../util/uris.js'
-import { Views } from '../../../../views/index.js'
-import { clearlyBadCursor, resHeaders } from '../../../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  const getRepostedBy = createPipeline(
-    skeleton,
-    hydration,
-    noBlocks,
-    presentation,
-  )
-  server.add(app.bsky.feed.getRepostedBy, {
-    auth: ctx.authVerifier.standardOptional,
-    handler: async ({ params, auth, req }) => {
-      const { viewer, includeTakedowns, skipViewerBlocks } =
-        ctx.authVerifier.parseCreds(auth)
-      const labelers = ctx.reqLabelers(req)
-      const hydrateCtx = await ctx.hydrator.createContext({
-        labelers,
-        viewer,
-        includeTakedowns,
-        skipViewerBlocks,
-      })
-      const result = await getRepostedBy({ ...params, hydrateCtx }, ctx)
-
-      return {
-        encoding: 'application/json',
-        body: result,
-        headers: resHeaders({ labelers: hydrateCtx.labelers }),
-      }
-    },
-  })
-}
-
-const skeleton = async (inputs: {
-  ctx: Context
-  params: Params
-}): Promise<Skeleton> => {
-  const { ctx, params } = inputs
-  if (clearlyBadCursor(params.cursor)) {
-    return { reposts: [] }
-  }
-  const res = await ctx.hydrator.dataplane.getRepostsBySubject({
-    subject: { uri: params.uri, cid: params.cid },
-    cursor: params.cursor,
-    limit: params.limit,
-  })
-  return {
-    reposts: res.uris as AtUriString[],
-    cursor: parseString(res.cursor),
-  }
-}
-
-const hydration = async (inputs: {
-  ctx: Context
-  params: Params
-  skeleton: Skeleton
-}) => {
-  const { ctx, params, skeleton } = inputs
-  return await ctx.hydrator.hydrateReposts(skeleton.reposts, params.hydrateCtx)
-}
-
-const noBlocks = (inputs: {
-  ctx: Context
-  skeleton: Skeleton
-  hydration: HydrationState
-}) => {
-  const { ctx, skeleton, hydration } = inputs
-  skeleton.reposts = skeleton.reposts.filter((uri) => {
-    const creator = creatorFromUri(uri)
-    return !ctx.views.viewerBlockExists(creator, hydration)
-  })
-  return skeleton
-}
-
-const presentation = (inputs: {
-  ctx: Context
-  params: Params
-  skeleton: Skeleton
-  hydration: HydrationState
-}) => {
-  const { ctx, params, skeleton, hydration } = inputs
-  const repostViews = mapDefined(skeleton.reposts, (uri) => {
-    const repost = hydration.reposts?.get(uri)
-    if (!repost?.record) {
-      return
-    }
-    const creatorDid = creatorFromUri(uri)
-    return ctx.views.profile(creatorDid, hydration)
-  })
-  return {
-    repostedBy: repostViews,
-    cursor: skeleton.cursor,
-    uri: params.uri,
-    cid: params.cid,
-  }
-}
-
-type Context = {
-  hydrator: Hydrator
-  views: Views
-}
-
-type Params = app.bsky.feed.getRepostedBy.$Params & { hydrateCtx: HydrateCtx }
-
-type Skeleton = {
-  reposts: AtUriString[]
-  cursor?: string
-}

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

@@ -1,39 +0,0 @@
-import { mapDefined } from '@atproto/common'
-import { AtUriString } from '@atproto/syntax'
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { parseString } from '../../../../hydration/util.js'
-import { app } from '../../../../lexicons/index.js'
-import { resHeaders } from '../../../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(app.bsky.feed.getSuggestedFeeds, {
-    auth: ctx.authVerifier.standardOptional,
-    handler: async ({ auth, params, req }) => {
-      const viewer = auth.credentials.iss
-      const labelers = ctx.reqLabelers(req)
-
-      // @NOTE no need to coordinate the cursor for appview swap, as v1 doesn't use the cursor
-      const suggestedRes = await ctx.dataplane.getSuggestedFeeds({
-        actorDid: viewer ?? undefined,
-        limit: params.limit,
-        cursor: params.cursor,
-      })
-      const uris = suggestedRes.uris as AtUriString[]
-      const hydrateCtx = await ctx.hydrator.createContext({ labelers, viewer })
-      const hydration = await ctx.hydrator.hydrateFeedGens(uris, hydrateCtx)
-      const feedViews = mapDefined(uris, (uri) =>
-        ctx.views.feedGenerator(uri, hydration),
-      )
-
-      return {
-        encoding: 'application/json',
-        body: {
-          feeds: feedViews,
-          cursor: parseString(suggestedRes.cursor),
-        },
-        headers: resHeaders({ labelers: hydrateCtx.labelers }),
-      }
-    },
-  })
-}