@actuate-media/cms-admin 0.12.0 → 0.12.1

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/)
+  })
+})

package/src/__tests__/lib/slash-command.test.ts

@@ -0,0 +1,146 @@
+import { describe, it, expect } from 'vitest'
+import {
+  parseAiSlashCommand,
+  isAiSlashCommandInput,
+  orderedAiActions,
+} from '../../lib/slash-command.js'
+
+describe('parseAiSlashCommand', () => {
+  it('parses /ai rewrite <text>', () => {
+    expect(parseAiSlashCommand('/ai rewrite hello world')).toEqual({
+      action: 'rewrite',
+      text: 'hello world',
+    })
+  })
+
+  it('parses every canonical action', () => {
+    expect(parseAiSlashCommand('/ai expand foo')).toEqual({ action: 'expand', text: 'foo' })
+    expect(parseAiSlashCommand('/ai compress bar')).toEqual({ action: 'compress', text: 'bar' })
+    expect(parseAiSlashCommand('/ai proofread baz')).toEqual({ action: 'proofread', text: 'baz' })
+  })
+
+  it('is case-insensitive on both prefix and action', () => {
+    expect(parseAiSlashCommand('/AI Rewrite ALL CAPS')).toEqual({
+      action: 'rewrite',
+      text: 'ALL CAPS',
+    })
+    expect(parseAiSlashCommand('/Ai PROOFREAD x')).toEqual({ action: 'proofread', text: 'x' })
+  })
+
+  it('tolerates leading whitespace', () => {
+    expect(parseAiSlashCommand('   /ai rewrite x')).toEqual({ action: 'rewrite', text: 'x' })
+  })
+
+  it('returns empty text when nothing follows the action', () => {
+    expect(parseAiSlashCommand('/ai rewrite')).toEqual({ action: 'rewrite', text: '' })
+    expect(parseAiSlashCommand('/ai rewrite   ')).toEqual({ action: 'rewrite', text: '' })
+  })
+
+  it('trims surrounding whitespace from the payload', () => {
+    expect(parseAiSlashCommand('/ai rewrite   hello   ')).toEqual({
+      action: 'rewrite',
+      text: 'hello',
+    })
+  })
+
+  it('preserves interior whitespace in the payload', () => {
+    expect(parseAiSlashCommand('/ai rewrite hello   world')).toEqual({
+      action: 'rewrite',
+      text: 'hello   world',
+    })
+  })
+
+  it('returns null for unknown actions', () => {
+    expect(parseAiSlashCommand('/ai summarize foo')).toBeNull()
+    expect(parseAiSlashCommand('/ai delete foo')).toBeNull()
+  })
+
+  it('returns null for non-AI slash commands', () => {
+    expect(parseAiSlashCommand('/help')).toBeNull()
+    expect(parseAiSlashCommand('/admin x')).toBeNull()
+  })
+
+  it('returns null for plain input without a slash', () => {
+    expect(parseAiSlashCommand('ai rewrite hello')).toBeNull()
+    expect(parseAiSlashCommand('hello world')).toBeNull()
+    expect(parseAiSlashCommand('')).toBeNull()
+  })
+
+  it('returns null when /ai is the entire input', () => {
+    expect(parseAiSlashCommand('/ai')).toBeNull()
+    expect(parseAiSlashCommand('/ai   ')).toBeNull()
+  })
+
+  it('returns null for non-string inputs', () => {
+    // @ts-expect-error — runtime guard
+    expect(parseAiSlashCommand(null)).toBeNull()
+    // @ts-expect-error — runtime guard
+    expect(parseAiSlashCommand(undefined)).toBeNull()
+    // @ts-expect-error — runtime guard
+    expect(parseAiSlashCommand(42)).toBeNull()
+  })
+})
+
+describe('isAiSlashCommandInput', () => {
+  it('returns true while the user is mid-typing the prefix', () => {
+    expect(isAiSlashCommandInput('/')).toBe(true)
+    expect(isAiSlashCommandInput('/a')).toBe(true)
+    expect(isAiSlashCommandInput('/ai')).toBe(true)
+    expect(isAiSlashCommandInput('/ai ')).toBe(true)
+    expect(isAiSlashCommandInput('/ai re')).toBe(true)
+    expect(isAiSlashCommandInput('/ai rewrite something')).toBe(true)
+  })
+
+  it('returns true when the user typed AI with capitals', () => {
+    expect(isAiSlashCommandInput('/AI')).toBe(true)
+    expect(isAiSlashCommandInput('/Ai rew')).toBe(true)
+  })
+
+  it('returns false for ordinary text', () => {
+    expect(isAiSlashCommandInput('')).toBe(false)
+    expect(isAiSlashCommandInput('hello')).toBe(false)
+    expect(isAiSlashCommandInput('ai rewrite')).toBe(false)
+  })
+
+  it('returns false for non-AI slash inputs', () => {
+    expect(isAiSlashCommandInput('/help')).toBe(false)
+    expect(isAiSlashCommandInput('/bots')).toBe(false)
+  })
+})
+
+describe('orderedAiActions', () => {
+  it('returns the canonical order when nothing is parsed', () => {
+    expect(orderedAiActions('')).toEqual(['rewrite', 'expand', 'compress', 'proofread'])
+    expect(orderedAiActions('/ai')).toEqual(['rewrite', 'expand', 'compress', 'proofread'])
+  })
+
+  it('hoists the matched action to the front', () => {
+    expect(orderedAiActions('/ai compress foo')).toEqual([
+      'compress',
+      'rewrite',
+      'expand',
+      'proofread',
+    ])
+    expect(orderedAiActions('/ai proofread bar')).toEqual([
+      'proofread',
+      'rewrite',
+      'expand',
+      'compress',
+    ])
+  })
+
+  it('returns canonical order for an unknown action', () => {
+    expect(orderedAiActions('/ai summarize foo')).toEqual([
+      'rewrite',
+      'expand',
+      'compress',
+      'proofread',
+    ])
+  })
+
+  it('contains every canonical action exactly once', () => {
+    const result = orderedAiActions('/ai rewrite x')
+    expect(result.length).toBe(4)
+    expect(new Set(result).size).toBe(4)
+  })
+})