@planningcenter/chat-react-native 3.35.0-rc.1 → 3.35.0-rc.3

package/src/hooks/use_conversation_messages.ts

@@ -1,28 +1,112 @@
+import {
+  AnyUseSuspenseInfiniteQueryOptions,
+  InfiniteData,
+  useSuspenseInfiniteQuery,
+  useSuspenseQueries,
+} from '@tanstack/react-query'
 import { useMemo } from 'react'
-import { MessageResource } from '../types'
+import { useConversationContext } from '../contexts/conversation_context'
+import { ApiCollection, MessageResource } from '../types'
+import {
+  anchoredSeedPageParams,
+  MessagesPageParam,
+  newerPageParam,
+  olderPageParam,
+  sortAndFilterMessages,
+} from '../utils/conversation_messages'
 import { getMessagesQueryKey, getMessagesRequestArgs } from '../utils/request/get_messages'
-import { SuspensePaginatorOptions, useSuspensePaginator } from './use_suspense_api'
+import { useApiClient } from './use_api_client'
+import { throwResponseError } from './use_suspense_api'
+
+type Args = { conversation_id: number; reply_root_id?: string | null }
+
+export type ConversationMessagesOptions = Omit<
+  AnyUseSuspenseInfiniteQueryOptions,
+  | 'getNextPageParam'
+  | 'getPreviousPageParam'
+  | 'initialData'
+  | 'initialPageParam'
+  | 'queryFn'
+  | 'queryKey'
+>
 
 export const useConversationMessages = (
-  { conversation_id, reply_root_id }: { conversation_id: number; reply_root_id?: string | null },
-  opts?: SuspensePaginatorOptions
+  { conversation_id, reply_root_id }: Args,
+  opts?: ConversationMessagesOptions
 ) => {
-  const { data, refetch, isRefetching, fetchNextPage } = useSuspensePaginator<MessageResource>(
-    getMessagesRequestArgs({ conversation_id, reply_root_id }),
-    opts
-  )
+  const apiClient = useApiClient()
+  const { initialMessageId } = useConversationContext()
+  const anchored = !reply_root_id && !!initialMessageId
+
+  const requestArgs = getMessagesRequestArgs({ conversation_id, reply_root_id })
   const queryKey = getMessagesQueryKey({ conversation_id, reply_root_id })
-  const messages = useMemo(
-    () =>
-      data
-        .filter(
-          message =>
-            (!message.deletedAt || message.replyRootId) &&
-            (message.attachments?.length || message.text?.length)
-        )
-        .sort((a, b) => -a.id.localeCompare(b.id)),
-    [data]
-  )
-
-  return { messages, refetch, isRefetching, fetchNextPage, queryKey }
+
+  const fetchPage = (pageParam: MessagesPageParam) => {
+    const data = {
+      ...requestArgs.data,
+      ...(pageParam.where ? { where: pageParam.where } : {}),
+      ...(pageParam.order ? { order: pageParam.order } : {}),
+    }
+    return apiClient.chat
+      .get<ApiCollection<MessageResource>>({ url: requestArgs.url, data })
+      .catch(throwResponseError)
+  }
+
+  const seedPageParams = anchored ? anchoredSeedPageParams(initialMessageId) : []
+  const seedQueries = useSuspenseQueries({
+    queries: seedPageParams.map((pageParam, index) => ({
+      queryKey: [...queryKey, 'seed', index],
+      queryFn: () => fetchPage(pageParam),
+      staleTime: Infinity,
+      gcTime: 0,
+    })),
+  })
+
+  const initialData: InfiniteData<ApiCollection<MessageResource>, MessagesPageParam> | undefined =
+    anchored
+      ? {
+          pages: seedQueries.map(q => q.data),
+          pageParams: seedPageParams,
+        }
+      : undefined
+
+  const initialPageParam: MessagesPageParam = anchored ? seedPageParams[0] : {}
+
+  const {
+    data,
+    refetch,
+    isRefetching,
+    fetchNextPage,
+    hasNextPage,
+    fetchPreviousPage,
+    hasPreviousPage,
+  } = useSuspenseInfiniteQuery<
+    ApiCollection<MessageResource>,
+    Response,
+    InfiniteData<ApiCollection<MessageResource>, MessagesPageParam>,
+    typeof queryKey,
+    MessagesPageParam
+  >({
+    queryKey,
+    queryFn: ({ pageParam }) => fetchPage(pageParam),
+    initialPageParam,
+    initialData,
+    getNextPageParam: olderPageParam,
+    getPreviousPageParam: anchored ? newerPageParam : () => undefined,
+    ...(opts || {}),
+    ...(anchored ? { staleTime: Infinity, refetchOnMount: false } : {}),
+  })
+
+  const messages = useMemo(() => sortAndFilterMessages(data.pages), [data.pages])
+
+  return {
+    messages,
+    refetch,
+    isRefetching,
+    fetchOlderMessages: fetchNextPage,
+    hasMoreOlderMessages: hasNextPage,
+    fetchNewerMessages: fetchPreviousPage,
+    hasMoreNewerMessages: hasPreviousPage,
+    queryKey,
+  }
 }

package/src/hooks/use_features.ts

@@ -38,6 +38,7 @@ export const availableFeatures = {
   message_reporting: 'ROLLOUT_MOBILE_message_reporting',
   granular_notifications_ui: 'ROLLOUT_granular_notification_preferences_ui',
   custom_conversation_avatars: 'ROLLOUT_custom_conversation_avatars',
+  jump_to_unread: 'ROLLOUT_jump_to_unread',
 }
 
 const stableEmptyFeatures: ApiCollection<FeatureResource> = {

package/src/hooks/use_suspense_api.ts

@@ -90,7 +90,7 @@ export const useSuspensePaginator = <T extends ResourceObject>(
   return { ...query, data, totalCount }
 }
 
-const throwResponseError = (error: unknown) => {
+export const throwResponseError = (error: unknown) => {
   if (error instanceof Response) {
     throw new ResponseError(error as FailedResponse)
   }

package/src/screens/conversation_screen.tsx

@@ -31,15 +31,15 @@ import { useConversation } from '../hooks/use_conversation'
 import { useConversationJoltEvents } from '../hooks/use_conversation_jolt_events'
 import { useConversationMessages } from '../hooks/use_conversation_messages'
 import { useConversationMessagesJoltEvents } from '../hooks/use_conversation_messages_jolt_events'
+import { useFeatures } from '../hooks/use_features'
 import { useMarkLatestMessageRead } from '../hooks/use_mark_latest_message_read'
 import {
   normalizeAnalyticsMetadata,
   usePublishProductAnalyticsEvent,
 } from '../hooks/use_product_analytics'
-import { MessageResource } from '../types'
 import { ConversationBadgeResource } from '../types/resources/conversation_badge'
 import { getRelativeDateStatus } from '../utils/date'
-import dayjs from '../utils/dayjs'
+import { groupMessages, type DateSeparator } from '../utils/group_messages'
 import { CONVERSATION_MESSAGE_LIST_PADDING_HORIZONTAL } from '../utils/styles'
 import { isSystemMessage } from '../utils/system_messages'
 
@@ -50,6 +50,7 @@ export type ConversationRouteProps = {
   chat_group_graph_id?: string
   clear_input?: boolean
   editing_message_id?: number | null
+  message_id?: string
   title?: string
   subtitle?: string
   badge?: ConversationBadgeResource
@@ -60,19 +61,27 @@ export type ConversationRouteProps = {
 export type ConversationScreenProps = StaticScreenProps<ConversationRouteProps>
 
 export function ConversationScreen({ route }: ConversationScreenProps) {
-  const { conversation_id, reply_root_id } = route.params
+  const { conversation_id, message_id, reply_root_id } = route.params
 
   const { data: conversation } = useConversation({ conversation_id })
+  const { featureEnabled } = useFeatures()
 
   usePublishProductAnalyticsEvent('chat.mobile.conversations.show.opened', {
     reply_root_id,
     ...normalizeAnalyticsMetadata(conversation),
   })
 
+  const lastReadMessageSortKey = conversation.conversationMembership?.lastReadMessageSortKey ?? null
+  const jumpToUnreadAnchor = featureEnabled('jump_to_unread') ? lastReadMessageSortKey : null
+  const initialMessageId = message_id ?? jumpToUnreadAnchor
+  const initialMessageIdIsAnchor = !!initialMessageId && !message_id
+
   return (
     <ConversationContextProvider
       conversationId={conversation_id}
       currentPageReplyRootId={reply_root_id ?? null}
+      initialMessageId={initialMessageId}
+      initialMessageIdIsAnchor={initialMessageIdIsAnchor}
     >
       <ConversationScreenContent route={route} />
     </ConversationContextProvider>
@@ -85,7 +94,7 @@ function ConversationScreenContent({ route }: ConversationScreenProps) {
   const { conversation_id, editing_message_id, reply_root_id, reply_root_author_name } =
     route.params
   const { data: conversation } = useConversation(route.params)
-  const { messages, refetch, isRefetching, fetchNextPage } = useConversationMessages({
+  const { messages, refetch, isRefetching, fetchOlderMessages } = useConversationMessages({
     conversation_id,
     reply_root_id,
   })
@@ -204,7 +213,7 @@ function ConversationScreenContent({ route }: ConversationScreenProps) {
                 />
               )
             }}
-            onEndReached={() => fetchNextPage()}
+            onEndReached={() => fetchOlderMessages()}
             ListHeaderComponent={<View style={styles.listHeader} />}
           />
         )}
@@ -238,8 +247,6 @@ function ConversationScreenContent({ route }: ConversationScreenProps) {
   )
 }
 
-export type DateSeparator = { type: 'DateSeparator'; id: string; date: string }
-
 function InlineDateSeparator({ date }: DateSeparator) {
   const styles = useDateSeparatorStyles()
   const { isThisYear } = getRelativeDateStatus(date)
@@ -278,130 +285,6 @@ const useDateSeparatorStyles = () => {
   })
 }
 
-type ReplyShadowMessage = {
-  type: 'ReplyShadowMessage'
-  id: string
-  messageId: string
-  isReplyShadowMessage: boolean
-  nextRendersAuthor: boolean
-}
-
-interface GroupMessagesProps {
-  ms: MessageResource[]
-  inReplyScreen?: boolean
-}
-
-export const groupMessages = ({ ms, inReplyScreen }: GroupMessagesProps) => {
-  let enrichedMessages: (MessageResource | DateSeparator | ReplyShadowMessage)[] = []
-  let encounteredOneOfMyMessages = false
-
-  ms.forEach((message, i) => {
-    const prevMessage = ms[i + 1]
-    const nextMessage = ms[i - 1]
-    const date = dayjs(message.createdAt).format('YYYY-MM-DD')
-
-    const prevMessageIsDateSeparator =
-      prevMessage && date !== dayjs(prevMessage.createdAt).format('YYYY-MM-DD')
-
-    if (isSystemMessage(message)) {
-      message.myLatestInConversation = false
-      message.lastInGroup = true
-      message.renderAuthor = false
-      message.nextRendersAuthor = nextMessage?.renderAuthor
-      message.isReplyShadowMessage = false
-      message.nextIsReplyShadowMessage = false
-      message.threadPosition = null
-      enrichedMessages.push(message)
-      if (prevMessageIsDateSeparator) {
-        enrichedMessages.push({ type: 'DateSeparator', id: `day-divider-${message.id}`, date })
-      }
-      return
-    }
-
-    const inThread = message.replyRootId !== null
-    const nextMessageInThread = nextMessage?.replyRootId !== null
-    const threadRoot = message.replyRootId === message.id
-    const nextMessageThreadRoot = nextMessage?.replyRootId === nextMessage?.id
-    const prevMessageDifferentThread = message.replyRootId !== prevMessage?.replyRootId
-    const nextMessageDifferentThread = message.replyRootId !== nextMessage?.replyRootId
-    const prevMessageDifferentAuthor = message.author?.id !== prevMessage?.author?.id
-    const nextMessageDifferentAuthor = message.author?.id !== nextMessage?.author?.id
-    const prevMessageMoreThan5Minutes =
-      prevMessage &&
-      new Date(message.createdAt).getTime() - new Date(prevMessage.createdAt).getTime() > 60000 * 5
-    const nextMessageMoreThan5Minutes =
-      nextMessage &&
-      new Date(nextMessage.createdAt).getTime() - new Date(message.createdAt).getTime() > 60000 * 5
-    const nextMessageIsDateSeparator =
-      nextMessage && date !== dayjs(nextMessage.createdAt).format('YYYY-MM-DD')
-    const insertReplyShadowMessage =
-      message.replyRootId &&
-      !threadRoot &&
-      (prevMessageDifferentThread || prevMessageIsDateSeparator)
-    const lastInGroup =
-      !nextMessage ||
-      nextMessageDifferentAuthor ||
-      nextMessageMoreThan5Minutes ||
-      nextMessageDifferentThread ||
-      nextMessageIsDateSeparator
-    const renderAuthor =
-      !message.mine &&
-      (!prevMessage ||
-        prevMessageDifferentAuthor ||
-        prevMessageMoreThan5Minutes ||
-        prevMessageDifferentThread ||
-        prevMessageIsDateSeparator)
-    const nextIsReplyShadowMessage =
-      nextMessageInThread &&
-      !nextMessageThreadRoot &&
-      (nextMessageDifferentThread || nextMessageIsDateSeparator)
-
-    if (message.mine && !encounteredOneOfMyMessages) {
-      encounteredOneOfMyMessages = true
-      message.myLatestInConversation = true
-    } else {
-      message.myLatestInConversation = false
-    }
-    message.lastInGroup = lastInGroup
-    message.renderAuthor = renderAuthor
-    message.threadPosition = null
-    message.nextRendersAuthor = nextMessage?.renderAuthor
-    message.isReplyShadowMessage = false
-    message.nextIsReplyShadowMessage = nextIsReplyShadowMessage
-
-    if (!inReplyScreen && inThread) {
-      message.prevIsMyReply = prevMessage?.mine
-      message.nextIsMyReply = nextMessage?.mine
-
-      const firstInThread = threadRoot
-      const lastInThread = nextMessageDifferentThread || nextMessageIsDateSeparator
-
-      if (firstInThread && lastInThread)
-        message.threadPosition = null // ensures we don't render a connector for root replies that aren't immediately followed up a reply
-      else if (firstInThread) message.threadPosition = 'first'
-      else if (lastInThread) message.threadPosition = 'last'
-      else message.threadPosition = 'center'
-    }
-
-    enrichedMessages.push(message)
-
-    if (insertReplyShadowMessage) {
-      enrichedMessages.push({
-        type: 'ReplyShadowMessage',
-        id: `${message.id}-${message.replyRootId}`,
-        messageId: message.replyRootId!,
-        isReplyShadowMessage: true,
-        nextRendersAuthor: message?.renderAuthor,
-      })
-    }
-
-    if (!prevMessage || date !== dayjs(prevMessage.createdAt).format('YYYY-MM-DD')) {
-      enrichedMessages.push({ type: 'DateSeparator', id: `day-divider-${message.id}`, date })
-    }
-  })
-
-  return enrichedMessages
-}
 interface ConversationScreenTitleProps extends HeaderTitleProps {
   conversation_id: number
   badge?: ConversationBadgeResource

package/src/utils/__tests__/conversation_messages.test.ts

@@ -0,0 +1,105 @@
+import { ApiCollection, MessageResource } from '../../types'
+import {
+  anchoredSeedPageParams,
+  newerPageParam,
+  olderPageParam,
+  sortAndFilterMessages,
+} from '../conversation_messages'
+
+const message = (id: string, overrides: Partial<MessageResource> = {}): MessageResource =>
+  ({
+    id,
+    type: 'Message',
+    text: `msg ${id}`,
+    attachments: [],
+    deletedAt: null,
+    replyRootId: null,
+    ...overrides,
+  }) as MessageResource
+
+const page = (
+  data: MessageResource[],
+  next?: { idLt?: string; idGt?: string }
+): ApiCollection<MessageResource> => ({
+  data,
+  links: {},
+  meta: { count: data.length, totalCount: data.length, next },
+})
+
+describe('anchoredSeedPageParams', () => {
+  it('returns one ascending after-page and one descending before-page', () => {
+    expect(anchoredSeedPageParams('01ABC')).toEqual([
+      { where: { id_gte: '01ABC' }, order: 'asc' },
+      { where: { id_lt: '01ABC' }, order: 'desc' },
+    ])
+  })
+})
+
+describe('olderPageParam', () => {
+  it('returns id_lt cursor when meta.next.idLt is present', () => {
+    expect(olderPageParam(page([], { idLt: '01XYZ' }))).toEqual({
+      where: { id_lt: '01XYZ' },
+      order: 'desc',
+    })
+  })
+
+  it('returns undefined when meta.next.idLt is missing', () => {
+    expect(olderPageParam(page([], {}))).toBeUndefined()
+    expect(olderPageParam(page([], { idGt: '01XYZ' }))).toBeUndefined()
+  })
+})
+
+describe('newerPageParam', () => {
+  it('returns id_gt cursor when meta.next.idGt is present', () => {
+    expect(newerPageParam(page([], { idGt: '01XYZ' }))).toEqual({
+      where: { id_gt: '01XYZ' },
+      order: 'asc',
+    })
+  })
+
+  it('returns undefined when meta.next.idGt is missing', () => {
+    expect(newerPageParam(page([], {}))).toBeUndefined()
+    expect(newerPageParam(page([], { idLt: '01XYZ' }))).toBeUndefined()
+  })
+})
+
+describe('sortAndFilterMessages', () => {
+  it('flattens pages and sorts descending by id (newest first)', () => {
+    const pages = [page([message('01B'), message('01A')]), page([message('01D'), message('01C')])]
+
+    expect(sortAndFilterMessages(pages).map(m => m.id)).toEqual(['01D', '01C', '01B', '01A'])
+  })
+
+  it('drops empty messages (no text, no attachments)', () => {
+    const pages = [page([message('01A'), message('01B', { text: '' })])]
+
+    expect(sortAndFilterMessages(pages).map(m => m.id)).toEqual(['01A'])
+  })
+
+  it('drops deleted messages outside reply threads', () => {
+    const pages = [page([message('01A'), message('01B', { deletedAt: '2026-01-01T00:00:00Z' })])]
+
+    expect(sortAndFilterMessages(pages).map(m => m.id)).toEqual(['01A'])
+  })
+
+  it('keeps deleted reply-thread messages so threads do not break', () => {
+    const pages = [
+      page([
+        message('01A'),
+        message('01B', { deletedAt: '2026-01-01T00:00:00Z', replyRootId: '01A' }),
+      ]),
+    ]
+
+    expect(sortAndFilterMessages(pages).map(m => m.id)).toEqual(['01B', '01A'])
+  })
+
+  it('keeps messages with attachments even when text is empty', () => {
+    const pages = [
+      page([
+        message('01A', { text: '', attachments: [{ id: '1' }] as MessageResource['attachments'] }),
+      ]),
+    ]
+
+    expect(sortAndFilterMessages(pages).map(m => m.id)).toEqual(['01A'])
+  })
+})

package/src/utils/__tests__/group_messages.test.ts

@@ -0,0 +1,143 @@
+import type { MessageResource } from '../../types/resources/message'
+import type { PersonResource } from '../../types/resources/person'
+import { groupMessages } from '../group_messages'
+
+const author = { id: 1, type: 'Person', name: 'A', avatar: null } as unknown as PersonResource
+const otherAuthor = {
+  id: 2,
+  type: 'Person',
+  name: 'B',
+  avatar: null,
+} as unknown as PersonResource
+
+const message = (id: string, overrides: Partial<MessageResource> = {}): MessageResource =>
+  ({
+    type: 'Message',
+    id,
+    text: `msg ${id}`,
+    html: `<p>msg ${id}</p>`,
+    createdAt: '2026-01-01T00:00:00Z',
+    deletedAt: null,
+    textEditedAt: null,
+    mine: false,
+    attachments: [],
+    author,
+    reactionCounts: [],
+    replyCount: 0,
+    replyRootId: null,
+    messageType: 'message',
+    personIdsForSystemEvent: null,
+    systemTextParts: null,
+    ...overrides,
+  }) as MessageResource
+
+const findEnriched = (items: ReturnType<typeof groupMessages>, id: string) =>
+  items.find(item => 'id' in item && item.id === id && !('type' in item && item.type !== 'Message'))
+
+describe('groupMessages — immutability', () => {
+  it('does not mutate the input messages', () => {
+    const input = [message('02'), message('01')]
+    const snapshot = JSON.parse(JSON.stringify(input))
+
+    groupMessages({ ms: input })
+
+    expect(input).toEqual(snapshot)
+  })
+})
+
+describe('groupMessages — grouping', () => {
+  it('breaks groups across a >5min gap (lastInGroup flips on the older message)', () => {
+    const messages = [
+      message('02', { createdAt: '2026-01-01T00:06:00Z' }),
+      message('01', { createdAt: '2026-01-01T00:00:00Z' }),
+    ]
+
+    const enriched = groupMessages({ ms: messages })
+
+    expect((findEnriched(enriched, '01') as MessageResource).lastInGroup).toBe(true)
+  })
+
+  it('breaks groups when authors differ (renderAuthor flips on the newer message)', () => {
+    const messages = [message('02', { author }), message('01', { author: otherAuthor })]
+
+    const enriched = groupMessages({ ms: messages })
+
+    expect((findEnriched(enriched, '02') as MessageResource).renderAuthor).toBe(true)
+  })
+
+  it('marks the first own message as myLatestInConversation and not later ones', () => {
+    const messages = [
+      message('03', { mine: true, createdAt: '2026-01-01T00:02:00Z' }),
+      message('02', { mine: true, createdAt: '2026-01-01T00:01:00Z' }),
+      message('01', { mine: false, createdAt: '2026-01-01T00:00:00Z' }),
+    ]
+
+    const enriched = groupMessages({ ms: messages })
+
+    expect((findEnriched(enriched, '03') as MessageResource).myLatestInConversation).toBe(true)
+    expect((findEnriched(enriched, '02') as MessageResource).myLatestInConversation).toBe(false)
+  })
+})
+
+describe('groupMessages — render order at thread + date boundaries', () => {
+  it('reply shadow precedes date separator so the date renders above', () => {
+    const messages = [
+      message('02', { createdAt: '2026-01-02T12:00:00Z', replyRootId: 'rootB' }),
+      message('01', { createdAt: '2026-01-01T12:00:00Z', replyRootId: 'rootA' }),
+    ]
+
+    const enriched = groupMessages({ ms: messages })
+
+    const shadowIdx = enriched.findIndex(
+      item => 'type' in item && item.type === 'ReplyShadowMessage' && item.id === '02-rootB'
+    )
+    const dateSepIdx = enriched.findIndex(
+      item => 'type' in item && item.type === 'DateSeparator' && item.id === 'day-divider-02'
+    )
+    expect(shadowIdx).toBeGreaterThan(-1)
+    expect(dateSepIdx).toBeGreaterThan(shadowIdx)
+  })
+
+  it('skips reply-shadow insertion when inReplyScreen is false but threadPosition still resolves', () => {
+    const messages = [
+      message('02', { replyRootId: 'rootA', createdAt: '2026-01-01T00:01:00Z' }),
+      message('01', { id: 'rootA', replyRootId: 'rootA', createdAt: '2026-01-01T00:00:00Z' }),
+    ]
+
+    const enriched = groupMessages({ ms: messages })
+
+    expect((findEnriched(enriched, '02') as MessageResource).threadPosition).toBe('last')
+    expect((findEnriched(enriched, 'rootA') as MessageResource).threadPosition).toBe('first')
+  })
+})
+
+describe('groupMessages — nextRendersAuthor mirrors the newer enriched neighbor', () => {
+  it('propagates the newer neighbor’s computed renderAuthor across an author-change boundary', () => {
+    const messages = [message('02', { author: otherAuthor }), message('01', { author })]
+
+    const enriched = groupMessages({ ms: messages })
+
+    const newer = findEnriched(enriched, '02') as MessageResource
+    const older = findEnriched(enriched, '01') as MessageResource
+    expect(newer.renderAuthor).toBe(true)
+    expect(older.nextRendersAuthor).toBe(true)
+  })
+})
+
+describe('groupMessages — system messages', () => {
+  it('flags lastInGroup true and renderAuthor false on system messages', () => {
+    const messages = [
+      message('sys', {
+        messageType: 'user_joined',
+        systemTextParts: { names: ['A'], overflowCount: 0, action: 'joined' },
+        personIdsForSystemEvent: [1],
+      }),
+    ]
+
+    const enriched = groupMessages({ ms: messages })
+
+    const sys = findEnriched(enriched, 'sys') as MessageResource
+    expect(sys.lastInGroup).toBe(true)
+    expect(sys.renderAuthor).toBe(false)
+  })
+})

package/src/utils/conversation_messages.ts

@@ -0,0 +1,37 @@
+import { ApiCollection, MessageResource } from '../types'
+import { RequestData } from './client'
+
+export type MessagesPageParam = Partial<RequestData> & {
+  order?: 'asc' | 'desc'
+}
+
+export const anchoredSeedPageParams = (anchor: string): MessagesPageParam[] => [
+  { where: { id_gte: anchor }, order: 'asc' },
+  { where: { id_lt: anchor }, order: 'desc' },
+]
+
+export const olderPageParam = (
+  page: ApiCollection<MessageResource>
+): MessagesPageParam | undefined => {
+  const idLt = page.meta?.next?.idLt
+  if (!idLt) return undefined
+  return { where: { id_lt: idLt }, order: 'desc' }
+}
+
+export const newerPageParam = (
+  page: ApiCollection<MessageResource>
+): MessagesPageParam | undefined => {
+  const idGt = page.meta?.next?.idGt
+  if (!idGt) return undefined
+  return { where: { id_gt: idGt }, order: 'asc' }
+}
+
+export const sortAndFilterMessages = (pages: ApiCollection<MessageResource>[]): MessageResource[] =>
+  pages
+    .flatMap(page => page.data)
+    .filter(
+      message =>
+        (!message.deletedAt || message.replyRootId) &&
+        (message.attachments?.length || message.text?.length)
+    )
+    .sort((a, b) => -a.id.localeCompare(b.id))