canopycms 0.0.0

package/src/content-store.test.ts

@@ -0,0 +1,1126 @@
+import fs from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+
+import { describe, expect, it } from 'vitest'
+
+import { defineCanopyTestConfig } from './config-test'
+import { flattenSchema } from './config'
+import { ContentStore, ContentStoreError } from './content-store'
+import { unsafeAsLogicalPath, unsafeAsEntrySlug } from './paths/test-utils'
+
+const tmpDir = async () => fs.mkdtemp(path.join(os.tmpdir(), 'canopycms-'))
+
+describe('ContentStore', () => {
+  it('writes and reads markdown content', async () => {
+    const root = await tmpDir()
+    const schema = {
+      collections: [
+        {
+          name: 'posts',
+          path: 'posts',
+          entries: [
+            {
+              name: 'post',
+              format: 'md' as const,
+              schema: [{ name: 'title', type: 'string' as const }],
+            },
+          ],
+        },
+      ],
+    } as const
+
+    const config = defineCanopyTestConfig({ schema })
+    const store = new ContentStore(root, flattenSchema(schema, config.contentRoot))
+
+    await store.write(unsafeAsLogicalPath('content/posts'), unsafeAsEntrySlug('hello-world'), {
+      format: 'md',
+      data: { title: 'Hello' },
+      body: 'Body text',
+    })
+
+    const doc = await store.read(
+      unsafeAsLogicalPath('content/posts'),
+      unsafeAsEntrySlug('hello-world'),
+    )
+    if (doc.format === 'json') throw new Error('expected markdown')
+    expect(doc.data.title).toBe('Hello')
+    expect(doc.body).toContain('Body text')
+    expect(doc.relativePath.endsWith('.md')).toBe(true)
+  })
+
+  it('writes and reads mdx content with frontmatter', async () => {
+    const root = await tmpDir()
+    const schema = {
+      collections: [
+        {
+          name: 'pages',
+          path: 'pages',
+          entries: [
+            {
+              name: 'page',
+              format: 'mdx' as const,
+              schema: [{ name: 'title', type: 'string' as const }],
+            },
+          ],
+        },
+      ],
+    } as const
+
+    const config = defineCanopyTestConfig({ schema })
+    const store = new ContentStore(root, flattenSchema(schema, config.contentRoot))
+
+    await store.write(unsafeAsLogicalPath('content/pages'), unsafeAsEntrySlug('landing'), {
+      format: 'mdx',
+      data: { title: 'Landing' },
+      body: '<Hero title="Hi" />',
+    })
+
+    const doc = await store.read(unsafeAsLogicalPath('content/pages'), unsafeAsEntrySlug('landing'))
+    if (doc.format === 'json') throw new Error('expected mdx')
+    expect(doc.data.title).toBe('Landing')
+    expect(doc.body?.includes('<Hero')).toBe(true)
+    expect(doc.absolutePath.endsWith('.mdx')).toBe(true)
+  })
+
+  it('writes and reads json content', async () => {
+    const root = await tmpDir()
+    const schema = {
+      collections: [
+        {
+          name: 'settings',
+          path: 'config',
+          entries: [
+            {
+              name: 'setting',
+              format: 'json' as const,
+              schema: [{ name: 'siteName', type: 'string' as const }],
+            },
+          ],
+        },
+      ],
+    } as const
+
+    const config = defineCanopyTestConfig({ schema })
+    const store = new ContentStore(root, flattenSchema(schema, config.contentRoot))
+
+    await store.write(unsafeAsLogicalPath('content/config'), unsafeAsEntrySlug('site'), {
+      format: 'json',
+      data: { siteName: 'CanopyCMS' },
+    })
+
+    const doc = await store.read(unsafeAsLogicalPath('content/config'), unsafeAsEntrySlug('site'))
+    expect(doc.data.siteName).toBe('CanopyCMS')
+    expect(doc.relativePath.endsWith('.json')).toBe(true)
+  })
+
+  it('prevents path traversal outside root', async () => {
+    const root = await tmpDir()
+    const schema = {
+      collections: [
+        {
+          name: 'posts',
+          path: 'posts',
+          entries: [
+            {
+              name: 'post',
+              format: 'md' as const,
+              schema: [{ name: 'title', type: 'string' as const }],
+            },
+          ],
+        },
+      ],
+    } as const
+
+    const config = defineCanopyTestConfig({ schema })
+    const store = new ContentStore(root, flattenSchema(schema, config.contentRoot))
+
+    await expect(
+      store.write(unsafeAsLogicalPath('content/posts'), unsafeAsEntrySlug('../escape'), {
+        format: 'md',
+        data: { title: 'bad' },
+        body: 'x',
+      }),
+    ).rejects.toBeInstanceOf(ContentStoreError)
+  })
+
+  it('reads and writes entry items with a slug', async () => {
+    const root = await tmpDir()
+    const schema = {
+      collections: [
+        {
+          name: 'settings',
+          path: 'settings',
+          entries: [
+            {
+              name: 'setting',
+              format: 'json' as const,
+              schema: [{ name: 'siteName', type: 'string' as const }],
+            },
+          ],
+        },
+      ],
+    } as const
+
+    const config = defineCanopyTestConfig({ schema })
+    const store = new ContentStore(root, flattenSchema(schema, config.contentRoot))
+
+    await store.write(unsafeAsLogicalPath('content/settings'), unsafeAsEntrySlug('site'), {
+      format: 'json',
+      data: { siteName: 'CanopyCMS' },
+    })
+
+    const doc = await store.read(unsafeAsLogicalPath('content/settings'), unsafeAsEntrySlug('site'))
+    expect(doc.format).toBe('json')
+    expect(doc.data.siteName).toBe('CanopyCMS')
+    // Pattern: {type}.{slug}.{id}.{ext}
+    expect(doc.relativePath).toMatch(/content\/settings\/setting\.site\.[a-zA-Z0-9]+\.json/)
+  })
+
+  it('rejects slugs with forward slashes', async () => {
+    const root = await tmpDir()
+    const schema = {
+      collections: [
+        {
+          name: 'posts',
+          path: 'posts',
+          entries: [
+            {
+              name: 'post',
+              format: 'md' as const,
+              schema: [{ name: 'title', type: 'string' as const }],
+            },
+          ],
+        },
+      ],
+    } as const
+
+    const config = defineCanopyTestConfig({ schema })
+    const store = new ContentStore(root, flattenSchema(schema, config.contentRoot))
+
+    await expect(
+      store.write(unsafeAsLogicalPath('content/posts'), unsafeAsEntrySlug('2024/hello'), {
+        format: 'md',
+        data: { title: 'Bad Slug' },
+        body: 'Content',
+      }),
+    ).rejects.toThrow('Slugs cannot contain forward slashes')
+  })
+
+  it('rejects slugs with backslashes', async () => {
+    const root = await tmpDir()
+    const schema = {
+      collections: [
+        {
+          name: 'posts',
+          path: 'posts',
+          entries: [
+            {
+              name: 'post',
+              format: 'md' as const,
+              schema: [{ name: 'title', type: 'string' as const }],
+            },
+          ],
+        },
+      ],
+    } as const
+
+    const config = defineCanopyTestConfig({ schema })
+    const store = new ContentStore(root, flattenSchema(schema, config.contentRoot))
+
+    await expect(
+      store.write(unsafeAsLogicalPath('content/posts'), unsafeAsEntrySlug('bad\\slug'), {
+        format: 'md',
+        data: { title: 'Bad Slug' },
+        body: 'Content',
+      }),
+    ).rejects.toThrow('Slugs cannot contain backslashes')
+  })
+
+  it('resolves paths using trivial algorithm: collection + slug', async () => {
+    const root = await tmpDir()
+    const schema = {
+      collections: [
+        {
+          name: 'posts',
+          path: 'posts',
+          entries: [
+            {
+              name: 'post',
+              format: 'md' as const,
+              schema: [{ name: 'title', type: 'string' as const }],
+            },
+          ],
+        },
+      ],
+    } as const
+
+    const config = defineCanopyTestConfig({ schema })
+    const store = new ContentStore(root, flattenSchema(schema, config.contentRoot))
+
+    // Path: content/posts/hello -> collection=content/posts, slug=hello
+    const result = store.resolvePath(['content', 'posts', 'hello'])
+    expect(result.schemaItem.logicalPath).toBe('content/posts')
+    expect(result.schemaItem.type).toBe('collection')
+    expect(result.slug).toBe('hello')
+  })
+
+  it('resolves paths for collection entries with slug', async () => {
+    const root = await tmpDir()
+    const schema = {
+      collections: [
+        {
+          name: 'settings',
+          path: 'settings',
+          entries: [
+            {
+              name: 'setting',
+              format: 'json' as const,
+              schema: [{ name: 'siteName', type: 'string' as const }],
+            },
+          ],
+        },
+      ],
+    } as const
+
+    const config = defineCanopyTestConfig({ schema })
+    const store = new ContentStore(root, flattenSchema(schema, config.contentRoot))
+
+    // Path: content/settings/site -> collection entry with slug
+    const result = store.resolvePath(['content', 'settings', 'site'])
+    expect(result.schemaItem.logicalPath).toBe('content/settings')
+    expect(result.schemaItem.type).toBe('collection')
+    expect(result.slug).toBe('site')
+  })
+
+  it('resolves nested collection paths', async () => {
+    const root = await tmpDir()
+    const schema = {
+      collections: [
+        {
+          name: 'docs',
+          path: 'docs',
+          entries: [
+            {
+              name: 'entry',
+              format: 'md' as const,
+              schema: [{ name: 'title', type: 'string' as const }],
+            },
+          ],
+          collections: [
+            {
+              name: 'guides',
+              path: 'guides',
+              entries: [
+                {
+                  name: 'entry',
+                  format: 'md' as const,
+                  schema: [{ name: 'title', type: 'string' as const }],
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    } as const
+
+    const config = defineCanopyTestConfig({ schema })
+    const store = new ContentStore(root, flattenSchema(schema, config.contentRoot))
+
+    // Path: content/docs/guides/getting-started
+    // -> collection=content/docs/guides, slug=getting-started
+    const result = store.resolvePath(['content', 'docs', 'guides', 'getting-started'])
+    expect(result.schemaItem.logicalPath).toBe('content/docs/guides')
+    expect(result.schemaItem.type).toBe('collection')
+    expect(result.slug).toBe('getting-started')
+  })
+
+  it('resolves 3-level nested collection paths', async () => {
+    const root = await tmpDir()
+    const schema = {
+      collections: [
+        {
+          name: 'docs',
+          path: 'docs',
+          entries: [
+            {
+              name: 'entry',
+              format: 'md' as const,
+              schema: [{ name: 'title', type: 'string' as const }],
+            },
+          ],
+          collections: [
+            {
+              name: 'api',
+              path: 'api',
+              entries: [
+                {
+                  name: 'entry',
+                  format: 'md' as const,
+                  schema: [{ name: 'title', type: 'string' as const }],
+                },
+              ],
+              collections: [
+                {
+                  name: 'v2',
+                  path: 'v2',
+                  entries: [
+                    {
+                      name: 'entry',
+                      format: 'md' as const,
+                      schema: [{ name: 'title', type: 'string' as const }],
+                    },
+                  ],
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    } as const
+
+    const config = defineCanopyTestConfig({ schema })
+    const store = new ContentStore(root, flattenSchema(schema, config.contentRoot))
+
+    // Path: content/docs/api/v2/authentication
+    // -> collection=content/docs/api/v2, slug=authentication
+    const result = store.resolvePath(['content', 'docs', 'api', 'v2', 'authentication'])
+    expect(result.schemaItem.logicalPath).toBe('content/docs/api/v2')
+    expect(result.schemaItem.type).toBe('collection')
+    expect(result.slug).toBe('authentication')
+  })
+
+  it('resolves 4-level nested collection paths', async () => {
+    const root = await tmpDir()
+    const schema = {
+      collections: [
+        {
+          name: 'docs',
+          path: 'docs',
+          entries: [
+            {
+              name: 'entry',
+              format: 'md' as const,
+              schema: [{ name: 'title', type: 'string' as const }],
+            },
+          ],
+          collections: [
+            {
+              name: 'api',
+              path: 'api',
+              entries: [
+                {
+                  name: 'entry',
+                  format: 'md' as const,
+                  schema: [{ name: 'title', type: 'string' as const }],
+                },
+              ],
+              collections: [
+                {
+                  name: 'v2',
+                  path: 'v2',
+                  entries: [
+                    {
+                      name: 'entry',
+                      format: 'md' as const,
+                      schema: [{ name: 'title', type: 'string' as const }],
+                    },
+                  ],
+                  collections: [
+                    {
+                      name: 'endpoints',
+                      path: 'endpoints',
+                      entries: [
+                        {
+                          name: 'entry',
+                          format: 'md' as const,
+                          schema: [{ name: 'title', type: 'string' as const }],
+                        },
+                      ],
+                    },
+                  ],
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    } as const
+
+    const config = defineCanopyTestConfig({ schema })
+    const store = new ContentStore(root, flattenSchema(schema, config.contentRoot))
+
+    // Path: content/docs/api/v2/endpoints/users
+    // -> collection=content/docs/api/v2/endpoints, slug=users
+    const result = store.resolvePath(['content', 'docs', 'api', 'v2', 'endpoints', 'users'])
+    expect(result.schemaItem.logicalPath).toBe('content/docs/api/v2/endpoints')
+    expect(result.schemaItem.type).toBe('collection')
+    expect(result.slug).toBe('users')
+  })
+
+  it('writes and reads content in deeply nested collections', async () => {
+    const root = await tmpDir()
+    const schema = {
+      collections: [
+        {
+          name: 'docs',
+          path: 'docs',
+          entries: [
+            {
+              name: 'entry',
+              format: 'md' as const,
+              schema: [{ name: 'title', type: 'string' as const }],
+            },
+          ],
+          collections: [
+            {
+              name: 'api',
+              path: 'api',
+              entries: [
+                {
+                  name: 'entry',
+                  format: 'md' as const,
+                  schema: [{ name: 'title', type: 'string' as const }],
+                },
+              ],
+              collections: [
+                {
+                  name: 'v2',
+                  path: 'v2',
+                  entries: [
+                    {
+                      name: 'entry',
+                      format: 'md' as const,
+                      schema: [{ name: 'title', type: 'string' as const }],
+                    },
+                  ],
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    } as const
+
+    const config = defineCanopyTestConfig({ schema })
+    const store = new ContentStore(root, flattenSchema(schema, config.contentRoot))
+
+    // Write to 3-level nested collection
+    await store.write(
+      unsafeAsLogicalPath('content/docs/api/v2'),
+      unsafeAsEntrySlug('authentication'),
+      {
+        format: 'md',
+        data: { title: 'Authentication Guide' },
+        body: '# Authentication\n\nHow to authenticate.',
+      },
+    )
+
+    // Read it back
+    const doc = await store.read(
+      unsafeAsLogicalPath('content/docs/api/v2'),
+      unsafeAsEntrySlug('authentication'),
+    )
+    if (doc.format === 'json') throw new Error('expected markdown')
+    expect(doc.data.title).toBe('Authentication Guide')
+    expect(doc.body).toContain('How to authenticate')
+    // Pattern: {type}.{slug}.{id}.{ext}
+    expect(doc.relativePath).toMatch(
+      /^content\/docs\/api\/v2\/entry\.authentication\.[a-zA-Z0-9]{12}\.md$/,
+    )
+  })
+
+  describe('renameEntry', () => {
+    it('renames an entry by changing its slug', async () => {
+      const root = await tmpDir()
+      const schema = {
+        collections: [
+          {
+            name: 'posts',
+            path: 'posts',
+            entries: [
+              {
+                name: 'post',
+                format: 'md' as const,
+                schema: [{ name: 'title', type: 'string' as const }],
+              },
+            ],
+          },
+        ],
+      } as const
+
+      const config = defineCanopyTestConfig({ schema })
+      const store = new ContentStore(root, flattenSchema(schema, config.contentRoot))
+
+      // Create an entry
+      await store.write(unsafeAsLogicalPath('content/posts'), unsafeAsEntrySlug('old-slug'), {
+        format: 'md',
+        data: { title: 'Test Post' },
+        body: 'Content here',
+      })
+
+      // Rename it
+      const result = await store.renameEntry(
+        unsafeAsLogicalPath('content/posts'),
+        unsafeAsEntrySlug('old-slug'),
+        unsafeAsEntrySlug('new-slug'),
+      )
+
+      // Verify new path is returned
+      expect(result.newPath).toBe('content/posts/new-slug')
+
+      // Verify old path doesn't exist anymore
+      await expect(
+        store.read(unsafeAsLogicalPath('content/posts'), unsafeAsEntrySlug('old-slug')),
+      ).rejects.toThrow()
+
+      // Verify new path works
+      const doc = await store.read(
+        unsafeAsLogicalPath('content/posts'),
+        unsafeAsEntrySlug('new-slug'),
+      )
+      if (doc.format === 'json') throw new Error('expected markdown')
+      expect(doc.data.title).toBe('Test Post')
+      expect(doc.body).toContain('Content here')
+    })
+
+    it('throws when entry does not exist', async () => {
+      const root = await tmpDir()
+      const schema = {
+        collections: [
+          {
+            name: 'posts',
+            path: 'posts',
+            entries: [{ name: 'post', format: 'json' as const, schema: [] }],
+          },
+        ],
+      } as const
+
+      const config = defineCanopyTestConfig({ schema })
+      const store = new ContentStore(root, flattenSchema(schema, config.contentRoot))
+
+      await expect(
+        store.renameEntry(
+          unsafeAsLogicalPath('content/posts'),
+          unsafeAsEntrySlug('nonexistent'),
+          unsafeAsEntrySlug('new-slug'),
+        ),
+      ).rejects.toThrow('Entry not found: nonexistent')
+    })
+
+    it('throws when new slug already exists', async () => {
+      const root = await tmpDir()
+      const schema = {
+        collections: [
+          {
+            name: 'posts',
+            path: 'posts',
+            entries: [{ name: 'post', format: 'json' as const, schema: [] }],
+          },
+        ],
+      } as const
+
+      const config = defineCanopyTestConfig({ schema })
+      const store = new ContentStore(root, flattenSchema(schema, config.contentRoot))
+
+      // Create two entries
+      await store.write(unsafeAsLogicalPath('content/posts'), unsafeAsEntrySlug('first-post'), {
+        format: 'json',
+        data: { title: 'First' },
+      })
+      await store.write(unsafeAsLogicalPath('content/posts'), unsafeAsEntrySlug('second-post'), {
+        format: 'json',
+        data: { title: 'Second' },
+      })
+
+      // Try to rename first-post to second-post (conflict)
+      await expect(
+        store.renameEntry(
+          unsafeAsLogicalPath('content/posts'),
+          unsafeAsEntrySlug('first-post'),
+          unsafeAsEntrySlug('second-post'),
+        ),
+      ).rejects.toThrow('already exists')
+    })
+
+    it('validates slug format', async () => {
+      const root = await tmpDir()
+      const schema = {
+        collections: [
+          {
+            name: 'posts',
+            path: 'posts',
+            entries: [{ name: 'post', format: 'json' as const, schema: [] }],
+          },
+        ],
+      } as const
+
+      const config = defineCanopyTestConfig({ schema })
+      const store = new ContentStore(root, flattenSchema(schema, config.contentRoot))
+
+      // Create an entry
+      await store.write(unsafeAsLogicalPath('content/posts'), unsafeAsEntrySlug('test-post'), {
+        format: 'json',
+        data: { title: 'Test' },
+      })
+
+      // Try invalid slug with slash
+      await expect(
+        store.renameEntry(
+          unsafeAsLogicalPath('content/posts'),
+          unsafeAsEntrySlug('test-post'),
+          unsafeAsEntrySlug('invalid/slug'),
+        ),
+      ).rejects.toThrow('cannot contain forward slashes')
+
+      // Try invalid slug with uppercase
+      await expect(
+        store.renameEntry(
+          unsafeAsLogicalPath('content/posts'),
+          unsafeAsEntrySlug('test-post'),
+          unsafeAsEntrySlug('Invalid-Slug'),
+        ),
+      ).rejects.toThrow('must start with a letter or number')
+    })
+
+    it('handles no-op when slug is unchanged', async () => {
+      const root = await tmpDir()
+      const schema = {
+        collections: [
+          {
+            name: 'posts',
+            path: 'posts',
+            entries: [{ name: 'post', format: 'json' as const, schema: [] }],
+          },
+        ],
+      } as const
+
+      const config = defineCanopyTestConfig({ schema })
+      const store = new ContentStore(root, flattenSchema(schema, config.contentRoot))
+
+      // Create an entry
+      await store.write(unsafeAsLogicalPath('content/posts'), unsafeAsEntrySlug('same-slug'), {
+        format: 'json',
+        data: { title: 'Test' },
+      })
+
+      // Rename to same slug (no-op)
+      const result = await store.renameEntry(
+        unsafeAsLogicalPath('content/posts'),
+        unsafeAsEntrySlug('same-slug'),
+        unsafeAsEntrySlug('same-slug'),
+      )
+
+      // Should return the same path
+      expect(result.newPath).toBe('content/posts/same-slug')
+
+      // Entry should still be readable
+      const doc = await store.read(
+        unsafeAsLogicalPath('content/posts'),
+        unsafeAsEntrySlug('same-slug'),
+      )
+      expect(doc.format).toBe('json')
+      if (doc.format === 'json') {
+        expect(doc.data.title).toBe('Test')
+      }
+    })
+
+    it('preserves content ID through rename', async () => {
+      const root = await tmpDir()
+      const schema = {
+        collections: [
+          {
+            name: 'posts',
+            path: 'posts',
+            entries: [{ name: 'post', format: 'json' as const, schema: [] }],
+          },
+        ],
+      } as const
+
+      const config = defineCanopyTestConfig({ schema })
+      const store = new ContentStore(root, flattenSchema(schema, config.contentRoot))
+
+      // Create an entry
+      await store.write(unsafeAsLogicalPath('content/posts'), unsafeAsEntrySlug('original'), {
+        format: 'json',
+        data: { title: 'Test' },
+      })
+
+      // Get the content ID before rename
+      const idBefore = await store.getIdForEntry(
+        unsafeAsLogicalPath('content/posts'),
+        unsafeAsEntrySlug('original'),
+      )
+
+      // Rename the entry
+      await store.renameEntry(
+        unsafeAsLogicalPath('content/posts'),
+        unsafeAsEntrySlug('original'),
+        unsafeAsEntrySlug('renamed'),
+      )
+
+      // Get the content ID after rename
+      const idAfter = await store.getIdForEntry(
+        unsafeAsLogicalPath('content/posts'),
+        unsafeAsEntrySlug('renamed'),
+      )
+
+      // IDs should match (preserved through rename)
+      expect(idBefore).toBe(idAfter)
+      expect(idBefore).toBeTruthy()
+    })
+  })
+
+  describe('multiple entry types', () => {
+    it('creates entries with specified entry type', async () => {
+      const root = await tmpDir()
+      const schema = {
+        collections: [
+          {
+            name: 'content',
+            path: 'content',
+            entries: [
+              {
+                name: 'post',
+                format: 'mdx' as const,
+                schema: [],
+                default: true,
+              },
+              { name: 'article', format: 'md' as const, schema: [] },
+              { name: 'note', format: 'json' as const, schema: [] },
+            ],
+          },
+        ],
+      } as const
+
+      const config = defineCanopyTestConfig({ schema })
+      const store = new ContentStore(root, flattenSchema(schema, config.contentRoot))
+
+      // Create entries of different types
+      const post = await store.write(
+        unsafeAsLogicalPath('content/content'),
+        unsafeAsEntrySlug('my-post'),
+        { format: 'mdx', data: {}, body: 'Post content' },
+        'post',
+      )
+      const article = await store.write(
+        unsafeAsLogicalPath('content/content'),
+        unsafeAsEntrySlug('my-article'),
+        { format: 'md', data: {}, body: 'Article content' },
+        'article',
+      )
+      const note = await store.write(
+        unsafeAsLogicalPath('content/content'),
+        unsafeAsEntrySlug('my-note'),
+        { format: 'json', data: { text: 'Note' } },
+        'note',
+      )
+
+      // Verify filenames include correct entry type (check the returned paths)
+      const postFile = path.basename(post.relativePath)
+      const articleFile = path.basename(article.relativePath)
+      const noteFile = path.basename(note.relativePath)
+
+      expect(postFile.startsWith('post.my-post.')).toBe(true)
+      expect(postFile.endsWith('.mdx')).toBe(true)
+      expect(articleFile.startsWith('article.my-article.')).toBe(true)
+      expect(articleFile.endsWith('.md')).toBe(true)
+      expect(noteFile.startsWith('note.my-note.')).toBe(true)
+      expect(noteFile.endsWith('.json')).toBe(true)
+    })
+
+    it('throws error for invalid entry type', async () => {
+      const root = await tmpDir()
+      const schema = {
+        collections: [
+          {
+            name: 'posts',
+            path: 'posts',
+            entries: [{ name: 'post', format: 'mdx' as const, schema: [] }],
+          },
+        ],
+      } as const
+
+      const config = defineCanopyTestConfig({ schema })
+      const store = new ContentStore(root, flattenSchema(schema, config.contentRoot))
+
+      await expect(
+        store.write(
+          unsafeAsLogicalPath('content/posts'),
+          unsafeAsEntrySlug('test'),
+          { format: 'mdx', data: {}, body: '' },
+          'invalid-type',
+        ),
+      ).rejects.toThrow("Entry type 'invalid-type' not found in collection")
+    })
+
+    it('uses default entry type when not specified', async () => {
+      const root = await tmpDir()
+      const schema = {
+        collections: [
+          {
+            name: 'docs',
+            path: 'docs',
+            entries: [
+              { name: 'guide', format: 'md' as const, schema: [] },
+              {
+                name: 'tutorial',
+                format: 'mdx' as const,
+                schema: [],
+                default: true,
+              },
+            ],
+          },
+        ],
+      } as const
+
+      const config = defineCanopyTestConfig({ schema })
+      const store = new ContentStore(root, flattenSchema(schema, config.contentRoot))
+
+      // Write without specifying entry type - should use default (tutorial)
+      const doc = await store.write(
+        unsafeAsLogicalPath('content/docs'),
+        unsafeAsEntrySlug('my-doc'),
+        { format: 'mdx', data: {}, body: 'Content' },
+      )
+
+      const tutorialFile = path.basename(doc.relativePath)
+      expect(tutorialFile.startsWith('tutorial.my-doc.')).toBe(true)
+      expect(tutorialFile.endsWith('.mdx')).toBe(true)
+    })
+
+    it('preserves entry type for existing entries (immutable after creation)', async () => {
+      const root = await tmpDir()
+      const schema = {
+        collections: [
+          {
+            name: 'content',
+            path: 'content',
+            entries: [
+              { name: 'post', format: 'mdx' as const, schema: [] },
+              { name: 'article', format: 'md' as const, schema: [] },
+            ],
+          },
+        ],
+      } as const
+
+      const config = defineCanopyTestConfig({ schema })
+      const store = new ContentStore(root, flattenSchema(schema, config.contentRoot))
+
+      // Create an entry with entry type "post"
+      const created = await store.write(
+        unsafeAsLogicalPath('content/content'),
+        unsafeAsEntrySlug('my-content'),
+        { format: 'mdx', data: {}, body: 'Original' },
+        'post',
+      )
+      const createdFile = path.basename(created.relativePath)
+      expect(createdFile.startsWith('post.my-content.')).toBe(true)
+
+      // Update the same entry WITHOUT specifying entry type
+      // The entry type should be automatically preserved from the existing file
+      const updated = await store.write(
+        unsafeAsLogicalPath('content/content'),
+        unsafeAsEntrySlug('my-content'),
+        { format: 'mdx', data: {}, body: 'Updated' },
+      )
+      const updatedFile = path.basename(updated.relativePath)
+
+      // Entry type should still be "post" (preserved from existing file)
+      expect(updatedFile.startsWith('post.my-content.')).toBe(true)
+      expect(updatedFile).toBe(createdFile) // Filename should be exactly the same
+
+      // Verify the content was updated
+      const read = await store.read(
+        unsafeAsLogicalPath('content/content'),
+        unsafeAsEntrySlug('my-content'),
+      )
+      if (read.format === 'json') throw new Error('Expected mdx')
+      expect(read.body.trim()).toBe('Updated')
+
+      // Also verify that even if we specify a different entry type, it gets ignored (preserved)
+      const updated2 = await store.write(
+        unsafeAsLogicalPath('content/content'),
+        unsafeAsEntrySlug('my-content'),
+        { format: 'mdx', data: {}, body: 'Updated again' },
+        'post',
+      )
+      const updated2File = path.basename(updated2.relativePath)
+      expect(updated2File).toBe(createdFile) // Still the same filename
+    })
+  })
+
+  describe('entry-type path delegation', () => {
+    // When buildPaths receives an entry-type schema item (e.g., from
+    // store.read('content/home', '')), it delegates to the parent collection.
+    // The API layer doesn't trigger this path (resolvePath returns collections
+    // directly), but direct ContentStore usage can.
+
+    it('writes and reads via entry-type logical path', async () => {
+      const root = await tmpDir()
+      const schema = {
+        entries: [
+          {
+            name: 'home',
+            format: 'json' as const,
+            schema: [{ name: 'hero', type: 'string' as const }],
+            maxItems: 1,
+          },
+          {
+            name: 'settings',
+            format: 'json' as const,
+            schema: [{ name: 'siteName', type: 'string' as const }],
+          },
+        ],
+      } as const
+
+      const config = defineCanopyTestConfig({ schema })
+      const store = new ContentStore(root, flattenSchema(schema, config.contentRoot))
+
+      // Write using the entry-type path (content/home) with empty slug
+      await store.write(unsafeAsLogicalPath('content/home'), unsafeAsEntrySlug(''), {
+        format: 'json',
+        data: { hero: 'Welcome' },
+      })
+
+      // Read it back via the same entry-type path
+      const doc = await store.read(unsafeAsLogicalPath('content/home'), unsafeAsEntrySlug(''))
+      expect(doc.format).toBe('json')
+      expect(doc.data.hero).toBe('Welcome')
+
+      // Verify 4-part filename: home.home.{id}.json
+      expect(doc.relativePath).toMatch(/^content\/home\.home\.[a-zA-Z0-9]{12}\.json$/)
+    })
+
+    it('uses provided slug instead of entry type name', async () => {
+      const root = await tmpDir()
+      const schema = {
+        entries: [
+          {
+            name: 'page',
+            format: 'json' as const,
+            schema: [{ name: 'title', type: 'string' as const }],
+          },
+        ],
+      } as const
+
+      const config = defineCanopyTestConfig({ schema })
+      const store = new ContentStore(root, flattenSchema(schema, config.contentRoot))
+
+      // Write with an explicit slug different from entry type name
+      await store.write(unsafeAsLogicalPath('content/page'), unsafeAsEntrySlug('about'), {
+        format: 'json',
+        data: { title: 'About Us' },
+      })
+
+      const doc = await store.read(unsafeAsLogicalPath('content/page'), unsafeAsEntrySlug('about'))
+      expect(doc.data.title).toBe('About Us')
+
+      // Verify filename: page.about.{id}.json (type from entry type, slug from arg)
+      expect(doc.relativePath).toMatch(/^content\/page\.about\.[a-zA-Z0-9]{12}\.json$/)
+    })
+
+    it('uses correct format and fields from entry-type schema', async () => {
+      const root = await tmpDir()
+      const schema = {
+        entries: [
+          {
+            name: 'post',
+            format: 'md' as const,
+            schema: [{ name: 'title', type: 'string' as const }],
+          },
+        ],
+      } as const
+
+      const config = defineCanopyTestConfig({ schema })
+      const store = new ContentStore(root, flattenSchema(schema, config.contentRoot))
+
+      await store.write(unsafeAsLogicalPath('content/post'), unsafeAsEntrySlug('hello'), {
+        format: 'md',
+        data: { title: 'Hello' },
+        body: 'World',
+      })
+
+      const doc = await store.read(unsafeAsLogicalPath('content/post'), unsafeAsEntrySlug('hello'))
+      if (doc.format === 'json') throw new Error('Expected md')
+      expect(doc.format).toBe('md')
+      expect(doc.data.title).toBe('Hello')
+      expect(doc.body).toContain('World')
+      expect(doc.relativePath).toMatch(/^content\/post\.hello\.[a-zA-Z0-9]{12}\.md$/)
+    })
+  })
+
+  describe('complex frontmatter roundtrip', () => {
+    it('preserves nested objects and arrays in markdown frontmatter via gray-matter', async () => {
+      const root = await tmpDir()
+      const schema = {
+        collections: [
+          {
+            name: 'posts',
+            path: 'posts',
+            entries: [
+              {
+                name: 'post',
+                format: 'md' as const,
+                schema: [
+                  { name: 'title', type: 'string' as const },
+                  { name: 'tags', type: 'string' as const, list: true },
+                  { name: 'published', type: 'boolean' as const },
+                ],
+              },
+            ],
+          },
+        ],
+      } as const
+
+      const config = defineCanopyTestConfig({ schema })
+      const store = new ContentStore(root, flattenSchema(schema, config.contentRoot))
+
+      const complexData = {
+        title: 'Complex Post',
+        author: '5NVkkrB1MJUv',
+        tags: ['typed', 'fast'],
+        published: false,
+        blocks: [
+          {
+            template: 'hero',
+            value: {
+              headline: 'Hero block',
+              body: 'Hero copy',
+            },
+          },
+          {
+            template: 'cta',
+            value: {
+              title: 'Try CanopyCMS',
+              ctaText: 'Click me',
+            },
+          },
+        ],
+      }
+
+      await store.write(unsafeAsLogicalPath('content/posts'), unsafeAsEntrySlug('complex'), {
+        format: 'md',
+        data: complexData,
+        body: '# Hello World\n\nSome **bold** text with `code`.',
+      })
+
+      const doc = await store.read(
+        unsafeAsLogicalPath('content/posts'),
+        unsafeAsEntrySlug('complex'),
+      )
+      if (doc.format === 'json') throw new Error('expected markdown')
+
+      // Verify all frontmatter data survived the roundtrip
+      expect(doc.data.title).toBe('Complex Post')
+      expect(doc.data.author).toBe('5NVkkrB1MJUv')
+      expect(doc.data.tags).toEqual(['typed', 'fast'])
+      expect(doc.data.published).toBe(false)
+      expect(doc.data.blocks).toEqual(complexData.blocks)
+
+      // Verify body survived
+      expect(doc.body).toContain('# Hello World')
+      expect(doc.body).toContain('Some **bold** text')
+    })
+  })
+})