@atproto/bsky 0.0.251 → 0.0.254

package/src/api/app/bsky/graph/getList.ts

@@ -1,152 +0,0 @@
-import { mapDefined } from '@atproto/common'
-import { AtUriString, DidString } from '@atproto/lex'
-import { InvalidRequestError, Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import {
-  HydrateCtx,
-  HydrationState,
-  Hydrator,
-  mergeManyStates,
-} from '../../../../hydration/hydrator.js'
-import { app } from '../../../../lexicons/index.js'
-import {
-  HydrationFnInput,
-  PresentationFnInput,
-  RulesFnInput,
-  SkeletonFnInput,
-  createPipeline,
-} from '../../../../pipeline.js'
-import { ListItemInfo } from '../../../../proto/bsky_pb.js'
-import { uriToDid as didFromUri } from '../../../../util/uris.js'
-import { Views } from '../../../../views/index.js'
-import { clearlyBadCursor, resHeaders } from '../../../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  const getList = createPipeline(skeleton, hydration, noBlocks, presentation)
-  server.add(app.bsky.graph.getList, {
-    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 getList({ ...params, hydrateCtx }, ctx)
-      return {
-        encoding: 'application/json',
-        body: result,
-        headers: resHeaders({ labelers: hydrateCtx.labelers }),
-      }
-    },
-  })
-}
-
-const skeleton = async (
-  input: SkeletonFnInput<Context, Params>,
-): Promise<SkeletonState> => {
-  const { ctx, params } = input
-  if (clearlyBadCursor(params.cursor)) {
-    return { listUri: params.list, listitems: [] }
-  }
-  const { listitems, cursor } = await ctx.hydrator.dataplane.getListMembers({
-    listUri: params.list,
-    limit: params.limit,
-    cursor: params.cursor,
-  })
-  return {
-    listUri: params.list,
-    listitems,
-    cursor: cursor || undefined,
-  }
-}
-
-const hydration = async (
-  input: HydrationFnInput<Context, Params, SkeletonState>,
-) => {
-  const { ctx, params, skeleton } = input
-  const { listUri, listitems } = skeleton
-  const [listState, profileState] = await Promise.all([
-    ctx.hydrator.hydrateLists([listUri], params.hydrateCtx),
-    ctx.hydrator.hydrateProfiles(
-      listitems.map(({ did }) => did as DidString),
-      params.hydrateCtx,
-    ),
-  ])
-  const bidirectionalBlocks = await maybeGetBlocksForReferenceAndCurateList({
-    ctx,
-    params,
-    skeleton,
-    listState,
-  })
-  return mergeManyStates(listState, profileState, { bidirectionalBlocks })
-}
-
-const noBlocks = (input: RulesFnInput<Context, Params, SkeletonState>) => {
-  const { skeleton, hydration } = input
-  const creator = didFromUri(skeleton.listUri)
-  const blocks = hydration.bidirectionalBlocks?.get(creator)
-  skeleton.listitems = skeleton.listitems.filter(({ did }) => {
-    return !blocks?.get(did as DidString)
-  })
-  return skeleton
-}
-
-const presentation = (
-  input: PresentationFnInput<Context, Params, SkeletonState>,
-) => {
-  const { ctx, skeleton, hydration } = input
-  const { listUri, listitems, cursor } = skeleton
-  const list = ctx.views.list(listUri, hydration)
-  const items = mapDefined(listitems, ({ uri, did }) =>
-    ctx.views.listItemView(uri as AtUriString, did as DidString, hydration),
-  )
-  if (!list) {
-    throw new InvalidRequestError('List not found')
-  }
-  return { list, items, cursor }
-}
-
-const maybeGetBlocksForReferenceAndCurateList = async (input: {
-  ctx: Context
-  listState: HydrationState
-  skeleton: SkeletonState
-  params: Params
-}) => {
-  const { ctx, params, listState, skeleton } = input
-  const { listitems } = skeleton
-  const { list } = params
-  const listRecord = listState.lists?.get(list)
-  const creator = didFromUri(list)
-  if (
-    params.hydrateCtx.viewer === creator ||
-    listRecord?.record.purpose === 'app.bsky.graph.defs#modlist'
-  ) {
-    return
-  }
-  const pairs: Map<DidString, DidString[]> = new Map()
-  pairs.set(
-    creator,
-    listitems.map(({ did }) => did as DidString),
-  )
-  return await ctx.hydrator.hydrateBidirectionalBlocks(pairs, params.hydrateCtx)
-}
-
-type Context = {
-  hydrator: Hydrator
-  views: Views
-}
-
-type Params = app.bsky.graph.getList.$Params & {
-  hydrateCtx: HydrateCtx
-}
-
-type SkeletonState = {
-  listUri: AtUriString
-  listitems: ListItemInfo[]
-  cursor?: string
-}

package/src/api/app/bsky/graph/getListBlocks.ts

@@ -1,87 +0,0 @@
-import { mapDefined } from '@atproto/common'
-import { AtUriString } from '@atproto/lex'
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import {
-  HydrateCtxWithViewer,
-  Hydrator,
-} from '../../../../hydration/hydrator.js'
-import { app } from '../../../../lexicons/index.js'
-import {
-  HydrationFnInput,
-  PresentationFnInput,
-  SkeletonFnInput,
-  createPipeline,
-  noRules,
-} from '../../../../pipeline.js'
-import { Views } from '../../../../views/index.js'
-import { clearlyBadCursor, resHeaders } from '../../../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  const getListBlocks = createPipeline(
-    skeleton,
-    hydration,
-    noRules,
-    presentation,
-  )
-  server.add(app.bsky.graph.getListBlocks, {
-    auth: ctx.authVerifier.standard,
-    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 getListBlocks({ ...params, hydrateCtx }, ctx)
-      return {
-        encoding: 'application/json',
-        body: result,
-        headers: resHeaders({ labelers: hydrateCtx.labelers }),
-      }
-    },
-  })
-}
-
-const skeleton = async (
-  input: SkeletonFnInput<Context, Params>,
-): Promise<SkeletonState> => {
-  const { ctx, params } = input
-  if (clearlyBadCursor(params.cursor)) {
-    return { listUris: [] }
-  }
-  const { listUris, cursor } =
-    await ctx.hydrator.dataplane.getBlocklistSubscriptions({
-      actorDid: params.hydrateCtx.viewer,
-      cursor: params.cursor,
-      limit: params.limit,
-    })
-  return { listUris: listUris as AtUriString[], cursor: cursor || undefined }
-}
-
-const hydration = async (
-  input: HydrationFnInput<Context, Params, SkeletonState>,
-) => {
-  const { ctx, params, skeleton } = input
-  return await ctx.hydrator.hydrateLists(skeleton.listUris, params.hydrateCtx)
-}
-
-const presentation = (
-  input: PresentationFnInput<Context, Params, SkeletonState>,
-) => {
-  const { ctx, skeleton, hydration } = input
-  const { listUris, cursor } = skeleton
-  const lists = mapDefined(listUris, (uri) => ctx.views.list(uri, hydration))
-  return { lists, cursor }
-}
-
-type Context = {
-  hydrator: Hydrator
-  views: Views
-}
-
-type Params = app.bsky.graph.getListBlocks.$Params & {
-  hydrateCtx: HydrateCtxWithViewer
-}
-
-type SkeletonState = {
-  listUris: AtUriString[]
-  cursor?: string
-}

package/src/api/app/bsky/graph/getListMutes.ts

@@ -1,87 +0,0 @@
-import { mapDefined } from '@atproto/common'
-import { AtUriString } from '@atproto/lex'
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import {
-  HydrateCtxWithViewer,
-  Hydrator,
-} from '../../../../hydration/hydrator.js'
-import { app } from '../../../../lexicons/index.js'
-import {
-  HydrationFnInput,
-  PresentationFnInput,
-  SkeletonFnInput,
-  createPipeline,
-  noRules,
-} from '../../../../pipeline.js'
-import { Views } from '../../../../views/index.js'
-import { clearlyBadCursor, resHeaders } from '../../../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  const getListMutes = createPipeline(
-    skeleton,
-    hydration,
-    noRules,
-    presentation,
-  )
-  server.add(app.bsky.graph.getListMutes, {
-    auth: ctx.authVerifier.standard,
-    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 getListMutes({ ...params, hydrateCtx }, ctx)
-      return {
-        encoding: 'application/json',
-        body: result,
-        headers: resHeaders({ labelers: hydrateCtx.labelers }),
-      }
-    },
-  })
-}
-
-const skeleton = async (
-  input: SkeletonFnInput<Context, Params>,
-): Promise<SkeletonState> => {
-  const { ctx, params } = input
-  if (clearlyBadCursor(params.cursor)) {
-    return { listUris: [] }
-  }
-  const { listUris, cursor } =
-    await ctx.hydrator.dataplane.getMutelistSubscriptions({
-      actorDid: params.hydrateCtx.viewer,
-      cursor: params.cursor,
-      limit: params.limit,
-    })
-  return { listUris: listUris as AtUriString[], cursor: cursor || undefined }
-}
-
-const hydration = async (
-  input: HydrationFnInput<Context, Params, SkeletonState>,
-) => {
-  const { ctx, params, skeleton } = input
-  return await ctx.hydrator.hydrateLists(skeleton.listUris, params.hydrateCtx)
-}
-
-const presentation = (
-  input: PresentationFnInput<Context, Params, SkeletonState>,
-) => {
-  const { ctx, skeleton, hydration } = input
-  const { listUris, cursor } = skeleton
-  const lists = mapDefined(listUris, (uri) => ctx.views.list(uri, hydration))
-  return { lists, cursor }
-}
-
-type Context = {
-  hydrator: Hydrator
-  views: Views
-}
-
-type Params = app.bsky.graph.getListBlocks.$Params & {
-  hydrateCtx: HydrateCtxWithViewer
-}
-
-type SkeletonState = {
-  listUris: AtUriString[]
-  cursor?: string
-}

package/src/api/app/bsky/graph/getLists.ts

@@ -1,125 +0,0 @@
-import { mapDefined } from '@atproto/common'
-import { AtUriString } from '@atproto/syntax'
-import { InvalidRequestError, Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { HydrateCtx, Hydrator } from '../../../../hydration/hydrator.js'
-import { parseString } from '../../../../hydration/util.js'
-import { app } from '../../../../lexicons/index.js'
-import {
-  HydrationFnInput,
-  PresentationFnInput,
-  RulesFnInput,
-  SkeletonFnInput,
-  createPipeline,
-} from '../../../../pipeline.js'
-import { Views } from '../../../../views/index.js'
-import { clearlyBadCursor, resHeaders } from '../../../util.js'
-
-const CURATELIST = app.bsky.graph.defs.curatelist.value
-const MODLIST = app.bsky.graph.defs.modlist.value
-
-export default function (server: Server, ctx: AppContext) {
-  const getLists = createPipeline(
-    skeleton,
-    hydration,
-    filterPurposes,
-    presentation,
-  )
-  server.add(app.bsky.graph.getLists, {
-    auth: ctx.authVerifier.optionalStandardOrRole,
-    handler: async ({ params, auth, req }) => {
-      const labelers = ctx.reqLabelers(req)
-      const { viewer, includeTakedowns, skipViewerBlocks } =
-        ctx.authVerifier.parseCreds(auth)
-      const hydrateCtx = await ctx.hydrator.createContext({
-        labelers,
-        viewer,
-        includeTakedowns,
-        skipViewerBlocks,
-      })
-      const result = await getLists({ ...params, hydrateCtx }, ctx)
-
-      return {
-        encoding: 'application/json',
-        body: result,
-        headers: resHeaders({ labelers: hydrateCtx.labelers }),
-      }
-    },
-  })
-}
-
-const skeleton = async (
-  input: SkeletonFnInput<Context, Params>,
-): Promise<SkeletonState> => {
-  const { ctx, params } = input
-  if (clearlyBadCursor(params.cursor)) {
-    return { listUris: [] }
-  }
-
-  const [did] = await ctx.hydrator.actor.getDids([params.actor])
-  if (!did) throw new InvalidRequestError('Profile not found')
-
-  const { listUris, cursor } = await ctx.hydrator.dataplane.getActorLists({
-    actorDid: did,
-    cursor: params.cursor,
-    limit: params.limit,
-  })
-  return {
-    listUris: listUris as AtUriString[],
-    cursor: parseString(cursor),
-  }
-}
-
-const hydration = async (
-  input: HydrationFnInput<Context, Params, SkeletonState>,
-) => {
-  const { ctx, params, skeleton } = input
-  const { listUris } = skeleton
-  return ctx.hydrator.hydrateLists(listUris, params.hydrateCtx)
-}
-
-const filterPurposes = (
-  input: RulesFnInput<Context, Params, SkeletonState>,
-) => {
-  const { skeleton, hydration, params } = input
-  const purposes = params.purposes || ['modlist', 'curatelist']
-
-  const acceptedPurposes = new Set()
-  if (purposes.includes('modlist')) acceptedPurposes.add(MODLIST)
-  if (purposes.includes(MODLIST)) acceptedPurposes.add(MODLIST)
-  if (purposes.includes('curatelist')) acceptedPurposes.add(CURATELIST)
-  if (purposes.includes(CURATELIST)) acceptedPurposes.add(CURATELIST)
-
-  // @NOTE: While we don't support filtering on the dataplane, this might result in empty pages.
-  // Despite the empty pages, the pagination still can enumerate all items for the specified filters.
-  skeleton.listUris = skeleton.listUris.filter((uri) => {
-    const list = hydration.lists?.get(uri)
-    return acceptedPurposes.has(list?.record.purpose)
-  })
-  return skeleton
-}
-
-const presentation = (
-  input: PresentationFnInput<Context, Params, SkeletonState>,
-) => {
-  const { ctx, skeleton, hydration } = input
-  const { listUris, cursor } = skeleton
-  const lists = mapDefined(listUris, (uri) => {
-    return ctx.views.list(uri, hydration)
-  })
-  return { lists, cursor }
-}
-
-type Context = {
-  hydrator: Hydrator
-  views: Views
-}
-
-type Params = app.bsky.graph.getLists.$Params & {
-  hydrateCtx: HydrateCtx
-}
-
-type SkeletonState = {
-  listUris: AtUriString[]
-  cursor?: string
-}

package/src/api/app/bsky/graph/getListsWithMembership.ts

@@ -1,146 +0,0 @@
-import { mapDefined } from '@atproto/common'
-import { AtUriString, DidString } from '@atproto/lex'
-import { InvalidRequestError, Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import {
-  HydrateCtxWithViewer,
-  Hydrator,
-} from '../../../../hydration/hydrator.js'
-import { parseString } from '../../../../hydration/util.js'
-import { app } from '../../../../lexicons/index.js'
-import {
-  HydrationFnInput,
-  PresentationFnInput,
-  RulesFnInput,
-  SkeletonFnInput,
-  createPipeline,
-} from '../../../../pipeline.js'
-import { Views } from '../../../../views/index.js'
-import { clearlyBadCursor, resHeaders } from '../../../util.js'
-
-const CURATELIST = app.bsky.graph.defs.curatelist.value
-const MODLIST = app.bsky.graph.defs.modlist.value
-
-export default function (server: Server, ctx: AppContext) {
-  const getListsWithMembership = createPipeline(
-    skeleton,
-    hydration,
-    filterPurposes,
-    presentation,
-  )
-  server.add(app.bsky.graph.getListsWithMembership, {
-    auth: ctx.authVerifier.standard,
-    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 getListsWithMembership(
-        { ...params, hydrateCtx },
-        ctx,
-      )
-
-      return {
-        encoding: 'application/json',
-        body: result,
-        headers: resHeaders({ labelers: hydrateCtx.labelers }),
-      }
-    },
-  })
-}
-
-const skeleton = async (
-  input: SkeletonFnInput<Context, Params>,
-): Promise<SkeletonState> => {
-  const { ctx, params } = input
-  const [actorDid] = await ctx.hydrator.actor.getDids([params.actor])
-  if (!actorDid) throw new InvalidRequestError('Profile not found')
-
-  if (clearlyBadCursor(params.cursor)) {
-    return { actorDid, listUris: [] }
-  }
-
-  const { listUris, cursor } = await ctx.hydrator.dataplane.getActorLists({
-    actorDid: params.hydrateCtx.viewer,
-    cursor: params.cursor,
-    limit: params.limit,
-  })
-  return {
-    actorDid,
-    listUris: listUris as AtUriString[],
-    cursor: parseString(cursor),
-  }
-}
-
-const hydration = async (
-  input: HydrationFnInput<Context, Params, SkeletonState>,
-) => {
-  const { ctx, params, skeleton } = input
-  const { actorDid, listUris } = skeleton
-  return ctx.hydrator.hydrateListsMembership(
-    listUris,
-    actorDid,
-    params.hydrateCtx,
-  )
-}
-
-const filterPurposes = (
-  input: RulesFnInput<Context, Params, SkeletonState>,
-) => {
-  const { skeleton, hydration, params } = input
-  const purposes = params.purposes || ['modlist', 'curatelist']
-
-  const acceptedPurposes = new Set()
-  if (purposes.includes('modlist')) acceptedPurposes.add(MODLIST)
-  if (purposes.includes(MODLIST)) acceptedPurposes.add(MODLIST)
-  if (purposes.includes('curatelist')) acceptedPurposes.add(CURATELIST)
-  if (purposes.includes(CURATELIST)) acceptedPurposes.add(CURATELIST)
-
-  // @NOTE: While we don't support filtering on the dataplane, this might result in empty pages.
-  // Despite the empty pages, the pagination still can enumerate all items for the specified filters.
-  skeleton.listUris = skeleton.listUris.filter((uri) => {
-    const list = hydration.lists?.get(uri)
-    return acceptedPurposes.has(list?.record.purpose)
-  })
-  return skeleton
-}
-
-const presentation = (
-  input: PresentationFnInput<Context, Params, SkeletonState>,
-) => {
-  const { ctx, skeleton, hydration } = input
-  const { actorDid, listUris, cursor } = skeleton
-  const listsWithMembership = mapDefined(listUris, (uri) => {
-    const list = ctx.views.list(uri, hydration)
-    if (!list) return
-
-    const listItemUri = hydration.listMemberships
-      ?.get(uri)
-      ?.get(actorDid)?.actorListItemUri
-
-    return {
-      list,
-      listItem: listItemUri
-        ? ctx.views.listItemView(listItemUri, actorDid, hydration)
-        : undefined,
-    }
-  })
-  return { listsWithMembership, cursor }
-}
-
-type Context = {
-  hydrator: Hydrator
-  views: Views
-}
-
-type Params = app.bsky.graph.getListsWithMembership.$Params & {
-  hydrateCtx: HydrateCtxWithViewer
-}
-
-type SkeletonState = {
-  actorDid: DidString
-  listUris: AtUriString[]
-  cursor?: string
-}

package/src/api/app/bsky/graph/getMutes.ts

@@ -1,87 +0,0 @@
-import { mapDefined } from '@atproto/common'
-import { DidString } from '@atproto/lex'
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import {
-  HydrateCtxWithViewer,
-  Hydrator,
-} from '../../../../hydration/hydrator.js'
-import { app } from '../../../../lexicons/index.js'
-import {
-  HydrationFnInput,
-  PresentationFnInput,
-  SkeletonFnInput,
-  createPipeline,
-  noRules,
-} from '../../../../pipeline.js'
-import { Views } from '../../../../views/index.js'
-import { clearlyBadCursor, resHeaders } from '../../../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  const getMutes = createPipeline(skeleton, hydration, noRules, presentation)
-  server.add(app.bsky.graph.getMutes, {
-    auth: ctx.authVerifier.standard,
-    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 getMutes({ ...params, hydrateCtx }, ctx)
-      return {
-        encoding: 'application/json',
-        body: result,
-        headers: resHeaders({ labelers: hydrateCtx.labelers }),
-      }
-    },
-  })
-}
-
-const skeleton = async (
-  input: SkeletonFnInput<Context, Params>,
-): Promise<SkeletonState> => {
-  const { params, ctx } = input
-  if (clearlyBadCursor(params.cursor)) {
-    return { mutedDids: [] }
-  }
-  const { dids, cursor } = await ctx.hydrator.dataplane.getMutes({
-    actorDid: params.hydrateCtx.viewer,
-    cursor: params.cursor,
-    limit: params.limit,
-  })
-  return {
-    mutedDids: dids as DidString[],
-    cursor: cursor || undefined,
-  }
-}
-
-const hydration = async (
-  input: HydrationFnInput<Context, Params, SkeletonState>,
-) => {
-  const { ctx, params, skeleton } = input
-  const { mutedDids } = skeleton
-  return ctx.hydrator.hydrateProfiles(mutedDids, params.hydrateCtx)
-}
-
-const presentation = (
-  input: PresentationFnInput<Context, Params, SkeletonState>,
-) => {
-  const { ctx, hydration, skeleton } = input
-  const { mutedDids, cursor } = skeleton
-  const mutes = mapDefined(mutedDids, (did) => {
-    return ctx.views.profile(did, hydration)
-  })
-  return { mutes, cursor }
-}
-
-type Context = {
-  hydrator: Hydrator
-  views: Views
-}
-
-type Params = app.bsky.graph.getMutes.$Params & {
-  hydrateCtx: HydrateCtxWithViewer
-}
-
-type SkeletonState = {
-  mutedDids: DidString[]
-  cursor?: string
-}