@planningcenter/chat-react-native 4.0.1-qa-staging.2 → 4.0.1-rc.0

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

@@ -1,73 +0,0 @@
-import { replaceEqualById } from '../replace_equal_by_id'
-
-type Record = { type: 'Message'; id: string; text: string; attachments: string[] }
-type Pages = { pages: { data: Record[]; links: {}; meta: {} }[]; pageParams: unknown[] }
-
-const record = (id: string, text = id): Record => ({ type: 'Message', id, text, attachments: [] })
-const pagesOf = (...pages: Record[][]): Pages => ({
-  pages: pages.map(data => ({ data, links: {}, meta: {} })),
-  pageParams: pages.map(() => ({})),
-})
-
-const share = (prev: Pages, next: Pages) => replaceEqualById(prev, next) as Pages
-
-describe('replaceEqualById', () => {
-  it('returns the previous data when nothing changed', () => {
-    const prev = pagesOf([record('c'), record('b')], [record('a')])
-    const next = pagesOf([record('c'), record('b')], [record('a')])
-
-    expect(share(prev, next)).toBe(prev)
-  })
-
-  it('keeps every existing record when one is inserted at the head', () => {
-    const [c, b] = [record('c'), record('b')]
-    const prev = pagesOf([c, b])
-    const next = pagesOf([record('d'), record('c'), record('b')])
-
-    const result = share(prev, next)
-
-    expect(result.pages[0].data[1]).toBe(c)
-    expect(result.pages[0].data[2]).toBe(b)
-    expect(result.pages[0].data[0].id).toBe('d')
-  })
-
-  it('keeps the survivors when a record is removed', () => {
-    const [c, b, a] = [record('c'), record('b'), record('a')]
-    const prev = pagesOf([c, b, a])
-    const next = pagesOf([record('c'), record('a')])
-
-    const result = share(prev, next)
-
-    expect(result.pages[0].data).toEqual([c, a])
-    expect(result.pages[0].data[0]).toBe(c)
-    expect(result.pages[0].data[1]).toBe(a)
-  })
-
-  it('replaces only the changed record and keeps its untouched nested references', () => {
-    const b = record('b')
-    const prev = pagesOf([record('c'), b])
-    const next = pagesOf([record('c'), { ...record('b', 'edited'), attachments: [] }])
-
-    const result = share(prev, next)
-
-    expect(result.pages[0].data[0]).toBe(prev.pages[0].data[0])
-    expect(result.pages[0].data[1]).not.toBe(b)
-    expect(result.pages[0].data[1].text).toBe('edited')
-    expect(result.pages[0].data[1].attachments).toBe(b.attachments)
-  })
-
-  it('keeps untouched pages when only another page changed', () => {
-    const prev = pagesOf([record('c')], [record('a')])
-    const next = pagesOf([record('d'), record('c')], [record('a')])
-
-    const result = share(prev, next)
-
-    expect(result.pages[1]).toBe(prev.pages[1])
-  })
-
-  it('returns the new data when there is nothing to share with', () => {
-    const next = pagesOf([record('a')])
-
-    expect(replaceEqualById(undefined, next)).toBe(next)
-  })
-})

package/src/utils/cache/__tests__/messages_cache.test.ts

@@ -1,89 +0,0 @@
-import { InfiniteData, QueryClient } from '@tanstack/react-query'
-import type { ApiCollection, MessageResource } from '../../../types'
-import type { PersonResource } from '../../../types/resources/person'
-import { updateCacheWithMessage } from '../messages_cache'
-
-type MessagesQueryData = InfiniteData<ApiCollection<MessageResource>>
-
-const queryKey = ['messages']
-const author = { type: 'Person', id: 1, name: 'Me', avatar: null } as unknown as PersonResource
-
-const message = (overrides: Partial<MessageResource>): MessageResource =>
-  ({
-    type: 'Message',
-    text: 'ok',
-    html: '',
-    createdAt: '2026-01-01T00:00:00Z',
-    deletedAt: null,
-    textEditedAt: null,
-    mine: true,
-    attachments: [],
-    author,
-    reactionCounts: [],
-    replyCount: 0,
-    replyRootId: null,
-    messageType: 'user',
-    ...overrides,
-  }) as MessageResource
-
-const seed = (queryClient: QueryClient, ...messages: MessageResource[]) =>
-  queryClient.setQueryData<MessagesQueryData>(queryKey, {
-    pages: [
-      { data: messages, links: {}, meta: { count: messages.length, totalCount: messages.length } },
-    ],
-    pageParams: [],
-  })
-
-const idsInCache = (queryClient: QueryClient) =>
-  queryClient.getQueryData<MessagesQueryData>(queryKey)!.pages[0].data.map(m => m.id)
-
-const echo = (queryClient: QueryClient, overrides: Partial<MessageResource>) =>
-  updateCacheWithMessage(queryClient, queryKey, message(overrides), 'message.created')
-
-describe('updateCacheWithMessage on message.created', () => {
-  let queryClient: QueryClient
-
-  beforeEach(() => {
-    queryClient = new QueryClient()
-    seed(
-      queryClient,
-      message({ id: '01B-temp', idempotentKey: 'key-b', pending: true }),
-      message({ id: '01A-temp', idempotentKey: 'key-a', pending: true })
-    )
-  })
-
-  it('swaps out only the pending message with the same idempotent key', () => {
-    echo(queryClient, { id: '01A', idempotentKey: 'key-a' })
-
-    expect(idsInCache(queryClient)).toEqual(['01A', '01B-temp'])
-  })
-
-  it('does not swap out a pending message that only shares the same text', () => {
-    echo(queryClient, { id: '01C', idempotentKey: 'key-c', text: 'ok' })
-
-    expect(idsInCache(queryClient)).toEqual(['01C', '01B-temp', '01A-temp'])
-  })
-
-  it('swaps out an attachment-only pending message, which has no text to match', () => {
-    seed(
-      queryClient,
-      message({ id: '01D-temp', idempotentKey: 'key-d', text: null, pending: true })
-    )
-
-    echo(queryClient, { id: '01D', idempotentKey: 'key-d', text: null })
-
-    expect(idsInCache(queryClient)).toEqual(['01D'])
-  })
-
-  it('leaves pending messages alone when the echo carries no key', () => {
-    echo(queryClient, { id: '01E', idempotentKey: null })
-
-    expect(idsInCache(queryClient)).toEqual(['01E', '01B-temp', '01A-temp'])
-  })
-
-  it("leaves pending messages alone when the echo is someone else's", () => {
-    echo(queryClient, { id: '01F', idempotentKey: 'key-a', mine: false })
-
-    expect(idsInCache(queryClient)).toEqual(['01F', '01B-temp', '01A-temp'])
-  })
-})

package/src/utils/cache/__tests__/messages_cache_reply_roots.test.ts

@@ -1,70 +0,0 @@
-import { InfiniteData, QueryClient } from '@tanstack/react-query'
-import type { ApiCollection } from '../../../types'
-import type { MessageResource } from '../../../types/resources/message'
-import type { PersonResource } from '../../../types/resources/person'
-import { updateCacheReplyRoots } from '../messages_cache'
-
-const author = { id: 1, type: 'Person', name: 'A', avatar: null } as unknown as PersonResource
-
-const message = (id: string, overrides: Partial<MessageResource> = {}): MessageResource =>
-  ({
-    type: 'Message',
-    id,
-    text: `msg ${id}`,
-    html: '',
-    createdAt: '2026-01-01T00:00:00Z',
-    deletedAt: null,
-    textEditedAt: null,
-    mine: false,
-    attachments: [],
-    author,
-    reactionCounts: [],
-    replyCount: 0,
-    replyRootId: null,
-    messageType: 'message',
-    ...overrides,
-  }) as MessageResource
-
-const queryKey = ['messages']
-
-const seedPages = (queryClient: QueryClient, messages: MessageResource[]) => {
-  queryClient.setQueryData<InfiniteData<ApiCollection<MessageResource>>>(queryKey, {
-    pageParams: [{}],
-    pages: [{ data: messages, links: {}, meta: { count: messages.length, totalCount: 1 } }],
-  })
-}
-
-const pageMessages = (queryClient: QueryClient) =>
-  queryClient.getQueryData<InfiniteData<ApiCollection<MessageResource>>>(queryKey)!.pages[0].data
-
-describe('updateCacheReplyRoots', () => {
-  it('merges a root update into every reply carrying that root', () => {
-    const queryClient = new QueryClient()
-    const root = message('rootA', { replyRootId: 'rootA', text: 'before' })
-    seedPages(queryClient, [
-      message('03', { replyRootId: 'rootA', replyRoot: root }),
-      message('02', { replyRootId: 'rootB', replyRoot: message('rootB', { text: 'other' }) }),
-      message('01', { replyRootId: 'rootA', replyRoot: root }),
-    ])
-
-    updateCacheReplyRoots(
-      queryClient,
-      queryKey,
-      message('rootA', { replyRootId: 'rootA', text: 'after', deletedAt: '2026-01-02T00:00:00Z' })
-    )
-
-    const [newest, other, oldest] = pageMessages(queryClient)
-    expect(newest.replyRoot).toMatchObject({ text: 'after', deletedAt: '2026-01-02T00:00:00Z' })
-    expect(oldest.replyRoot).toMatchObject({ text: 'after' })
-    expect(other.replyRoot?.text).toBe('other')
-  })
-
-  it('ignores replies without an inline root', () => {
-    const queryClient = new QueryClient()
-    seedPages(queryClient, [message('01', { replyRootId: 'rootA' })])
-
-    updateCacheReplyRoots(queryClient, queryKey, message('rootA', { replyRootId: 'rootA' }))
-
-    expect(pageMessages(queryClient)[0].replyRoot).toBeUndefined()
-  })
-})

package/src/utils/client/__tests__/transform_response.test.ts

@@ -1,62 +0,0 @@
-import transformResponse from '../transform_response'
-
-const person = (id: string, name: string) => ({
-  type: 'Person',
-  id,
-  attributes: { name, avatar: null },
-})
-
-const message = (
-  id: string,
-  { authorId, replyRootId }: { authorId: string; replyRootId: string | null }
-) => ({
-  type: 'Message',
-  id,
-  attributes: { text: `msg ${id}` },
-  relationships: {
-    author: { data: { type: 'Person', id: authorId } },
-    reply_root: { data: replyRootId ? { type: 'Message', id: replyRootId } : null },
-    reaction_counts: { data: [] },
-  },
-})
-
-const root = message('01ROOT', { authorId: '2', replyRootId: '01ROOT' })
-const reply = message('01REPLY', { authorId: '1', replyRootId: '01ROOT' })
-
-describe('transformResponse — reply_root include', () => {
-  it('attaches the included root and its author to a reply', () => {
-    const result = transformResponse({
-      data: [reply],
-      included: [root, person('1', 'Replier'), person('2', 'Root Author')],
-    })
-
-    const [transformedReply] = result.data
-    expect(transformedReply.replyRootId).toBe('01ROOT')
-    expect(transformedReply.replyRoot.id).toBe('01ROOT')
-    expect(transformedReply.replyRoot.text).toBe('msg 01ROOT')
-    expect(transformedReply.replyRoot.author.name).toBe('Root Author')
-  })
-
-  it('drops a record’s self reference so the result stays acyclic', () => {
-    const result = transformResponse({
-      data: [reply, root],
-      included: [root, person('1', 'Replier'), person('2', 'Root Author')],
-    })
-
-    const [transformedReply, transformedRoot] = result.data
-    expect(transformedReply.replyRoot.replyRoot).toBeNull()
-    expect(transformedRoot.replyRootId).toBe('01ROOT')
-    expect(transformedRoot.replyRoot).toBeNull()
-    expect(() => JSON.stringify(result)).not.toThrow()
-  })
-
-  it('leaves replyRoot null when the root is not included', () => {
-    const result = transformResponse({
-      data: [reply],
-      included: [person('1', 'Replier')],
-    })
-
-    expect(result.data[0].replyRootId).toBe('01ROOT')
-    expect(result.data[0].replyRoot).toBeNull()
-  })
-})

package/src/utils/replace_equal_by_id.ts

@@ -1,42 +0,0 @@
-import { InfiniteData, replaceEqualDeep } from '@tanstack/react-query'
-import { ApiCollection, ResourceObject } from '../types'
-
-type Pages = InfiniteData<ApiCollection<ResourceObject>>
-
-/** replaceEqualById
- * TanStack's default structural sharing compares arrays by index, so an insert or
- * delete gives every shifted record a new identity. Match by id instead.
- */
-export function replaceEqualById(oldData: unknown, newData: unknown): unknown {
-  const prev = oldData as Pages | undefined
-  const next = newData as Pages
-  if (!prev?.pages || !next?.pages) return replaceEqualDeep(prev, next)
-
-  const prevById = new Map<ResourceObject['id'], ResourceObject>()
-  prev.pages.forEach(page => page.data.forEach(record => prevById.set(record.id, record)))
-
-  let changed = prev.pages.length !== next.pages.length
-  const pages = next.pages.map((page, index) => {
-    const prevPage = prev.pages[index]
-    const data = page.data.map(record => {
-      const previous = prevById.get(record.id)
-      return previous ? replaceEqualDeep(previous, record) : record
-    })
-    const links = replaceEqualDeep(prevPage?.links, page.links)
-    const meta = replaceEqualDeep(prevPage?.meta, page.meta)
-    const sameRecords =
-      !!prevPage &&
-      data.length === prevPage.data.length &&
-      data.every((record, i) => record === prevPage.data[i])
-
-    if (prevPage && sameRecords && links === prevPage.links && meta === prevPage.meta) {
-      return prevPage
-    }
-    changed = true
-    return { ...page, data, links, meta }
-  })
-  const pageParams = replaceEqualDeep(prev.pageParams, next.pageParams)
-
-  if (!changed && pageParams === prev.pageParams) return prev
-  return { ...next, pages, pageParams }
-}