@atproto/bsky 0.0.250 → 0.0.253

package/src/api/app/bsky/unspecced/getAgeAssuranceState.ts

@@ -1,48 +0,0 @@
-import { DatetimeString } from '@atproto/syntax'
-import { Server, UpstreamFailureError } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { app } from '../../../../lexicons/index.js'
-import { ActorInfo } from '../../../../proto/bsky_pb.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(app.bsky.unspecced.getAgeAssuranceState, {
-    auth: ctx.authVerifier.standard,
-    handler: async ({ auth }) => {
-      const viewer = auth.credentials.iss
-      const actorInfo = await getAgeVerificationState(ctx, viewer)
-
-      const lastInitiatedAt = actorInfo.ageAssuranceStatus?.lastInitiatedAt
-
-      return {
-        encoding: 'application/json',
-        body: {
-          lastInitiatedAt: lastInitiatedAt
-            ? (lastInitiatedAt.toDate().toISOString() as DatetimeString)
-            : undefined,
-          status: actorInfo.ageAssuranceStatus?.status ?? 'unknown',
-        },
-      }
-    },
-  })
-}
-
-const getAgeVerificationState = async (
-  ctx: AppContext,
-  actorDid: string,
-): Promise<ActorInfo> => {
-  try {
-    const res = await ctx.dataplane.getActors({
-      dids: [actorDid],
-      returnAgeAssuranceForDids: [actorDid],
-      skipCacheForDids: [actorDid],
-    })
-
-    return res.actors[0]
-  } catch (err) {
-    throw new UpstreamFailureError(
-      'Cannot get current age assurance state',
-      'GetAgeAssuranceStateFailed',
-      { cause: err },
-    )
-  }
-}

package/src/api/app/bsky/unspecced/getConfig.ts

@@ -1,20 +0,0 @@
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { app } from '../../../../lexicons/index.js'
-
-// THIS IS A TEMPORARY UNSPECCED ROUTE
-export default function (server: Server, ctx: AppContext) {
-  server.add(app.bsky.unspecced.getConfig, {
-    handler: async () => {
-      return {
-        encoding: 'application/json',
-        body: {
-          checkEmailConfirmed: ctx.cfg.clientCheckEmailConfirmed,
-          // @ts-expect-error un-specced field
-          topicsEnabled: ctx.cfg.topicsEnabled,
-          liveNow: ctx.cfg.liveNowConfig,
-        } satisfies app.bsky.unspecced.getConfig.$OutputBody,
-      }
-    },
-  })
-}

package/src/api/app/bsky/unspecced/getOnboardingSuggestedStarterPacks.ts

@@ -1,162 +0,0 @@
-import { mapDefined, noUndefinedVals } from '@atproto/common'
-import { Client } from '@atproto/lex'
-import { AtUri, AtUriString, DidString } from '@atproto/syntax'
-import { MethodNotImplementedError, Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import {
-  HydrateCtx,
-  Hydrator,
-  mergeManyStates,
-} from '../../../../hydration/hydrator.js'
-import { app } from '../../../../lexicons/index.js'
-import {
-  HydrationFn,
-  PresentationFn,
-  RulesFn,
-  SkeletonFn,
-  createPipeline,
-} from '../../../../pipeline.js'
-import { Views } from '../../../../views/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  const getOnboardingSuggestedStarterPacks = createPipeline(
-    skeleton,
-    hydration,
-    noBlocks,
-    presentation,
-  )
-  server.add(app.bsky.unspecced.getOnboardingSuggestedStarterPacks, {
-    auth: ctx.authVerifier.standardOptional,
-    handler: async ({ auth, params, req }) => {
-      const viewer = auth.credentials.iss
-      const labelers = ctx.reqLabelers(req)
-      const hydrateCtx = await ctx.hydrator.createContext({ labelers, viewer })
-      const headers = noUndefinedVals({
-        'accept-language': req.headers['accept-language'],
-        'x-bsky-topics': Array.isArray(req.headers['x-bsky-topics'])
-          ? req.headers['x-bsky-topics'].join(',')
-          : req.headers['x-bsky-topics'],
-      })
-      const result = await getOnboardingSuggestedStarterPacks(
-        {
-          ...params,
-          hydrateCtx,
-          headers,
-        },
-        ctx,
-      )
-      return {
-        encoding: 'application/json',
-        body: result,
-      }
-    },
-  })
-}
-
-const skeleton: SkeletonFn<Context, Params, SkeletonState> = async (
-  input,
-): Promise<SkeletonState> => {
-  const { params, ctx } = input
-
-  if (!ctx.topicsClient) {
-    // Use 501 instead of 500 as these are not considered retry-able by clients
-    throw new MethodNotImplementedError('Topics agent not available')
-  }
-
-  const skeleton = await ctx.topicsClient.call(
-    app.bsky.unspecced.getOnboardingSuggestedStarterPacksSkeleton,
-    { limit: params.limit, viewer: params.hydrateCtx.viewer ?? undefined },
-    { headers: params.headers },
-  )
-
-  // @TODO Make sure upstream always provides this
-  skeleton.starterPacks ??= []
-
-  return skeleton
-}
-
-const hydration: HydrationFn<Context, Params, SkeletonState> = async (
-  input,
-) => {
-  const { ctx, params, skeleton } = input
-
-  const pairs: Map<DidString, DidString[]> = new Map()
-  const viewer = params.hydrateCtx.viewer
-  if (viewer) {
-    pairs.set(viewer, getUniqueDidsFromStarterPacks(skeleton.starterPacks))
-  }
-  const [starterPacksState, bidirectionalBlocks] = await Promise.all([
-    ctx.hydrator.hydrateStarterPacks(skeleton.starterPacks, params.hydrateCtx),
-    ctx.hydrator.hydrateBidirectionalBlocks(pairs, params.hydrateCtx),
-  ])
-
-  return mergeManyStates(starterPacksState, { bidirectionalBlocks })
-}
-
-const noBlocks: RulesFn<Context, Params, SkeletonState> = (input) => {
-  const { skeleton, params, hydration } = input
-  const viewer = params.hydrateCtx.viewer
-  if (!viewer) {
-    return skeleton
-  }
-
-  const blocks = hydration.bidirectionalBlocks?.get(viewer)
-  const filteredSkeleton: SkeletonState = {
-    starterPacks: skeleton.starterPacks.filter((uri) => {
-      try {
-        return !blocks?.get(new AtUri(uri).did)
-      } catch {
-        return false
-      }
-    }),
-  }
-
-  return filteredSkeleton
-}
-
-const presentation: PresentationFn<
-  Context,
-  Params,
-  SkeletonState,
-  app.bsky.unspecced.getOnboardingSuggestedStarterPacks.$OutputBody
-> = (input) => {
-  const { ctx, skeleton, hydration } = input
-
-  return {
-    starterPacks: mapDefined(skeleton.starterPacks, (uri) =>
-      ctx.views.starterPack(uri, hydration),
-    ),
-  }
-}
-
-type Context = {
-  hydrator: Hydrator
-  views: Views
-  topicsClient: Client | undefined
-}
-
-type Params = app.bsky.unspecced.getOnboardingSuggestedStarterPacks.$Params & {
-  hydrateCtx: HydrateCtx
-  headers: Record<string, string>
-}
-
-type SkeletonState =
-  app.bsky.unspecced.getOnboardingSuggestedStarterPacksSkeleton.$OutputBody
-
-function getUniqueDidsFromStarterPacks(
-  starterPacks?: AtUriString[],
-): DidString[] {
-  if (!starterPacks) return []
-
-  const dids = new Set<DidString>()
-
-  for (const uri of starterPacks) {
-    try {
-      dids.add(new AtUri(uri).did)
-    } catch {
-      continue
-    }
-  }
-
-  return Array.from(dids)
-}

package/src/api/app/bsky/unspecced/getPopularFeedGenerators.ts

@@ -1,91 +0,0 @@
-import { mapDefined } from '@atproto/common'
-import { AtUriString } from '@atproto/syntax'
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { parseString } from '../../../../hydration/util.js'
-import { app } from '../../../../lexicons/index.js'
-import {
-  clearlyBadCursor,
-  resHeaders,
-  resolveSearchV2Override,
-} from '../../../util.js'
-
-// THIS IS A TEMPORARY UNSPECCED ROUTE
-// @TODO currently mirrors getSuggestedFeeds and ignores the "query" param.
-// In the future may take into consideration popularity via likes w/ its own dataplane endpoint.
-export default function (server: Server, ctx: AppContext) {
-  server.add(app.bsky.unspecced.getPopularFeedGenerators, {
-    auth: ctx.authVerifier.standardOptional,
-    handler: async ({ auth, params, req }) => {
-      const viewer = auth.credentials.iss
-      const labelers = ctx.reqLabelers(req)
-      const features = ctx.featureGatesClient.scope(
-        ctx.featureGatesClient.parseUserContextFromHandler({
-          viewer,
-          req,
-        }),
-      )
-      const hydrateCtx = await ctx.hydrator.createContext({
-        viewer,
-        labelers,
-        features,
-      })
-
-      if (clearlyBadCursor(params.cursor)) {
-        return {
-          encoding: 'application/json',
-          body: { feeds: [] },
-        }
-      }
-
-      let uris: AtUriString[]
-      let cursor: string | undefined
-
-      const isV2Override = resolveSearchV2Override(req, ctx.cfg)
-
-      const query = params.query?.trim() ?? ''
-      if (query) {
-        const useV2 =
-          features.checkGate(features.Gate.SearchV2Enable) || isV2Override
-        if (useV2) {
-          const res = await ctx.dataplane.searchFeedGeneratorsV2({
-            params: {
-              query,
-              viewer: viewer ?? undefined,
-              limit: params.limit,
-            },
-          })
-          uris = res.feedGenerators.map(({ uri }) => uri) as AtUriString[]
-        } else {
-          const res = await ctx.dataplane.searchFeedGenerators({
-            query,
-            limit: params.limit,
-          })
-          uris = res.uris as AtUriString[]
-        }
-      } else {
-        const res = await ctx.dataplane.getSuggestedFeeds({
-          actorDid: viewer ?? undefined,
-          limit: params.limit,
-          cursor: params.cursor,
-        })
-        uris = res.uris as AtUriString[]
-        cursor = parseString(res.cursor)
-      }
-
-      const hydration = await ctx.hydrator.hydrateFeedGens(uris, hydrateCtx)
-      const feedViews = mapDefined(uris, (uri) =>
-        ctx.views.feedGenerator(uri, hydration),
-      )
-
-      return {
-        encoding: 'application/json',
-        body: {
-          feeds: feedViews,
-          cursor,
-        },
-        headers: resHeaders({ labelers: hydrateCtx.labelers }),
-      }
-    },
-  })
-}

package/src/api/app/bsky/unspecced/getPostThreadOtherV2.ts

@@ -1,126 +0,0 @@
-import { AtUriString } from '@atproto/syntax'
-import { Server } from '@atproto/xrpc-server'
-import { ServerConfig } from '../../../../config.js'
-import { AppContext } from '../../../../context.js'
-import {
-  Code,
-  DataPlaneClient,
-  isDataplaneError,
-} from '../../../../data-plane/index.js'
-import { HydrateCtx, 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 { resHeaders } from '../../../util.js'
-
-// No parents for hidden replies (it would be the anchor post).
-const ABOVE = 0
-
-// For hidden replies we don't get more than the top-level replies.
-// To get nested replies, load the thread as one of the hidden replies as anchor.
-const BELOW = 1
-
-// It doesn't really matter since BELOW is 1, so it will not be used.
-const BRANCHING_FACTOR = 0
-
-export default function (server: Server, ctx: AppContext) {
-  const getPostThreadOther = createPipeline(
-    skeleton,
-    hydration,
-    noRules, // handled in presentation: 3p block-violating replies are turned to #blockedPost, viewer blocks turned to #notFoundPost.
-    presentation,
-  )
-  server.add(app.bsky.unspecced.getPostThreadOtherV2, {
-    auth: ctx.authVerifier.optionalStandardOrRole,
-    handler: async ({ params, auth, req }) => {
-      const { viewer, includeTakedowns, include3pBlocks, skipViewerBlocks } =
-        ctx.authVerifier.parseCreds(auth)
-      const labelers = ctx.reqLabelers(req)
-      const hydrateCtx = await ctx.hydrator.createContext({
-        labelers,
-        viewer,
-        includeTakedowns,
-        include3pBlocks,
-        skipViewerBlocks,
-      })
-
-      return {
-        encoding: 'application/json',
-        body: await getPostThreadOther({ ...params, hydrateCtx }, ctx),
-        headers: resHeaders({
-          labelers: hydrateCtx.labelers,
-        }),
-      }
-    },
-  })
-}
-
-const skeleton = async (
-  inputs: SkeletonFnInput<Context, Params>,
-): Promise<Skeleton> => {
-  const { ctx, params } = inputs
-  const anchor = await ctx.hydrator.resolveUri(params.anchor)
-  try {
-    const res = await ctx.dataplane.getThread({
-      postUri: anchor,
-      above: ABOVE,
-      below: BELOW,
-    })
-    return {
-      anchor,
-      uris: res.uris as AtUriString[],
-    }
-  } catch (err) {
-    if (isDataplaneError(err, Code.NotFound)) {
-      return {
-        anchor,
-        uris: [],
-      }
-    } else {
-      throw err
-    }
-  }
-}
-
-const hydration = async (
-  inputs: HydrationFnInput<Context, Params, Skeleton>,
-) => {
-  const { ctx, params, skeleton } = inputs
-  return ctx.hydrator.hydrateThreadPosts(
-    skeleton.uris.map((uri) => ({ uri })),
-    params.hydrateCtx,
-  )
-}
-
-const presentation = (
-  inputs: PresentationFnInput<Context, Params, Skeleton>,
-) => {
-  const { ctx, skeleton, hydration } = inputs
-  const thread = ctx.views.threadOtherV2(skeleton, hydration, {
-    below: BELOW,
-    branchingFactor: BRANCHING_FACTOR,
-  })
-  return { thread }
-}
-
-type Context = {
-  dataplane: DataPlaneClient
-  hydrator: Hydrator
-  views: Views
-  cfg: ServerConfig
-}
-
-type Params = app.bsky.unspecced.getPostThreadOtherV2.$Params & {
-  hydrateCtx: HydrateCtx
-}
-
-type Skeleton = {
-  anchor: AtUriString
-  uris: AtUriString[]
-}

package/src/api/app/bsky/unspecced/getPostThreadV2.ts

@@ -1,148 +0,0 @@
-import { AtUriString } from '@atproto/syntax'
-import { Server } from '@atproto/xrpc-server'
-import { ServerConfig } from '../../../../config.js'
-import { AppContext } from '../../../../context.js'
-import {
-  Code,
-  DataPlaneClient,
-  isDataplaneError,
-} from '../../../../data-plane/index.js'
-import { HydrateCtx, Hydrator } from '../../../../hydration/hydrator.js'
-import { app } from '../../../../lexicons/index.js'
-import {
-  HydrationFnInput,
-  PresentationFnInput,
-  SkeletonFnInput,
-  createPipeline,
-  noRules,
-} from '../../../../pipeline.js'
-import { postUriToThreadgateUri } from '../../../../util/uris.js'
-import { Views } from '../../../../views/index.js'
-import { resHeaders } from '../../../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  const getPostThread = createPipeline(
-    skeleton,
-    hydration,
-    noRules, // handled in presentation: 3p block-violating replies are turned to #blockedPost, viewer blocks turned to #notFoundPost.
-    presentation,
-  )
-  server.add(app.bsky.unspecced.getPostThreadV2, {
-    auth: ctx.authVerifier.optionalStandardOrRole,
-    handler: async ({ params, auth, req }) => {
-      const { viewer, includeTakedowns, include3pBlocks, skipViewerBlocks } =
-        ctx.authVerifier.parseCreds(auth)
-      const labelers = ctx.reqLabelers(req)
-      const features = ctx.featureGatesClient.scope(
-        ctx.featureGatesClient.parseUserContextFromHandler({
-          viewer,
-          req,
-        }),
-      )
-      // temp
-      void features.checkGate(features.Gate.AATest)
-      const hydrateCtx = await ctx.hydrator.createContext({
-        labelers,
-        viewer,
-        includeTakedowns,
-        include3pBlocks,
-        skipViewerBlocks,
-        features,
-      })
-
-      return {
-        encoding: 'application/json',
-        body: await getPostThread({ ...params, hydrateCtx }, ctx),
-        headers: resHeaders({
-          labelers: hydrateCtx.labelers,
-        }),
-      }
-    },
-  })
-}
-
-const skeleton = async (
-  inputs: SkeletonFnInput<Context, Params>,
-): Promise<Skeleton> => {
-  const { ctx, params } = inputs
-  const anchor = await ctx.hydrator.resolveUri(params.anchor)
-  try {
-    const res = await ctx.dataplane.getThread({
-      postUri: anchor,
-      above: calculateAbove(ctx, params),
-      below: calculateBelow(ctx, anchor, params),
-    })
-    return {
-      anchor,
-      uris: res.uris as AtUriString[],
-    }
-  } catch (err) {
-    if (isDataplaneError(err, Code.NotFound)) {
-      return {
-        anchor,
-        uris: [],
-      }
-    } else {
-      throw err
-    }
-  }
-}
-
-const hydration = async (
-  inputs: HydrationFnInput<Context, Params, Skeleton>,
-) => {
-  const { ctx, params, skeleton } = inputs
-  return ctx.hydrator.hydrateThreadPosts(
-    skeleton.uris.map((uri) => ({ uri })),
-    params.hydrateCtx,
-  )
-}
-
-const presentation = (
-  inputs: PresentationFnInput<Context, Params, Skeleton>,
-) => {
-  const { ctx, params, skeleton, hydration } = inputs
-  const { hasOtherReplies, thread } = ctx.views.threadV2(skeleton, hydration, {
-    above: calculateAbove(ctx, params),
-    below: calculateBelow(ctx, skeleton.anchor, params),
-    branchingFactor: params.branchingFactor,
-    sort: params.sort,
-  })
-
-  const rootUri =
-    hydration.posts?.get(skeleton.anchor)?.record.reply?.root.uri ??
-    skeleton.anchor
-  const threadgate = ctx.views.threadgate(
-    postUriToThreadgateUri(rootUri),
-    hydration,
-  )
-  return { hasOtherReplies, thread, threadgate }
-}
-
-type Context = {
-  dataplane: DataPlaneClient
-  hydrator: Hydrator
-  views: Views
-  cfg: ServerConfig
-}
-
-type Params = app.bsky.unspecced.getPostThreadV2.$Params & {
-  hydrateCtx: HydrateCtx
-}
-
-type Skeleton = {
-  anchor: AtUriString
-  uris: AtUriString[]
-}
-
-const calculateAbove = (ctx: Context, params: Params) => {
-  return params.above ? ctx.cfg.maxThreadParents : 0
-}
-
-const calculateBelow = (ctx: Context, anchor: string, params: Params) => {
-  let maxDepth = ctx.cfg.maxThreadDepth
-  if (ctx.cfg.bigThreadUris.has(anchor) && ctx.cfg.bigThreadDepth) {
-    maxDepth = ctx.cfg.bigThreadDepth
-  }
-  return maxDepth ? Math.min(maxDepth, params.below) : params.below
-}

package/src/api/app/bsky/unspecced/getSuggestedFeeds.ts

@@ -1,100 +0,0 @@
-import { mapDefined, noUndefinedVals } from '@atproto/common'
-import { AtUriString, Client } from '@atproto/lex'
-import { MethodNotImplementedError, Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { HydrateCtx, 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 getFeeds = createPipeline(skeleton, hydration, noRules, presentation)
-  server.add(app.bsky.unspecced.getSuggestedFeeds, {
-    auth: ctx.authVerifier.standardOptional,
-    handler: async ({ auth, params, req }) => {
-      const viewer = auth.credentials.iss
-      const labelers = ctx.reqLabelers(req)
-      const hydrateCtx = await ctx.hydrator.createContext({ labelers, viewer })
-      const headers = noUndefinedVals({
-        'accept-language': req.headers['accept-language'],
-        'x-bsky-topics': Array.isArray(req.headers['x-bsky-topics'])
-          ? req.headers['x-bsky-topics'].join(',')
-          : req.headers['x-bsky-topics'],
-      })
-      const result = await getFeeds(
-        {
-          ...params,
-          hydrateCtx,
-          headers,
-        },
-        ctx,
-      )
-      return {
-        encoding: 'application/json',
-        body: result,
-      }
-    },
-  })
-}
-
-const skeleton = async (
-  input: SkeletonFnInput<Context, Params>,
-): Promise<SkeletonState> => {
-  const { params, ctx } = input
-
-  if (!ctx.topicsClient) {
-    // Use 501 instead of 500 as these are not considered retry-able by clients
-    throw new MethodNotImplementedError('Topics agent not available')
-  }
-
-  return ctx.topicsClient.call(
-    app.bsky.unspecced.getSuggestedFeedsSkeleton,
-    {
-      limit: params.limit,
-      viewer: params.hydrateCtx.viewer ?? undefined,
-    },
-    {
-      headers: params.headers,
-    },
-  )
-}
-
-const hydration = async (
-  input: HydrationFnInput<Context, Params, SkeletonState>,
-) => {
-  const { ctx, params, skeleton } = input
-  return await ctx.hydrator.hydrateFeedGens(skeleton.feeds, params.hydrateCtx)
-}
-
-const presentation = (
-  input: PresentationFnInput<Context, Params, SkeletonState>,
-) => {
-  const { ctx, skeleton, hydration } = input
-
-  return {
-    feeds: mapDefined(skeleton.feeds, (uri) =>
-      ctx.views.feedGenerator(uri, hydration),
-    ),
-  }
-}
-
-type Context = {
-  hydrator: Hydrator
-  views: Views
-  topicsClient: Client | undefined
-}
-
-type Params = app.bsky.unspecced.getSuggestedFeeds.$Params & {
-  hydrateCtx: HydrateCtx
-  headers: Record<string, string>
-}
-
-type SkeletonState = {
-  feeds: AtUriString[]
-}