@atproto/bsky 0.0.250 → 0.0.253

package/src/api/app/bsky/notification/listNotifications.ts

@@ -1,272 +0,0 @@
-import { mapDefined } from '@atproto/common'
-import { AtUriString, DatetimeString, DidString } from '@atproto/syntax'
-import { InvalidRequestError, Server } from '@atproto/xrpc-server'
-import { ServerConfig } from '../../../../config.js'
-import { AppContext } from '../../../../context.js'
-import {
-  HydrateCtxWithViewer,
-  Hydrator,
-} from '../../../../hydration/hydrator.js'
-import { app } from '../../../../lexicons/index.js'
-import {
-  HydrationFnInput,
-  PresentationFnInput,
-  RulesFnInput,
-  SkeletonFnInput,
-  createPipeline,
-} from '../../../../pipeline.js'
-import { Notification } from '../../../../proto/bsky_pb.js'
-import { uriToDid as didFromUri } from '../../../../util/uris.js'
-import { Views } from '../../../../views/index.js'
-import { isPostRecordType } from '../../../../views/types.js'
-import { resHeaders } from '../../../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  const listNotifications = createPipeline(
-    skeleton,
-    hydration,
-    noBlockOrMutesOrNeedsFiltering,
-    presentation,
-  )
-  server.add(app.bsky.notification.listNotifications, {
-    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 listNotifications({ ...params, hydrateCtx }, ctx)
-      return {
-        encoding: 'application/json',
-        body: result,
-        headers: resHeaders({ labelers: hydrateCtx.labelers }),
-      }
-    },
-  })
-}
-
-const paginateNotifications = async (opts: {
-  ctx: Context
-  priority: boolean
-  reasons?: string[]
-  cursor?: string
-  limit: number
-  viewer: string
-}) => {
-  const { ctx, priority, reasons, limit, viewer } = opts
-
-  // if not filtering, then just pass through the response from dataplane
-  if (!reasons) {
-    const res = await ctx.hydrator.dataplane.getNotifications({
-      actorDid: viewer,
-      priority,
-      cursor: opts.cursor,
-      limit,
-    })
-    return {
-      notifications: res.notifications,
-      cursor: res.cursor,
-    }
-  }
-
-  let nextCursor: string | undefined = opts.cursor
-  let toReturn: Notification[] = []
-  const maxAttempts = 10
-  const attemptSize = Math.ceil(limit / 2)
-  for (let i = 0; i < maxAttempts; i++) {
-    const res = await ctx.hydrator.dataplane.getNotifications({
-      actorDid: viewer,
-      priority,
-      cursor: nextCursor,
-      limit,
-    })
-    const filtered = res.notifications.filter((notif) =>
-      reasons.includes(notif.reason),
-    )
-    toReturn = [...toReturn, ...filtered]
-    nextCursor = res.cursor ?? undefined
-    if (toReturn.length >= attemptSize || !nextCursor) {
-      break
-    }
-  }
-  return {
-    notifications: toReturn,
-    cursor: nextCursor,
-  }
-}
-
-/**
- * Applies a configurable delay to the datetime string of a cursor,
- * effectively allowing for a delay on listing the notifications.
- * This is useful to allow time for services to process notifications
- * before they are listed to the user.
- */
-export const delayCursor = (
-  cursorStr: string | undefined,
-  delayMs: number,
-): string => {
-  const nowMinusDelay = Date.now() - delayMs
-  if (cursorStr === undefined) return new Date(nowMinusDelay).toISOString()
-  const cursor = new Date(cursorStr).getTime()
-  if (isNaN(cursor)) return cursorStr
-  return new Date(Math.min(cursor, nowMinusDelay)).toISOString()
-}
-
-const skeleton = async (
-  input: SkeletonFnInput<Context, Params>,
-): Promise<SkeletonState> => {
-  const { params, ctx } = input
-  if (params.seenAt) {
-    throw new InvalidRequestError('The seenAt parameter is unsupported')
-  }
-
-  const originalCursor = params.cursor
-  const delayedCursor = delayCursor(
-    originalCursor,
-    ctx.cfg.notificationsDelayMs,
-  )
-  const viewer = params.hydrateCtx.viewer
-  const priority = params.priority ?? (await getPriority(ctx, viewer))
-  const [res, lastSeenRes] = await Promise.all([
-    paginateNotifications({
-      ctx,
-      priority,
-      reasons: params.reasons,
-      cursor: delayedCursor,
-      limit: params.limit,
-      viewer,
-    }),
-    ctx.hydrator.dataplane.getNotificationSeen({
-      actorDid: viewer,
-      priority,
-    }),
-  ])
-  // @NOTE for the first page of results if there's no last-seen time, consider top notification unread
-  // rather than all notifications. bit of a hack to be more graceful when seen times are out of sync.
-  let lastSeenDate = lastSeenRes.timestamp?.toDate()
-  if (!lastSeenDate && !originalCursor) {
-    lastSeenDate = res.notifications.at(0)?.timestamp?.toDate()
-  }
-  return {
-    notifs: res.notifications,
-    cursor: res.cursor || undefined,
-    priority,
-    lastSeenNotifs: lastSeenDate
-      ? (lastSeenDate.toISOString() as DatetimeString)
-      : undefined,
-  }
-}
-
-const hydration = async (
-  input: HydrationFnInput<Context, Params, SkeletonState>,
-) => {
-  const { skeleton, params, ctx } = input
-  return ctx.hydrator.hydrateNotifications(skeleton.notifs, params.hydrateCtx)
-}
-
-const noBlockOrMutesOrNeedsFiltering = (
-  input: RulesFnInput<Context, Params, SkeletonState>,
-) => {
-  const { skeleton, hydration, ctx, params } = input
-  skeleton.notifs = skeleton.notifs.filter((item) => {
-    const uri = item.uri as AtUriString
-    const did = didFromUri(uri)
-    if (
-      ctx.views.viewerBlockExists(did, hydration) ||
-      ctx.views.viewerMuteExists(did, hydration)
-    ) {
-      return false
-    }
-    // Filter out hidden replies only if the viewer owns
-    // the threadgate and they hid the reply.
-    if (item.reason === 'reply') {
-      const post = hydration.posts?.get(uri)
-      if (post) {
-        const rootPostUri = isPostRecordType(post.record)
-          ? post.record.reply?.root.uri
-          : undefined
-        const isRootPostByViewer =
-          rootPostUri && didFromUri(rootPostUri) === params.hydrateCtx?.viewer
-        const isHiddenByThreadgate = isRootPostByViewer
-          ? ctx.views.replyIsHiddenByThreadgate(uri, rootPostUri, hydration)
-          : false
-        if (isHiddenByThreadgate) {
-          return false
-        }
-      }
-    }
-    // Filter out notifications from users that have thread hide tags and are from people they
-    // are not following
-    if (
-      item.reason === 'reply' ||
-      item.reason === 'quote' ||
-      item.reason === 'mention'
-    ) {
-      const post = hydration.posts?.get(uri)
-      if (post) {
-        for (const [tag] of post.tags.entries()) {
-          if (ctx.cfg.threadTagsHide.has(tag)) {
-            if (!hydration.profileViewers?.get(did)?.following) {
-              return false
-            } else {
-              break
-            }
-          }
-        }
-      }
-    }
-    // Filter out notifications from users that need review unless moots
-    if (
-      item.reason === 'reply' ||
-      item.reason === 'quote' ||
-      item.reason === 'mention' ||
-      item.reason === 'like' ||
-      item.reason === 'follow'
-    ) {
-      if (!ctx.views.viewerSeesNeedsReview({ did, uri }, hydration)) {
-        return false
-      }
-    }
-    return true
-  })
-  return skeleton
-}
-
-const presentation = (
-  input: PresentationFnInput<Context, Params, SkeletonState>,
-): app.bsky.notification.listNotifications.$OutputBody => {
-  const { skeleton, hydration, ctx } = input
-  const { notifs, lastSeenNotifs, cursor } = skeleton
-  const notifications = mapDefined(notifs, (notif) =>
-    ctx.views.notification(notif, lastSeenNotifs, hydration),
-  )
-  return {
-    notifications,
-    cursor,
-    priority: skeleton.priority,
-    seenAt: skeleton.lastSeenNotifs,
-  }
-}
-
-type Context = {
-  hydrator: Hydrator
-  views: Views
-  cfg: ServerConfig
-}
-
-type Params = app.bsky.notification.listNotifications.$Params & {
-  hydrateCtx: HydrateCtxWithViewer
-}
-
-type SkeletonState = {
-  notifs: Notification[]
-  priority: boolean
-  lastSeenNotifs?: DatetimeString
-  cursor?: string
-}
-
-const getPriority = async (ctx: Context, did: DidString) => {
-  const actors = await ctx.hydrator.actor.getActors([did], {
-    skipCacheForDids: [did],
-  })
-  return !!actors.get(did)?.priorityNotifications
-}

package/src/api/app/bsky/notification/putActivitySubscription.ts

@@ -1,69 +0,0 @@
-import { TID } from '@atproto/common'
-import { InvalidRequestError, Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { isActivitySubscriptionEnabled } from '../../../../hydration/util.js'
-import { app } from '../../../../lexicons/index.js'
-import { Namespaces } from '../../../../stash.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(app.bsky.notification.putActivitySubscription, {
-    auth: ctx.authVerifier.standard,
-    handler: async ({ input, auth }) => {
-      const actorDid = auth.credentials.iss
-      const { subject, activitySubscription } = input.body
-      if (actorDid === subject) {
-        throw new InvalidRequestError('Cannot subscribe to own activity')
-      }
-
-      const existingKey = await getExistingKey(ctx, actorDid, subject)
-      const enabled = isActivitySubscriptionEnabled(activitySubscription)
-
-      const stashInput = {
-        actorDid,
-        namespace:
-          Namespaces.AppBskyNotificationDefsSubjectActivitySubscription,
-        payload: {
-          subject,
-          activitySubscription,
-        },
-        key: existingKey ?? TID.nextStr(),
-      }
-
-      if (existingKey) {
-        if (enabled) {
-          await ctx.stashClient.update(stashInput)
-        } else {
-          await ctx.stashClient.delete(stashInput)
-        }
-      } else {
-        if (enabled) {
-          await ctx.stashClient.create(stashInput)
-        } else {
-          // no-op: subscription already doesn't exist
-        }
-      }
-
-      return {
-        encoding: 'application/json',
-        body: {
-          subject,
-          activitySubscription: enabled ? activitySubscription : undefined,
-        },
-      }
-    },
-  })
-}
-
-const getExistingKey = async (
-  ctx: AppContext,
-  actorDid: string,
-  subject: string,
-): Promise<string | null> => {
-  const res = await ctx.dataplane.getActivitySubscriptionsByActorAndSubjects({
-    actorDid,
-    subjectDids: [subject],
-  })
-  const [existing] = res.subscriptions
-  const key = existing.key
-  return key || null
-}

package/src/api/app/bsky/notification/putPreferences.ts

@@ -1,17 +0,0 @@
-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.notification.putPreferences, {
-    auth: ctx.authVerifier.standard,
-    handler: async ({ input, auth }) => {
-      const { priority } = input.body
-      const viewer = auth.credentials.iss
-      await ctx.bsyncClient.addNotifOperation({
-        actorDid: viewer,
-        priority,
-      })
-    },
-  })
-}

package/src/api/app/bsky/notification/putPreferencesV2.ts

@@ -1,64 +0,0 @@
-import assert from 'node:assert'
-import { Un$Typed } from '@atproto/lex'
-import { Server, UpstreamFailureError } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { app } from '../../../../lexicons/index.js'
-import { GetNotificationPreferencesResponse } from '../../../../proto/bsky_pb.js'
-import { Namespaces } from '../../../../stash.js'
-import { DEFAULT_CHAT_PREFERENCE, protobufToLex } from './util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(app.bsky.notification.putPreferencesV2, {
-    auth: ctx.authVerifier.standard,
-    handler: async ({ auth, input }) => {
-      const actorDid = auth.credentials.iss
-      const preferences = await computePreferences(ctx, actorDid, input)
-
-      // Notification preferences are created automatically on the dataplane on signup, so we just update.
-      await ctx.stashClient.update({
-        actorDid,
-        namespace: Namespaces.AppBskyNotificationDefsPreferences,
-        key: 'self',
-        payload: preferences,
-      })
-
-      return {
-        encoding: 'application/json',
-        body: {
-          preferences,
-        },
-      }
-    },
-  })
-}
-
-const computePreferences = async (
-  ctx: AppContext,
-  actorDid: string,
-  input: app.bsky.notification.putPreferencesV2.$Input,
-): Promise<Un$Typed<app.bsky.notification.defs.Preferences>> => {
-  let res: GetNotificationPreferencesResponse
-  try {
-    res = await ctx.dataplane.getNotificationPreferences({
-      dids: [actorDid],
-    })
-  } catch (err) {
-    throw new UpstreamFailureError(
-      'cannot get current notification preferences',
-      'NotificationPreferencesFailed',
-      { cause: err },
-    )
-  }
-
-  assert(
-    res.preferences.length === 1,
-    `expected exactly one preferences entry, got ${res.preferences.length}`,
-  )
-
-  const currentPreferences = protobufToLex(res.preferences[0])
-  const preferences = { ...currentPreferences, ...input.body }
-  // NOTE: See the deprecation notice on the lexicon. This field returns a static default value and shouldn't be used.
-  // Use the chat.bsky.notification.defs#preferences type instead.
-  preferences.chat = DEFAULT_CHAT_PREFERENCE
-  return preferences
-}

package/src/api/app/bsky/notification/registerPush.ts

@@ -1,40 +0,0 @@
-import {
-  InvalidRequestError,
-  MethodNotImplementedError,
-  Server,
-} from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { app } from '../../../../lexicons/index.js'
-import { assertLexPlatform, lexPlatformToProtoPlatform } from './util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(app.bsky.notification.registerPush, {
-    auth: ctx.authVerifier.standard,
-    handler: async ({ auth, input }) => {
-      if (!ctx.courierClient) {
-        throw new MethodNotImplementedError(
-          'This service is not configured to support push token registration.',
-        )
-      }
-      const { token, platform, serviceDid, appId, ageRestricted } = input.body
-      const did = auth.credentials.iss
-      if (serviceDid !== auth.credentials.aud) {
-        throw new InvalidRequestError('Invalid serviceDid.')
-      }
-      try {
-        assertLexPlatform(platform)
-      } catch (err) {
-        throw new InvalidRequestError(
-          'Unsupported platform: must be "ios", "android", or "web".',
-        )
-      }
-      await ctx.courierClient.registerDeviceToken({
-        did,
-        token,
-        platform: lexPlatformToProtoPlatform(platform),
-        appId,
-        ageRestricted,
-      })
-    },
-  })
-}

package/src/api/app/bsky/notification/unregisterPush.ts

@@ -1,39 +0,0 @@
-import {
-  InvalidRequestError,
-  MethodNotImplementedError,
-  Server,
-} from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { app } from '../../../../lexicons/index.js'
-import { assertLexPlatform, lexPlatformToProtoPlatform } from './util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(app.bsky.notification.unregisterPush, {
-    auth: ctx.authVerifier.standard,
-    handler: async ({ auth, input }) => {
-      if (!ctx.courierClient) {
-        throw new MethodNotImplementedError(
-          'This service is not configured to support push token registration.',
-        )
-      }
-      const { token, platform, serviceDid, appId } = input.body
-      const did = auth.credentials.iss
-      if (serviceDid !== auth.credentials.aud) {
-        throw new InvalidRequestError('Invalid serviceDid.')
-      }
-      try {
-        assertLexPlatform(platform)
-      } catch (err) {
-        throw new InvalidRequestError(
-          'Unsupported platform: must be "ios", "android", or "web".',
-        )
-      }
-      await ctx.courierClient.unregisterDeviceToken({
-        did,
-        token,
-        platform: lexPlatformToProtoPlatform(platform),
-        appId,
-      })
-    },
-  })
-}

package/src/api/app/bsky/notification/updateSeen.ts

@@ -1,52 +0,0 @@
-import { Struct, Timestamp } from '@bufbuild/protobuf'
-// eslint-disable-next-line import/no-named-as-default-member
-import murmur from 'murmurhash'
-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.notification.updateSeen, {
-    auth: ctx.authVerifier.standard,
-    handler: async ({ input, auth }) => {
-      const viewer = auth.credentials.iss
-      const seenAt = new Date(input.body.seenAt)
-      // For now we keep separate seen times behind the scenes for priority, but treat them as a single seen time.
-      await Promise.all([
-        ctx.dataplane.updateNotificationSeen({
-          actorDid: viewer,
-          timestamp: Timestamp.fromDate(seenAt),
-          priority: false,
-        }),
-        ctx.dataplane.updateNotificationSeen({
-          actorDid: viewer,
-          timestamp: Timestamp.fromDate(seenAt),
-          priority: true,
-        }),
-        ctx.courierClient?.pushNotifications({
-          notifications: [
-            {
-              id: getNotifId(viewer, seenAt),
-              clientControlled: true,
-              recipientDid: viewer,
-              alwaysDeliver: false,
-              collapseKey: 'mark-read-generic',
-              timestamp: Timestamp.fromDate(new Date()),
-              additional: Struct.fromJson({
-                reason: 'mark-read-generic',
-              }),
-            },
-          ],
-        }),
-      ])
-    },
-  })
-}
-
-function getNotifId(viewer: string, seenAt: Date) {
-  const key = ['mark-read-generic', viewer, seenAt.getTime().toString()].join(
-    '::',
-  )
-  // eslint-disable-next-line import/no-named-as-default-member
-  return murmur.v3(key).toString(16)
-}

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

@@ -1,134 +0,0 @@
-import { app } from '../../../../lexicons/index.js'
-import {
-  FilterableNotificationPreference,
-  NotificationInclude,
-  NotificationPreference,
-  NotificationPreferences,
-} from '../../../../proto/bsky_pb.js'
-import { AppPlatform } from '../../../../proto/courier_pb.js'
-
-type DeepPartial<T> = T extends object
-  ? {
-      [P in keyof T]?: DeepPartial<T[P]>
-    }
-  : T
-
-const ensureChatPreference = (
-  p?: DeepPartial<app.bsky.notification.defs.ChatPreference>,
-): app.bsky.notification.defs.ChatPreference => {
-  const includeValues = ['all', 'accepted']
-  return {
-    include:
-      typeof p?.include === 'string' && includeValues.includes(p.include)
-        ? p.include
-        : 'all',
-    push: p?.push ?? true,
-  }
-}
-
-const ensureFilterablePreference = (
-  p?: DeepPartial<app.bsky.notification.defs.FilterablePreference>,
-): app.bsky.notification.defs.FilterablePreference => {
-  const includeValues = ['all', 'follows']
-  return {
-    include:
-      typeof p?.include === 'string' && includeValues.includes(p.include)
-        ? p.include
-        : 'all',
-    list: p?.list ?? true,
-    push: p?.push ?? true,
-  }
-}
-
-const ensurePreference = (
-  p?: DeepPartial<app.bsky.notification.defs.Preference>,
-): app.bsky.notification.defs.Preference => {
-  return {
-    list: p?.list ?? true,
-    push: p?.push ?? true,
-  }
-}
-
-const ensurePreferences = (
-  p: DeepPartial<app.bsky.notification.defs.Preferences>,
-): app.bsky.notification.defs.Preferences => {
-  return {
-    chat: ensureChatPreference(p.chat),
-    follow: ensureFilterablePreference(p.follow),
-    like: ensureFilterablePreference(p.like),
-    likeViaRepost: ensureFilterablePreference(p.likeViaRepost),
-    mention: ensureFilterablePreference(p.mention),
-    quote: ensureFilterablePreference(p.quote),
-    reply: ensureFilterablePreference(p.reply),
-    repost: ensureFilterablePreference(p.repost),
-    repostViaRepost: ensureFilterablePreference(p.repostViaRepost),
-    starterpackJoined: ensurePreference(p.starterpackJoined),
-    subscribedPost: ensurePreference(p.subscribedPost),
-    unverified: ensurePreference(p.unverified),
-    verified: ensurePreference(p.verified),
-  }
-}
-
-export const DEFAULT_CHAT_PREFERENCE: app.bsky.notification.defs.ChatPreference =
-  {
-    include: 'all',
-    push: true,
-  }
-
-const protobufFilterablePreferenceToLex = (
-  p?: DeepPartial<FilterableNotificationPreference>,
-): Partial<app.bsky.notification.defs.FilterablePreference> => {
-  return {
-    include: p?.include === NotificationInclude.FOLLOWS ? 'follows' : 'all',
-    list: p?.list?.enabled,
-    push: p?.push?.enabled,
-  }
-}
-
-const protobufPreferenceToLex = (
-  p?: DeepPartial<NotificationPreference>,
-): Partial<app.bsky.notification.defs.Preference> => {
-  return {
-    list: p?.list?.enabled,
-    push: p?.push?.enabled,
-  }
-}
-
-export const protobufToLex = (
-  res: DeepPartial<NotificationPreferences>,
-): app.bsky.notification.defs.Preferences => {
-  return ensurePreferences({
-    // NOTE: See the deprecation notice on the lexicon. This field returns a static default value and shouldn't be used.
-    // Use the chat.bsky.notification.defs#preferences type instead.
-    chat: DEFAULT_CHAT_PREFERENCE,
-    follow: protobufFilterablePreferenceToLex(res.follow),
-    like: protobufFilterablePreferenceToLex(res.like),
-    likeViaRepost: protobufFilterablePreferenceToLex(res.likeViaRepost),
-    mention: protobufFilterablePreferenceToLex(res.mention),
-    quote: protobufFilterablePreferenceToLex(res.quote),
-    reply: protobufFilterablePreferenceToLex(res.reply),
-    repost: protobufFilterablePreferenceToLex(res.repost),
-    repostViaRepost: protobufFilterablePreferenceToLex(res.repostViaRepost),
-    starterpackJoined: protobufPreferenceToLex(res.starterpackJoined),
-    subscribedPost: protobufPreferenceToLex(res.subscribedPost),
-    unverified: protobufPreferenceToLex(res.unverified),
-    verified: protobufPreferenceToLex(res.verified),
-  })
-}
-
-type LexPlatform = 'ios' | 'android' | 'web'
-
-export function assertLexPlatform(
-  platform: string,
-): asserts platform is LexPlatform {
-  if (platform !== 'ios' && platform !== 'android' && platform !== 'web') {
-    throw new Error('Unsupported platform: must be "ios", "android", or "web".')
-  }
-}
-
-export const lexPlatformToProtoPlatform = (platform: string): AppPlatform =>
-  platform === 'ios'
-    ? AppPlatform.IOS
-    : platform === 'android'
-      ? AppPlatform.ANDROID
-      : AppPlatform.WEB