@atproto/bsky 0.0.198 → 0.0.200

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

@@ -0,0 +1,167 @@
+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,
+} from '@atproto/xrpc-server'
+import { AppContext } from '../../../../context'
+import { Server } from '../../../../lexicon'
+import { InputSchema } from '../../../../lexicon/types/app/bsky/ageassurance/begin'
+import { httpLogger as log } from '../../../../logger'
+import { ActorInfo } from '../../../../proto/bsky_pb'
+import { AGE_ASSURANCE_CONFIG } from '../../../age-assurance/const'
+import {
+  KWS_SUPPORTED_LANGUAGES,
+  KWS_V2_COUNTRIES,
+} from '../../../age-assurance/kws/const'
+import {
+  KWSExternalPayloadTooLargeError,
+  KWSExternalPayloadVersion,
+  serializeKWSExternalPayloadV2,
+} from '../../../age-assurance/kws/external-payload'
+import { createEvent } from '../../../age-assurance/stash'
+import { createLocationString } from '../../../age-assurance/util'
+import { getClientUa } from '../../../kws/util'
+
+export default function (server: Server, ctx: AppContext) {
+  server.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)
+
+      if (actorInfo?.ageAssuranceStatus) {
+        if (
+          actorInfo.ageAssuranceStatus.status !== 'unknown' &&
+          actorInfo.ageAssuranceStatus.status !== 'pending'
+        ) {
+          throw new InvalidRequestError(
+            `Cannot initiate age assurance flow from current state: ${actorInfo.ageAssuranceStatus.status}`,
+            '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,
+        })
+      }
+
+      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: 'pending',
+        access: 'unknown',
+        countryCode,
+        regionCode,
+      })
+
+      return {
+        encoding: 'application/json',
+        body: {
+          lastInitiatedAt: event.createdAt,
+          status: 'pending',
+          access: 'unknown',
+        },
+      }
+    },
+  })
+}
+
+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

@@ -0,0 +1,15 @@
+import { AGE_ASSURANCE_CONFIG } from '../../../../api/age-assurance/const'
+import { AppContext } from '../../../../context'
+import { Server } from '../../../../lexicon'
+
+export default function (server: Server, ctx: AppContext) {
+  server.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

@@ -0,0 +1,53 @@
+import { UpstreamFailureError } from '@atproto/xrpc-server'
+import { AppContext } from '../../../../context'
+import { Server } from '../../../../lexicon'
+import { ActorInfo } from '../../../../proto/bsky_pb'
+
+export default function (server: Server, ctx: AppContext) {
+  server.app.bsky.ageassurance.getState({
+    auth: ctx.authVerifier.standard,
+    handler: async ({ auth }) => {
+      const viewer = auth.credentials.iss
+      const actor = await getActorInfo(ctx, viewer)
+
+      return {
+        encoding: 'application/json',
+        body: {
+          state: {
+            lastInitiatedAt:
+              actor.ageAssuranceStatus?.lastInitiatedAt
+                ?.toDate()
+                .toISOString() || undefined,
+            status: actor.ageAssuranceStatus?.status || 'unknown',
+            access: actor.ageAssuranceStatus?.access || 'unknown',
+          },
+          metadata: {
+            accountCreatedAt:
+              actor.createdAt?.toDate().toISOString() || 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/contact/dismissMatch.ts

@@ -0,0 +1,24 @@
+import { AppContext } from '../../../../context'
+import { Server } from '../../../../lexicon'
+import { assertRolodexOrThrowUnimplemented } from './util'
+
+export default function (server: Server, ctx: AppContext) {
+  server.app.bsky.contact.dismissMatch({
+    auth: ctx.authVerifier.standard,
+    handler: async ({ input, auth }) => {
+      assertRolodexOrThrowUnimplemented(ctx)
+
+      const actor = auth.credentials.iss
+      // TODO: Error handling.
+      await ctx.rolodexClient.dismissMatch({
+        actor,
+        subject: input.body.subject,
+      })
+
+      return {
+        encoding: 'application/json',
+        body: {},
+      }
+    },
+  })
+}

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

@@ -0,0 +1,111 @@
+import { mapDefined } from '@atproto/common'
+import { AppContext } from '../../../../context'
+import {
+  HydrateCtx,
+  HydrationState,
+  Hydrator,
+} from '../../../../hydration/hydrator'
+import { Server } from '../../../../lexicon'
+import { QueryParams } from '../../../../lexicon/types/app/bsky/contact/getMatches'
+import {
+  HydrationFnInput,
+  SkeletonFnInput,
+  createPipeline,
+} from '../../../../pipeline'
+import { RolodexClient } from '../../../../rolodex'
+import { Views } from '../../../../views'
+import { assertRolodexOrThrowUnimplemented } from './util'
+
+export default function (server: Server, ctx: AppContext) {
+  const getMatches = createPipeline(skeleton, hydration, noBlocks, presentation)
+  server.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: hydrateCtx.copy({ viewer }) },
+        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
+  // TODO: Error handling.
+  const { cursor, subjects } = await ctx.rolodexClient.getMatches({
+    actor: params.hydrateCtx.viewer,
+    limit: params.limit,
+    cursor: params.cursor,
+  })
+  return {
+    actor,
+    subjects,
+    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 = QueryParams & {
+  hydrateCtx: HydrateCtx & { viewer: string }
+}
+
+type SkeletonState = {
+  actor: string
+  subjects: string[]
+  cursor?: string
+}

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

@@ -0,0 +1,35 @@
+import { AppContext } from '../../../../context'
+import { Server } from '../../../../lexicon'
+import { SyncStatus } from '../../../../lexicon/types/app/bsky/contact/defs'
+import { assertRolodexOrThrowUnimplemented } from './util'
+
+export default function (server: Server, ctx: AppContext) {
+  server.app.bsky.contact.getSyncStatus({
+    auth: ctx.authVerifier.standard,
+    handler: async ({ auth }) => {
+      assertRolodexOrThrowUnimplemented(ctx)
+
+      const actor = auth.credentials.iss
+      // TODO: Error handling.
+      const res = await ctx.rolodexClient.getSyncStatus({
+        actor,
+      })
+
+      let syncStatus: SyncStatus | undefined
+      if (res.status && res.status.syncedAt) {
+        const syncedAt = res.status?.syncedAt?.toDate().toISOString()
+        syncStatus = {
+          matchesCount: res.status.matchesCount,
+          syncedAt,
+        }
+      }
+
+      return {
+        encoding: 'application/json',
+        body: {
+          syncStatus,
+        },
+      }
+    },
+  })
+}

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

@@ -0,0 +1,118 @@
+import { mapDefined } from '@atproto/common'
+import { AppContext } from '../../../../context'
+import {
+  HydrateCtx,
+  HydrationState,
+  Hydrator,
+} from '../../../../hydration/hydrator'
+import { Server } from '../../../../lexicon'
+import { MatchAndContactIndex } from '../../../../lexicon/types/app/bsky/contact/defs'
+import { InputSchema } from '../../../../lexicon/types/app/bsky/contact/importContacts'
+import {
+  HydrationFnInput,
+  SkeletonFnInput,
+  createPipeline,
+  noRules,
+} from '../../../../pipeline'
+import { ImportContactsMatch } from '../../../../proto/rolodex_pb'
+import { RolodexClient } from '../../../../rolodex'
+import { Views } from '../../../../views'
+import { assertRolodexOrThrowUnimplemented } from './util'
+
+export default function (server: Server, ctx: AppContext) {
+  const importContacts = createPipeline(
+    skeleton,
+    hydration,
+    noRules, //
+    presentation,
+  )
+  server.app.bsky.contact.importContacts({
+    auth: ctx.authVerifier.standard,
+    handler: async ({ input, 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 importContacts(
+        { ...input.body, hydrateCtx: hydrateCtx.copy({ viewer }) },
+        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
+  // TODO: Error handling.
+  const { matches } = await ctx.rolodexClient.importContacts({
+    actor: params.hydrateCtx.viewer,
+    contacts: params.contacts,
+    token: params.token,
+  })
+  return {
+    actor,
+    matches,
+  }
+}
+
+const hydration = async (
+  input: HydrationFnInput<Context, Params, SkeletonState>,
+) => {
+  const { ctx, params, skeleton } = input
+  const { matches } = skeleton
+  const subjects = matches.map((m) => m.subject)
+  return ctx.hydrator.hydrateProfiles(subjects, params.hydrateCtx)
+}
+
+const presentation = (input: {
+  ctx: Context
+  params: Params
+  skeleton: SkeletonState
+  hydration: HydrationState
+}) => {
+  const { ctx, skeleton, hydration } = input
+  const matchesAndContactIndexes = mapDefined(
+    skeleton.matches,
+    ({ subject, inputIndex }): MatchAndContactIndex | undefined => {
+      const profile = ctx.views.profile(subject, hydration)
+
+      if (!profile) {
+        return undefined
+      }
+
+      return {
+        contactIndex: inputIndex,
+        match: profile,
+      }
+    },
+  )
+  return { matchesAndContactIndexes }
+}
+
+type Context = {
+  hydrator: Hydrator
+  rolodexClient: RolodexClient
+  views: Views
+}
+
+type Params = InputSchema & {
+  hydrateCtx: HydrateCtx & { viewer: string }
+}
+
+type SkeletonState = {
+  actor: string
+  matches: ImportContactsMatch[]
+}

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

@@ -0,0 +1,23 @@
+import { AppContext } from '../../../../context'
+import { Server } from '../../../../lexicon'
+import { assertRolodexOrThrowUnimplemented } from './util'
+
+export default function (server: Server, ctx: AppContext) {
+  server.app.bsky.contact.removeData({
+    auth: ctx.authVerifier.standard,
+    handler: async ({ auth }) => {
+      assertRolodexOrThrowUnimplemented(ctx)
+
+      const actor = auth.credentials.iss
+      // TODO: Error handling.
+      await ctx.rolodexClient.removeData({
+        actor,
+      })
+
+      return {
+        encoding: 'application/json',
+        body: {},
+      }
+    },
+  })
+}

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

@@ -0,0 +1,24 @@
+import { AppContext } from '../../../../context'
+import { Server } from '../../../../lexicon'
+import { assertRolodexOrThrowUnimplemented } from './util'
+
+export default function (server: Server, ctx: AppContext) {
+  server.app.bsky.contact.startPhoneVerification({
+    auth: ctx.authVerifier.standard,
+    handler: async ({ auth, input }) => {
+      assertRolodexOrThrowUnimplemented(ctx)
+
+      const actor = auth.credentials.iss
+      // TODO: Error handling.
+      await ctx.rolodexClient.startPhoneVerification({
+        actor,
+        phone: input.body.phone,
+      })
+
+      return {
+        encoding: 'application/json',
+        body: {},
+      }
+    },
+  })
+}

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

@@ -0,0 +1,13 @@
+import { MethodNotImplementedError } from '@atproto/xrpc-server'
+import { AppContext } from '../../../..'
+import { RolodexClient } from '../../../../rolodex'
+
+export function assertRolodexOrThrowUnimplemented(
+  ctx: AppContext,
+): asserts ctx is AppContext & { rolodexClient: RolodexClient } {
+  if (!ctx.rolodexClient) {
+    throw new MethodNotImplementedError(
+      'This service is not configured to support contact imports.',
+    )
+  }
+}

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

@@ -0,0 +1,27 @@
+import { AppContext } from '../../../../context'
+import { Server } from '../../../../lexicon'
+import { assertRolodexOrThrowUnimplemented } from './util'
+
+export default function (server: Server, ctx: AppContext) {
+  server.app.bsky.contact.verifyPhone({
+    auth: ctx.authVerifier.standard,
+    handler: async ({ auth, input }) => {
+      assertRolodexOrThrowUnimplemented(ctx)
+
+      const actor = auth.credentials.iss
+      // TODO: Error handling.
+      const res = await ctx.rolodexClient.verifyPhone({
+        actor,
+        verificationCode: input.body.code,
+        phone: input.body.phone,
+      })
+
+      return {
+        encoding: 'application/json',
+        body: {
+          token: res.token,
+        },
+      }
+    },
+  })
+}

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

@@ -26,6 +26,10 @@ export default function (server: Server, ctx: AppContext) {
               did,
               following: subject.following,
               followedBy: subject.followedBy,
+              blocking: subject.blocking,
+              blockedBy: subject.blockedBy,
+              blockingByList: subject.blockingByList,
+              blockedByList: subject.blockedByList,
             }
           : {
               $type: 'app.bsky.graph.defs#notFoundActor',

package/src/api/external.ts

@@ -1,5 +1,6 @@
 import { Router } from 'express'
 import { AppContext } from '../context'
+import * as aaApi from './age-assurance'
 import * as kwsApi from './kws'
 
 export const createRouter = (ctx: AppContext): Router => {
@@ -7,6 +8,7 @@ export const createRouter = (ctx: AppContext): Router => {
 
   if (ctx.kwsClient) {
     router.use('/kws', kwsApi.createRouter(ctx))
+    router.use(aaApi.createRouter(ctx))
   }
 
   return router

package/src/api/index.ts

@@ -5,9 +5,19 @@ import getProfiles from './app/bsky/actor/getProfiles'
 import getSuggestions from './app/bsky/actor/getSuggestions'
 import searchActors from './app/bsky/actor/searchActors'
 import searchActorsTypeahead from './app/bsky/actor/searchActorsTypeahead'
+import aaBegin from './app/bsky/ageassurance/begin'
+import aaGetConfig from './app/bsky/ageassurance/getConfig'
+import aaGetState from './app/bsky/ageassurance/getState'
 import createBookmark from './app/bsky/bookmark/createBookmark'
 import deleteBookmark from './app/bsky/bookmark/deleteBookmark'
 import getBookmarks from './app/bsky/bookmark/getBookmarks'
+import dismissMatch from './app/bsky/contact/dismissMatch'
+import getMatches from './app/bsky/contact/getMatches'
+import getSyncStatus from './app/bsky/contact/getSyncStatus'
+import importContacts from './app/bsky/contact/importContacts'
+import removeData from './app/bsky/contact/removeData'
+import startPhoneVerification from './app/bsky/contact/startPhoneVerification'
+import verifyPhone from './app/bsky/contact/verifyPhone'
 import getActorFeeds from './app/bsky/feed/getActorFeeds'
 import getActorLikes from './app/bsky/feed/getActorLikes'
 import getAuthorFeed from './app/bsky/feed/getAuthorFeed'
@@ -91,6 +101,13 @@ export default function (server: Server, ctx: AppContext) {
   createBookmark(server, ctx)
   deleteBookmark(server, ctx)
   getBookmarks(server, ctx)
+  dismissMatch(server, ctx)
+  getMatches(server, ctx)
+  getSyncStatus(server, ctx)
+  importContacts(server, ctx)
+  removeData(server, ctx)
+  startPhoneVerification(server, ctx)
+  verifyPhone(server, ctx)
   getActorFeeds(server, ctx)
   getSuggestedFeeds(server, ctx)
   getAuthorFeed(server, ctx)
@@ -156,6 +173,9 @@ export default function (server: Server, ctx: AppContext) {
   getTaggedSuggestions(server, ctx)
   getAgeAssuranceState(server, ctx)
   initAgeAssurance(server, ctx)
+  aaGetConfig(server, ctx)
+  aaGetState(server, ctx)
+  aaBegin(server, ctx)
   // com.atproto
   getSubjectStatus(server, ctx)
   updateSubjectStatus(server, ctx)