@prenta/admin 1.5.1 → 1.6.1

package/src/__tests__/lib/page-editor-service-api.test.ts

@@ -9,8 +9,14 @@ vi.mock('../../lib/api.js', () => ({
   cmsApi: (...args: unknown[]) => cmsApi(...args),
 }))
 
-const { fetchPageForEditor, savePageDraft, publishPage, missingPageFields, emptyPage } =
-  await import('../../lib/page-editor-service.js')
+const {
+  fetchPageForEditor,
+  savePageDraft,
+  publishPage,
+  transitionPageWorkflow,
+  missingPageFields,
+  emptyPage,
+} = await import('../../lib/page-editor-service.js')
 
 afterEach(() => {
   cmsApi.mockReset()
@@ -188,18 +194,34 @@ describe('savePageDraft', () => {
   })
 })
 
-describe('publishPage', () => {
-  it('includes status: PUBLISHED in the payload', async () => {
-    cmsApi.mockResolvedValue({
-      data: { id: 'p1', title: 'About', slug: 'about', status: 'PUBLISHED', data: {} },
+describe('transitionPageWorkflow', () => {
+  it('transitionPageWorkflow POSTs stage to /workflow then reloads the page', async () => {
+    cmsApi.mockResolvedValueOnce({ data: { success: true }, status: 200 }).mockResolvedValueOnce({
+      data: {
+        id: 'p1',
+        title: 'About',
+        slug: 'about',
+        status: 'DRAFT',
+        workflowStage: 'IN_REVIEW',
+        reviewNote: null,
+        data: {},
+      },
       status: 200,
     })
 
-    await publishPage(draft('p1'))
+    const next = await transitionPageWorkflow(draft('p1'), 'IN_REVIEW')
+    expect(cmsApi.mock.calls[0]![0]).toBe('/collections/pages/p1/workflow')
+    expect(JSON.parse((cmsApi.mock.calls[0]![1] as RequestInit).body as string)).toEqual({
+      stage: 'IN_REVIEW',
+    })
+    expect(next.workflowStage).toBe('IN_REVIEW')
+  })
+})
 
-    const [, opts] = cmsApi.mock.calls[0] as [string, RequestInit]
-    const body = JSON.parse(opts.body as string)
-    expect(body.status).toBe('PUBLISHED')
+describe('publishPage', () => {
+  it('publishPage refuses to skip review', async () => {
+    await expect(publishPage(draft('p1'))).rejects.toThrow(/Submit for review before publishing/)
+    expect(cmsApi).not.toHaveBeenCalled()
   })
 })
 
@@ -282,13 +304,10 @@ describe('section settings survive a save', () => {
     expect(body.sections[0].settings).toEqual(styled.settings)
   })
 
-  it('round-trips them through publish too', async () => {
-    cmsApi.mockResolvedValue({ data: { id: 'p1', data: {} } })
-
-    await publishPage({ ...draft('p1'), sections: [styled] })
-
-    const body = JSON.parse((cmsApi.mock.calls[0]![1] as { body: string }).body)
-    expect(body.sections[0].settings).toEqual(styled.settings)
-    expect(body.status).toBe('PUBLISHED')
+  it('does not persist via publishPage (review gate)', async () => {
+    await expect(publishPage({ ...draft('p1'), sections: [styled] })).rejects.toThrow(
+      /Submit for review before publishing/,
+    )
+    expect(cmsApi).not.toHaveBeenCalled()
   })
 })

package/src/__tests__/lib/post-editor-service-api.test.ts

@@ -0,0 +1,74 @@
+// @vitest-environment node
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+// Mock the network layer so we can assert on request shape (endpoint,
+// method, body) and drive responses. This is the class of bug — response
+// unwrapping and write-payload drift — these tests exist to catch.
+const cmsApi = vi.fn()
+vi.mock('../../lib/api.js', () => ({
+  cmsApi: (...args: unknown[]) => cmsApi(...args),
+}))
+
+const { transitionPostWorkflow, publishPost } = await import('../../lib/post-editor-service.js')
+
+afterEach(() => {
+  cmsApi.mockReset()
+})
+
+function draft(id: string | null) {
+  return {
+    id,
+    postType: 'blog',
+    title: 'Hello',
+    slug: 'hello',
+    excerpt: '',
+    featuredImage: '',
+    featuredImageUrl: '',
+    body: '',
+    category: '',
+    tags: [],
+    status: 'DRAFT' as const,
+    workflowStage: 'DRAFT' as const,
+    reviewNote: null,
+    publishDate: null,
+    scheduledAt: null,
+    scheduledUnpublishAt: null,
+    sections: [],
+    seoTitle: '',
+    seoDescription: '',
+    publishedAt: null,
+    updatedAt: null,
+  }
+}
+
+describe('transitionPostWorkflow', () => {
+  it('transitionPostWorkflow POSTs stage to /workflow then reloads the post', async () => {
+    cmsApi.mockResolvedValueOnce({ data: { success: true }, status: 200 }).mockResolvedValueOnce({
+      data: {
+        id: 'p1',
+        title: 'Hello',
+        slug: 'hello',
+        status: 'DRAFT',
+        workflowStage: 'IN_REVIEW',
+        reviewNote: null,
+        data: {},
+      },
+      status: 200,
+    })
+
+    const next = await transitionPostWorkflow(draft('p1'), 'IN_REVIEW')
+    expect(cmsApi.mock.calls[0]![0]).toBe('/collections/blog/p1/workflow')
+    expect(JSON.parse((cmsApi.mock.calls[0]![1] as RequestInit).body as string)).toEqual({
+      stage: 'IN_REVIEW',
+    })
+    expect(cmsApi.mock.calls[1]![0]).toBe('/collections/blog/p1')
+    expect(next.workflowStage).toBe('IN_REVIEW')
+  })
+})
+
+describe('publishPost', () => {
+  it('publishPost refuses to skip review', async () => {
+    await expect(publishPost(draft('p1'))).rejects.toThrow(/Submit for review before publishing/)
+    expect(cmsApi).not.toHaveBeenCalled()
+  })
+})

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

@@ -17,6 +17,7 @@ const {
   missingPostFields,
   savePostDraft,
   parseFeaturedImage,
+  parseFeaturedImageRef,
 } = await import('../../lib/post-editor-service.js')
 
 type EditorPostT = Awaited<ReturnType<typeof emptyPostFromTemplate>>
@@ -29,10 +30,13 @@ function basePost(over: Partial<EditorPostT> = {}): EditorPostT {
     slug: 'hello',
     excerpt: '',
     featuredImage: '',
+    featuredImageUrl: '',
     body: '',
     category: '',
     tags: [],
     status: 'DRAFT',
+    workflowStage: 'DRAFT',
+    reviewNote: null,
     publishDate: null,
     scheduledAt: null,
     scheduledUnpublishAt: null,
@@ -492,21 +496,34 @@ describe('tags round-trip', () => {
     expect(post.tags).toEqual(['AI', 'Nextjs'])
   })
 
+  it('parseFeaturedImageRef splits persist id from display url', () => {
+    const mediaId = 'cmry1z9yr000004l832th7bf2'
+    const url = 'https://cdn.example.com/hero.webp'
+    expect(parseFeaturedImageRef({ id: mediaId, url, alt: 'Hero' })).toEqual({
+      id: mediaId,
+      url,
+    })
+    expect(parseFeaturedImageRef(mediaId)).toEqual({ id: mediaId, url: '' })
+    expect(parseFeaturedImageRef(url)).toEqual({ id: url, url })
+    expect(parseFeaturedImageRef({ publicUrl: url })).toEqual({ id: url, url })
+    expect(parseFeaturedImageRef({ src: '/uploads/hero.webp' })).toEqual({
+      id: '/uploads/hero.webp',
+      url: '/uploads/hero.webp',
+    })
+  })
+
   it('parseFeaturedImage / fetchPostForEditor keep denormalized media objects (#671)', async () => {
     const mediaId = 'cmry1z9yr000004l832th7bf2'
+    const url = 'https://cdn.example.com/hero.webp'
     expect(
       parseFeaturedImage({
         id: mediaId,
-        url: 'https://cdn.example.com/hero.webp',
+        url,
         alt: 'Hero',
       }),
     ).toBe(mediaId)
-    expect(parseFeaturedImage('https://cdn.example.com/hero.webp')).toBe(
-      'https://cdn.example.com/hero.webp',
-    )
-    expect(parseFeaturedImage({ url: 'https://cdn.example.com/hero.webp' })).toBe(
-      'https://cdn.example.com/hero.webp',
-    )
+    expect(parseFeaturedImage(url)).toBe(url)
+    expect(parseFeaturedImage({ url })).toBe(url)
 
     cmsApiMock.mockResolvedValueOnce({
       data: {
@@ -517,7 +534,7 @@ describe('tags round-trip', () => {
         data: {
           featuredImage: {
             id: mediaId,
-            url: 'https://cdn.example.com/hero.webp',
+            url,
             alt: 'Hero',
           },
         },
@@ -525,16 +542,18 @@ describe('tags round-trip', () => {
     })
     const post = await fetchPostForEditor('blog', 'p1')
     expect(post.featuredImage).toBe(mediaId)
+    expect(post.featuredImageUrl).toBe(url)
 
     cmsApiMock.mockResolvedValueOnce({
       data: { id: 'p1', title: 'Hello', slug: 'hello', status: 'DRAFT', data: {} },
     })
-    await savePostDraft(basePost({ id: 'p1', featuredImage: mediaId }))
+    await savePostDraft(basePost({ id: 'p1', featuredImage: mediaId, featuredImageUrl: url }))
     const body = JSON.parse(cmsApiMock.mock.calls[1]![1].body as string) as {
       featuredImage: string
     }
     expect(body.featuredImage).toBe(mediaId)
     expect(body.featuredImage).not.toBe('')
+    expect(body).not.toHaveProperty('featuredImageUrl')
   })
 })
 

package/src/__tests__/lib/version-history.test.ts

@@ -60,6 +60,35 @@ describe('toPageVersion', () => {
     expect(mapped.body).toBe('<p>Snapshot body</p>')
   })
 
+  it('does not treat a bare media id as a canvas preview URL', () => {
+    const mapped = toPageVersion({
+      id: 'v1',
+      changeType: 'UPDATE',
+      createdAt: '2026-08-02T12:00:00Z',
+      data: {
+        featuredImage: 'cmssbdfxo000004jrzphzt2bj',
+        sections: [],
+      },
+    })
+    expect(mapped.featuredImage).toBeUndefined()
+  })
+
+  it('prefers the public URL over the media id on a denormalized snapshot', () => {
+    const mapped = toPageVersion({
+      id: 'v1',
+      changeType: 'UPDATE',
+      createdAt: '2026-08-02T12:00:00Z',
+      data: {
+        featuredImage: {
+          id: 'cmssbdfxo000004jrzphzt2bj',
+          url: 'https://cdn.example.com/hero.webp',
+        },
+        sections: [],
+      },
+    })
+    expect(mapped.featuredImage).toBe('https://cdn.example.com/hero.webp')
+  })
+
   it('preserves an unmanaged section rather than dropping it from the snapshot', () => {
     // Coercing a snapshot more strictly than the live document reads would
     // make an externally-managed section look deleted in every version.

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

@@ -39,10 +39,13 @@ function basePost(over: Partial<ModalProps['post']> = {}): ModalProps['post'] {
     slug: 'hello',
     excerpt: '',
     featuredImage: '',
+    featuredImageUrl: '',
     body: '',
     category: '',
     tags: [],
     status: 'DRAFT',
+    workflowStage: 'DRAFT',
+    reviewNote: null,
     publishDate: null,
     scheduledAt: null,
     scheduledUnpublishAt: null,
@@ -173,4 +176,42 @@ describe('PostFieldsModal', () => {
     expect(onClose).toHaveBeenCalledTimes(1)
     expect(screen.queryByRole('dialog', { name: 'Discard unsaved changes?' })).toBeNull()
   })
+
+  it('previews the featured image URL, not the stored media id', () => {
+    const mediaId = 'cmssbdfxo000004jrzphzt2bj'
+    const url = 'https://cdn.example.com/hero.webp'
+    render(
+      <PostFieldsModal
+        open
+        post={basePost({ featuredImage: mediaId, featuredImageUrl: url })}
+        canEdit
+        onClose={() => {}}
+        onSave={() => {}}
+      />,
+    )
+    const input = screen.getByLabelText('Featured image') as HTMLInputElement
+    expect(input.value).toBe(url)
+    expect(input.value).not.toBe(mediaId)
+    const preview = document.querySelector('img')
+    expect(preview?.getAttribute('src')).toBe(url)
+  })
+
+  it('saves the media id when the input is showing the public URL', () => {
+    const onSave = vi.fn()
+    const mediaId = 'cmssbdfxo000004jrzphzt2bj'
+    const url = 'https://cdn.example.com/hero.webp'
+    render(
+      <PostFieldsModal
+        open
+        post={basePost({ featuredImage: mediaId, featuredImageUrl: url })}
+        canEdit
+        onClose={() => {}}
+        onSave={onSave}
+      />,
+    )
+    fireEvent.click(screen.getByRole('button', { name: 'Done' }))
+    expect(onSave).toHaveBeenCalledWith(
+      expect.objectContaining({ featuredImage: mediaId, featuredImageUrl: url }),
+    )
+  })
 })

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

@@ -49,10 +49,13 @@ function loadedPost(
     slug: 'logan',
     excerpt: '',
     featuredImage: '',
+    featuredImageUrl: '',
     body: '',
     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

@@ -27,10 +27,13 @@ function basePost(over: Partial<EditorPost> = {}): EditorPost {
     slug: 'hello',
     excerpt: 'A short summary.',
     featuredImage: '',
+    featuredImageUrl: '',
     body: '',
     category: '',
     tags: [],
     status: 'DRAFT',
+    workflowStage: 'DRAFT',
+    reviewNote: null,
     publishDate: null,
     scheduledAt: null,
     scheduledUnpublishAt: null,