@atproto/bsky 0.0.176 → 0.0.178

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

@@ -0,0 +1,139 @@
+import { mapDefined } from '@atproto/common'
+import { InvalidRequestError } from '@atproto/xrpc-server'
+import { AppContext } from '../../../../context'
+import { HydrateCtx, Hydrator } from '../../../../hydration/hydrator'
+import { Server } from '../../../../lexicon'
+import {
+  CURATELIST,
+  MODLIST,
+} from '../../../../lexicon/types/app/bsky/graph/defs'
+import { QueryParams } from '../../../../lexicon/types/app/bsky/graph/getListsWithMembership'
+import {
+  HydrationFnInput,
+  PresentationFnInput,
+  RulesFnInput,
+  SkeletonFnInput,
+  createPipeline,
+} from '../../../../pipeline'
+import { Views } from '../../../../views'
+import { clearlyBadCursor, resHeaders } from '../../../util'
+
+export default function (server: Server, ctx: AppContext) {
+  const getListsWithMembership = createPipeline(
+    skeleton,
+    hydration,
+    filterPurposes,
+    presentation,
+  )
+  server.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: hydrateCtx.copy({ viewer }) },
+        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, cursor: cursor || undefined }
+}
+
+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 = QueryParams & {
+  hydrateCtx: HydrateCtx & { viewer: string }
+}
+
+type SkeletonState = {
+  actorDid: string
+  listUris: string[]
+  cursor?: string
+}

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

@@ -0,0 +1,135 @@
+import { mapDefined } from '@atproto/common'
+import { InvalidRequestError } from '@atproto/xrpc-server'
+import { AppContext } from '../../../../context'
+import {
+  HydrateCtx,
+  Hydrator,
+  mergeManyStates,
+} from '../../../../hydration/hydrator'
+import { Server } from '../../../../lexicon'
+import {
+  OutputSchema,
+  QueryParams,
+} from '../../../../lexicon/types/app/bsky/graph/getStarterPacksWithMembership'
+import {
+  HydrationFnInput,
+  PresentationFnInput,
+  SkeletonFnInput,
+  createPipeline,
+  noRules,
+} from '../../../../pipeline'
+import { Views } from '../../../../views'
+import { clearlyBadCursor, resHeaders } from '../../../util'
+
+export default function (server: Server, ctx: AppContext) {
+  const getStarterPacksWithMembership = createPipeline(
+    skeleton,
+    hydration,
+    noRules,
+    presentation,
+  )
+  server.app.bsky.graph.getStarterPacksWithMembership({
+    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 getStarterPacksWithMembership(
+        { ...params, hydrateCtx: hydrateCtx.copy({ viewer }) },
+        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, starterPackUris: [] }
+  }
+
+  const { uris: starterPackUris, cursor } =
+    await ctx.hydrator.dataplane.getActorStarterPacks({
+      actorDid: params.hydrateCtx.viewer,
+      cursor: params.cursor,
+      limit: params.limit,
+    })
+
+  return { actorDid, starterPackUris, cursor: cursor || undefined }
+}
+
+const hydration = async (
+  input: HydrationFnInput<Context, Params, SkeletonState>,
+) => {
+  const { ctx, params, skeleton } = input
+  const { actorDid, starterPackUris } = skeleton
+  const spHydrationState = await ctx.hydrator.hydrateStarterPacks(
+    starterPackUris,
+    params.hydrateCtx,
+  )
+  const listUris = mapDefined(
+    starterPackUris,
+    (uri) => spHydrationState.starterPacks?.get(uri)?.record.list,
+  )
+  const listMembershipHydrationState =
+    await ctx.hydrator.hydrateListsMembership(
+      listUris,
+      actorDid,
+      params.hydrateCtx,
+    )
+  return mergeManyStates(spHydrationState, listMembershipHydrationState)
+}
+
+const presentation = (
+  input: PresentationFnInput<Context, Params, SkeletonState>,
+): OutputSchema => {
+  const { ctx, skeleton, hydration } = input
+  const { actorDid, starterPackUris, cursor } = skeleton
+
+  const starterPacksWithMembership = mapDefined(starterPackUris, (spUri) => {
+    const listUri = hydration.starterPacks?.get(spUri)?.record.list
+    const starterPack = ctx.views.starterPack(spUri, hydration)
+    if (!listUri || !starterPack) return
+
+    const listItemUri = hydration.listMemberships
+      ?.get(listUri)
+      ?.get(actorDid)?.actorListItemUri
+
+    return {
+      starterPack,
+      listItem: listItemUri
+        ? ctx.views.listItemView(listItemUri, actorDid, hydration)
+        : undefined,
+    }
+  })
+  return { starterPacksWithMembership, cursor }
+}
+
+type Context = {
+  hydrator: Hydrator
+  views: Views
+}
+
+type Params = QueryParams & {
+  hydrateCtx: HydrateCtx & { viewer: string }
+}
+
+type SkeletonState = {
+  actorDid: string
+  starterPackUris: string[]
+  cursor?: string
+}

package/src/api/index.ts

@@ -29,10 +29,12 @@ import getList from './app/bsky/graph/getList'
 import getListBlocks from './app/bsky/graph/getListBlocks'
 import getListMutes from './app/bsky/graph/getListMutes'
 import getLists from './app/bsky/graph/getLists'
+import getListsWithMembership from './app/bsky/graph/getListsWithMembership'
 import getMutes from './app/bsky/graph/getMutes'
 import getRelationships from './app/bsky/graph/getRelationships'
 import getStarterPack from './app/bsky/graph/getStarterPack'
 import getStarterPacks from './app/bsky/graph/getStarterPacks'
+import getStarterPacksWithMembership from './app/bsky/graph/getStarterPacksWithMembership'
 import getSuggestedFollowsByActor from './app/bsky/graph/getSuggestedFollowsByActor'
 import muteActor from './app/bsky/graph/muteActor'
 import muteActorList from './app/bsky/graph/muteActorList'
@@ -108,11 +110,13 @@ export default function (server: Server, ctx: AppContext) {
   getFollows(server, ctx)
   getList(server, ctx)
   getLists(server, ctx)
+  getListsWithMembership(server, ctx)
   getListMutes(server, ctx)
   getMutes(server, ctx)
   getRelationships(server, ctx)
   getStarterPack(server, ctx)
   getStarterPacks(server, ctx)
+  getStarterPacksWithMembership(server, ctx)
   searchStarterPacks(server, ctx)
   muteActor(server, ctx)
   unmuteActor(server, ctx)

package/src/hydration/graph.ts

@@ -22,6 +22,14 @@ export type ListViewerState = {
 
 export type ListViewerStates = HydrationMap<ListViewerState>
 
+export type ListMembershipState = {
+  actorListItemUri?: string
+}
+// list uri => actor did => state
+export type ListMembershipStates = HydrationMap<
+  HydrationMap<ListMembershipState>
+>
+
 export type Follow = RecordInfo<FollowRecord>
 export type Follows = HydrationMap<Follow>
 

package/src/hydration/hydrator.ts

@@ -43,6 +43,8 @@ import {
   GraphHydrator,
   ListAggs,
   ListItems,
+  ListMembershipState,
+  ListMembershipStates,
   ListViewerStates,
   Lists,
   RelationshipPair,
@@ -109,6 +111,7 @@ export type HydrationState = {
   postgates?: Postgates
   lists?: Lists
   listAggs?: ListAggs
+  listMemberships?: ListMembershipStates
   listViewers?: ListViewerStates
   listItems?: ListItems
   likes?: Likes
@@ -363,6 +366,45 @@ export class Hydrator {
     return mergeStates(profileState, { listItems, ctx })
   }
 
+  async hydrateListsMembership(
+    uris: string[],
+    did: string,
+    ctx: HydrateCtx,
+  ): Promise<HydrationState> {
+    const [
+      actorsHydrationState,
+      listsHydrationState,
+      { listitemUris: listItemUris },
+    ] = await Promise.all([
+      this.hydrateProfiles([did], ctx),
+      this.hydrateLists(uris, ctx),
+      this.dataplane.getListMembership({
+        actorDid: did,
+        listUris: uris,
+      }),
+    ])
+
+    // mapping uri -> did -> { actorListItemUri }
+    const listMemberships = new HydrationMap(
+      uris.map((uri, i) => {
+        const listItemUri = listItemUris[i]
+        return [
+          uri,
+          new HydrationMap<ListMembershipState>([
+            listItemUri
+              ? [did, { actorListItemUri: listItemUri }]
+              : [did, null],
+          ]),
+        ]
+      }),
+    )
+
+    return mergeManyStates(actorsHydrationState, listsHydrationState, {
+      listMemberships,
+      ctx,
+    })
+  }
+
   // app.bsky.feed.defs#postView
   // - post
   //   - profile
@@ -1356,6 +1398,7 @@ export const mergeStates = (
     postgates: mergeMaps(stateA.postgates, stateB.postgates),
     lists: mergeMaps(stateA.lists, stateB.lists),
     listAggs: mergeMaps(stateA.listAggs, stateB.listAggs),
+    listMemberships: mergeMaps(stateA.listMemberships, stateB.listMemberships),
     listViewers: mergeMaps(stateA.listViewers, stateB.listViewers),
     listItems: mergeMaps(stateA.listItems, stateB.listItems),
     likes: mergeMaps(stateA.likes, stateB.likes),