fix(collection): handle root index collisions

Author: onmax

src/module/src/runtime/utils/collection.ts

@@ -5,6 +5,33 @@ import { join, dirname, parse } from 'pathe'
 import { withoutLeadingSlash, withoutTrailingSlash } from 'ufo'
 import { parseSourceBase } from './source'
 
+function joinSourcePath(root: string, path: string) {
+  return withoutLeadingSlash(withoutTrailingSlash(!root || root === '/' ? path : join(root, path)))
+}
+
+function getSourceRoot(source: ResolvedCollectionSource) {
+  const { fixed } = parseSourceBase(source)
+  const normalizedFixed = withoutLeadingSlash(withoutTrailingSlash(fixed))
+  const normalizedCwd = withoutLeadingSlash(withoutTrailingSlash(source.cwd || ''))
+
+  let cwdRoot = ''
+
+  if (normalizedCwd === 'content' || normalizedCwd.endsWith('/content')) {
+    cwdRoot = ''
+  }
+  else if (normalizedCwd.startsWith('content/')) {
+    cwdRoot = normalizedCwd.slice('content/'.length)
+  }
+  else if (normalizedCwd.includes('/content/')) {
+    cwdRoot = normalizedCwd.split('/content/').pop() || ''
+  }
+  else if (normalizedCwd) {
+    cwdRoot = normalizedCwd
+  }
+
+  return joinSourcePath(cwdRoot, normalizedFixed)
+}
+
 /**
  * Generation methods
  */
@@ -13,33 +40,29 @@ export function generateStemFromFsPath(path: string) {
 }
 
 export function generateIdFromFsPath(path: string, collectionInfo: CollectionInfo) {
-  const { fixed } = parseSourceBase(collectionInfo.source[0]!)
+  const source = collectionInfo.source[0]!
+  const sourceRoot = getSourceRoot(source)
+  const normalizedPath = withoutLeadingSlash(path)
 
-  const pathWithoutFixed = path.substring(fixed.length)
+  const pathWithoutFixed = sourceRoot && normalizedPath.startsWith(sourceRoot + '/')
+    ? normalizedPath.substring(sourceRoot.length + 1)
+    : normalizedPath
 
-  return join(collectionInfo.name, collectionInfo.source[0]?.prefix || '', pathWithoutFixed)
+  return join(collectionInfo.name, source.prefix || '', pathWithoutFixed)
 }
 
 export function generateFsPathFromId(id: string, source: ResolvedCollectionSource) {
   const [_, ...rest] = id.split(/[/:]/)
   let path = rest.join('/')
-
-  const { fixed } = parseSourceBase(source)
-  const normalizedFixed = withoutTrailingSlash(fixed)
+  const sourceRoot = getSourceRoot(source)
 
   // If source has a prefix and the path starts with the prefix, remove the prefix
   const prefix = withoutTrailingSlash(withoutLeadingSlash(source.prefix || ''))
   if (prefix && prefix !== '/' && path.startsWith(prefix + '/')) {
     path = path.substring(prefix.length + 1)
   }
 
-  // If path already starts with the fixed part, return as is
-  if (normalizedFixed && path.startsWith(normalizedFixed)) {
-    return path
-  }
-
-  // Otherwise, join fixed part with path
-  return join(fixed, path)
+  return joinSourcePath(sourceRoot, path)
 }
 
 /**
@@ -70,8 +93,9 @@ export function getCollectionByFilePath(path: string, collections: Record<string
     const paths = path === '/' ? ['index.yml', 'index.yaml', 'index.md', 'index.json'] : [path]
     return paths.some((p) => {
       matchedSource = collection.source.find((source) => {
-        const include = minimatch(p, source.include, { dot: true })
-        const exclude = source.exclude?.some(exclude => minimatch(p, exclude))
+        const sourceRoot = getSourceRoot(source)
+        const include = minimatch(p, joinSourcePath(sourceRoot, source.include), { dot: true })
+        const exclude = source.exclude?.some(exclude => minimatch(p, joinSourcePath(sourceRoot, exclude)))
 
         return include && !exclude
       })

src/module/test/utils/collection.test.ts

@@ -53,6 +53,61 @@ describe('getCollectionByFilePath', () => {
     const result = generateFsPathFromId(id, source)
     expect(result).toBe('fs-prefix/hello.md')
   })
+
+  it('should keep root and prefixed collection indexes distinct', () => {
+    const marketing: CollectionInfo = {
+      name: 'marketing',
+      pascalName: 'Marketing',
+      tableName: '_content_marketing',
+      source: [
+        {
+          _resolved: true,
+          include: '*.md',
+          prefix: '/',
+          cwd: 'content',
+        },
+      ],
+      type: 'page',
+      fields: {},
+      schema: {
+        $schema: 'http://json-schema.org/draft-07/schema#',
+        $ref: '#/definitions/marketing',
+        definitions: {},
+      },
+      tableDefinition: '',
+    }
+
+    const guides: CollectionInfo = {
+      name: 'guides',
+      pascalName: 'Guides',
+      tableName: '_content_guides',
+      source: [
+        {
+          _resolved: true,
+          include: '**/*.md',
+          prefix: '/guides',
+          cwd: 'content/guides',
+        },
+      ],
+      type: 'page',
+      fields: {},
+      schema: {
+        $schema: 'http://json-schema.org/draft-07/schema#',
+        $ref: '#/definitions/guides',
+        definitions: {},
+      },
+      tableDefinition: '',
+    }
+
+    const collections = { marketing, guides }
+
+    expect(generateIdFromFsPath('index.md', marketing)).toBe('marketing/index.md')
+    expect(generateIdFromFsPath('guides/index.md', guides)).toBe('guides/guides/index.md')
+    expect(generateFsPathFromId('marketing/index.md', marketing.source[0]!)).toBe('index.md')
+    expect(generateFsPathFromId('guides/guides/index.md', guides.source[0]!)).toBe('guides/index.md')
+    expect(getCollectionByFilePath('index.md', collections)?.name).toBe('marketing')
+    expect(getCollectionByFilePath('guides/index.md', collections)?.name).toBe('guides')
+  })
 })
 
 describe('generateFsPathFromId', () => {