@atproto/bsky 0.0.250 → 0.0.253

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

@@ -1,119 +0,0 @@
-import { mapDefined } from '@atproto/common'
-import { DidString } from '@atproto/syntax'
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import {
-  HydrateCtx,
-  HydrationState,
-  Hydrator,
-} from '../../../../hydration/hydrator.js'
-import { app } from '../../../../lexicons/index.js'
-import {
-  HydrationFnInput,
-  SkeletonFnInput,
-  createPipeline,
-  noRules,
-} from '../../../../pipeline.js'
-import { ImportContactsMatch } from '../../../../proto/rolodex_pb.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 importContacts = createPipeline(
-    skeleton,
-    hydration,
-    noRules, //
-    presentation,
-  )
-  server.add(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 }, 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 { matches } = await callRolodexClient(
-    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 as DidString)
-  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,
-    }): app.bsky.contact.defs.MatchAndContactIndex | undefined => {
-      const profile = ctx.views.profile(subject as DidString, hydration)
-
-      if (!profile) {
-        return undefined
-      }
-
-      return {
-        contactIndex: inputIndex,
-        match: profile,
-      }
-    },
-  )
-  return { matchesAndContactIndexes }
-}
-
-type Context = {
-  hydrator: Hydrator
-  rolodexClient: RolodexClient
-  views: Views
-}
-
-type Params = app.bsky.contact.importContacts.$InputBody & {
-  hydrateCtx: HydrateCtx & { viewer: string }
-}
-
-type SkeletonState = {
-  actor: string
-  matches: ImportContactsMatch[]
-}

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

@@ -1,25 +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.removeData, {
-    auth: ctx.authVerifier.standard,
-    handler: async ({ auth }) => {
-      assertRolodexOrThrowUnimplemented(ctx)
-
-      const actor = auth.credentials.iss
-      await callRolodexClient(
-        ctx.rolodexClient.removeData({
-          actor,
-        }),
-      )
-
-      return {
-        encoding: 'application/json',
-        body: {},
-      }
-    },
-  })
-}

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

@@ -1,33 +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 { assertRolodexOrThrowUnimplemented } from './util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(app.bsky.contact.sendNotification, {
-    auth: ctx.authVerifier.role,
-    handler: async ({ input }) => {
-      // Assert rolodex even though we don't call it, it is a proxy to whether the app is configured with contact import support.
-      assertRolodexOrThrowUnimplemented(ctx)
-
-      const { from, to } = input.body
-
-      await ctx.stashClient.create({
-        actorDid: from,
-        namespace: Namespaces.AppBskyContactDefsNotification,
-        payload: {
-          from,
-          to,
-        } satisfies app.bsky.contact.defs.Notification,
-        key: TID.nextStr(),
-      })
-
-      return {
-        encoding: 'application/json',
-        body: {},
-      }
-    },
-  })
-}

package/src/api/app/bsky/contact/startPhoneVerification.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.startPhoneVerification, {
-    auth: ctx.authVerifier.standard,
-    handler: async ({ auth, input }) => {
-      assertRolodexOrThrowUnimplemented(ctx)
-
-      const actor = auth.credentials.iss
-      await callRolodexClient(
-        ctx.rolodexClient.startPhoneVerification({
-          actor,
-          phone: input.body.phone,
-        }),
-      )
-
-      return {
-        encoding: 'application/json',
-        body: {},
-      }
-    },
-  })
-}

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

@@ -1,92 +0,0 @@
-import { ConnectError } from '@connectrpc/connect'
-import {
-  InternalServerError,
-  InvalidRequestError,
-  MethodNotImplementedError,
-} from '@atproto/xrpc-server'
-import { AppContext } from '../../../../index.js'
-import { RolodexClient } from '../../../../rolodex.js'
-
-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.',
-    )
-  }
-}
-
-/**
- * Converts UPPERCASE_ERROR from Rolodex to PascalCase for XRPC.
- */
-function convertErrorName(reason: string): string {
-  switch (reason) {
-    case 'INVALID_DID':
-      return 'InvalidDid'
-    case 'INVALID_LIMIT':
-      return 'InvalidLimit'
-    case 'INVALID_CURSOR':
-      return 'InvalidCursor'
-    case 'INVALID_CONTACTS':
-      return 'InvalidContacts'
-    case 'TOO_MANY_CONTACTS':
-      return 'TooManyContacts'
-    case 'INVALID_TOKEN':
-      return 'InvalidToken'
-    case 'RATE_LIMIT_EXCEEDED':
-      return 'RateLimitExceeded'
-    case 'INVALID_PHONE':
-      return 'InvalidPhone'
-    case 'INVALID_CODE':
-      return 'InvalidCode'
-    case 'INTERNAL_ERROR':
-      return 'InternalError'
-    default:
-      return reason
-  }
-}
-
-/**
- * Helper to call Rolodex client methods and translate RPC errors to XRPC
- * errors.
- *
- * These `reason` values need to stay in sync with the Rolodex service
- */
-export async function callRolodexClient<T>(caller: T) {
-  try {
-    return await caller
-  } catch (e) {
-    // might be something we want to handle
-    if (e instanceof ConnectError) {
-      /**
-       * https://connectrpc.com/docs/protocol#error-end-stream
-       */
-      const details = e.details?.at(0) as
-        | {
-            debug: {
-              reason: string
-              message: string
-            }
-          }
-        | undefined
-      const reason = details?.debug?.reason // e.g. INVALID_DID
-      // Handle known error reasons
-      if (reason) {
-        const errorName = convertErrorName(reason)
-        // NOTE: Don't leak e.message to the response.
-
-        if (reason === 'INTERNAL_ERROR') {
-          throw new InternalServerError('Upstream error', errorName, {
-            cause: e,
-          })
-        } else {
-          throw new InvalidRequestError('An error occurred', errorName, {
-            cause: e,
-          })
-        }
-      }
-    }
-    throw e
-  }
-}

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

@@ -1,29 +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.verifyPhone, {
-    auth: ctx.authVerifier.standard,
-    handler: async ({ auth, input }) => {
-      assertRolodexOrThrowUnimplemented(ctx)
-
-      const actor = auth.credentials.iss
-      const res = await callRolodexClient(
-        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/draft/createDraft.ts

@@ -1,45 +0,0 @@
-import { TID } from '@atproto/common'
-import { InvalidRequestError, Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { app } from '../../../../lexicons/index.js'
-import { Namespaces } from '../../../../stash.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(app.bsky.draft.createDraft, {
-    auth: ctx.authVerifier.standard,
-    handler: async ({ input, auth }) => {
-      const actorDid = auth.credentials.iss
-      const { draft } = input.body
-
-      const res = await ctx.dataplane.getCountsForUsers({
-        dids: [actorDid],
-      })
-
-      const draftsCount = res.drafts[0]
-      if (draftsCount >= ctx.cfg.draftsLimit) {
-        throw new InvalidRequestError(
-          `Drafts limit reached`,
-          'DraftLimitReached',
-        )
-      }
-
-      const draftId = TID.nextStr()
-      const draftWithId: app.bsky.draft.defs.DraftWithId = {
-        id: draftId,
-        draft,
-      }
-
-      await ctx.stashClient.create({
-        actorDid,
-        namespace: Namespaces.AppBskyDraftDefsDraftWithId,
-        payload: draftWithId,
-        key: draftId,
-      })
-
-      return {
-        encoding: 'application/json' as const,
-        body: { id: draftId },
-      }
-    },
-  })
-}

package/src/api/app/bsky/draft/deleteDraft.ts

@@ -1,20 +0,0 @@
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { app } from '../../../../lexicons/index.js'
-import { Namespaces } from '../../../../stash.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(app.bsky.draft.deleteDraft, {
-    auth: ctx.authVerifier.standard,
-    handler: async ({ input, auth }) => {
-      const actorDid = auth.credentials.iss
-      const { id } = input.body
-
-      await ctx.stashClient.delete({
-        actorDid,
-        namespace: Namespaces.AppBskyDraftDefsDraftWithId,
-        key: id,
-      })
-    },
-  })
-}

package/src/api/app/bsky/draft/getDrafts.ts

@@ -1,44 +0,0 @@
-import { DatetimeString, lexParse } from '@atproto/lex'
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { app } from '../../../../lexicons/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(app.bsky.draft.getDrafts, {
-    auth: ctx.authVerifier.standard,
-    handler: async ({ params, auth }) => {
-      const viewer = auth.credentials.iss
-
-      const { cursor, drafts } = await ctx.hydrator.dataplane.getActorDrafts({
-        actorDid: viewer,
-        limit: params.limit,
-        cursor: params.cursor,
-      })
-
-      const draftViews = drafts.map((d): app.bsky.draft.defs.DraftView => {
-        const jsonStr = Buffer.from(d.payload).toString('utf8')
-        const draftWithId = lexParse<app.bsky.draft.defs.DraftWithId>(jsonStr)
-        return {
-          id: draftWithId.id,
-          draft: draftWithId.draft,
-          // The date should always be present, but we avoid required fields on protobuf by convention,
-          // so requires a fallback value to please TS.
-          createdAt: (
-            d.createdAt?.toDate() ?? new Date(0)
-          ).toISOString() as DatetimeString,
-          updatedAt: (
-            d.updatedAt?.toDate() ?? new Date(0)
-          ).toISOString() as DatetimeString,
-        }
-      })
-
-      return {
-        encoding: 'application/json',
-        body: {
-          cursor,
-          drafts: draftViews,
-        },
-      }
-    },
-  })
-}

package/src/api/app/bsky/draft/updateDraft.ts

@@ -1,26 +0,0 @@
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { app } from '../../../../lexicons/index.js'
-import { Namespaces } from '../../../../stash.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(app.bsky.draft.updateDraft, {
-    auth: ctx.authVerifier.standard,
-    handler: async ({ input, auth }) => {
-      const actorDid = auth.credentials.iss
-      const { draft: draftWithId } = input.body
-
-      // NOTE: update drafts does not enforce limits, because if it did, we would not allow updating when the limit is reached,
-      // which is not the desired behavior.
-      // But this means the consumer of the stash operations can't do an upsert behavior on update, and needs instead to drop non-existent
-      // drafts. This avoid misusing the update as a create that does not check limits.
-
-      await ctx.stashClient.update({
-        actorDid,
-        namespace: Namespaces.AppBskyDraftDefsDraftWithId,
-        payload: draftWithId satisfies app.bsky.draft.defs.DraftWithId,
-        key: draftWithId.id,
-      })
-    },
-  })
-}

package/src/api/app/bsky/embed/getEmbedExternalView.ts

@@ -1,154 +0,0 @@
-import { AtUriString, LexMap } from '@atproto/lex'
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import {
-  SiteStandardDocuments,
-  SiteStandardPublications,
-  getSiteStandardRecordsFromHydrationMapsByDocumentUri,
-} from '../../../../hydration/external.js'
-import { HydrateCtx, Hydrator } from '../../../../hydration/hydrator.js'
-import { app, com } from '../../../../lexicons/index.js'
-import {
-  HydrationFnInput,
-  PresentationFnInput,
-  SkeletonFnInput,
-  createPipeline,
-  noRules,
-} from '../../../../pipeline.js'
-import { Views } from '../../../../views/index.js'
-import { ExternalEmbedView, StrongRef } from '../../../../views/types.js'
-import { resHeaders } from '../../../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  const getEmbedExternalView = createPipeline(
-    skeleton,
-    hydration,
-    noRules,
-    presentation,
-  )
-  server.add(app.bsky.embed.getEmbedExternalView, {
-    auth: ctx.authVerifier.standardOptional,
-    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 getEmbedExternalView({ ...params, hydrateCtx }, ctx)
-      return {
-        encoding: 'application/json',
-        body: result,
-        headers: resHeaders({ labelers: hydrateCtx.labelers }),
-      }
-    },
-  })
-}
-
-const skeleton = async (
-  inputs: SkeletonFnInput<Context, Params>,
-): Promise<Skeleton> => {
-  return { uris: inputs.params.uris as AtUriString[] }
-}
-
-const hydration = async (
-  inputs: HydrationFnInput<Context, Params, Skeleton>,
-) => {
-  const { ctx, params, skeleton } = inputs
-  return ctx.hydrator.hydrateEmbedExternalViewFromUris(
-    skeleton.uris,
-    params.hydrateCtx,
-  )
-}
-
-const presentation = (
-  inputs: PresentationFnInput<Context, Params, Skeleton>,
-): Output => {
-  const { hydration } = inputs
-  const documents = hydration.siteStandardDocuments
-  const publications = hydration.siteStandardPublications
-  // Dispatch by record type. Today site.standard is the only kind we know
-  // how to render; future record types get their own branch.
-  if (
-    (documents && documents.size > 0) ||
-    (publications && publications.size > 0)
-  ) {
-    return standardSitePresentation(inputs, documents, publications)
-  }
-  return {}
-}
-
-const standardSitePresentation = (
-  inputs: PresentationFnInput<Context, Params, Skeleton>,
-  documents: SiteStandardDocuments | undefined,
-  publications: SiteStandardPublications | undefined,
-): Output => {
-  const { ctx, params, hydration } = inputs
-
-  // Pick the first hydrated doc, then pair it with the publication its
-  // `site` field points at (if any). Docs the dataplane auto-resolved a
-  // publication for end up matched; unrelated publications fall away.
-  const { document, publication } =
-    getSiteStandardRecordsFromHydrationMapsByDocumentUri(
-      documents,
-      publications,
-    )
-
-  // Emit response refs/records only for the records we actually selected.
-  // Anything else (e.g. extra publications the dataplane returned) is
-  // intentionally excluded so the strongRefs Cardy writes onto the post
-  // match the view we built. Profiles are emitted in the same order as
-  // refs (one per slot) so consumers can match by index.
-  const associatedRefs: StrongRef[] = []
-  const associatedRecords: LexMap[] = []
-  for (const slot of [document, publication]) {
-    if (!slot) continue
-    associatedRefs.push(
-      com.atproto.repo.strongRef.$build({
-        uri: slot.ref.uri,
-        cid: slot.info.cid,
-      }),
-    )
-    associatedRecords.push(slot.info.record as LexMap)
-  }
-
-  if (!associatedRefs.length) return {}
-
-  const overlay = ctx.views.externalEmbedFromStandardSiteRecords({
-    document,
-    publication,
-    state: hydration,
-    assumedUrl: params.url,
-  })
-  // The view builder rejected the records (validation failed, or the pair
-  // didn't produce the title viewExternal requires). Return nothing — Cardy
-  // falls back to its own card render and doesn't write strongRefs to the
-  // post.
-  if (!overlay) return {}
-
-  const view = app.bsky.embed.external.view.$build({
-    external: {
-      ...overlay,
-      uri: params.url,
-      associatedRefs,
-    },
-  })
-
-  return { view, associatedRefs, associatedRecords }
-}
-
-type Context = {
-  hydrator: Hydrator
-  views: Views
-}
-
-type Params = app.bsky.embed.getEmbedExternalView.$Params & {
-  hydrateCtx: HydrateCtx
-}
-
-type Skeleton = {
-  uris: AtUriString[]
-}
-
-type Output = {
-  view?: ExternalEmbedView
-  associatedRefs?: StrongRef[]
-  associatedRecords?: LexMap[]
-}