@atproto/bsky 0.0.250 → 0.0.253

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

@@ -1,103 +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 { DataPlaneClient } from '../../../../data-plane/index.js'
-import { HydrateCtx, Hydrator } from '../../../../hydration/hydrator.js'
-import { parseString } from '../../../../hydration/util.js'
-import { app } from '../../../../lexicons/index.js'
-import {
-  HydrationFnInput,
-  PresentationFnInput,
-  SkeletonFnInput,
-  createPipeline,
-  noRules,
-} from '../../../../pipeline.js'
-import { Views } from '../../../../views/index.js'
-import { resHeaders } from '../../../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  const getActorStarterPacks = createPipeline(
-    skeleton,
-    hydration,
-    noRules,
-    presentation,
-  )
-  server.add(app.bsky.graph.getActorStarterPacks, {
-    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 getActorStarterPacks({ ...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 [did] = await ctx.hydrator.actor.getDids([params.actor])
-  if (!did) {
-    throw new InvalidRequestError('Profile not found')
-  }
-  const starterPacks = await ctx.dataplane.getActorStarterPacks({
-    actorDid: did,
-    cursor: params.cursor,
-    limit: params.limit,
-  })
-  return {
-    starterPackUris: starterPacks.uris as AtUriString[],
-    cursor: parseString(starterPacks.cursor),
-  }
-}
-
-const hydration = async (
-  input: HydrationFnInput<Context, Params, SkeletonState>,
-) => {
-  const { ctx, params, skeleton } = input
-  return ctx.hydrator.hydrateStarterPacksBasic(
-    skeleton.starterPackUris,
-    params.hydrateCtx,
-  )
-}
-
-const presentation = (
-  input: PresentationFnInput<Context, Params, SkeletonState>,
-) => {
-  const { ctx, skeleton, hydration } = input
-  const starterPacks = mapDefined(skeleton.starterPackUris, (uri) =>
-    ctx.views.starterPackBasic(uri, hydration),
-  )
-  return {
-    starterPacks,
-    cursor: skeleton.cursor,
-  }
-}
-
-type Context = {
-  hydrator: Hydrator
-  views: Views
-  dataplane: DataPlaneClient
-}
-
-type Params = app.bsky.graph.getActorStarterPacks.$Params & {
-  hydrateCtx: HydrateCtx
-}
-
-type SkeletonState = {
-  starterPackUris: AtUriString[]
-  cursor?: string
-}

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

@@ -1,94 +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 {
-  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 getBlocks = createPipeline(skeleton, hydration, noRules, presentation)
-  server.add(app.bsky.graph.getBlocks, {
-    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 getBlocks({ ...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 { blockedDids: [] }
-  }
-  const { blockUris, cursor } = (await ctx.hydrator.dataplane.getBlocks({
-    actorDid: params.hydrateCtx.viewer,
-    cursor: params.cursor,
-    limit: params.limit,
-  })) as {
-    blockUris: AtUriString[]
-    cursor?: string
-  }
-  const blocks = await ctx.hydrator.graph.getBlocks(blockUris)
-  const blockedDids = mapDefined(
-    blockUris,
-    (uri) => blocks.get(uri)?.record.subject,
-  )
-  return {
-    blockedDids,
-    cursor: cursor || undefined,
-  }
-}
-
-const hydration = async (
-  input: HydrationFnInput<Context, Params, SkeletonState>,
-) => {
-  const { ctx, params, skeleton } = input
-  return ctx.hydrator.hydrateProfiles(skeleton.blockedDids, params.hydrateCtx)
-}
-
-const presentation = (
-  input: PresentationFnInput<Context, Params, SkeletonState>,
-) => {
-  const { ctx, hydration, skeleton } = input
-  const { blockedDids, cursor } = skeleton
-  const blocks = mapDefined(blockedDids, (did) => {
-    return ctx.views.profile(did, hydration)
-  })
-  return { blocks, cursor }
-}
-
-type Context = {
-  hydrator: Hydrator
-  views: Views
-}
-
-type Params = app.bsky.graph.getBlocks.$Params & {
-  hydrateCtx: HydrateCtxWithViewer
-}
-
-type SkeletonState = {
-  blockedDids: DidString[]
-  cursor?: string
-}

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

@@ -1,153 +0,0 @@
-import { mapDefined } from '@atproto/common'
-import { AtUriString, DidString } from '@atproto/syntax'
-import { InvalidRequestError, Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import {
-  HydrateCtx,
-  Hydrator,
-  mergeStates,
-} from '../../../../hydration/hydrator.js'
-import { app } from '../../../../lexicons/index.js'
-import {
-  HydrationFnInput,
-  PresentationFnInput,
-  RulesFnInput,
-  SkeletonFnInput,
-  createPipeline,
-} from '../../../../pipeline.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 getFollowers = createPipeline(
-    skeleton,
-    hydration,
-    noBlocks,
-    presentation,
-  )
-  server.add(app.bsky.graph.getFollowers, {
-    auth: ctx.authVerifier.optionalStandardOrRole,
-    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 getFollowers({ ...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
-  const [subjectDid] = await ctx.hydrator.actor.getDidsDefined([params.actor])
-  if (!subjectDid) {
-    throw new InvalidRequestError(`Actor not found: ${params.actor}`)
-  }
-  if (clearlyBadCursor(params.cursor)) {
-    return { subjectDid, followUris: [] }
-  }
-  const { followers, cursor } = await ctx.hydrator.graph.getActorFollowers({
-    did: subjectDid,
-    cursor: params.cursor,
-    limit: params.limit,
-  })
-  return {
-    subjectDid,
-    followUris: followers.map((f) => f.uri as AtUriString),
-    cursor: cursor || undefined,
-  }
-}
-
-const hydration = async (
-  input: HydrationFnInput<Context, Params, SkeletonState>,
-) => {
-  const { ctx, params, skeleton } = input
-  const { followUris, subjectDid } = skeleton
-  const followState = await ctx.hydrator.hydrateFollows(
-    followUris,
-    params.hydrateCtx,
-  )
-  const dids = [subjectDid]
-  if (followState.follows) {
-    for (const [uri, follow] of followState.follows) {
-      if (follow) {
-        dids.push(didFromUri(uri))
-      }
-    }
-  }
-  const profileState = await ctx.hydrator.hydrateProfiles(
-    dids,
-    params.hydrateCtx,
-  )
-  return mergeStates(followState, profileState)
-}
-
-const noBlocks = (input: RulesFnInput<Context, Params, SkeletonState>) => {
-  const { skeleton, params, hydration, ctx } = input
-  const viewer = params.hydrateCtx.viewer
-  skeleton.followUris = skeleton.followUris.filter((followUri) => {
-    const followerDid = didFromUri(followUri)
-    return (
-      !hydration.followBlocks?.get(followUri) &&
-      (!viewer || !ctx.views.viewerBlockExists(followerDid, hydration))
-    )
-  })
-  return skeleton
-}
-
-const presentation = (
-  input: PresentationFnInput<Context, Params, SkeletonState>,
-) => {
-  const { ctx, hydration, skeleton, params } = input
-  const { subjectDid, followUris, cursor } = skeleton
-  const isNoHosted = (did: DidString) =>
-    ctx.views.actorIsNoHosted(did, hydration)
-
-  const subject = ctx.views.profile(subjectDid, hydration)
-  if (
-    !subject ||
-    (!params.hydrateCtx.includeTakedowns && isNoHosted(subjectDid))
-  ) {
-    throw new InvalidRequestError(`Actor not found: ${params.actor}`)
-  }
-
-  const followers = mapDefined(followUris, (followUri) => {
-    const followerDid = didFromUri(followUri)
-    if (!params.hydrateCtx.includeTakedowns && isNoHosted(followerDid)) {
-      return
-    }
-    return ctx.views.profile(didFromUri(followUri), hydration)
-  })
-
-  return { followers, subject, cursor }
-}
-
-type Context = {
-  hydrator: Hydrator
-  views: Views
-}
-
-type Params = app.bsky.graph.getFollowers.$Params & {
-  hydrateCtx: HydrateCtx
-}
-
-type SkeletonState = {
-  subjectDid: DidString
-  followUris: AtUriString[]
-  cursor?: string
-}

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

@@ -1,151 +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,
-  Hydrator,
-  mergeStates,
-} from '../../../../hydration/hydrator.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'
-
-export default function (server: Server, ctx: AppContext) {
-  const getFollows = createPipeline(skeleton, hydration, noBlocks, presentation)
-  server.add(app.bsky.graph.getFollows, {
-    auth: ctx.authVerifier.optionalStandardOrRole,
-    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,
-      })
-
-      // @TODO ensure canViewTakedowns gets threaded through and applied properly
-      const result = await getFollows({ ...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
-  const [subjectDid] = await ctx.hydrator.actor.getDidsDefined([params.actor])
-  if (!subjectDid) {
-    throw new InvalidRequestError(`Actor not found: ${params.actor}`)
-  }
-  if (clearlyBadCursor(params.cursor)) {
-    return { subjectDid, followUris: [] }
-  }
-  const { follows, cursor } = await ctx.hydrator.graph.getActorFollows({
-    did: subjectDid,
-    cursor: params.cursor,
-    limit: params.limit,
-  })
-  return {
-    subjectDid,
-    followUris: follows.map((f) => f.uri as AtUriString),
-    cursor: cursor || undefined,
-  }
-}
-
-const hydration = async (
-  input: HydrationFnInput<Context, Params, SkeletonState>,
-) => {
-  const { ctx, params, skeleton } = input
-  const { followUris, subjectDid } = skeleton
-  const followState = await ctx.hydrator.hydrateFollows(
-    followUris,
-    params.hydrateCtx,
-  )
-  const dids = [subjectDid]
-  if (followState.follows) {
-    for (const follow of followState.follows.values()) {
-      if (follow) {
-        dids.push(follow.record.subject)
-      }
-    }
-  }
-  const profileState = await ctx.hydrator.hydrateProfiles(
-    dids,
-    params.hydrateCtx,
-  )
-  return mergeStates(followState, profileState)
-}
-
-const noBlocks = (input: RulesFnInput<Context, Params, SkeletonState>) => {
-  const { skeleton, params, hydration, ctx } = input
-  const viewer = params.hydrateCtx.viewer
-  skeleton.followUris = skeleton.followUris.filter((followUri) => {
-    const follow = hydration.follows?.get(followUri)
-    if (!follow) return false
-    return (
-      !hydration.followBlocks?.get(followUri) &&
-      (!viewer ||
-        !ctx.views.viewerBlockExists(follow.record.subject, hydration))
-    )
-  })
-  return skeleton
-}
-
-const presentation = (
-  input: PresentationFnInput<Context, Params, SkeletonState>,
-) => {
-  const { ctx, hydration, skeleton, params } = input
-  const { subjectDid, followUris, cursor } = skeleton
-  const isNoHosted = (did: DidString) =>
-    ctx.views.actorIsNoHosted(did, hydration)
-
-  const subject = ctx.views.profile(subjectDid, hydration)
-  if (
-    !subject ||
-    (!params.hydrateCtx.includeTakedowns && isNoHosted(subjectDid))
-  ) {
-    throw new InvalidRequestError(`Actor not found: ${params.actor}`)
-  }
-
-  const follows = mapDefined(followUris, (followUri) => {
-    const followDid = hydration.follows?.get(followUri)?.record.subject
-    if (!followDid) return
-    if (!params.hydrateCtx.includeTakedowns && isNoHosted(followDid)) {
-      return
-    }
-    return ctx.views.profile(followDid, hydration)
-  })
-
-  return { follows, subject, cursor }
-}
-
-type Context = {
-  hydrator: Hydrator
-  views: Views
-}
-
-type Params = app.bsky.graph.getFollowers.$Params & {
-  hydrateCtx: HydrateCtx
-}
-
-type SkeletonState = {
-  subjectDid: DidString
-  followUris: AtUriString[]
-  cursor?: string
-}

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

@@ -1,123 +0,0 @@
-import { mapDefined } from '@atproto/common'
-import { DidString } from '@atproto/lex'
-import { InvalidRequestError, 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,
-  RulesFnInput,
-  SkeletonFnInput,
-  createPipeline,
-} from '../../../../pipeline.js'
-import { Views } from '../../../../views/index.js'
-import { clearlyBadCursor, resHeaders } from '../../../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  const getKnownFollowers = createPipeline(
-    skeleton,
-    hydration,
-    noBlocks,
-    presentation,
-  )
-  server.add(app.bsky.graph.getKnownFollowers, {
-    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 getKnownFollowers({ ...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
-  const [subjectDid] = await ctx.hydrator.actor.getDidsDefined([params.actor])
-  if (!subjectDid) {
-    throw new InvalidRequestError(`Actor not found: ${params.actor}`)
-  }
-  if (clearlyBadCursor(params.cursor)) {
-    return { subjectDid, knownFollowers: [], cursor: undefined }
-  }
-
-  const res = await ctx.hydrator.dataplane.getFollowsFollowing({
-    actorDid: params.hydrateCtx.viewer,
-    targetDids: [subjectDid],
-  })
-  const result = res.results.at(0)
-  const knownFollowers = result
-    ? (result.dids.slice(0, params.limit) as DidString[])
-    : []
-
-  return {
-    subjectDid,
-    knownFollowers,
-    cursor: undefined,
-  }
-}
-
-const hydration = async (
-  input: HydrationFnInput<Context, Params, SkeletonState>,
-) => {
-  const { ctx, params, skeleton } = input
-  const { knownFollowers } = skeleton
-  const profilesState = await ctx.hydrator.hydrateProfiles(
-    knownFollowers.concat(skeleton.subjectDid),
-    params.hydrateCtx,
-  )
-  return profilesState
-}
-
-const noBlocks = (input: RulesFnInput<Context, Params, SkeletonState>) => {
-  const { skeleton, hydration, ctx } = input
-  skeleton.knownFollowers = skeleton.knownFollowers.filter((did) => {
-    return !ctx.views.viewerBlockExists(did, hydration)
-  })
-  return skeleton
-}
-
-const presentation = (
-  input: PresentationFnInput<Context, Params, SkeletonState>,
-) => {
-  const { ctx, hydration, skeleton } = input
-  const { knownFollowers } = skeleton
-
-  const followers = mapDefined(knownFollowers, (did) => {
-    return ctx.views.profile(did, hydration)
-  })
-  const subject = ctx.views.profile(skeleton.subjectDid, hydration)!
-
-  return { subject, followers, cursor: undefined }
-}
-
-type Context = {
-  hydrator: Hydrator
-  views: Views
-}
-
-type Params = app.bsky.graph.getKnownFollowers.$Params & {
-  hydrateCtx: HydrateCtxWithViewer
-}
-
-type SkeletonState = {
-  subjectDid: DidString
-  knownFollowers: DidString[]
-  cursor?: string
-}