@prenta/admin 1.5.1 → 1.6.0

package/src/__tests__/lib/workflow-chrome.test.ts

@@ -0,0 +1,125 @@
+import { describe, expect, it } from 'vitest'
+import { resolveWorkflowChrome } from '../../lib/workflow-chrome.js'
+
+const draft = {
+  stage: 'DRAFT' as const,
+  status: 'DRAFT' as const,
+  canEdit: true,
+}
+
+describe('resolveWorkflowChrome', () => {
+  it('author on draft sees Submit for review', () => {
+    expect(resolveWorkflowChrome({ ...draft, role: 'AUTHOR' })).toMatchObject({
+      primary: 'submit',
+      showRequestChanges: false,
+      showSchedule: false,
+      statusLabel: 'Draft',
+    })
+  })
+
+  it('editor on draft also submits — no one-click publish', () => {
+    expect(resolveWorkflowChrome({ ...draft, role: 'EDITOR' })).toMatchObject({
+      primary: 'submit',
+      showRequestChanges: false,
+      showSchedule: false,
+    })
+  })
+
+  it('author in review waits', () => {
+    const chrome = resolveWorkflowChrome({
+      stage: 'IN_REVIEW',
+      status: 'DRAFT',
+      role: 'AUTHOR',
+      canEdit: true,
+    })
+    expect(chrome.primary).toBe('waiting')
+    expect(chrome.waitingLabel).toBe('Waiting for review.')
+    expect(chrome.showRequestChanges).toBe(false)
+    expect(chrome.showSchedule).toBe(false)
+    expect(chrome.statusLabel).toBe('In review')
+  })
+
+  it('editor in review can approve, request changes, and schedule', () => {
+    expect(
+      resolveWorkflowChrome({
+        stage: 'IN_REVIEW',
+        status: 'DRAFT',
+        role: 'ADMIN',
+        canEdit: true,
+      }),
+    ).toMatchObject({
+      primary: 'approve',
+      showRequestChanges: true,
+      showSchedule: true,
+      statusLabel: 'In review',
+    })
+  })
+
+  it('does not stop on APPROVED — editor still approves', () => {
+    expect(
+      resolveWorkflowChrome({
+        stage: 'APPROVED',
+        status: 'DRAFT',
+        role: 'EDITOR',
+        canEdit: true,
+      }).primary,
+    ).toBe('approve')
+  })
+
+  it('treats status PUBLISHED as published even when stage is still DRAFT', () => {
+    const chrome = resolveWorkflowChrome({
+      stage: 'DRAFT',
+      status: 'PUBLISHED',
+      role: 'ADMIN',
+      canEdit: true,
+    })
+    expect(chrome.primary).toBeNull()
+    expect(chrome.showRequestChanges).toBe(false)
+    expect(chrome.showSchedule).toBe(false)
+    expect(chrome.statusLabel).toBe('Published')
+  })
+
+  it('shows Scheduled when status is SCHEDULED', () => {
+    const chrome = resolveWorkflowChrome({
+      stage: 'IN_REVIEW',
+      status: 'SCHEDULED',
+      role: 'EDITOR',
+      canEdit: true,
+    })
+    expect(chrome.primary).toBeNull()
+    expect(chrome.showSchedule).toBe(true)
+    expect(chrome.showRequestChanges).toBe(true)
+    expect(chrome.statusLabel).toBe('Scheduled')
+  })
+
+  it('scheduled reviewer actions do not require IN_REVIEW or APPROVED stage', () => {
+    expect(
+      resolveWorkflowChrome({
+        stage: 'DRAFT',
+        status: 'SCHEDULED',
+        role: 'EDITOR',
+        canEdit: true,
+      }),
+    ).toMatchObject({
+      primary: null,
+      showRequestChanges: true,
+      showSchedule: true,
+      statusLabel: 'Scheduled',
+    })
+  })
+
+  it('hides mutations when canEdit is false', () => {
+    expect(
+      resolveWorkflowChrome({
+        stage: 'DRAFT',
+        status: 'DRAFT',
+        role: 'AUTHOR',
+        canEdit: false,
+      }),
+    ).toMatchObject({
+      primary: null,
+      showRequestChanges: false,
+      showSchedule: false,
+    })
+  })
+})

package/src/__tests__/views/editor-top-bar.render.test.tsx

@@ -7,83 +7,80 @@ import { EditorTopBar } from '../../views/page-editor/EditorTopBar.js'
 const baseProps = {
   title: 'About',
   status: 'DRAFT' as const,
+  workflowStage: 'DRAFT' as const,
+  role: 'EDITOR',
   dirty: false,
   saveState: 'idle' as const,
   publishing: false,
   canEdit: true,
-  canPublish: true,
   viewport: 'wide' as const,
   onViewport: vi.fn(),
   onBack: vi.fn(),
   onOpenSettings: vi.fn(),
   onSaveDraft: vi.fn(),
-  onPublish: vi.fn(),
+  onSubmitForReview: vi.fn(),
+  onApprove: vi.fn(),
+  onRequestChanges: vi.fn(),
 }
 
-describe('EditorTopBar publish gating', () => {
-  it('disables Publish when publishReady is false and shows the blocking reason', () => {
-    render(
-      <EditorTopBar
-        {...baseProps}
-        publishReady={false}
-        publishDisabledReason="Add at least one visible section before publishing."
-      />,
-    )
-    const btn = screen.getByRole('button', { name: 'Publish' }) as HTMLButtonElement
-    expect(btn.disabled).toBe(true)
-    expect(btn.getAttribute('title')).toBe('Add at least one visible section before publishing.')
+describe('EditorTopBar review chrome', () => {
+  it('shows Submit for review on a draft, not Publish', () => {
+    render(<EditorTopBar {...baseProps} />)
+    expect(screen.getByRole('button', { name: 'Submit for review' })).toBeTruthy()
+    expect(screen.queryByRole('button', { name: 'Publish' })).toBeNull()
+    expect(screen.queryByRole('button', { name: 'Approve' })).toBeNull()
   })
 
-  it('enables Publish when the user can publish and the document is ready', () => {
-    render(<EditorTopBar {...baseProps} publishReady />)
-    expect((screen.getByRole('button', { name: 'Publish' }) as HTMLButtonElement).disabled).toBe(
-      false,
-    )
+  it('author in review sees Waiting for review and no Approve', () => {
+    render(<EditorTopBar {...baseProps} role="AUTHOR" workflowStage="IN_REVIEW" />)
+    expect(screen.getByText('Waiting for review.')).toBeTruthy()
+    expect(screen.queryByRole('button', { name: 'Approve' })).toBeNull()
+    expect(screen.getByLabelText('Status: In review')).toBeTruthy()
   })
 
-  it('stays disabled without publish permission even when publishReady', () => {
+  it('editor in review can Approve; Request changes opens the note dialog', () => {
+    const onApprove = vi.fn()
+    const onRequestChanges = vi.fn()
     render(
       <EditorTopBar
         {...baseProps}
-        canPublish={false}
+        workflowStage="IN_REVIEW"
         publishReady
-        publishDisabledReason="Should not show for role block"
+        onApprove={onApprove}
+        onRequestChanges={onRequestChanges}
       />,
     )
-    const btn = screen.getByRole('button', { name: 'Publish' }) as HTMLButtonElement
-    expect(btn.disabled).toBe(true)
-    expect(btn.getAttribute('title')).toBe('You do not have permission to publish')
+    fireEvent.click(screen.getByRole('button', { name: 'Approve' }))
+    expect(onApprove).toHaveBeenCalledOnce()
+    fireEvent.click(screen.getByRole('button', { name: 'Request changes' }))
+    expect(screen.getByRole('dialog', { name: 'Request changes' })).toBeTruthy()
+    fireEvent.click(screen.getByRole('button', { name: 'Send back' }))
+    expect(onRequestChanges).toHaveBeenCalledWith('')
   })
 
-  it('calls onPublish when enabled and clicked', () => {
-    const onPublish = vi.fn()
-    render(<EditorTopBar {...baseProps} publishReady onPublish={onPublish} />)
-    fireEvent.click(screen.getByRole('button', { name: 'Publish' }))
-    expect(onPublish).toHaveBeenCalledOnce()
+  it('disables Request changes while publishing', () => {
+    render(<EditorTopBar {...baseProps} workflowStage="IN_REVIEW" publishing publishReady />)
+    const btn = screen.getByRole('button', { name: 'Request changes' }) as HTMLButtonElement
+    expect(btn.disabled).toBe(true)
   })
 
-  it('shows Schedule when onSchedule is provided and calls it when ready', () => {
-    const onSchedule = vi.fn()
+  it('disables Approve when publishReady is false and shows the reason', () => {
     render(
       <EditorTopBar
         {...baseProps}
-        publishReady
-        scheduleReady
-        onSchedule={onSchedule}
-        scheduledAt="2026-07-11T16:00:00.000Z"
+        workflowStage="IN_REVIEW"
+        publishReady={false}
+        publishDisabledReason="Add at least one visible section before publishing."
       />,
     )
-    const btn = screen.getByRole('button', { name: 'Reschedule publish' })
-    expect((btn as HTMLButtonElement).disabled).toBe(false)
-    fireEvent.click(btn)
-    expect(onSchedule).toHaveBeenCalledOnce()
+    const btn = screen.getByRole('button', { name: 'Approve' }) as HTMLButtonElement
+    expect(btn.disabled).toBe(true)
+    expect(btn.getAttribute('title')).toBe('Add at least one visible section before publishing.')
   })
 
-  it('disables Schedule when scheduleReady is false', () => {
-    render(<EditorTopBar {...baseProps} publishReady scheduleReady={false} onSchedule={vi.fn()} />)
-    expect(
-      (screen.getByRole('button', { name: 'Schedule publish' }) as HTMLButtonElement).disabled,
-    ).toBe(true)
+  it('shows the reviewer note on a draft', () => {
+    render(<EditorTopBar {...baseProps} reviewNote="Need a stronger lede." />)
+    expect(screen.getByText('Reviewer note: Need a stronger lede.')).toBeTruthy()
   })
 })
 

package/src/__tests__/views/page-section-editor.test.tsx

@@ -103,6 +103,8 @@ function loadedPage(sections: Array<{ id: string; sectionType: string; name: str
     slug: 'home',
     path: '/home',
     status: 'DRAFT',
+    workflowStage: 'DRAFT',
+    reviewNote: null,
     sections: sections.map((s) => ({ ...s, visible: true, content: {}, settings: {} })),
     seoTitle: '',
     seoDescription: '',
@@ -181,6 +183,22 @@ describe('PageSectionEditor structure mode', () => {
     await screen.findByText('Sections')
     expect(screen.getByRole('button', { name: 'Version history' })).toBeTruthy()
   })
+
+  it('does not show Publish for an author on a draft', async () => {
+    fetchPageForEditor.mockResolvedValue(
+      loadedPage([{ id: 's1', sectionType: 'hero', name: 'Hero' }]),
+    )
+    render(
+      <PageSectionEditor
+        documentId="p1"
+        config={validConfig}
+        onNavigate={() => {}}
+        session={{ user: { role: 'AUTHOR' } }}
+      />,
+    )
+    await screen.findByText('Sections')
+    expect(screen.queryByRole('button', { name: 'Publish' })).toBeNull()
+  })
 })
 
 /**

package/src/__tests__/views/page-tab.render.test.tsx

@@ -11,6 +11,8 @@ const page: EditorPage = {
   slug: 'about',
   path: '/about',
   status: 'PUBLISHED',
+  workflowStage: 'PUBLISHED',
+  reviewNote: null,
   parentPageId: null,
   sections: [],
   seoTitle: '',

package/src/__tests__/views/post-fields-modal.render.test.tsx

@@ -43,6 +43,8 @@ function basePost(over: Partial<ModalProps['post']> = {}): ModalProps['post'] {
     category: '',
     tags: [],
     status: 'DRAFT',
+    workflowStage: 'DRAFT',
+    reviewNote: null,
     publishDate: null,
     scheduledAt: null,
     scheduledUnpublishAt: null,

package/src/__tests__/views/post-section-editor.test.tsx

@@ -53,6 +53,8 @@ function loadedPost(
     category: '',
     tags: [],
     status: 'DRAFT',
+    workflowStage: 'DRAFT',
+    reviewNote: null,
     publishDate: null,
     sections: sections.map((s) => ({ ...s, visible: true, content: {}, settings: {} })),
     seoTitle: '',

package/src/__tests__/views/post-tab.render.test.tsx

@@ -31,6 +31,8 @@ function basePost(over: Partial<EditorPost> = {}): EditorPost {
     category: '',
     tags: [],
     status: 'DRAFT',
+    workflowStage: 'DRAFT',
+    reviewNote: null,
     publishDate: null,
     scheduledAt: null,
     scheduledUnpublishAt: null,

package/src/components/RequestChangesDialog.tsx

@@ -0,0 +1,56 @@
+'use client'
+
+import { useRef, useState } from 'react'
+import { Modal } from './ui/Modal.js'
+import { Button } from './ui/Button.js'
+
+export function RequestChangesDialog({
+  open,
+  onClose,
+  onConfirm,
+}: {
+  open: boolean
+  onClose: () => void
+  onConfirm: (note: string) => void
+}) {
+  const [note, setNote] = useState('')
+  const inputRef = useRef<HTMLTextAreaElement>(null)
+  return (
+    <Modal
+      open={open}
+      onClose={onClose}
+      title="Request changes"
+      description="Optional note for the author. The page returns to draft."
+      initialFocusRef={inputRef}
+      actions={
+        <>
+          <Button variant="ghost" onClick={onClose}>
+            Cancel
+          </Button>
+          <Button
+            variant="primary"
+            onClick={() => {
+              onConfirm(note.trim())
+              setNote('')
+              onClose()
+            }}
+          >
+            Send back
+          </Button>
+        </>
+      }
+    >
+      <label className="text-foreground block text-sm font-medium" htmlFor="review-note">
+        Note
+      </label>
+      <textarea
+        id="review-note"
+        ref={inputRef}
+        value={note}
+        onChange={(e) => setNote(e.target.value)}
+        rows={4}
+        className="border-border bg-input-background mt-1 w-full rounded-md border px-3 py-2 text-sm"
+      />
+    </Modal>
+  )
+}

package/src/lib/page-editor-service.ts

@@ -39,6 +39,7 @@ import {
 import { validateSlug } from '@prenta/core/client'
 
 import { missingCollectionFields } from './collection-schema.js'
+import { SUBMIT_BEFORE_PUBLISH_ERROR, type WorkflowStage } from './workflow-chrome.js'
 
 export type { PageSection } from '@prenta/core/page-sections'
 
@@ -68,6 +69,8 @@ export interface EditorPage {
   slug: string
   path: string
   status: PageStatus
+  workflowStage: WorkflowStage
+  reviewNote: string | null
   /**
    * Parent page for the tree hierarchy (`data.parentPageId`), or null for
    * a top-level page. Preselected when arriving via "Add sub-page"
@@ -186,6 +189,8 @@ interface DocumentApiRow {
   title: string | null
   slug: string | null
   status: PageStatus
+  workflowStage?: WorkflowStage
+  reviewNote?: string | null
   publishedAt: string | null
   scheduledAt?: string | null
   scheduledUnpublishAt?: string | null
@@ -211,6 +216,8 @@ function rowToEditorPage(doc: DocumentApiRow): EditorPage {
     slug,
     path: typeof data.path === 'string' && data.path ? data.path : slug ? `/${slug}` : '/',
     status: doc.status ?? 'DRAFT',
+    workflowStage: (doc.workflowStage as WorkflowStage | undefined) ?? 'DRAFT',
+    reviewNote: typeof doc.reviewNote === 'string' ? doc.reviewNote : null,
     parentPageId:
       typeof data.parentPageId === 'string' && data.parentPageId ? data.parentPageId : null,
     // Preserve unknown (externally-managed) sections so the editor can show
@@ -290,17 +297,23 @@ export async function savePageDraft(page: EditorPage): Promise<EditorPage> {
   return rowToEditorPage(res.data)
 }
 
-/** Publish: persist the latest content and flip status to PUBLISHED. */
-export async function publishPage(page: EditorPage): Promise<EditorPage> {
-  const endpoint = page.id
-    ? `/collections/${PAGES_COLLECTION}/${page.id}`
-    : `/collections/${PAGES_COLLECTION}`
-  const res = await cmsApi<DocumentApiRow>(endpoint, {
-    method: page.id ? 'PUT' : 'POST',
-    body: toWriteBody(page, { status: 'PUBLISHED' }),
-  })
-  if (res.error || !res.data) throw new Error(res.error ?? 'Failed to publish page')
-  return rowToEditorPage(res.data)
+export async function transitionPageWorkflow(
+  page: EditorPage,
+  stage: WorkflowStage,
+  note?: string,
+): Promise<EditorPage> {
+  if (!page.id) throw new Error('Save the page before changing review state')
+  const res = await cmsApi<{ success: boolean }>(
+    `/collections/${PAGES_COLLECTION}/${page.id}/workflow`,
+    { method: 'POST', body: JSON.stringify({ stage, note }) },
+  )
+  if (res.error) throw new Error(res.error)
+  return fetchPageForEditor(page.id)
+}
+
+/** Leftover callers must not skip review — use `transitionPageWorkflow`. */
+export async function publishPage(_page: EditorPage): Promise<EditorPage> {
+  throw new Error(SUBMIT_BEFORE_PUBLISH_ERROR)
 }
 
 /**
@@ -314,6 +327,8 @@ export function emptyPage(parentPageId: string | null = null): EditorPage {
     slug: '',
     path: '',
     status: 'DRAFT',
+    workflowStage: 'DRAFT',
+    reviewNote: null,
     parentPageId,
     sections: [],
     seoTitle: '',

package/src/lib/post-editor-service.ts

@@ -21,6 +21,7 @@
  */
 import { cmsApi } from './api.js'
 import { missingCollectionFields } from './collection-schema.js'
+import { SUBMIT_BEFORE_PUBLISH_ERROR, type WorkflowStage } from './workflow-chrome.js'
 import {
   getSectionType,
   generateSectionId,
@@ -79,6 +80,8 @@ export interface EditorPost {
   /** Editorial tags as plain strings (stored as `[{ tag }]` rows, see {@link parseTags}). */
   tags: string[]
   status: PostStatus
+  workflowStage: WorkflowStage
+  reviewNote: string | null
   publishDate: string | null
   /** When set and status is SCHEDULED, the cron publishes at this time. */
   scheduledAt: string | null
@@ -199,6 +202,8 @@ interface DocumentApiRow {
   title: string | null
   slug: string | null
   status: PostStatus
+  workflowStage?: WorkflowStage
+  reviewNote?: string | null
   publishedAt: string | null
   scheduledAt?: string | null
   scheduledUnpublishAt?: string | null
@@ -263,6 +268,8 @@ function rowToEditorPost(postType: string, doc: DocumentApiRow): EditorPost {
     category: dataStr(data, 'category'),
     tags: parseTags(data.tags),
     status: doc.status ?? 'DRAFT',
+    workflowStage: (doc.workflowStage as WorkflowStage | undefined) ?? 'DRAFT',
+    reviewNote: typeof doc.reviewNote === 'string' ? doc.reviewNote : null,
     publishDate: (data.publishDate as string) ?? doc.scheduledAt ?? null,
     scheduledAt: doc.scheduledAt ?? null,
     scheduledUnpublishAt: doc.scheduledUnpublishAt ?? null,
@@ -410,16 +417,23 @@ export async function savePostDraft(post: EditorPost): Promise<EditorPost> {
   return rowToEditorPost(post.postType, res.data)
 }
 
-export async function publishPost(post: EditorPost): Promise<EditorPost> {
-  const endpoint = post.id
-    ? `/collections/${encodeURIComponent(post.postType)}/${post.id}`
-    : `/collections/${encodeURIComponent(post.postType)}`
-  const res = await cmsApi<DocumentApiRow>(endpoint, {
-    method: post.id ? 'PUT' : 'POST',
-    body: toWriteBody(post, { status: 'PUBLISHED' }),
-  })
-  if (res.error || !res.data) throw new Error(res.error ?? 'Failed to publish post')
-  return rowToEditorPost(post.postType, res.data)
+export async function transitionPostWorkflow(
+  post: EditorPost,
+  stage: WorkflowStage,
+  note?: string,
+): Promise<EditorPost> {
+  if (!post.id) throw new Error('Save the post before changing review state')
+  const res = await cmsApi<{ success: boolean }>(
+    `/collections/${encodeURIComponent(post.postType)}/${post.id}/workflow`,
+    { method: 'POST', body: JSON.stringify({ stage, note }) },
+  )
+  if (res.error) throw new Error(res.error)
+  return fetchPostForEditor(post.postType, post.id)
+}
+
+/** Leftover callers must not skip review — use `transitionPostWorkflow`. */
+export async function publishPost(_post: EditorPost): Promise<EditorPost> {
+  throw new Error(SUBMIT_BEFORE_PUBLISH_ERROR)
 }
 
 /** A blank post scaffold seeded with the post type's template sections. */
@@ -447,6 +461,8 @@ export async function emptyPostFromTemplate(postType: string): Promise<EditorPos
     category: '',
     tags: [],
     status: 'DRAFT',
+    workflowStage: 'DRAFT',
+    reviewNote: null,
     publishDate: null,
     scheduledAt: null,
     scheduledUnpublishAt: null,

package/src/lib/workflow-chrome.ts

@@ -0,0 +1,105 @@
+export type WorkflowStage = 'DRAFT' | 'IN_REVIEW' | 'APPROVED' | 'ARCHIVED' | 'PUBLISHED'
+
+export type WorkflowChromeAction = 'submit' | 'approve' | 'waiting'
+
+export const SUBMIT_FOR_REVIEW_LABEL = 'Submit for review'
+export const APPROVE_LABEL = 'Approve'
+export const REQUEST_CHANGES_LABEL = 'Request changes'
+export const WAITING_FOR_REVIEW_LABEL = 'Waiting for review.'
+export const REVIEWER_NOTE_PREFIX = 'Reviewer note:'
+export const SUBMIT_BEFORE_PUBLISH_ERROR = 'Submit for review before publishing.'
+
+const REVIEWER_ROLES = new Set(['ADMIN', 'EDITOR'])
+const SUBMIT_ROLES = new Set(['ADMIN', 'EDITOR', 'AUTHOR'])
+
+const STATUS_PILL: Record<WorkflowStage | 'SCHEDULED', { label: string; className: string }> = {
+  DRAFT: { label: 'Draft', className: 'text-warning' },
+  IN_REVIEW: { label: 'In review', className: 'text-warning' },
+  APPROVED: { label: 'Approved', className: 'text-warning' },
+  PUBLISHED: { label: 'Published', className: 'text-success' },
+  ARCHIVED: { label: 'Archived', className: 'text-muted-foreground' },
+  SCHEDULED: { label: 'Scheduled', className: 'text-warning' },
+}
+
+export function resolveWorkflowChrome(input: {
+  stage: WorkflowStage
+  status: 'DRAFT' | 'PUBLISHED' | 'SCHEDULED' | 'ARCHIVED'
+  role: string
+  canEdit: boolean
+}): {
+  primary: WorkflowChromeAction | null
+  showRequestChanges: boolean
+  showSchedule: boolean
+  waitingLabel?: string
+  statusLabel: string
+  statusClassName: string
+} {
+  const role = input.role.toUpperCase()
+  const published = input.status === 'PUBLISHED'
+  const scheduled = input.status === 'SCHEDULED'
+  const pillKey = published ? 'PUBLISHED' : scheduled ? 'SCHEDULED' : input.stage
+  const pill = STATUS_PILL[pillKey]
+
+  if (!input.canEdit || published) {
+    return {
+      primary: null,
+      showRequestChanges: false,
+      showSchedule: false,
+      statusLabel: pill.label,
+      statusClassName: pill.className,
+    }
+  }
+
+  const reviewer = REVIEWER_ROLES.has(role)
+  const canSubmit = SUBMIT_ROLES.has(role)
+  const inReview = input.stage === 'IN_REVIEW' || input.stage === 'APPROVED'
+
+  if (scheduled) {
+    return {
+      primary: null,
+      showRequestChanges: reviewer,
+      showSchedule: reviewer,
+      statusLabel: pill.label,
+      statusClassName: pill.className,
+    }
+  }
+
+  if (input.stage === 'DRAFT' && canSubmit) {
+    return {
+      primary: 'submit',
+      showRequestChanges: false,
+      showSchedule: false,
+      statusLabel: pill.label,
+      statusClassName: pill.className,
+    }
+  }
+
+  if (inReview && reviewer) {
+    return {
+      primary: 'approve',
+      showRequestChanges: true,
+      showSchedule: true,
+      statusLabel: pill.label,
+      statusClassName: pill.className,
+    }
+  }
+
+  if (inReview && canSubmit) {
+    return {
+      primary: 'waiting',
+      showRequestChanges: false,
+      showSchedule: false,
+      waitingLabel: WAITING_FOR_REVIEW_LABEL,
+      statusLabel: pill.label,
+      statusClassName: pill.className,
+    }
+  }
+
+  return {
+    primary: null,
+    showRequestChanges: false,
+    showSchedule: false,
+    statusLabel: pill.label,
+    statusClassName: pill.className,
+  }
+}