@atproto/bsky 0.0.176 → 0.0.177

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),

package/src/lexicon/index.ts

@@ -127,10 +127,12 @@ import * as AppBskyGraphGetList from './types/app/bsky/graph/getList.js'
 import * as AppBskyGraphGetListBlocks from './types/app/bsky/graph/getListBlocks.js'
 import * as AppBskyGraphGetListMutes from './types/app/bsky/graph/getListMutes.js'
 import * as AppBskyGraphGetLists from './types/app/bsky/graph/getLists.js'
+import * as AppBskyGraphGetListsWithMembership from './types/app/bsky/graph/getListsWithMembership.js'
 import * as AppBskyGraphGetMutes from './types/app/bsky/graph/getMutes.js'
 import * as AppBskyGraphGetRelationships from './types/app/bsky/graph/getRelationships.js'
 import * as AppBskyGraphGetStarterPack from './types/app/bsky/graph/getStarterPack.js'
 import * as AppBskyGraphGetStarterPacks from './types/app/bsky/graph/getStarterPacks.js'
+import * as AppBskyGraphGetStarterPacksWithMembership from './types/app/bsky/graph/getStarterPacksWithMembership.js'
 import * as AppBskyGraphGetSuggestedFollowsByActor from './types/app/bsky/graph/getSuggestedFollowsByActor.js'
 import * as AppBskyGraphMuteActor from './types/app/bsky/graph/muteActor.js'
 import * as AppBskyGraphMuteActorList from './types/app/bsky/graph/muteActorList.js'
@@ -1825,6 +1827,18 @@ export class AppBskyGraphNS {
     return this._server.xrpc.method(nsid, cfg)
   }
 
+  getListsWithMembership<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyGraphGetListsWithMembership.QueryParams,
+      AppBskyGraphGetListsWithMembership.HandlerInput,
+      AppBskyGraphGetListsWithMembership.HandlerOutput
+    >,
+  ) {
+    const nsid = 'app.bsky.graph.getListsWithMembership' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
   getMutes<A extends Auth = void>(
     cfg: MethodConfigOrHandler<
       A,
@@ -1873,6 +1887,18 @@ export class AppBskyGraphNS {
     return this._server.xrpc.method(nsid, cfg)
   }
 
+  getStarterPacksWithMembership<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyGraphGetStarterPacksWithMembership.QueryParams,
+      AppBskyGraphGetStarterPacksWithMembership.HandlerInput,
+      AppBskyGraphGetStarterPacksWithMembership.HandlerOutput
+    >,
+  ) {
+    const nsid = 'app.bsky.graph.getStarterPacksWithMembership' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
   getSuggestedFollowsByActor<A extends Auth = void>(
     cfg: MethodConfigOrHandler<
       A,

package/src/lexicon/lexicons.ts

@@ -8958,6 +8958,15 @@ export const schemaDict = {
             cursor: {
               type: 'string',
             },
+            purposes: {
+              type: 'array',
+              description:
+                'Optional filter by list purpose. If not specified, all supported types are returned.',
+              items: {
+                type: 'string',
+                knownValues: ['modlist', 'curatelist'],
+              },
+            },
           },
         },
         output: {
@@ -8982,6 +8991,81 @@ export const schemaDict = {
       },
     },
   },
+  AppBskyGraphGetListsWithMembership: {
+    lexicon: 1,
+    id: 'app.bsky.graph.getListsWithMembership',
+    defs: {
+      main: {
+        type: 'query',
+        description:
+          'Enumerates the lists created by the session user, and includes membership information about `actor` in those lists. Only supports curation and moderation lists (no reference lists, used in starter packs). Requires auth.',
+        parameters: {
+          type: 'params',
+          required: ['actor'],
+          properties: {
+            actor: {
+              type: 'string',
+              format: 'at-identifier',
+              description: 'The account (actor) to check for membership.',
+            },
+            limit: {
+              type: 'integer',
+              minimum: 1,
+              maximum: 100,
+              default: 50,
+            },
+            cursor: {
+              type: 'string',
+            },
+            purposes: {
+              type: 'array',
+              description:
+                'Optional filter by list purpose. If not specified, all supported types are returned.',
+              items: {
+                type: 'string',
+                knownValues: ['modlist', 'curatelist'],
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['listsWithMembership'],
+            properties: {
+              cursor: {
+                type: 'string',
+              },
+              listsWithMembership: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:app.bsky.graph.getListsWithMembership#listWithMembership',
+                },
+              },
+            },
+          },
+        },
+      },
+      listWithMembership: {
+        description:
+          'A list and an optional list item indicating membership of a target user to that list.',
+        type: 'object',
+        required: ['list'],
+        properties: {
+          list: {
+            type: 'ref',
+            ref: 'lex:app.bsky.graph.defs#listView',
+          },
+          listItem: {
+            type: 'ref',
+            ref: 'lex:app.bsky.graph.defs#listItemView',
+          },
+        },
+      },
+    },
+  },
   AppBskyGraphGetMutes: {
     lexicon: 1,
     id: 'app.bsky.graph.getMutes',
@@ -9162,6 +9246,72 @@ export const schemaDict = {
       },
     },
   },
+  AppBskyGraphGetStarterPacksWithMembership: {
+    lexicon: 1,
+    id: 'app.bsky.graph.getStarterPacksWithMembership',
+    defs: {
+      main: {
+        type: 'query',
+        description:
+          'Enumerates the starter packs created by the session user, and includes membership information about `actor` in those starter packs. Requires auth.',
+        parameters: {
+          type: 'params',
+          required: ['actor'],
+          properties: {
+            actor: {
+              type: 'string',
+              format: 'at-identifier',
+              description: 'The account (actor) to check for membership.',
+            },
+            limit: {
+              type: 'integer',
+              minimum: 1,
+              maximum: 100,
+              default: 50,
+            },
+            cursor: {
+              type: 'string',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['starterPacksWithMembership'],
+            properties: {
+              cursor: {
+                type: 'string',
+              },
+              starterPacksWithMembership: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:app.bsky.graph.getStarterPacksWithMembership#starterPackWithMembership',
+                },
+              },
+            },
+          },
+        },
+      },
+      starterPackWithMembership: {
+        description:
+          'A starter pack and an optional list item indicating membership of a target user to that starter pack.',
+        type: 'object',
+        required: ['starterPack'],
+        properties: {
+          starterPack: {
+            type: 'ref',
+            ref: 'lex:app.bsky.graph.defs#starterPackView',
+          },
+          listItem: {
+            type: 'ref',
+            ref: 'lex:app.bsky.graph.defs#listItemView',
+          },
+        },
+      },
+    },
+  },
   AppBskyGraphGetSuggestedFollowsByActor: {
     lexicon: 1,
     id: 'app.bsky.graph.getSuggestedFollowsByActor',
@@ -13596,10 +13746,13 @@ export const ids = {
   AppBskyGraphGetListBlocks: 'app.bsky.graph.getListBlocks',
   AppBskyGraphGetListMutes: 'app.bsky.graph.getListMutes',
   AppBskyGraphGetLists: 'app.bsky.graph.getLists',
+  AppBskyGraphGetListsWithMembership: 'app.bsky.graph.getListsWithMembership',
   AppBskyGraphGetMutes: 'app.bsky.graph.getMutes',
   AppBskyGraphGetRelationships: 'app.bsky.graph.getRelationships',
   AppBskyGraphGetStarterPack: 'app.bsky.graph.getStarterPack',
   AppBskyGraphGetStarterPacks: 'app.bsky.graph.getStarterPacks',
+  AppBskyGraphGetStarterPacksWithMembership:
+    'app.bsky.graph.getStarterPacksWithMembership',
   AppBskyGraphGetSuggestedFollowsByActor:
     'app.bsky.graph.getSuggestedFollowsByActor',
   AppBskyGraphList: 'app.bsky.graph.list',

package/src/lexicon/types/app/bsky/graph/getLists.ts

@@ -20,6 +20,8 @@ export type QueryParams = {
   actor: string
   limit: number
   cursor?: string
+  /** Optional filter by list purpose. If not specified, all supported types are returned. */
+  purposes?: 'modlist' | 'curatelist' | (string & {})[]
 }
 export type InputSchema = undefined
 

package/src/lexicon/types/app/bsky/graph/getListsWithMembership.ts

@@ -0,0 +1,63 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import type * as AppBskyGraphDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.bsky.graph.getListsWithMembership'
+
+export type QueryParams = {
+  /** The account (actor) to check for membership. */
+  actor: string
+  limit: number
+  cursor?: string
+  /** Optional filter by list purpose. If not specified, all supported types are returned. */
+  purposes?: 'modlist' | 'curatelist' | (string & {})[]
+}
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  cursor?: string
+  listsWithMembership: ListWithMembership[]
+}
+
+export type HandlerInput = void
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess
+
+/** A list and an optional list item indicating membership of a target user to that list. */
+export interface ListWithMembership {
+  $type?: 'app.bsky.graph.getListsWithMembership#listWithMembership'
+  list: AppBskyGraphDefs.ListView
+  listItem?: AppBskyGraphDefs.ListItemView
+}
+
+const hashListWithMembership = 'listWithMembership'
+
+export function isListWithMembership<V>(v: V) {
+  return is$typed(v, id, hashListWithMembership)
+}
+
+export function validateListWithMembership<V>(v: V) {
+  return validate<ListWithMembership & V>(v, id, hashListWithMembership)
+}