@atproto/bsky 0.0.251 → 0.0.254

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

@@ -1,169 +0,0 @@
-import { mapDefined } from '@atproto/common'
-import { AtUriString, Client } from '@atproto/lex'
-import { 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,
-  RulesFnInput,
-  SkeletonFnInput,
-  createPipeline,
-} from '../../../../pipeline.js'
-import { uriToDid as creatorFromUri } from '../../../../util/uris.js'
-import { Views } from '../../../../views/index.js'
-import { resHeaders, resolveSearchV2Override } from '../../../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  const searchStarterPacks = createPipeline(
-    skeleton,
-    hydration,
-    noBlocks,
-    presentation,
-  )
-  server.add(app.bsky.graph.searchStarterPacks, {
-    auth: ctx.authVerifier.standardOptional,
-    handler: async ({ auth, params, req }) => {
-      const { viewer, includeTakedowns, skipViewerBlocks } =
-        ctx.authVerifier.parseCreds(auth)
-      const labelers = ctx.reqLabelers(req)
-      const hydrateCtx = await ctx.hydrator.createContext({
-        viewer,
-        labelers,
-        includeTakedowns,
-        skipViewerBlocks,
-        features: ctx.featureGatesClient.scope(
-          ctx.featureGatesClient.parseUserContextFromHandler({
-            viewer,
-            req,
-          }),
-        ),
-      })
-      const results = await searchStarterPacks(
-        {
-          ...params,
-          hydrateCtx,
-          isV2Override: resolveSearchV2Override(req, ctx.cfg),
-        },
-        ctx,
-      )
-      return {
-        encoding: 'application/json',
-        body: results,
-        headers: resHeaders({ labelers: hydrateCtx.labelers }),
-      }
-    },
-  })
-}
-
-const skeletonV1 = async (
-  inputs: SkeletonFnInput<Context, Params>,
-): Promise<Skeleton> => {
-  const { ctx, params } = inputs
-  const { q } = params
-
-  if (ctx.searchClient) {
-    // @NOTE cursors won't change on appview swap
-    const res = await ctx.searchClient.call(
-      app.bsky.unspecced.searchStarterPacksSkeleton,
-      {
-        q,
-        cursor: params.cursor,
-        limit: params.limit,
-        viewer: params.hydrateCtx.viewer ?? undefined,
-      },
-    )
-    return {
-      uris: res.starterPacks.map(({ uri }) => uri),
-      cursor: parseString(res.cursor),
-    }
-  }
-
-  const res = await ctx.dataplane.searchStarterPacks({
-    term: q,
-    limit: params.limit,
-    cursor: params.cursor,
-  })
-  return {
-    uris: res.uris as AtUriString[],
-    cursor: parseString(res.cursor),
-  }
-}
-
-const skeletonV2 = async (
-  inputs: SkeletonFnInput<Context, Params>,
-): Promise<Skeleton> => {
-  const { ctx, params } = inputs
-  const { q } = params
-
-  const res = await ctx.dataplane.searchStarterPacksV2({
-    params: {
-      query: q,
-      viewer: params.hydrateCtx.viewer ?? undefined,
-      limit: params.limit,
-      cursor: params.cursor,
-    },
-  })
-  return {
-    uris: res.starterPacks.map(({ uri }) => uri as AtUriString),
-    cursor: parseString(res.pageInfo?.cursor),
-  }
-}
-
-const skeleton = async (input: SkeletonFnInput<Context, Params>) => {
-  const useV2 =
-    input.params.hydrateCtx.features.checkGate(
-      input.params.hydrateCtx.features.Gate.SearchV2Enable,
-    ) || input.params.isV2Override
-  const skeletonFn = useV2 ? skeletonV2 : skeletonV1
-  return skeletonFn(input)
-}
-
-const hydration = async (
-  inputs: HydrationFnInput<Context, Params, Skeleton>,
-) => {
-  const { ctx, params, skeleton } = inputs
-  return ctx.hydrator.hydrateStarterPacksBasic(skeleton.uris, params.hydrateCtx)
-}
-
-const noBlocks = (inputs: RulesFnInput<Context, Params, Skeleton>) => {
-  const { ctx, skeleton, hydration } = inputs
-  skeleton.uris = skeleton.uris.filter((uri) => {
-    const creator = creatorFromUri(uri)
-    return !ctx.views.viewerBlockExists(creator, hydration)
-  })
-  return skeleton
-}
-
-const presentation = (
-  inputs: PresentationFnInput<Context, Params, Skeleton>,
-) => {
-  const { ctx, skeleton, hydration } = inputs
-  const starterPacks = mapDefined(skeleton.uris, (uri) =>
-    ctx.views.starterPackBasic(uri, hydration),
-  )
-  return {
-    starterPacks: starterPacks,
-    cursor: skeleton.cursor,
-  }
-}
-
-type Context = {
-  dataplane: DataPlaneClient
-  hydrator: Hydrator
-  views: Views
-  searchClient?: Client
-}
-
-type Params = app.bsky.graph.searchStarterPacks.$Params & {
-  hydrateCtx: HydrateCtx
-  isV2Override: boolean
-}
-
-type Skeleton = {
-  uris: AtUriString[]
-  cursor?: string
-}

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

@@ -1,21 +0,0 @@
-import { InvalidRequestError, Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { app } from '../../../../lexicons/index.js'
-import { MuteOperation_Type } from '../../../../proto/bsync_pb.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(app.bsky.graph.unmuteActor, {
-    auth: ctx.authVerifier.standard,
-    handler: async ({ auth, input }) => {
-      const { actor } = input.body
-      const requester = auth.credentials.iss
-      const [did] = await ctx.hydrator.actor.getDids([actor])
-      if (!did) throw new InvalidRequestError('Actor not found')
-      await ctx.bsyncClient.addMuteOperation({
-        type: MuteOperation_Type.REMOVE,
-        actorDid: requester,
-        subject: did,
-      })
-    },
-  })
-}

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

@@ -1,19 +0,0 @@
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { app } from '../../../../lexicons/index.js'
-import { MuteOperation_Type } from '../../../../proto/bsync_pb.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(app.bsky.graph.unmuteActorList, {
-    auth: ctx.authVerifier.standard,
-    handler: async ({ auth, input }) => {
-      const { list } = input.body
-      const requester = auth.credentials.iss
-      await ctx.bsyncClient.addMuteOperation({
-        type: MuteOperation_Type.REMOVE,
-        actorDid: requester,
-        subject: list,
-      })
-    },
-  })
-}

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

@@ -1,19 +0,0 @@
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { app } from '../../../../lexicons/index.js'
-import { MuteOperation_Type } from '../../../../proto/bsync_pb.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(app.bsky.graph.unmuteThread, {
-    auth: ctx.authVerifier.standard,
-    handler: async ({ auth, input }) => {
-      const { root } = input.body
-      const requester = auth.credentials.iss
-      await ctx.bsyncClient.addMuteOperation({
-        type: MuteOperation_Type.REMOVE,
-        actorDid: requester,
-        subject: root,
-      })
-    },
-  })
-}

package/src/api/app/bsky/labeler/getServices.ts

@@ -1,41 +0,0 @@
-import { mapDefined } from '@atproto/common'
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { app } from '../../../../lexicons/index.js'
-import { resHeaders } from '../../../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(app.bsky.labeler.getServices, {
-    auth: ctx.authVerifier.standardOptional,
-    handler: async ({ params, auth, req }) => {
-      const { dids, detailed } = params
-      const viewer = auth.credentials.iss
-      const labelers = ctx.reqLabelers(req)
-      const hydrateCtx = await ctx.hydrator.createContext({
-        viewer,
-        labelers,
-      })
-      const hydration = await ctx.hydrator.hydrateLabelers(dids, hydrateCtx)
-
-      const views = mapDefined(dids, (did) => {
-        if (detailed) {
-          const view = ctx.views.labelerDetailed(did, hydration)
-          if (!view) return
-          return app.bsky.labeler.defs.labelerViewDetailed.$build(view)
-        } else {
-          const view = ctx.views.labeler(did, hydration)
-          if (!view) return
-          return app.bsky.labeler.defs.labelerView.$build(view)
-        }
-      })
-
-      return {
-        encoding: 'application/json',
-        body: {
-          views,
-        },
-        headers: resHeaders({ labelers: hydrateCtx.labelers }),
-      }
-    },
-  })
-}

package/src/api/app/bsky/notification/getPreferences.ts

@@ -1,49 +0,0 @@
-import assert from 'node:assert'
-import { Un$Typed } from '@atproto/lex'
-import { Server, UpstreamFailureError } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { app } from '../../../../lexicons/index.js'
-import { GetNotificationPreferencesResponse } from '../../../../proto/bsky_pb.js'
-import { protobufToLex } from './util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(app.bsky.notification.getPreferences, {
-    auth: ctx.authVerifier.standard,
-    handler: async ({ auth }) => {
-      const actorDid = auth.credentials.iss
-      const preferences = await computePreferences(ctx, actorDid)
-      return {
-        encoding: 'application/json',
-        body: {
-          preferences,
-        },
-      }
-    },
-  })
-}
-
-const computePreferences = async (
-  ctx: AppContext,
-  actorDid: string,
-): Promise<Un$Typed<app.bsky.notification.defs.Preferences>> => {
-  let res: GetNotificationPreferencesResponse
-  try {
-    res = await ctx.dataplane.getNotificationPreferences({
-      dids: [actorDid],
-    })
-  } catch (err) {
-    throw new UpstreamFailureError(
-      'cannot get current notification preferences',
-      'NotificationPreferencesFailed',
-      { cause: err },
-    )
-  }
-
-  assert(
-    res.preferences.length === 1,
-    `expected exactly one preferences entry, got ${res.preferences.length}`,
-  )
-
-  const currentPreferences = protobufToLex(res.preferences[0])
-  return currentPreferences
-}

package/src/api/app/bsky/notification/getUnreadCount.ts

@@ -1,83 +0,0 @@
-import { DidString } from '@atproto/syntax'
-import { InvalidRequestError, Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { 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'
-
-export default function (server: Server, ctx: AppContext) {
-  const getUnreadCount = createPipeline(
-    skeleton,
-    hydration,
-    noRules,
-    presentation,
-  )
-  server.add(app.bsky.notification.getUnreadCount, {
-    auth: ctx.authVerifier.standard,
-    handler: async ({ auth, params }) => {
-      const viewer = auth.credentials.iss
-      const result = await getUnreadCount({ ...params, viewer }, ctx)
-      return {
-        encoding: 'application/json',
-        body: result,
-      }
-    },
-  })
-}
-
-const skeleton = async (
-  input: SkeletonFnInput<Context, Params>,
-): Promise<SkeletonState> => {
-  const { params, ctx } = input
-  if (params.seenAt) {
-    throw new InvalidRequestError('The seenAt parameter is unsupported')
-  }
-  const priority = params.priority ?? (await getPriority(ctx, params.viewer))
-  const res = await ctx.hydrator.dataplane.getUnreadNotificationCount({
-    actorDid: params.viewer,
-    priority,
-  })
-  return {
-    count: res.count,
-  }
-}
-
-const hydration = async (
-  _input: HydrationFnInput<Context, Params, SkeletonState>,
-) => {
-  return {}
-}
-
-const presentation = (
-  input: PresentationFnInput<Context, Params, SkeletonState>,
-) => {
-  const { skeleton } = input
-  return { count: skeleton.count }
-}
-
-type Context = {
-  hydrator: Hydrator
-  views: Views
-}
-
-type Params = app.bsky.notification.getUnreadCount.$Params & {
-  viewer: DidString
-}
-
-type SkeletonState = {
-  count: number
-}
-
-const getPriority = async (ctx: Context, did: DidString) => {
-  const actors = await ctx.hydrator.actor.getActors([did], {
-    skipCacheForDids: [did],
-  })
-  return !!actors.get(did)?.priorityNotifications
-}

package/src/api/app/bsky/notification/listActivitySubscriptions.ts

@@ -1,116 +0,0 @@
-import { mapDefined } from '@atproto/common'
-import { 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,
-  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 listActivitySubscriptions = createPipeline(
-    skeleton,
-    hydration,
-    noBlocks,
-    presentation,
-  )
-  server.add(app.bsky.notification.listActivitySubscriptions, {
-    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 listActivitySubscriptions(
-        { ...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 actorDid = params.hydrateCtx.viewer
-  if (clearlyBadCursor(params.cursor)) {
-    return { actorDid, dids: [] }
-  }
-  const { dids, cursor } =
-    await ctx.hydrator.dataplane.getActivitySubscriptionDids({
-      actorDid: params.hydrateCtx.viewer,
-      limit: params.limit,
-      cursor: params.cursor,
-    })
-  return {
-    actorDid,
-    dids: dids as DidString[],
-    cursor: cursor || undefined,
-  }
-}
-
-const hydration = async (
-  input: HydrationFnInput<Context, Params, SkeletonState>,
-) => {
-  const { ctx, params, skeleton } = input
-  const { dids } = skeleton
-  const state = await ctx.hydrator.hydrateProfilesDetailed(
-    dids,
-    params.hydrateCtx,
-  )
-  return state
-}
-
-const noBlocks = (input: RulesFnInput<Context, Params, SkeletonState>) => {
-  const { skeleton, hydration, ctx } = input
-  skeleton.dids = skeleton.dids.filter(
-    (did) => !ctx.views.viewerBlockExists(did, hydration),
-  )
-  return skeleton
-}
-
-const presentation = (
-  input: PresentationFnInput<Context, Params, SkeletonState>,
-) => {
-  const { ctx, hydration, skeleton } = input
-  const { dids, cursor } = skeleton
-  const subscriptions = mapDefined(dids, (did) => {
-    return ctx.views.profile(did, hydration)
-  })
-  return { subscriptions, cursor }
-}
-
-type Context = {
-  hydrator: Hydrator
-  views: Views
-}
-
-type Params = app.bsky.notification.listActivitySubscriptions.$Params & {
-  hydrateCtx: HydrateCtxWithViewer
-}
-
-type SkeletonState = {
-  actorDid: DidString
-  dids: DidString[]
-  cursor?: string
-}