@atproto/bsky 0.0.250 → 0.0.253

package/src/feature-gates/utils.ts

@@ -1,135 +0,0 @@
-import crypto from 'node:crypto'
-import { type UserContext as GrowthBookUserContext } from '@growthbook/growthbook'
-import {
-  NormalizedUserContext,
-  TrackingMetadata,
-  UserContext,
-} from './types.js'
-
-export function normalizeUserContext(
-  userContext: UserContext,
-): NormalizedUserContext {
-  const did = userContext.did ?? undefined
-  let deviceId = userContext.deviceId
-  let sessionId = userContext.sessionId
-
-  if (!deviceId) {
-    /*
-     * If we don't have a deviceId by other means, such as a request header,
-     * fall back to the DID. Our event proxy ensures ordering based on this
-     * deviceId (also called a stableId in the proxy), so if we have a DID, we
-     * want to use it to ensure client and server events are properly ordered.
-     *
-     * Without any better option for identifying the user, we generate a
-     * random deviceId.
-     */
-    deviceId = did ?? `anon-${crypto.randomUUID()}`
-  }
-
-  if (!sessionId) {
-    /*
-     * If we don't have a sessionId by other means, such as a request header,
-     * generate a random sessionId.
-     */
-    sessionId = `anon-${crypto.randomUUID()}`
-  }
-
-  return {
-    did,
-    deviceId,
-    sessionId,
-  }
-}
-
-/**
- * Merge the base user context with any overrides provided at check time. This
- * allows us to set a base context for the request, but also override or add
- * properties for specific gate checks if needed.
- */
-export function mergeUserContexts(
-  base: NormalizedUserContext,
-  overrides?: UserContext,
-): NormalizedUserContext {
-  const did = overrides?.did ?? base.did ?? undefined
-  let deviceId = overrides?.deviceId ?? base.deviceId
-  let sessionId = overrides?.sessionId ?? base.sessionId
-
-  let isDifferentDid = false
-
-  if (did && deviceId.startsWith('anon-')) {
-    /*
-     * If we have a DID, but the existing deviceId is anonymous, use the DID as
-     * the deviceId to ensure proper ordering of events in our event proxy.
-     * This matches the logic in `normalizeUserContext` where we fall back to
-     * the DID for the deviceId if we don't have a deviceId from other means.
-     */
-    deviceId = did
-  } else if (did && deviceId !== did) {
-    /*
-     * If we have both a DID and a deviceId, but they don't match, we may be
-     * overriding context to check a feature that is independent of a single
-     * request handler lifecycle.
-     *
-     * Example: a ScopedFeatureGatesClient was created in the root request
-     * handler with a user context that has a DID, but later on in the request
-     * lifecycle we may check a gate using the DID of the author of the image
-     * we're returning as part of the response.
-     */
-    deviceId = did
-    isDifferentDid = true
-  }
-
-  if (isDifferentDid) {
-    /*
-     * If we're merging in a different DID, we should also generate a new
-     * sessionId to avoid mixing events from different users under the same
-     * session.
-     */
-    sessionId = `anon-${crypto.randomUUID()}`
-  }
-
-  return {
-    did,
-    deviceId,
-    sessionId,
-  }
-}
-
-/**
- * Extract the `UserContext` from GrowthBook's own `UserContext`, which we
- * passed into `isOn` as `attributes`.
- */
-export function extractUserContextFromGrowthbookUserContext(
-  userContext: GrowthBookUserContext,
-): NormalizedUserContext {
-  /*
-   * The values passed to Growthbook already should have been
-   * `NormalizedUserContext`, but for type safety we run them through the
-   * normalizer again to ensure we have all the required properties and
-   * fallbacks in place.
-   */
-  return normalizeUserContext({
-    did: userContext.attributes?.did,
-    deviceId: userContext.attributes?.deviceId,
-    sessionId: userContext.attributes?.sessionId,
-  })
-}
-
-/**
- * Convert the `UserContext` into the `TrackingMetadata` format that we
- * use for our analytics events. This ensures that we have the same user
- * properties as we do for events from our client app.
- */
-export function parsedUserContextToTrackingMetadata(
-  userContext: NormalizedUserContext,
-): TrackingMetadata {
-  return {
-    base: {
-      deviceId: userContext.deviceId,
-      sessionId: userContext.sessionId,
-    },
-    session: {
-      did: userContext.did ?? undefined,
-    },
-  }
-}

package/src/hydration/actor.ts

@@ -1,578 +0,0 @@
-import { mapDefined } from '@atproto/common'
-import {
-  AtIdentifierString,
-  AtUriString,
-  DatetimeString,
-  DidString,
-  HandleString,
-  isDidIdentifier,
-  isHandleIdentifier,
-  normalizeHandle,
-} from '@atproto/syntax'
-import { DataPlaneClient } from '../data-plane/client/index.js'
-import { app, chat, com } from '../lexicons/index.js'
-import { ActivitySubscription, VerificationMeta } from '../proto/bsky_pb.js'
-import {
-  ChatDeclarationRecord,
-  GermDeclarationRecord,
-  NotificationDeclarationRecord,
-  ProfileRecord,
-  StatusRecord,
-} from '../views/types.js'
-import {
-  HydrationMap,
-  RecordInfo,
-  isActivitySubscriptionEnabled,
-  parseDate,
-  parseRecord,
-  parseString,
-  safeTakedownRef,
-} from './util.js'
-
-type AllowActivitySubscriptions = Extract<
-  app.bsky.notification.declaration.Main['allowSubscriptions'],
-  'followers' | 'mutuals' | 'none'
->
-
-export type Actor = {
-  did: DidString
-  handle?: HandleString
-  profile?: ProfileRecord
-  profileCid?: string
-  profileTakedownRef?: string
-  sortedAt?: Date
-  indexedAt?: Date
-  takedownRef?: string
-  isLabeler: boolean
-  allowIncomingChatsFrom?: string
-  allowGroupChatInvitesFrom?: string
-  upstreamStatus?: string
-  createdAt?: Date
-  priorityNotifications: boolean
-  trustedVerifier?: boolean
-  verifications: VerificationHydrationState[]
-  status?: RecordInfo<StatusRecord>
-  germ?: RecordInfo<GermDeclarationRecord>
-  allowActivitySubscriptionsFrom: AllowActivitySubscriptions
-  /**
-   * Debug information for internal development
-   */
-  debug?: {
-    pagerank?: string
-    accountTags?: string[]
-    profileTags?: string[]
-  }
-}
-
-export type VerificationHydrationState = {
-  issuer: DidString
-  uri: AtUriString
-  handle: HandleString
-  displayName: string
-  createdAt: DatetimeString
-}
-
-export type VerificationMetaRequired = Required<VerificationMeta>
-
-export type Actors = HydrationMap<DidString, Actor>
-
-export type ChatDeclaration = RecordInfo<ChatDeclarationRecord>
-export type ChatDeclarations = HydrationMap<AtUriString, ChatDeclaration>
-
-export type GermDeclaration = RecordInfo<GermDeclarationRecord>
-export type GermDeclarations = HydrationMap<AtUriString, GermDeclaration>
-
-export type NotificationDeclaration = RecordInfo<NotificationDeclarationRecord>
-export type NotificationDeclarations = HydrationMap<
-  AtUriString,
-  NotificationDeclaration
->
-
-export type Status = RecordInfo<StatusRecord>
-export type Statuses = HydrationMap<AtUriString, Status>
-
-export type ProfileViewerState = {
-  did: DidString
-  muted?: boolean
-  mutedByList?: AtUriString
-  blockedBy?: AtUriString
-  blocking?: AtUriString
-  blockedByList?: AtUriString
-  blockingByList?: AtUriString
-  following?: AtUriString
-  followedBy?: AtUriString
-}
-
-export type ProfileViewerStates = HydrationMap<
-  AtIdentifierString,
-  ProfileViewerState
->
-
-type ActivitySubscriptionState = {
-  post: boolean
-  reply: boolean
-}
-
-export type ActivitySubscriptionStates = HydrationMap<
-  DidString,
-  ActivitySubscriptionState | undefined
->
-
-type KnownFollowersState = {
-  count: number
-  followers: DidString[]
-}
-
-export type KnownFollowersStates = HydrationMap<
-  DidString,
-  KnownFollowersState | undefined
->
-
-export type ProfileAgg = {
-  followers: number
-  follows: number
-  posts: number
-  lists: number
-  feeds: number
-  starterPacks: number
-}
-
-export type ProfileAggs = HydrationMap<DidString, ProfileAgg>
-
-export class ActorHydrator {
-  constructor(public dataplane: DataPlaneClient) {}
-
-  async getRepoRevSafe(did: string | null): Promise<string | null> {
-    if (!did) return null
-    try {
-      const res = await this.dataplane.getLatestRev({ actorDid: did })
-      return parseString(res.rev) ?? null
-    } catch {
-      return null
-    }
-  }
-
-  /**
-   * @note handles do not need to be normalized
-   */
-  async getDids(
-    handleOrDids: AtIdentifierString[],
-    opts?: { lookupUnidirectional?: boolean },
-  ): Promise<(DidString | undefined)[]> {
-    const didByHandle = new Map<HandleString, DidString>()
-
-    const handles = handleOrDids.filter(isHandleIdentifier)
-    if (handles.length) {
-      const { dids } = await this.dataplane.getDidsByHandles({
-        handles: handles.map(normalizeHandle),
-        lookupUnidirectional: opts?.lookupUnidirectional,
-      })
-
-      for (let i = 0; i < handles.length; i++) {
-        const did = parseString<DidString>(dids[i])
-        if (did) didByHandle.set(handles[i], did)
-      }
-    }
-
-    return handleOrDids.map((id) =>
-      isDidIdentifier(id) ? id : didByHandle.get(id),
-    )
-  }
-
-  async getDidsDefined(
-    handleOrDids: AtIdentifierString[],
-  ): Promise<DidString[]> {
-    const res = await this.getDids(handleOrDids)
-    return res.filter((v) => v != null)
-  }
-
-  async getActors(
-    dids: DidString[],
-    opts: {
-      includeTakedowns?: boolean
-      skipCacheForDids?: DidString[]
-    } = {},
-  ): Promise<Actors> {
-    const map: Actors = new HydrationMap()
-    if (!dids.length) return map
-
-    const { includeTakedowns = false, skipCacheForDids } = opts
-
-    const res = await this.dataplane.getActors({ dids, skipCacheForDids })
-    for (let i = 0; i < dids.length; i++) {
-      const did = dids[i]
-
-      const actor = res.actors[i]
-      const isNoHosted =
-        actor.takenDown ||
-        (actor.upstreamStatus && actor.upstreamStatus !== 'active')
-      if (
-        !actor.exists ||
-        (isNoHosted && !includeTakedowns) ||
-        !!actor.tombstonedAt
-      ) {
-        map.set(did, null)
-        continue
-      }
-
-      const profile = actor.profile?.record
-        ? parseRecord(
-            app.bsky.actor.profile.main,
-            actor.profile,
-            includeTakedowns,
-          )
-        : undefined
-
-      const status = actor.statusRecord
-        ? parseRecord(
-            app.bsky.actor.status.main,
-            actor.statusRecord,
-            /*
-             * Always true, we filter this out in the `Views.status()`. If we
-             * ever remove that filter, we'll want to reinstate this here.
-             */
-            true,
-          )
-        : undefined
-
-      const germ = actor.germRecord
-        ? parseRecord(
-            com.germnetwork.declaration.main,
-            actor.germRecord,
-            includeTakedowns,
-          )
-        : undefined
-
-      const verifications = mapDefined(
-        Object.entries(actor.verifiedBy) as [DidString, VerificationMeta][],
-        ([actorDid, verificationMeta]):
-          | VerificationHydrationState
-          | undefined => {
-          if (
-            verificationMeta.handle &&
-            verificationMeta.rkey &&
-            verificationMeta.sortedAt
-          ) {
-            return {
-              issuer: actorDid,
-              uri: `at://${actorDid}/app.bsky.graph.verification/${verificationMeta.rkey}`,
-              handle: verificationMeta.handle as HandleString,
-              displayName: verificationMeta.displayName,
-              createdAt: (
-                parseDate(verificationMeta.sortedAt) ?? new Date(0)
-              ).toISOString() as DatetimeString,
-            }
-          }
-          // Filter out the verification meta that doesn't contain all info.
-          return undefined
-        },
-      )
-
-      const allowActivitySubscriptionsFrom = (
-        val: string,
-      ): AllowActivitySubscriptions => {
-        switch (val) {
-          case 'followers':
-          case 'mutuals':
-          case 'none':
-            return val
-          default:
-            // The dataplane should set the default of "FOLLOWERS". Just in case.
-            return 'followers'
-        }
-      }
-
-      const debug = {
-        pagerank: actor.pagerank ? actor.pagerank.toString() : undefined,
-        accountTags: actor.tags,
-        profileTags: actor.profileTags,
-      }
-
-      map.set(did, {
-        did,
-        handle: parseString<HandleString>(actor.handle),
-        profile: profile?.record,
-        profileCid: profile?.cid,
-        profileTakedownRef: profile?.takedownRef,
-        sortedAt: profile?.sortedAt,
-        indexedAt: profile?.indexedAt,
-        takedownRef: safeTakedownRef(actor),
-        isLabeler: actor.labeler ?? false,
-        allowIncomingChatsFrom: actor.allowIncomingChatsFrom || undefined,
-        allowGroupChatInvitesFrom: actor.allowGroupChatInvitesFrom || undefined,
-        upstreamStatus: actor.upstreamStatus || undefined,
-        createdAt: parseDate(actor.createdAt),
-        priorityNotifications: actor.priorityNotifications,
-        trustedVerifier: actor.trustedVerifier,
-        verifications,
-        status: status,
-        germ: germ,
-        allowActivitySubscriptionsFrom: allowActivitySubscriptionsFrom(
-          actor.allowActivitySubscriptionsFrom,
-        ),
-        debug,
-      })
-    }
-
-    return map
-  }
-
-  async getChatDeclarations(
-    uris: AtUriString[],
-    includeTakedowns = false,
-  ): Promise<ChatDeclarations> {
-    const map: ChatDeclarations = new HydrationMap()
-    if (!uris.length) return map
-
-    const res = await this.dataplane.getActorChatDeclarationRecords({ uris })
-    for (let i = 0; i < uris.length; i++) {
-      const uri = uris[i]
-      const record = parseRecord(
-        chat.bsky.actor.declaration.main,
-        res.records[i],
-        includeTakedowns,
-      )
-      map.set(uri, record ?? null)
-    }
-
-    return map
-  }
-
-  async getGermDeclarations(
-    uris: AtUriString[],
-    includeTakedowns = false,
-  ): Promise<GermDeclarations> {
-    const map: GermDeclarations = new HydrationMap()
-    if (!uris.length) return map
-
-    const res = await this.dataplane.getGermDeclarationRecords({ uris })
-    for (let i = 0; i < uris.length; i++) {
-      const record = parseRecord(
-        com.germnetwork.declaration.main,
-        res.records[i],
-        includeTakedowns,
-      )
-      map.set(uris[i], record ?? null)
-    }
-
-    return map
-  }
-
-  async getNotificationDeclarations(
-    uris: AtUriString[],
-    includeTakedowns = false,
-  ): Promise<NotificationDeclarations> {
-    const map: NotificationDeclarations = new HydrationMap()
-    if (!uris.length) return map
-
-    const res = await this.dataplane.getNotificationDeclarationRecords({
-      uris,
-    })
-    for (let i = 0; i < uris.length; i++) {
-      const uri = uris[i]
-      const record = parseRecord(
-        app.bsky.notification.declaration.main,
-        res.records[i],
-        includeTakedowns,
-      )
-      map.set(uri, record ?? null)
-    }
-
-    return map
-  }
-
-  async getStatus(
-    uris: AtUriString[],
-    includeTakedowns = false,
-  ): Promise<Statuses> {
-    const map: Statuses = new HydrationMap()
-    if (!uris.length) return map
-
-    const res = await this.dataplane.getStatusRecords({ uris })
-    for (let i = 0; i < uris.length; i++) {
-      const uri = uris[i]
-      const record = parseRecord(
-        app.bsky.actor.status.main,
-        res.records[i],
-        includeTakedowns,
-      )
-      map.set(uri, record ?? null)
-    }
-
-    return map
-  }
-
-  // "naive" because this method does not verify the existence of the list itself
-  // a later check in the main hydrator will remove list uris that have been deleted or
-  // repurposed to "curate lists"
-  async getProfileViewerStatesNaive(
-    actors: AtIdentifierString[],
-    viewer: DidString,
-  ): Promise<ProfileViewerStates> {
-    const map: ProfileViewerStates = new HydrationMap()
-    if (!actors.length) return map
-
-    // @TODO we could use "await this.getDids(actors)" here to resolve the
-    // handles (no other code change should be needed). This was not done as
-    // part of this PR to avoid changing the behavior of this method.
-    const actorDids = actors.map((a) => (isDidIdentifier(a) ? a : undefined))
-
-    // getRelationships requires DidString so we remove anything that isn't one
-    const actorDidsDefined = Array.from(
-      new Set(
-        actorDids
-          .filter((did) => did != null)
-          // Since we special case self-relationship below, we can skip querying
-          // the dataplane for the viewer's own DID if it's included in the
-          // input.
-          .filter((did) => did !== viewer),
-      ),
-    )
-
-    const res = await this.dataplane.getRelationships({
-      actorDid: viewer,
-      targetDids: actorDidsDefined,
-    })
-
-    const actorToDid = new Map<AtIdentifierString, DidString | undefined>(
-      actors.map((actor, i) => [actor, actorDids[i]]),
-    )
-
-    for (let i = 0; i < actors.length; i++) {
-      const actor = actors[i]
-
-      const did = actorToDid.get(actor)
-      // ignore unresolved handles
-      if (!did) continue
-
-      if (did === viewer) {
-        // ignore self-follows, self-mutes, self-blocks, self-activity-subscriptions
-        map.set(actor, { did })
-        continue
-      }
-
-      // Get the index that was used to query the relationships for this actor
-      const index = actorDidsDefined.indexOf(did)
-      if (index === -1) continue
-
-      const rels = res.relationships[index]
-      map.set(actor, {
-        did,
-        muted: rels.muted ?? false,
-        mutedByList: parseString(rels.mutedByList),
-        blockedBy: parseString(rels.blockedBy),
-        blocking: parseString<AtUriString>(rels.blocking),
-        blockedByList: parseString(rels.blockedByList),
-        blockingByList: parseString(rels.blockingByList),
-        following: parseString<AtUriString>(rels.following),
-        followedBy: parseString(rels.followedBy),
-      })
-    }
-
-    return map
-  }
-
-  async getKnownFollowers(
-    dids: DidString[],
-    viewer: DidString | null,
-  ): Promise<KnownFollowersStates> {
-    const map: KnownFollowersStates = new HydrationMap()
-    if (!viewer) return map
-    if (!dids.length) return map
-
-    try {
-      const { results: knownFollowersResults } =
-        await this.dataplane.getFollowsFollowing(
-          {
-            actorDid: viewer,
-            targetDids: dids,
-          },
-          {
-            signal: AbortSignal.timeout(100),
-          },
-        )
-
-      for (let i = 0; i < dids.length; i++) {
-        const did = dids[i]
-
-        const result = knownFollowersResults[i]?.dids
-
-        map.set(
-          did,
-          result && result.length > 0
-            ? {
-                count: result.length,
-                followers: result.slice(0, 5) as DidString[],
-              }
-            : undefined,
-        )
-      }
-    } catch {
-      // ignore errors and return empty map
-    }
-
-    return map
-  }
-
-  async getActivitySubscriptions(
-    dids: DidString[],
-    viewer: DidString | null,
-  ): Promise<ActivitySubscriptionStates> {
-    const map: ActivitySubscriptionStates = new HydrationMap()
-    if (!viewer) return map
-    if (!dids.length) return map
-
-    try {
-      const { subscriptions } =
-        await this.dataplane.getActivitySubscriptionsByActorAndSubjects(
-          { actorDid: viewer, subjectDids: dids },
-          { signal: AbortSignal.timeout(100) },
-        )
-
-      for (let i = 0; i < dids.length; i++) {
-        // @NOTE Although not typed as nullable, the code here used to defend
-        // against potentially missing subscription objects in the response, so
-        // we keep that defense in place.
-        const subscription = subscriptions[i] as
-          | ActivitySubscription
-          | undefined
-
-        const state = {
-          post: subscription?.post != null,
-          reply: subscription?.reply != null,
-        }
-
-        const did = dids[i]!
-        if (isActivitySubscriptionEnabled(state)) {
-          map.set(did, state)
-        } else {
-          map.set(did, undefined)
-        }
-      }
-    } catch {
-      // ignore errors and return empty map
-    }
-
-    return map
-  }
-
-  async getProfileAggregates(dids: DidString[]): Promise<ProfileAggs> {
-    const map: ProfileAggs = new HydrationMap()
-    if (!dids.length) return map
-
-    const counts = await this.dataplane.getCountsForUsers({ dids })
-    for (let i = 0; i < dids.length; i++) {
-      const did = dids[i]
-      map.set(did, {
-        followers: counts.followers[i] ?? 0,
-        follows: counts.following[i] ?? 0,
-        posts: counts.posts[i] ?? 0,
-        lists: counts.lists[i] ?? 0,
-        feeds: counts.feeds[i] ?? 0,
-        starterPacks: counts.starterPacks[i] ?? 0,
-      })
-    }
-
-    return map
-  }
-}