@atproto/bsky 0.0.251 → 0.0.254

package/src/api/app/bsky/ageassurance/begin.ts

@@ -1,175 +0,0 @@
-import crypto from 'node:crypto'
-import { isEmailValid } from '@hapi/address'
-import { isDisposableEmail } from 'disposable-email-domains-js'
-import { getAgeAssuranceRegionConfig } from '@atproto/api'
-import {
-  InvalidRequestError,
-  MethodNotImplementedError,
-  Server,
-} from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-type InputSchema = app.bsky.ageassurance.begin.$InputBody
-import { app } from '../../../../lexicons/index.js'
-import { httpLogger as log } from '../../../../logger.js'
-import { ActorInfo } from '../../../../proto/bsky_pb.js'
-import { AGE_ASSURANCE_CONFIG } from '../../../age-assurance/const.js'
-import {
-  KWS_SUPPORTED_LANGUAGES,
-  KWS_V2_COUNTRIES,
-} from '../../../age-assurance/kws/const.js'
-import {
-  KWSExternalPayloadTooLargeError,
-  KWSExternalPayloadVersion,
-  serializeKWSExternalPayloadV2,
-} from '../../../age-assurance/kws/external-payload.js'
-import { createEvent } from '../../../age-assurance/stash.js'
-import { createLocationString } from '../../../age-assurance/util.js'
-import { getClientUa } from '../../../kws/util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(app.bsky.ageassurance.begin, {
-    auth: ctx.authVerifier.standard,
-    handler: async ({ auth, input, req }) => {
-      if (!ctx.kwsClient) {
-        throw new MethodNotImplementedError(
-          'This service is not configured to support age assurance.',
-        )
-      }
-
-      const actorDid = auth.credentials.iss
-      const actorInfo = await getAgeVerificationState(ctx, actorDid)
-      const existingStatus = actorInfo?.ageAssuranceStatus?.status
-      const existingAccess = actorInfo?.ageAssuranceStatus?.access
-
-      if (existingStatus === 'blocked') {
-        throw new InvalidRequestError(
-          `Cannot initiate age assurance flow from current state: ${existingStatus}`,
-          'InvalidInitiation',
-        )
-      }
-
-      const attemptId = crypto.randomUUID()
-      const { email, language, countryCode, regionCode } = validateInput(
-        input.body,
-      )
-
-      let externalPayload: string
-      try {
-        externalPayload = serializeKWSExternalPayloadV2({
-          version: KWSExternalPayloadVersion.V2,
-          actorDid,
-          attemptId,
-          countryCode,
-          regionCode,
-        })
-      } catch (err) {
-        if (err instanceof KWSExternalPayloadTooLargeError) {
-          log.error({ err, actorDid }, err.message)
-          throw new InvalidRequestError(
-            'Age Assurance flow failed because DID is too long',
-            'DidTooLong',
-          )
-        }
-        throw err
-      }
-
-      /*
-       * Determine if age assurance config exists for this region. The calling
-       * application should already have checked for this, so this is just a
-       * safeguard.
-       */
-      const region = getAgeAssuranceRegionConfig(AGE_ASSURANCE_CONFIG, {
-        countryCode,
-        regionCode,
-      })
-      if (!region) {
-        const message = 'Age Assurance is not required in this region'
-        log.error({ actorDid, countryCode, regionCode }, message)
-        throw new InvalidRequestError(message, 'RegionNotSupported')
-      }
-
-      const location = createLocationString(countryCode, regionCode)
-
-      if (KWS_V2_COUNTRIES.has(region.countryCode)) {
-        // `age-verified` flow
-        await ctx.kwsClient.sendAgeVerifiedFlowEmail({
-          location,
-          email,
-          externalPayload,
-          language,
-        })
-      } else {
-        // `adult-verified` flow is what we've been using prior to `age-verified`
-        await ctx.kwsClient.sendAdultVerifiedFlowEmail({
-          location,
-          email,
-          externalPayload,
-          language,
-        })
-      }
-
-      // If we have existing status/access for this region, retain it.
-      const nextStatus =
-        existingStatus && existingStatus !== 'unknown'
-          ? existingStatus
-          : 'pending'
-      const nextAccess =
-        existingAccess && existingAccess !== 'unknown'
-          ? existingAccess
-          : 'unknown'
-
-      const event = await createEvent(ctx, actorDid, {
-        attemptId,
-        email,
-        // Assumes `app.set('trust proxy', ...)` configured with `true` or specific values.
-        initIp: req.ip,
-        initUa: getClientUa(req),
-        status: nextStatus,
-        access: nextAccess,
-        countryCode,
-        regionCode,
-      })
-
-      return {
-        encoding: 'application/json',
-        body: {
-          lastInitiatedAt: event.createdAt,
-          status: nextStatus,
-          access: nextAccess,
-        },
-      }
-    },
-  })
-}
-
-function validateInput({ email, language, ...rest }: InputSchema): InputSchema {
-  if (!isEmailValid(email) || isDisposableEmail(email)) {
-    throw new InvalidRequestError(
-      'This email address is not supported, please use a different email.',
-      'InvalidEmail',
-    )
-  }
-
-  return {
-    email,
-    language: KWS_SUPPORTED_LANGUAGES.has(language) ? language : 'en',
-    ...rest,
-  }
-}
-
-async function getAgeVerificationState(
-  ctx: AppContext,
-  actorDid: string,
-): Promise<ActorInfo | undefined> {
-  try {
-    const res = await ctx.dataplane.getActors({
-      dids: [actorDid],
-      returnAgeAssuranceForDids: [actorDid],
-      skipCacheForDids: [actorDid],
-    })
-
-    return res.actors[0]
-  } catch (err) {
-    return undefined
-  }
-}

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

@@ -1,16 +0,0 @@
-import { Server } from '@atproto/xrpc-server'
-import { AGE_ASSURANCE_CONFIG } from '../../../../api/age-assurance/const.js'
-import { AppContext } from '../../../../context.js'
-import { app } from '../../../../lexicons/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(app.bsky.ageassurance.getConfig, {
-    auth: ctx.authVerifier.standardOptional,
-    handler: async () => {
-      return {
-        encoding: 'application/json',
-        body: AGE_ASSURANCE_CONFIG,
-      }
-    },
-  })
-}

package/src/api/app/bsky/ageassurance/getState.ts

@@ -1,58 +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.ageassurance.getState, {
-    auth: ctx.authVerifier.standard,
-    handler: async ({
-      auth,
-    }): Promise<app.bsky.ageassurance.getState.$Output> => {
-      const viewer = auth.credentials.iss
-      const actor = await getActorInfo(ctx, viewer)
-
-      const lastInitiatedAt = actor.ageAssuranceStatus?.lastInitiatedAt
-
-      return {
-        encoding: 'application/json',
-        body: {
-          state: {
-            lastInitiatedAt: lastInitiatedAt
-              ? (lastInitiatedAt.toDate().toISOString() as DatetimeString)
-              : undefined,
-            status: actor.ageAssuranceStatus?.status || 'unknown',
-            access: actor.ageAssuranceStatus?.access || 'unknown',
-          },
-          metadata: {
-            accountCreatedAt: actor.createdAt
-              ? (actor.createdAt.toDate().toISOString() as DatetimeString)
-              : undefined,
-          },
-        },
-      }
-    },
-  })
-}
-
-const getActorInfo = 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/bookmark/createBookmark.ts

@@ -1,39 +0,0 @@
-import { TID } from '@atproto/common'
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { app } from '../../../../lexicons/index.js'
-import { Namespaces } from '../../../../stash.js'
-import { validateUri } from './util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(app.bsky.bookmark.createBookmark, {
-    auth: ctx.authVerifier.standard,
-    handler: async ({ input, auth }) => {
-      const actorDid = auth.credentials.iss
-      const { cid, uri } = input.body
-      validateUri(uri)
-
-      const res = await ctx.dataplane.getBookmarksByActorAndSubjects({
-        actorDid,
-        uris: [uri],
-      })
-      const [existing] = res.bookmarks
-      if (existing.ref?.key) {
-        // Idempotent, return without creating.
-        return
-      }
-
-      await ctx.stashClient.create({
-        actorDid,
-        namespace: Namespaces.AppBskyBookmarkDefsBookmark,
-        payload: {
-          subject: {
-            cid,
-            uri,
-          },
-        } satisfies app.bsky.bookmark.defs.Bookmark,
-        key: TID.nextStr(),
-      })
-    },
-  })
-}

package/src/api/app/bsky/bookmark/deleteBookmark.ts

@@ -1,32 +0,0 @@
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { app } from '../../../../lexicons/index.js'
-import { Namespaces } from '../../../../stash.js'
-import { validateUri } from './util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(app.bsky.bookmark.deleteBookmark, {
-    auth: ctx.authVerifier.standard,
-    handler: async ({ input, auth }) => {
-      const actorDid = auth.credentials.iss
-      const { uri } = input.body
-      validateUri(uri)
-
-      const res = await ctx.dataplane.getBookmarksByActorAndSubjects({
-        actorDid,
-        uris: [uri],
-      })
-      const [existing] = res.bookmarks
-      if (!existing.ref?.key) {
-        // Idempotent, return without deleting.
-        return
-      }
-
-      await ctx.stashClient.delete({
-        actorDid,
-        namespace: Namespaces.AppBskyBookmarkDefsBookmark,
-        key: existing.ref.key,
-      })
-    },
-  })
-}

package/src/api/app/bsky/bookmark/getBookmarks.ts

@@ -1,97 +0,0 @@
-import { mapDefined } from '@atproto/common'
-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 { BookmarkInfo } from '../../../../proto/bsky_pb.js'
-import { Views } from '../../../../views/index.js'
-import { resHeaders } from '../../../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  const getBookmarks = createPipeline(
-    skeleton,
-    hydration,
-    noRules, // Blocks are included and handled on views. Mutes are included.
-    presentation,
-  )
-  server.add(app.bsky.bookmark.getBookmarks, {
-    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 getBookmarks({ ...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
-  const { bookmarks, cursor } = await ctx.hydrator.dataplane.getActorBookmarks({
-    actorDid: params.hydrateCtx.viewer,
-    limit: params.limit,
-    cursor: params.cursor,
-  })
-  return {
-    actorDid,
-    bookmarkInfos: bookmarks,
-    cursor: cursor || undefined,
-  }
-}
-
-const hydration = async (
-  input: HydrationFnInput<Context, Params, SkeletonState>,
-) => {
-  const { ctx, params, skeleton } = input
-  const { bookmarkInfos } = skeleton
-  return ctx.hydrator.hydrateBookmarks(bookmarkInfos, params.hydrateCtx)
-}
-
-const presentation = (
-  input: PresentationFnInput<Context, Params, SkeletonState>,
-) => {
-  const { ctx, hydration, skeleton } = input
-  const { bookmarkInfos, cursor } = skeleton
-  const bookmarkViews = mapDefined(bookmarkInfos, (bookmarkInfo) =>
-    ctx.views.bookmark(bookmarkInfo.key, hydration),
-  )
-  return { bookmarks: bookmarkViews, cursor }
-}
-
-type Context = {
-  hydrator: Hydrator
-  views: Views
-}
-
-type Params = app.bsky.bookmark.getBookmarks.$Params & {
-  hydrateCtx: HydrateCtxWithViewer
-}
-
-type SkeletonState = {
-  actorDid: string
-  bookmarkInfos: BookmarkInfo[]
-  cursor?: string
-}

package/src/api/app/bsky/bookmark/util.ts

@@ -1,13 +0,0 @@
-import { AtUri } from '@atproto/syntax'
-import { InvalidRequestError } from '@atproto/xrpc-server'
-import { app } from '../../../../lexicons/index.js'
-
-export const validateUri = (uri: string) => {
-  const atUri = new AtUri(uri)
-  if (atUri.collection !== app.bsky.feed.post.$type) {
-    throw new InvalidRequestError(
-      `Only '${app.bsky.feed.post.$type}' records can be bookmarked`,
-      'UnsupportedCollection',
-    )
-  }
-}

package/src/api/app/bsky/contact/dismissMatch.ts

@@ -1,26 +0,0 @@
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { app } from '../../../../lexicons/index.js'
-import { assertRolodexOrThrowUnimplemented, callRolodexClient } from './util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(app.bsky.contact.dismissMatch, {
-    auth: ctx.authVerifier.standard,
-    handler: async ({ input, auth }) => {
-      assertRolodexOrThrowUnimplemented(ctx)
-
-      const actor = auth.credentials.iss
-      await callRolodexClient(
-        ctx.rolodexClient.dismissMatch({
-          actor,
-          subject: input.body.subject,
-        }),
-      )
-
-      return {
-        encoding: 'application/json',
-        body: {},
-      }
-    },
-  })
-}

package/src/api/app/bsky/contact/getMatches.ts

@@ -1,111 +0,0 @@
-import { mapDefined } from '@atproto/common'
-import { DidString } from '@atproto/lex'
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import {
-  HydrateCtxWithViewer,
-  HydrationState,
-  Hydrator,
-} from '../../../../hydration/hydrator.js'
-import { app } from '../../../../lexicons/index.js'
-import {
-  HydrationFnInput,
-  SkeletonFnInput,
-  createPipeline,
-} from '../../../../pipeline.js'
-import { RolodexClient } from '../../../../rolodex.js'
-import { Views } from '../../../../views/index.js'
-import { assertRolodexOrThrowUnimplemented, callRolodexClient } from './util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  const getMatches = createPipeline(skeleton, hydration, noBlocks, presentation)
-
-  server.add(app.bsky.contact.getMatches, {
-    auth: ctx.authVerifier.standard,
-    handler: async ({ params, auth, req }) => {
-      assertRolodexOrThrowUnimplemented(ctx)
-
-      const viewer = auth.credentials.iss
-      const labelers = ctx.reqLabelers(req)
-      const hydrateCtx = await ctx.hydrator.createContext({
-        labelers,
-        viewer,
-      })
-
-      const result = await getMatches({ ...params, hydrateCtx }, ctx)
-
-      return {
-        encoding: 'application/json',
-        body: result,
-      }
-    },
-  })
-}
-
-const skeleton = async (
-  input: SkeletonFnInput<Context, Params>,
-): Promise<SkeletonState> => {
-  const { params, ctx } = input
-  const actor = params.hydrateCtx.viewer
-  const { cursor, subjects } = await callRolodexClient(
-    ctx.rolodexClient.getMatches({
-      actor: params.hydrateCtx.viewer,
-      limit: params.limit,
-      cursor: params.cursor,
-    }),
-  )
-  return {
-    actor,
-    subjects: subjects as DidString[],
-    cursor: cursor || undefined,
-  }
-}
-
-const hydration = async (
-  input: HydrationFnInput<Context, Params, SkeletonState>,
-) => {
-  const { ctx, params, skeleton } = input
-  const { subjects } = skeleton
-  return ctx.hydrator.hydrateProfiles(subjects, params.hydrateCtx)
-}
-
-const noBlocks = (inputs: {
-  ctx: Context
-  skeleton: SkeletonState
-  hydration: HydrationState
-}) => {
-  const { ctx, skeleton, hydration } = inputs
-  skeleton.subjects = skeleton.subjects.filter((subject) => {
-    return !ctx.views.viewerBlockExists(subject, hydration)
-  })
-  return skeleton
-}
-
-const presentation = (input: {
-  ctx: Context
-  params: Params
-  skeleton: SkeletonState
-  hydration: HydrationState
-}) => {
-  const { ctx, skeleton, hydration } = input
-  const matches = mapDefined(skeleton.subjects, (did) =>
-    ctx.views.profile(did, hydration),
-  )
-  return { matches }
-}
-
-type Context = {
-  hydrator: Hydrator
-  rolodexClient: RolodexClient
-  views: Views
-}
-
-type Params = app.bsky.contact.getMatches.$Params & {
-  hydrateCtx: HydrateCtxWithViewer
-}
-
-type SkeletonState = {
-  actor: string
-  subjects: DidString[]
-  cursor?: string
-}

package/src/api/app/bsky/contact/getSyncStatus.ts

@@ -1,38 +0,0 @@
-import { DatetimeString } from '@atproto/syntax'
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { app } from '../../../../lexicons/index.js'
-import { assertRolodexOrThrowUnimplemented, callRolodexClient } from './util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(app.bsky.contact.getSyncStatus, {
-    auth: ctx.authVerifier.standard,
-    handler: async ({ auth }) => {
-      assertRolodexOrThrowUnimplemented(ctx)
-
-      const actor = auth.credentials.iss
-      const res = await callRolodexClient(
-        ctx.rolodexClient.getSyncStatus({
-          actor,
-        }),
-      )
-
-      const syncStatus: app.bsky.contact.defs.SyncStatus | undefined =
-        res.status && res.status.syncedAt
-          ? {
-              matchesCount: res.status.matchesCount,
-              syncedAt: res.status.syncedAt
-                .toDate()
-                .toISOString() as DatetimeString,
-            }
-          : undefined
-
-      return {
-        encoding: 'application/json',
-        body: {
-          syncStatus,
-        },
-      }
-    },
-  })
-}