@actuate-media/cms-admin 0.42.1 → 0.42.4

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

@@ -11,7 +11,9 @@ const {
   validatePost,
   validateTemplate,
   emptyPostFromTemplate,
+  fetchPostForEditor,
   fetchTemplateForEditor,
+  missingPostFields,
   savePostDraft,
 } = await import('../../lib/post-editor-service.js')
 
@@ -89,6 +91,30 @@ describe('validatePost', () => {
     expect(r.warnings.some((w) => w.includes('SEO title'))).toBe(true)
   })
 
+  it('does not block publish on unmanaged (externally-managed) sections', () => {
+    const r = validatePost(
+      basePost({
+        seoTitle: 'T',
+        seoDescription: 'D',
+        sections: [
+          // No registered definition for `opal-hero` → validateSectionContent
+          // would report "Unknown section type"; the unmanaged flag must skip it.
+          {
+            id: 's1',
+            sectionType: 'opal-hero',
+            name: 'Opal Hero',
+            visible: true,
+            content: { heading: 'Hi' },
+            settings: {},
+            unmanaged: true,
+          },
+        ],
+      }),
+      true,
+    )
+    expect(r.errors).toEqual([])
+  })
+
   it('skips hidden sections during publish validation', () => {
     const r = validatePost(
       basePost({
@@ -240,6 +266,116 @@ describe('saveTemplate', () => {
   })
 })
 
+describe('unmanaged section round-trip (data-loss regression)', () => {
+  // The old service coerced sections with the default `'drop'` strategy, so a
+  // post containing a section type unknown to the admin bundle (e.g. a custom
+  // `opal-*` type missing from config) lost those sections on open + save.
+  const OPAL_SECTION = {
+    id: 'op1',
+    sectionType: 'opal-prose-band',
+    name: 'Prose Band',
+    visible: true,
+    content: { html: '<p>kept</p>' },
+    settings: { paddingY: 'lg' as const },
+  }
+
+  it('fetchPostForEditor preserves unknown section types as unmanaged', async () => {
+    cmsApiMock.mockResolvedValueOnce({
+      data: {
+        id: 'p1',
+        title: 'Logan',
+        slug: 'logan',
+        status: 'PUBLISHED',
+        data: {
+          sections: [
+            OPAL_SECTION,
+            { id: 'q1', sectionType: 'quote', name: 'Q', visible: true, content: {}, settings: {} },
+          ],
+        },
+      },
+    })
+    const post = await fetchPostForEditor('locations', 'p1')
+    expect(post.sections.map((s) => s.sectionType)).toEqual(['opal-prose-band', 'quote'])
+    const opal = post.sections[0]!
+    expect(opal.unmanaged).toBe(true)
+    // content/settings survive verbatim
+    expect(opal.content).toEqual({ html: '<p>kept</p>' })
+  })
+
+  it('savePostDraft round-trips unmanaged sections, stripping the derived marker', async () => {
+    cmsApiMock.mockResolvedValueOnce({
+      data: { id: 'p1', title: 'Logan', slug: 'logan', status: 'DRAFT', data: { sections: [] } },
+    })
+    await savePostDraft(
+      basePost({
+        postType: 'locations',
+        sections: [{ ...OPAL_SECTION, unmanaged: true }],
+      }),
+    )
+    const [, init] = cmsApiMock.mock.calls[0]!
+    const body = JSON.parse(init.body as string)
+    expect(body.sections).toHaveLength(1)
+    expect(body.sections[0].sectionType).toBe('opal-prose-band')
+    expect(body.sections[0].content).toEqual({ html: '<p>kept</p>' })
+    // The marker is derived from the registry on read — never persisted.
+    expect('unmanaged' in body.sections[0]).toBe(false)
+  })
+
+  it('fetchTemplateForEditor preserves unknown section types in templates', async () => {
+    cmsApiMock.mockResolvedValueOnce({
+      data: { postType: 'locations', docId: 'tmpl-1', header: {}, sections: [OPAL_SECTION] },
+    })
+    const t = await fetchTemplateForEditor('locations')
+    expect(t.sections).toHaveLength(1)
+    expect(t.sections[0]!.unmanaged).toBe(true)
+  })
+
+  it('emptyPostFromTemplate clones unmanaged template sections without throwing', async () => {
+    // `createSection` throws for unregistered types — the clone must not use it.
+    cmsApiMock.mockResolvedValueOnce({
+      data: { postType: 'locations', docId: 'tmpl-1', header: {}, sections: [OPAL_SECTION] },
+    })
+    const post = await emptyPostFromTemplate('locations')
+    expect(post.sections).toHaveLength(1)
+    expect(post.sections[0]!.sectionType).toBe('opal-prose-band')
+    expect(post.sections[0]!.id).not.toBe('op1')
+  })
+})
+
+describe('missingPostFields (schema guard)', () => {
+  const FULL_FIELDS = {
+    title: { type: 'text' },
+    slug: { type: 'slug' },
+    sections: { type: 'json' },
+    excerpt: { type: 'text' },
+    featuredImage: { type: 'media' },
+    body: { type: 'richText' },
+    category: { type: 'text' },
+    publishDate: { type: 'date' },
+    metaTitle: { type: 'text' },
+    metaDescription: { type: 'text' },
+  }
+
+  it('returns [] for a fully-declared post-type collection', () => {
+    const config = { collections: { blog: { slug: 'blog', fields: FULL_FIELDS } } }
+    expect(missingPostFields(config, 'blog')).toEqual([])
+  })
+
+  it('reports fields the editor writes that the collection does not declare', () => {
+    const config = {
+      collections: { blog: { slug: 'blog', fields: { title: { type: 'text' } } } },
+    }
+    const missing = missingPostFields(config, 'blog')
+    expect(missing).toContain('sections')
+    expect(missing).toContain('metaTitle')
+  })
+
+  it('trusts the consumer when config or the collection is absent', () => {
+    expect(missingPostFields(undefined, 'blog')).toEqual([])
+    expect(missingPostFields({ collections: {} }, 'blog')).toEqual([])
+  })
+})
+
 describe('savePostDraft', () => {
   it('PUTs the post fields + sections for an existing post', async () => {
     cmsApiMock.mockResolvedValueOnce({

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

@@ -0,0 +1,147 @@
+// @vitest-environment happy-dom
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { render, screen } from '@testing-library/react'
+
+const fetchPostForEditor = vi.fn()
+const fetchTemplateForEditor = vi.fn()
+vi.mock('../../lib/post-editor-service.js', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('../../lib/post-editor-service.js')>()
+  return {
+    ...actual,
+    fetchPostForEditor: (...args: unknown[]) => fetchPostForEditor(...args),
+    fetchTemplateForEditor: (...args: unknown[]) => fetchTemplateForEditor(...args),
+  }
+})
+
+const { PostSectionEditor } = await import('../../views/post-editor/PostSectionEditor.js')
+
+const validConfig = {
+  collections: {
+    blog: {
+      slug: 'blog',
+      labels: { singular: 'Post', plural: 'Posts' },
+      fields: {
+        title: { type: 'text' },
+        slug: { type: 'slug' },
+        sections: { type: 'json' },
+        excerpt: { type: 'text' },
+        featuredImage: { type: 'media' },
+        body: { type: 'richText' },
+        category: { type: 'text' },
+        publishDate: { type: 'date' },
+        metaTitle: { type: 'text' },
+        metaDescription: { type: 'text' },
+      },
+    },
+  },
+} as any
+
+function loadedPost(
+  sections: Array<{ id: string; sectionType: string; name: string; unmanaged?: boolean }>,
+) {
+  return {
+    id: 'p1',
+    postType: 'blog',
+    title: 'Logan',
+    slug: 'logan',
+    excerpt: '',
+    featuredImage: '',
+    body: '',
+    category: '',
+    status: 'DRAFT',
+    publishDate: null,
+    sections: sections.map((s) => ({ ...s, visible: true, content: {}, settings: {} })),
+    seoTitle: '',
+    seoDescription: '',
+    publishedAt: null,
+    updatedAt: null,
+  }
+}
+
+afterEach(() => {
+  fetchPostForEditor.mockReset()
+  fetchTemplateForEditor.mockReset()
+})
+
+describe('PostSectionEditor schema guard', () => {
+  it('refuses to operate when the post-type collection is missing the sections field', async () => {
+    const badConfig = {
+      collections: { blog: { slug: 'blog', fields: { title: { type: 'text' } } } },
+    } as any
+
+    render(
+      <PostSectionEditor
+        postType="blog"
+        documentId="p1"
+        config={badConfig}
+        onNavigate={() => {}}
+        session={{}}
+      />,
+    )
+
+    expect(await screen.findByText(/missing required field/i)).toBeTruthy()
+    // The guard must short-circuit before any network read.
+    expect(fetchPostForEditor).not.toHaveBeenCalled()
+  })
+
+  it('does not block when no config is provided (embedding/test contexts)', async () => {
+    fetchTemplateForEditor.mockRejectedValue(new Error('no template'))
+    fetchPostForEditor.mockResolvedValue(
+      loadedPost([{ id: 's1', sectionType: 'quote', name: 'Quote' }]),
+    )
+    render(
+      <PostSectionEditor
+        postType="blog"
+        documentId="p1"
+        config={undefined}
+        onNavigate={() => {}}
+        session={{}}
+      />,
+    )
+    expect(await screen.findByText('Sections')).toBeTruthy()
+  })
+})
+
+describe('PostSectionEditor unmanaged sections', () => {
+  it('shows the externally-managed banner when a post has unmanaged sections', async () => {
+    fetchTemplateForEditor.mockRejectedValue(new Error('no template'))
+    fetchPostForEditor.mockResolvedValue(
+      loadedPost([
+        { id: 's1', sectionType: 'quote', name: 'Quote' },
+        { id: 's2', sectionType: 'opal-prose-band', name: 'Prose Band', unmanaged: true },
+      ]),
+    )
+    render(
+      <PostSectionEditor
+        postType="blog"
+        documentId="p1"
+        config={validConfig}
+        onNavigate={() => {}}
+        session={{}}
+      />,
+    )
+
+    await screen.findByText('Sections')
+    const banner = screen.getByText(/managed outside the editor/)
+    expect(banner.textContent).toContain('opal-prose-band')
+  })
+
+  it('shows no banner when every section type is registered', async () => {
+    fetchTemplateForEditor.mockRejectedValue(new Error('no template'))
+    fetchPostForEditor.mockResolvedValue(
+      loadedPost([{ id: 's1', sectionType: 'quote', name: 'Quote' }]),
+    )
+    render(
+      <PostSectionEditor
+        postType="blog"
+        documentId="p1"
+        config={validConfig}
+        onNavigate={() => {}}
+        session={{}}
+      />,
+    )
+
+    await screen.findByText('Sections')
+    expect(screen.queryByText(/managed outside the editor/)).toBeNull()
+  })
+})

package/src/lib/collection-schema.ts

@@ -0,0 +1,62 @@
+/**
+ * Collection schema guard shared by the Page and Post editors.
+ *
+ * Both editors persist content as top-level keys on a collection document
+ * (`sections`, `metaTitle`, …). The server's field-access layer only writes
+ * keys that are *declared as fields* on the collection — any undeclared key is
+ * silently dropped on save. A collection missing e.g. the `sections` field
+ * would therefore discard all section content with no error, so the editors
+ * use this check to refuse to operate (and explain why) instead.
+ *
+ * When `config` (or its collections) is not provided — some embedding/test
+ * contexts don't pass it — we can't check, so we report nothing missing and
+ * trust the consumer.
+ */
+
+interface CollectionLike {
+  slug?: string
+  fields?: unknown
+}
+
+/** Look up a collection by slug; `collections` may be a record or an array. */
+export function findCollection(config: unknown, slug: string): CollectionLike | null {
+  const collections = (config as { collections?: unknown } | null | undefined)?.collections
+  if (!collections) return null
+  if (Array.isArray(collections)) {
+    return (collections as CollectionLike[]).find((c) => c?.slug === slug) ?? null
+  }
+  if (typeof collections === 'object') {
+    return (collections as Record<string, CollectionLike>)[slug] ?? null
+  }
+  return null
+}
+
+/** Field definitions may be a record (keyed by name) or an array of `{ name }`. */
+export function declaredFieldNames(fields: unknown): Set<string> | null {
+  if (!fields) return null
+  if (Array.isArray(fields)) {
+    return new Set(
+      (fields as Array<{ name?: string }>)
+        .map((f) => f?.name)
+        .filter((n): n is string => typeof n === 'string'),
+    )
+  }
+  if (typeof fields === 'object') return new Set(Object.keys(fields as Record<string, unknown>))
+  return null
+}
+
+/**
+ * Returns the `required` field keys absent from the collection's declared
+ * fields, or `[]` when the collection / its fields can't be inspected.
+ */
+export function missingCollectionFields(
+  config: unknown,
+  slug: string,
+  required: readonly string[],
+): string[] {
+  const collection = findCollection(config, slug)
+  if (!collection) return []
+  const declared = declaredFieldNames(collection.fields)
+  if (declared === null) return []
+  return required.filter((k) => !declared.has(k))
+}

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

@@ -34,6 +34,8 @@ import {
   type PageSection,
 } from '@actuate-media/cms-core/page-sections'
 
+import { missingCollectionFields } from './collection-schema.js'
+
 export type { PageSection } from '@actuate-media/cms-core/page-sections'
 
 // Re-export the pure section helpers so existing editor imports
@@ -151,41 +153,7 @@ export function validatePage(page: EditorPage, forPublish = false): ValidationRe
 const REQUIRED_PAGE_FIELDS = ['sections', 'path', 'metaTitle', 'metaDescription'] as const
 
 export function missingPageFields(config: unknown): string[] {
-  const pages = findPagesCollection(config)
-  if (!pages) return []
-  const declared = declaredFieldNames(pages.fields)
-  if (declared === null) return []
-  return REQUIRED_PAGE_FIELDS.filter((k) => !declared.has(k))
-}
-
-function findPagesCollection(config: unknown): { fields?: unknown } | null {
-  const collections = (config as { collections?: unknown } | null | undefined)?.collections
-  if (!collections) return null
-  if (Array.isArray(collections)) {
-    return (
-      (collections as Array<{ slug?: string; fields?: unknown }>).find(
-        (c) => c?.slug === PAGES_COLLECTION,
-      ) ?? null
-    )
-  }
-  if (typeof collections === 'object') {
-    return (collections as Record<string, { fields?: unknown }>)[PAGES_COLLECTION] ?? null
-  }
-  return null
-}
-
-/** Field definitions may be a record (keyed by name) or an array of `{ name }`. */
-function declaredFieldNames(fields: unknown): Set<string> | null {
-  if (!fields) return null
-  if (Array.isArray(fields)) {
-    return new Set(
-      (fields as Array<{ name?: string }>)
-        .map((f) => f?.name)
-        .filter((n): n is string => typeof n === 'string'),
-    )
-  }
-  if (typeof fields === 'object') return new Set(Object.keys(fields as Record<string, unknown>))
-  return null
+  return missingCollectionFields(config, PAGES_COLLECTION, REQUIRED_PAGE_FIELDS)
 }
 
 // ─── API row mapping ─────────────────────────────────────────────────

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

@@ -20,8 +20,10 @@
  * so the field-access layer doesn't strip them on write.
  */
 import { cmsApi } from './api.js'
+import { missingCollectionFields } from './collection-schema.js'
 import {
   getSectionType,
+  generateSectionId,
   createSection,
   addSection,
   removeSection,
@@ -93,6 +95,30 @@ export interface ValidationResult {
   warnings: string[]
 }
 
+// ─── Schema guard ────────────────────────────────────────────────────
+
+/**
+ * The Post Editor persists these as top-level keys on the post-type
+ * collection's documents. The server's field-access layer silently drops any
+ * key not declared as a field on the collection, so a post-type collection
+ * missing e.g. `sections` would discard all section content on save with no
+ * error. Mirrors the Page Editor's `missingPageFields` guard.
+ */
+const REQUIRED_POST_FIELDS = [
+  'sections',
+  'excerpt',
+  'featuredImage',
+  'body',
+  'category',
+  'publishDate',
+  'metaTitle',
+  'metaDescription',
+] as const
+
+export function missingPostFields(config: unknown, postType: string): string[] {
+  return missingCollectionFields(config, postType, REQUIRED_POST_FIELDS)
+}
+
 // ─── Validation ──────────────────────────────────────────────────────
 
 function isBlank(v: unknown): boolean {
@@ -113,7 +139,9 @@ export function validatePost(post: EditorPost, forPublish = false): ValidationRe
 
   if (forPublish) {
     const visible = post.sections.filter((s) => s.visible)
-    for (const section of visible) {
+    // Unmanaged (externally-managed) sections have no registered field schema,
+    // so they can't be content-validated here and must not block publish.
+    for (const section of visible.filter((s) => !s.unmanaged)) {
       const def = getSectionType(section.sectionType)
       const label = section.name || def?.name || 'Section'
       const result = validateSectionContent(section.sectionType, section.content, section.settings)
@@ -133,7 +161,7 @@ export function validatePost(post: EditorPost, forPublish = false): ValidationRe
 export function validateTemplate(template: EditorPostTemplate): ValidationResult {
   const errors: string[] = []
   const warnings: string[] = []
-  for (const section of template.sections.filter((s) => s.visible)) {
+  for (const section of template.sections.filter((s) => s.visible && !s.unmanaged)) {
     const def = getSectionType(section.sectionType)
     const label = section.name || def?.name || 'Section'
     const result = validateSectionContent(section.sectionType, section.content, section.settings)
@@ -175,7 +203,9 @@ function rowToEditorPost(postType: string, doc: DocumentApiRow): EditorPost {
     category: dataStr(data, 'category'),
     status: doc.status ?? 'DRAFT',
     publishDate: (data.publishDate as string) ?? doc.scheduledAt ?? null,
-    sections: coerceSections(data.sections),
+    // Preserve unknown (externally-managed) sections so the editor can show
+    // them read-only and round-trip them on save instead of dropping them.
+    sections: coerceSections(data.sections, { onUnknown: 'preserve' }),
     seoTitle: dataStr(data, 'metaTitle'),
     seoDescription: dataStr(data, 'metaDescription'),
     publishedAt: doc.publishedAt ?? null,
@@ -216,7 +246,7 @@ export async function fetchTemplateForEditor(postType: string): Promise<EditorPo
   const r = res.data
   const docId = r.docId ?? null
   const header = coercePostHeader(r.header)
-  let sections = coerceSections(r.sections)
+  let sections = coerceSections(r.sections, { onUnknown: 'preserve' })
   // Defend against an older server (or an empty stored template): an unsaved
   // type should still seed the default sections so authors aren't faced with a
   // blank canvas.
@@ -230,7 +260,10 @@ export async function fetchTemplateForEditor(postType: string): Promise<EditorPo
 export async function saveTemplate(template: EditorPostTemplate): Promise<EditorPostTemplate> {
   const res = await cmsApi<TemplateApiResponse>(templateEndpoint(template.postType), {
     method: 'PUT',
-    body: JSON.stringify({ header: template.header, sections: template.sections }),
+    body: JSON.stringify({
+      header: template.header,
+      sections: template.sections.map(stripUnmanagedMarker),
+    }),
   })
   if (res.error || !res.data) throw new Error(res.error ?? 'Failed to save template')
   const r = res.data
@@ -238,7 +271,7 @@ export async function saveTemplate(template: EditorPostTemplate): Promise<Editor
     docId: r.docId ?? null,
     postType: template.postType,
     header: coercePostHeader(r.header),
-    sections: coerceSections(r.sections),
+    sections: coerceSections(r.sections, { onUnknown: 'preserve' }),
   }
 }
 
@@ -263,6 +296,15 @@ interface PostWritePayload {
   metaDescription: string
 }
 
+/**
+ * Strip the derived `unmanaged` marker before persisting — it is recomputed
+ * from the registry on read, so persisting it would only stale.
+ */
+function stripUnmanagedMarker(section: PageSection): Omit<PageSection, 'unmanaged'> {
+  const { unmanaged: _unmanaged, ...rest } = section
+  return rest
+}
+
 function toWriteBody(post: EditorPost, extra?: Record<string, unknown>): string {
   const payload: PostWritePayload & Record<string, unknown> = {
     title: post.title,
@@ -272,7 +314,9 @@ function toWriteBody(post: EditorPost, extra?: Record<string, unknown>): string
     body: post.body,
     category: post.category,
     publishDate: post.publishDate,
-    sections: post.sections,
+    // Unmanaged sections are part of `post.sections`, so they round-trip on
+    // every save (no data loss).
+    sections: post.sections.map(stripUnmanagedMarker),
     metaTitle: post.seoTitle,
     metaDescription: post.seoDescription,
     ...extra,
@@ -318,7 +362,9 @@ export async function emptyPostFromTemplate(postType: string): Promise<EditorPos
     const template = await fetchTemplateForEditor(postType)
     // Clone with fresh ids so the post owns its own sections, decoupled from
     // the template (editing the post never mutates the type template).
-    sections = template.sections.map((s) => ({ ...s, id: createSection(s.sectionType).id }))
+    // `generateSectionId` (not `createSection`) because preserved unmanaged
+    // template sections have no registered type and `createSection` throws.
+    sections = template.sections.map((s) => ({ ...s, id: generateSectionId() }))
   } catch {
     // No template / fetch failure → start from an empty section list.
     sections = []

package/src/lib/posts-service.ts

@@ -87,6 +87,7 @@ interface CollectionApiRow {
   group: string | null
   hidden: boolean
   fieldCount: number
+  excludeFromPostsAggregate?: boolean
 }
 
 function isPostsCollection(c: CollectionApiRow): boolean {
@@ -96,7 +97,9 @@ function isPostsCollection(c: CollectionApiRow): boolean {
 async function fetchPostCollections(): Promise<CollectionApiRow[]> {
   const res = await cmsApi<CollectionApiRow[]>('/collections')
   if (res.error || !res.data) return []
-  return res.data.filter((c) => !c.hidden && isPostsCollection(c))
+  // `excludeFromPostsAggregate` mirrors the server-side /posts filter: a
+  // post-shaped collection with its own workflow stays out of the Posts UI.
+  return res.data.filter((c) => !c.hidden && !c.excludeFromPostsAggregate && isPostsCollection(c))
 }
 
 export async function fetchPostTypes(): Promise<PostType[]> {

package/src/views/page-editor/PageSectionEditor.tsx

@@ -58,8 +58,11 @@ interface PageSectionEditorProps {
 
 function deriveCan(session: any): { canEdit: boolean; canPublish: boolean } {
   const role: string | undefined = session?.user?.role
-  // No session info (e.g. local dev) → allow; otherwise gate by role.
-  if (!role) return { canEdit: true, canPublish: true }
+  // Default closed: when we can't identify a role, hide the edit/publish
+  // affordances rather than exposing them. The server independently enforces
+  // access on every write, so this is a UX guard — but it should fail safe.
+  // (Matches the Post editor's behavior.)
+  if (!role) return { canEdit: false, canPublish: false }
   const editors = ['ADMIN', 'EDITOR', 'AUTHOR']
   const publishers = ['ADMIN', 'EDITOR']
   return { canEdit: editors.includes(role), canPublish: publishers.includes(role) }