@actuate-media/cms-admin 0.11.0 → 0.12.1

package/src/__tests__/lib/comment-anchor.test.ts

@@ -0,0 +1,188 @@
+import { describe, expect, it } from 'vitest'
+import * as Y from 'yjs'
+
+import { decodeAnchor, encodeAnchor } from '../../lib/comment-anchor.js'
+
+/**
+ * Build a Yjs doc with a TipTap-style XmlFragment containing one
+ * paragraph element whose text is the supplied string. Returns both the
+ * doc and the `Y.XmlText` leaf so tests can anchor against the right
+ * type (`createRelativePositionFromTypeIndex` indexes characters when
+ * called against an `XmlText`/`Text`, and child slots when called
+ * against the `XmlFragment` / element).
+ */
+function makeDoc(text: string): { doc: Y.Doc; yText: Y.XmlText } {
+  const doc = new Y.Doc()
+  const fragment = doc.getXmlFragment('default')
+  const paragraph = new Y.XmlElement('paragraph')
+  const yText = new Y.XmlText(text)
+  paragraph.insert(0, [yText])
+  fragment.insert(0, [paragraph])
+  return { doc, yText }
+}
+
+describe('encodeAnchor', () => {
+  it('produces non-empty base64 strings for a valid selection', () => {
+    const { doc, yText } = makeDoc('Hello world')
+    const anchor = encodeAnchor({ doc, yType: yText, from: 0, to: 5 })
+    expect(anchor).not.toBeNull()
+    if (!anchor) return
+    expect(anchor.from.length).toBeGreaterThan(0)
+    expect(anchor.to.length).toBeGreaterThan(0)
+    expect(anchor.from).not.toBe(anchor.to)
+  })
+
+  it('returns null for an empty range', () => {
+    const { doc, yText } = makeDoc('Hello world')
+    expect(encodeAnchor({ doc, yType: yText, from: 3, to: 3 })).toBeNull()
+  })
+
+  it('returns null for an inverted range', () => {
+    const { doc, yText } = makeDoc('Hello world')
+    expect(encodeAnchor({ doc, yType: yText, from: 5, to: 1 })).toBeNull()
+  })
+
+  it('returns null when from < 0', () => {
+    const { doc, yText } = makeDoc('Hello world')
+    expect(encodeAnchor({ doc, yType: yText, from: -1, to: 5 })).toBeNull()
+  })
+
+  it('returns null when to > yType.length', () => {
+    const { doc, yText } = makeDoc('Hello world')
+    expect(encodeAnchor({ doc, yType: yText, from: 0, to: 999 })).toBeNull()
+  })
+
+  it('produces stable output for the same range called twice', () => {
+    const { doc, yText } = makeDoc('Hello world')
+    const a1 = encodeAnchor({ doc, yType: yText, from: 0, to: 5 })
+    const a2 = encodeAnchor({ doc, yType: yText, from: 0, to: 5 })
+    expect(a1).toEqual(a2)
+  })
+})
+
+describe('decodeAnchor — round trip', () => {
+  it('round-trips the original positions on an unchanged doc', () => {
+    const { doc, yText } = makeDoc('Hello world')
+    const anchor = encodeAnchor({ doc, yType: yText, from: 6, to: 11 })
+    expect(anchor).not.toBeNull()
+    if (!anchor) return
+    const resolved = decodeAnchor({ doc, anchor })
+    expect(resolved).not.toBeNull()
+    if (!resolved) return
+    expect(resolved.from).toBe(6)
+    expect(resolved.to).toBe(11)
+    expect(resolved.yType).toBe(yText)
+  })
+
+  it('returns null when the anchor blobs are not valid base64', () => {
+    const { doc } = makeDoc('Hello world')
+    expect(
+      decodeAnchor({
+        doc,
+        anchor: { from: 'not valid !@#$', to: 'also not !@#$' },
+      }),
+    ).toBeNull()
+  })
+})
+
+describe('decodeAnchor — survives concurrent edits', () => {
+  it('shifts the anchor right when text is inserted before it', () => {
+    const { doc, yText } = makeDoc('Hello world')
+    // Anchor "world" (chars 6..11).
+    const anchor = encodeAnchor({ doc, yType: yText, from: 6, to: 11 })
+    expect(anchor).not.toBeNull()
+    if (!anchor) return
+
+    // Prepend "Hey, " — five characters — to the text.
+    yText.insert(0, 'Hey, ')
+
+    const resolved = decodeAnchor({ doc, anchor })
+    expect(resolved).not.toBeNull()
+    if (!resolved) return
+    expect(yText.toString().slice(resolved.from, resolved.to)).toBe('world')
+  })
+
+  it('still resolves when text is appended after the anchor', () => {
+    const { doc, yText } = makeDoc('Hello world')
+    const anchor = encodeAnchor({ doc, yType: yText, from: 0, to: 5 })
+    expect(anchor).not.toBeNull()
+    if (!anchor) return
+
+    yText.insert(yText.length, '!')
+
+    const resolved = decodeAnchor({ doc, anchor })
+    expect(resolved).not.toBeNull()
+    if (!resolved) return
+    expect(yText.toString().slice(resolved.from, resolved.to)).toBe('Hello')
+  })
+
+  it('detaches (returns null) when the anchored text is deleted', () => {
+    const { doc, yText } = makeDoc('Hello world')
+    const anchor = encodeAnchor({ doc, yType: yText, from: 6, to: 11 })
+    expect(anchor).not.toBeNull()
+    if (!anchor) return
+
+    // Delete "world" — five chars starting at index 6.
+    yText.delete(6, 5)
+
+    const resolved = decodeAnchor({ doc, anchor })
+    // After deletion both ends collapse; we treat `from >= to` as detached
+    // so the panel can flag the comment as "anchor lost".
+    expect(resolved).toBeNull()
+  })
+
+  it('survives a sequence of inserts on both sides', () => {
+    const { doc, yText } = makeDoc('alpha beta gamma')
+    const anchor = encodeAnchor({ doc, yType: yText, from: 6, to: 10 }) // "beta"
+    expect(anchor).not.toBeNull()
+    if (!anchor) return
+
+    yText.insert(0, '>> ')
+    yText.insert(yText.length, ' <<')
+    yText.insert(0, '!')
+
+    const resolved = decodeAnchor({ doc, anchor })
+    expect(resolved).not.toBeNull()
+    if (!resolved) return
+    expect(yText.toString().slice(resolved.from, resolved.to)).toBe('beta')
+  })
+})
+
+describe('decodeAnchor — independent docs', () => {
+  it('survives transport between two clones (the multi-user scenario)', () => {
+    const a = makeDoc('Hello world')
+    const anchor = encodeAnchor({ doc: a.doc, yType: a.yText, from: 6, to: 11 })
+    expect(anchor).not.toBeNull()
+    if (!anchor) return
+
+    // Sync a fresh clone (the other client's doc) from author A's state.
+    const docB = new Y.Doc()
+    Y.applyUpdate(docB, Y.encodeStateAsUpdate(a.doc))
+
+    const resolved = decodeAnchor({ doc: docB, anchor })
+    expect(resolved).not.toBeNull()
+    if (!resolved) return
+    expect(resolved.from).toBe(6)
+    expect(resolved.to).toBe(11)
+  })
+
+  it('still resolves after the clone makes its own edit', () => {
+    const a = makeDoc('Hello world')
+    const anchor = encodeAnchor({ doc: a.doc, yType: a.yText, from: 6, to: 11 })
+    expect(anchor).not.toBeNull()
+    if (!anchor) return
+
+    const docB = new Y.Doc()
+    Y.applyUpdate(docB, Y.encodeStateAsUpdate(a.doc))
+    // Look up B's mirror of the same text node and edit it.
+    const fragmentB = docB.getXmlFragment('default')
+    const paragraphB = fragmentB.firstChild as Y.XmlElement
+    const yTextB = paragraphB.firstChild as Y.XmlText
+    yTextB.insert(0, 'Hey, ')
+
+    const resolved = decodeAnchor({ doc: docB, anchor })
+    expect(resolved).not.toBeNull()
+    if (!resolved) return
+    expect(yTextB.toString().slice(resolved.from, resolved.to)).toBe('world')
+  })
+})

package/src/__tests__/lib/comments-client.test.ts

@@ -0,0 +1,239 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+const cmsApiMock = vi.fn()
+vi.mock('../../lib/api.js', () => ({
+  cmsApi: (...args: unknown[]) => cmsApiMock(...args),
+}))
+
+const {
+  createComment,
+  deleteComment,
+  groupCommentsIntoThreads,
+  listComments,
+  reopenComment,
+  resolveComment,
+  updateComment,
+} = await import('../../lib/comments-client.js')
+import type { Comment } from '../../lib/comments-client.js'
+
+function commentRow(overrides: Partial<Comment> = {}): Comment {
+  return {
+    id: 'c-1',
+    documentId: 'doc-1',
+    parentId: null,
+    userId: 'user-1',
+    body: 'hi',
+    anchor: null,
+    resolvedAt: null,
+    resolvedById: null,
+    deletedAt: null,
+    createdAt: '2026-01-01T00:00:00.000Z',
+    updatedAt: '2026-01-01T00:00:00.000Z',
+    isResolved: false,
+    ...overrides,
+  }
+}
+
+beforeEach(() => {
+  cmsApiMock.mockReset()
+})
+
+describe('createComment', () => {
+  it('posts to the document scoped endpoint and unwraps the envelope', async () => {
+    const row = commentRow({ id: 'c-99', body: 'fresh' })
+    cmsApiMock.mockResolvedValueOnce({ data: row, status: 201 })
+
+    const out = await createComment({ documentId: 'doc-1', body: '  fresh  ' })
+    expect(out.ok).toBe(true)
+    if (!out.ok) return
+    expect(out.result.id).toBe('c-99')
+
+    expect(cmsApiMock).toHaveBeenCalledWith('/documents/doc-1/comments', {
+      method: 'POST',
+      body: JSON.stringify({ body: 'fresh' }),
+    })
+  })
+
+  it('forwards anchor + parentId when supplied', async () => {
+    cmsApiMock.mockResolvedValueOnce({ data: commentRow(), status: 201 })
+    await createComment({
+      documentId: 'doc-1',
+      body: 'reply',
+      anchor: { from: 'AQ==', to: 'Ag==' },
+      parentId: 'c-1',
+    })
+    const [, init] = cmsApiMock.mock.calls[0] as [string, RequestInit]
+    expect(JSON.parse(init.body as string)).toEqual({
+      body: 'reply',
+      anchor: { from: 'AQ==', to: 'Ag==' },
+      parentId: 'c-1',
+    })
+  })
+
+  it('rejects empty bodies before hitting the wire', async () => {
+    const out = await createComment({ documentId: 'doc-1', body: '   ' })
+    expect(out.ok).toBe(false)
+    expect(cmsApiMock).not.toHaveBeenCalled()
+  })
+
+  it('rejects missing documentId before hitting the wire', async () => {
+    const out = await createComment({ documentId: '', body: 'hi' })
+    expect(out.ok).toBe(false)
+    expect(cmsApiMock).not.toHaveBeenCalled()
+  })
+
+  it('URL-encodes documentIds with awkward characters', async () => {
+    cmsApiMock.mockResolvedValueOnce({ data: commentRow(), status: 201 })
+    await createComment({ documentId: 'doc with space/?', body: 'hi' })
+    expect(cmsApiMock).toHaveBeenCalledWith(
+      `/documents/${encodeURIComponent('doc with space/?')}/comments`,
+      expect.anything(),
+    )
+  })
+
+  it('propagates server errors as { ok: false }', async () => {
+    cmsApiMock.mockResolvedValueOnce({ error: 'CSRF rejected', status: 403 })
+    const out = await createComment({ documentId: 'doc-1', body: 'hi' })
+    expect(out.ok).toBe(false)
+    if (out.ok) return
+    expect(out.status).toBe(403)
+    expect(out.error).toBe('CSRF rejected')
+  })
+
+  it('falls back to a generic message when the server omits one', async () => {
+    cmsApiMock.mockResolvedValueOnce({ status: 500 })
+    const out = await createComment({ documentId: 'doc-1', body: 'hi' })
+    expect(out.ok).toBe(false)
+    if (out.ok) return
+    expect(out.error).toContain('500')
+  })
+})
+
+describe('listComments', () => {
+  it('GETs the document endpoint with no query when no filters are set', async () => {
+    cmsApiMock.mockResolvedValueOnce({ data: [commentRow()], status: 200 })
+    const out = await listComments('doc-1')
+    expect(out.ok).toBe(true)
+    expect(cmsApiMock).toHaveBeenCalledWith('/documents/doc-1/comments', { method: 'GET' })
+  })
+
+  it('appends ?includeResolved + ?includeDeleted + ?pageSize when set', async () => {
+    cmsApiMock.mockResolvedValueOnce({ data: [], status: 200 })
+    await listComments('doc-1', { includeResolved: true, includeDeleted: true, pageSize: 25 })
+    expect(cmsApiMock).toHaveBeenCalledWith(
+      '/documents/doc-1/comments?includeResolved=true&includeDeleted=true&pageSize=25',
+      { method: 'GET' },
+    )
+  })
+
+  it('rejects empty documentId before hitting the wire', async () => {
+    const out = await listComments('')
+    expect(out.ok).toBe(false)
+    expect(cmsApiMock).not.toHaveBeenCalled()
+  })
+
+  it('returns the data array unchanged', async () => {
+    const rows = [commentRow({ id: 'c-1' }), commentRow({ id: 'c-2' })]
+    cmsApiMock.mockResolvedValueOnce({ data: rows, status: 200 })
+    const out = await listComments('doc-1')
+    expect(out.ok).toBe(true)
+    if (!out.ok) return
+    expect(out.result.map((c) => c.id)).toEqual(['c-1', 'c-2'])
+  })
+})
+
+describe('updateComment / resolveComment / reopenComment / deleteComment', () => {
+  it('PATCHes the comment endpoint with the trimmed body', async () => {
+    cmsApiMock.mockResolvedValueOnce({ data: commentRow({ body: 'next' }), status: 200 })
+    await updateComment('c-1', '  next  ')
+    expect(cmsApiMock).toHaveBeenCalledWith('/comments/c-1', {
+      method: 'PATCH',
+      body: JSON.stringify({ body: 'next' }),
+    })
+  })
+
+  it('rejects empty bodies on update', async () => {
+    const out = await updateComment('c-1', '   ')
+    expect(out.ok).toBe(false)
+    expect(cmsApiMock).not.toHaveBeenCalled()
+  })
+
+  it('POSTs to /resolve and /reopen with an empty body', async () => {
+    cmsApiMock
+      .mockResolvedValueOnce({
+        data: commentRow({ resolvedAt: 'now', isResolved: true }),
+        status: 200,
+      })
+      .mockResolvedValueOnce({ data: commentRow(), status: 200 })
+
+    await resolveComment('c-1')
+    await reopenComment('c-1')
+
+    expect(cmsApiMock).toHaveBeenNthCalledWith(1, '/comments/c-1/resolve', {
+      method: 'POST',
+      body: '{}',
+    })
+    expect(cmsApiMock).toHaveBeenNthCalledWith(2, '/comments/c-1/reopen', {
+      method: 'POST',
+      body: '{}',
+    })
+  })
+
+  it('DELETEs the comment endpoint and returns the soft-deleted DTO', async () => {
+    cmsApiMock.mockResolvedValueOnce({
+      data: commentRow({ deletedAt: '2026-01-02T00:00:00.000Z' }),
+      status: 200,
+    })
+    const out = await deleteComment('c-1')
+    expect(out.ok).toBe(true)
+    if (!out.ok) return
+    expect(out.result.deletedAt).toBe('2026-01-02T00:00:00.000Z')
+    expect(cmsApiMock).toHaveBeenCalledWith('/comments/c-1', { method: 'DELETE' })
+  })
+
+  it('rejects missing id without hitting the wire', async () => {
+    expect((await updateComment('', 'x')).ok).toBe(false)
+    expect((await resolveComment('')).ok).toBe(false)
+    expect((await reopenComment('')).ok).toBe(false)
+    expect((await deleteComment('')).ok).toBe(false)
+    expect(cmsApiMock).not.toHaveBeenCalled()
+  })
+})
+
+describe('groupCommentsIntoThreads', () => {
+  it('returns roots in chronological order with their replies attached', () => {
+    const root1 = commentRow({
+      id: 'r-1',
+      createdAt: '2026-01-01T00:00:00.000Z',
+    })
+    const root2 = commentRow({
+      id: 'r-2',
+      createdAt: '2026-01-01T00:00:02.000Z',
+    })
+    const reply1 = commentRow({
+      id: 'reply-1',
+      parentId: 'r-1',
+      createdAt: '2026-01-01T00:00:01.000Z',
+    })
+    const reply2 = commentRow({
+      id: 'reply-2',
+      parentId: 'r-1',
+      createdAt: '2026-01-01T00:00:03.000Z',
+    })
+
+    const threads = groupCommentsIntoThreads([reply2, root1, root2, reply1])
+    expect(threads.map((t) => t.root.id)).toEqual(['r-1', 'r-2'])
+    expect(threads[0]!.replies.map((r) => r.id)).toEqual(['reply-1', 'reply-2'])
+    expect(threads[1]!.replies).toEqual([])
+  })
+
+  it('drops replies whose root is missing from the input', () => {
+    const orphan = commentRow({ id: 'orphan', parentId: 'missing-root' })
+    const threads = groupCommentsIntoThreads([orphan])
+    expect(threads).toEqual([])
+  })
+
+  it('handles an empty input', () => {
+    expect(groupCommentsIntoThreads([])).toEqual([])
+  })
+})

package/src/__tests__/lib/notifications-client.test.ts

@@ -0,0 +1,195 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const cmsApiMock = vi.fn()
+vi.mock('../../lib/api.js', () => ({
+  cmsApi: (...args: unknown[]) => cmsApiMock(...args),
+}))
+
+const {
+  listNotifications,
+  markAllNotificationsRead,
+  markNotificationRead,
+  notificationSummary,
+  unreadCount,
+} = await import('../../lib/notifications-client.js')
+import type { Notification } from '../../lib/notifications-client.js'
+
+function row(overrides: Partial<Notification> = {}): Notification {
+  return {
+    id: 'n-1',
+    userId: 'user-1',
+    kind: 'comment_reply',
+    documentId: 'doc-1',
+    commentId: 'c-1',
+    payload: {
+      kind: 'comment_reply',
+      actorId: 'someone',
+      actorName: 'Someone',
+      excerpt: 'hi',
+    },
+    readAt: null,
+    createdAt: '2026-01-01T00:00:00.000Z',
+    ...overrides,
+  }
+}
+
+beforeEach(() => {
+  cmsApiMock.mockReset()
+})
+
+describe('listNotifications', () => {
+  it('GETs /notifications without query when no options', async () => {
+    cmsApiMock.mockResolvedValueOnce({ data: [row()], status: 200 })
+    const out = await listNotifications()
+    expect(out.ok).toBe(true)
+    expect(cmsApiMock).toHaveBeenCalledWith('/notifications', { method: 'GET' })
+  })
+
+  it('appends ?includeRead and ?pageSize when set', async () => {
+    cmsApiMock.mockResolvedValueOnce({ data: [], status: 200 })
+    await listNotifications({ includeRead: true, pageSize: 25 })
+    expect(cmsApiMock).toHaveBeenCalledWith('/notifications?includeRead=true&pageSize=25', {
+      method: 'GET',
+    })
+  })
+
+  it('returns the data array unchanged', async () => {
+    const rows = [row({ id: 'a' }), row({ id: 'b' })]
+    cmsApiMock.mockResolvedValueOnce({ data: rows, status: 200 })
+    const out = await listNotifications()
+    expect(out.ok).toBe(true)
+    if (!out.ok) return
+    expect(out.result.map((n) => n.id)).toEqual(['a', 'b'])
+  })
+
+  it('propagates errors as { ok: false }', async () => {
+    cmsApiMock.mockResolvedValueOnce({ error: 'nope', status: 500 })
+    const out = await listNotifications()
+    expect(out.ok).toBe(false)
+    if (out.ok) return
+    expect(out.error).toBe('nope')
+    expect(out.status).toBe(500)
+  })
+})
+
+describe('unreadCount', () => {
+  it('returns the count from the envelope', async () => {
+    cmsApiMock.mockResolvedValueOnce({ data: { count: 7 }, status: 200 })
+    const out = await unreadCount()
+    expect(out.ok).toBe(true)
+    if (!out.ok) return
+    expect(out.result).toBe(7)
+  })
+
+  it('propagates failure when the server returns no data', async () => {
+    cmsApiMock.mockResolvedValueOnce({ status: 503 })
+    const out = await unreadCount()
+    expect(out.ok).toBe(false)
+  })
+})
+
+describe('markNotificationRead', () => {
+  it('POSTs to the id-specific endpoint', async () => {
+    cmsApiMock.mockResolvedValueOnce({ data: row({ readAt: 'now' }), status: 200 })
+    const out = await markNotificationRead('n-1')
+    expect(out.ok).toBe(true)
+    expect(cmsApiMock).toHaveBeenCalledWith('/notifications/n-1/read', {
+      method: 'POST',
+      body: '{}',
+    })
+  })
+
+  it('URL-encodes weird ids', async () => {
+    cmsApiMock.mockResolvedValueOnce({ data: row(), status: 200 })
+    await markNotificationRead('n/1?')
+    expect(cmsApiMock).toHaveBeenCalledWith(
+      `/notifications/${encodeURIComponent('n/1?')}/read`,
+      expect.anything(),
+    )
+  })
+
+  it('rejects an empty id without hitting the wire', async () => {
+    const out = await markNotificationRead('')
+    expect(out.ok).toBe(false)
+    expect(cmsApiMock).not.toHaveBeenCalled()
+  })
+})
+
+describe('markAllNotificationsRead', () => {
+  it('POSTs /notifications/read-all and returns the count', async () => {
+    cmsApiMock.mockResolvedValueOnce({ data: { count: 4 }, status: 200 })
+    const out = await markAllNotificationsRead()
+    expect(out.ok).toBe(true)
+    if (!out.ok) return
+    expect(out.result).toBe(4)
+    expect(cmsApiMock).toHaveBeenCalledWith('/notifications/read-all', {
+      method: 'POST',
+      body: '{}',
+    })
+  })
+
+  it('propagates a server error', async () => {
+    cmsApiMock.mockResolvedValueOnce({ error: 'CSRF', status: 403 })
+    const out = await markAllNotificationsRead()
+    expect(out.ok).toBe(false)
+  })
+})
+
+describe('notificationSummary', () => {
+  it('formats comment_reply with the actor + excerpt', () => {
+    expect(
+      notificationSummary(
+        row({
+          payload: {
+            kind: 'comment_reply',
+            actorId: 'a',
+            actorName: 'Alice',
+            excerpt: 'good point',
+          },
+        }),
+      ),
+    ).toBe('Alice replied: "good point"')
+  })
+
+  it('formats comment_resolved with rootExcerpt', () => {
+    expect(
+      notificationSummary(
+        row({
+          kind: 'comment_resolved',
+          payload: {
+            kind: 'comment_resolved',
+            actorId: 'a',
+            actorName: 'Bob',
+            rootExcerpt: 'fix this',
+          },
+        }),
+      ),
+    ).toBe('Bob resolved your thread: "fix this"')
+  })
+
+  it('formats comment_mention with excerpt', () => {
+    expect(
+      notificationSummary(
+        row({
+          kind: 'comment_mention',
+          payload: {
+            kind: 'comment_mention',
+            actorId: 'a',
+            actorName: 'Carol',
+            excerpt: 'cc @you',
+          },
+        }),
+      ),
+    ).toBe('Carol mentioned you: "cc @you"')
+  })
+
+  it('falls back to "Someone" when actorName is null', () => {
+    expect(
+      notificationSummary(
+        row({
+          payload: { kind: 'comment_reply', actorId: null, actorName: null, excerpt: 'x' },
+        }),
+      ),
+    ).toMatch(/^Someone replied/)
+  })
+})