@nuasite/cms 0.46.2 → 0.46.4

package/package.json

@@ -14,7 +14,7 @@
     "directory": "packages/astro-cms"
   },
   "license": "Apache-2.0",
-  "version": "0.46.2",
+  "version": "0.46.4",
   "module": "src/index.ts",
   "types": "src/index.ts",
   "type": "module",
@@ -26,8 +26,8 @@
     }
   },
   "dependencies": {
-    "@nuasite/cms-core": "0.46.2",
-    "@nuasite/cms-types": "0.46.2",
+    "@nuasite/cms-core": "0.46.4",
+    "@nuasite/cms-types": "0.46.4",
     "@astrojs/compiler": "^3.0.1",
     "@babel/parser": "^7.29.2",
     "node-html-parser": "^7.1.0",
@@ -35,8 +35,8 @@
     "yaml": "^2.8.3"
   },
   "devDependencies": {
-    "@nuasite/cms-sidecar": "0.46.2",
-    "@nuasite/collections-admin": "0.46.2",
+    "@nuasite/cms-sidecar": "0.46.4",
+    "@nuasite/collections-admin": "0.46.4",
     "@babel/types": "^7.29.0",
     "@types/react": "^19.2.7",
     "@types/react-dom": "^19.2.3",
@@ -76,8 +76,8 @@
     "typescript": "^6.0.2",
     "vite": "^7.0.0",
     "@aws-sdk/client-s3": "^3.0.0",
-    "@nuasite/cms-sidecar": "0.46.2",
-    "@nuasite/collections-admin": "0.46.2",
+    "@nuasite/cms-sidecar": "0.46.4",
+    "@nuasite/collections-admin": "0.46.4",
     "react": "^19.0.0",
     "react-dom": "^19.0.0"
   },

package/src/dev-middleware.ts

@@ -17,6 +17,7 @@ import { processHtml } from './html-processor'
 import type { ManifestWriter } from './manifest-writer'
 import type { MediaStorageAdapter } from './media/types'
 import {
+	declaredSitePathFromData,
 	enhanceManifestWithSourceSnippets,
 	findCollectionSource,
 	findImageSourceLocation,
@@ -28,6 +29,7 @@ import type {
 	CmsMarkerOptions,
 	CollectionDefinition,
 	CollectionEntry,
+	CollectionEntryInfo,
 	ComponentDefinition,
 	ComponentInstance,
 	ManifestEntry,
@@ -176,24 +178,36 @@ export function createDevMiddleware(
 			}
 
 			// 2. Add collection entry pages from collection definitions,
-			//    pre-populating pathnames from filesystem routes so the collections
-			//    browser can redirect to detail pages without visiting them first.
-			//    We build patched copies rather than mutating the originals so that
-			//    heuristic pathnames don't persist if the route file is later removed.
+			//    pre-populating pathnames so the collections browser can redirect to
+			//    detail pages without visiting them first. Prefer the entry's own
+			//    declared URL (urlPath/permalink/…) from frontmatter, which is
+			//    correct even when the collection is served under a *dynamic* route
+			//    prefix (e.g. `[topic]/[slug]`) that discoverCollectionRoutes can't
+			//    map to a static prefix. Fall back to the discovered static route
+			//    prefix + slug. We build patched copies rather than mutating the
+			//    originals so that heuristic pathnames don't persist if the route
+			//    file is later removed.
 			const collectionDefs = manifestWriter.getCollectionDefinitions()
 			const collectionRoutes = await discoverCollectionRoutes()
 			const responseCollectionDefs: Record<string, CollectionDefinition> = {}
 
 			for (const [name, def] of Object.entries(collectionDefs)) {
-				const routePrefix = collectionRoutes.get(def.name)
-				const needsPatching = routePrefix && def.entries?.some(e => !e.pathname)
+				const routeInfo = collectionRoutes.get(def.name)
 
-				if (!needsPatching) {
+				if (routeInfo === undefined) {
+					// No page renders this collection at all — leave entries alone rather
+					// than fabricating a pathname from an unrelated frontmatter field
+					// (e.g. a data collection's own `url` field pointing elsewhere).
 					responseCollectionDefs[name] = def
 				} else {
-					responseCollectionDefs[name] = {
+					const routePrefix = typeof routeInfo === 'string' ? routeInfo : undefined
+					const resolvePathname = (entry: CollectionEntryInfo): string | undefined =>
+						declaredSitePathFromData(entry.data) ?? (routePrefix ? `${routePrefix}${entry.slug}` : undefined)
+					const needsPatching = def.entries?.some(e => !e.pathname && resolvePathname(e))
+
+					responseCollectionDefs[name] = !needsPatching ? def : {
 						...def,
-						entries: def.entries!.map(e => e.pathname ? e : { ...e, pathname: `${routePrefix}${e.slug}` }),
+						entries: def.entries!.map(e => e.pathname ? e : { ...e, pathname: resolvePathname(e) ?? e.pathname }),
 					}
 				}
 
@@ -693,8 +707,17 @@ async function discoverPagesFromFilesystem(): Promise<string[]> {
 	return pages
 }
 
+/**
+ * A collection's route info: a usable static URL prefix (e.g. '/blog/'), or
+ * `true` when the collection is confirmed routed by some page but no static
+ * prefix can be fabricated because an ancestor path segment is itself dynamic
+ * (e.g. `[topic]/[slug].astro`) — callers must resolve those entries' pathnames
+ * from their own declared URL instead of `${prefix}${slug}`.
+ */
+type CollectionRouteInfo = string | true
+
 /** Cached result of collection route discovery; invalidated by file watcher */
-let collectionRoutesCache: Map<string, string> | null = null
+let collectionRoutesCache: Map<string, CollectionRouteInfo> | null = null
 
 /** Invalidate the cached collection routes (called from vite-plugin when route files change) */
 export function invalidateCollectionRoutesCache() {
@@ -702,16 +725,19 @@ export function invalidateCollectionRoutesCache() {
 }
 
 /**
- * Discover collection route patterns by scanning src/pages for dynamic route files
- * (e.g. [slug].astro) that call getCollection(). Returns a map from collection name
- * to the URL prefix (e.g. 'blog' → '/blog/'). Result is cached after first call.
+ * Discover which collections are rendered as pages by scanning src/pages for
+ * dynamic route files (e.g. [slug].astro) that call getCollection(). Returns a
+ * map from collection name to its route info (see {@link CollectionRouteInfo}).
+ * Recurses into dynamic directories too (e.g. `[topic]/[slug].astro`) so those
+ * collections are still recognized as routed, just without a static prefix.
+ * Result is cached after first call.
  */
-async function discoverCollectionRoutes(): Promise<Map<string, string>> {
+export async function discoverCollectionRoutes(): Promise<Map<string, CollectionRouteInfo>> {
 	if (collectionRoutesCache) return collectionRoutesCache
 
 	const projectRoot = getProjectRoot()
 	const pagesDir = path.join(projectRoot, 'src', 'pages')
-	const routes = new Map<string, string>()
+	const routes = new Map<string, CollectionRouteInfo>()
 
 	try {
 		await fs.access(pagesDir)
@@ -720,16 +746,14 @@ async function discoverCollectionRoutes(): Promise<Map<string, string>> {
 		return routes
 	}
 
-	async function walk(dir: string, urlPrefix: string) {
+	async function walk(dir: string, urlPrefix: string, dynamicAncestor: boolean) {
 		const entries = await fs.readdir(dir, { withFileTypes: true })
 		for (const entry of entries) {
 			if (entry.name.startsWith('_') || entry.name.startsWith('.')) continue
 
 			const fullPath = path.join(dir, entry.name)
 			if (entry.isDirectory()) {
-				// Skip directories with dynamic segments
-				if (entry.name.includes('[')) continue
-				await walk(fullPath, `${urlPrefix}${entry.name}/`)
+				await walk(fullPath, `${urlPrefix}${entry.name}/`, dynamicAncestor || entry.name.includes('['))
 			} else {
 				const ext = path.extname(entry.name)
 				if (!PAGE_EXTENSIONS.has(ext)) continue
@@ -740,14 +764,17 @@ async function discoverCollectionRoutes(): Promise<Map<string, string>> {
 					const content = await fs.readFile(fullPath, 'utf-8')
 					const match = content.match(/getCollection\(\s*['"](\w+)['"]\s*\)/)
 					if (match?.[1]) {
-						routes.set(match[1], urlPrefix)
+						// A static prefix is only usable when no ancestor directory is
+						// itself dynamic — otherwise record "routed, no prefix" so the
+						// caller still trusts declared URLs without fabricating one.
+						routes.set(match[1], dynamicAncestor ? true : urlPrefix)
 					}
 				} catch { /* skip unreadable files */ }
 			}
 		}
 	}
 
-	await walk(pagesDir, '/')
+	await walk(pagesDir, '/', false)
 	collectionRoutesCache = routes
 	return routes
 }

package/src/editor/components/markdown-editor-overlay.tsx

@@ -1,6 +1,6 @@
 import { type Editor, editorViewCtx } from '@milkdown/core'
 import { useCallback, useEffect, useRef, useState } from 'preact/hooks'
-import { slugify } from '../../shared'
+import { resolveCreateRedirectUrl, slugify } from '../../shared'
 import { updateMarkdownPage } from '../api'
 import { STORAGE_KEYS, Z_INDEX } from '../constants'
 import { cn } from '../lib/cn'
@@ -240,17 +240,7 @@ export function MarkdownEditorOverlay() {
 			})
 
 			if (result.success) {
-				// Derive the new page URL from existing collection entry pathnames
-				const entries = opts.collectionDefinition.entries ?? []
-				const existingEntry = entries.find((e) => e.pathname)
-				let redirectUrl: string | undefined
-				if (existingEntry?.pathname) {
-					// Extract base path from an existing entry pathname (e.g., "/blog/first-post" → "/blog/")
-					const lastSlash = existingEntry.pathname.lastIndexOf('/')
-					if (lastSlash >= 0) {
-						redirectUrl = existingEntry.pathname.slice(0, lastSlash + 1) + slug
-					}
-				}
+				const redirectUrl = resolveCreateRedirectUrl(opts.collectionDefinition.entries ?? [], slug)
 
 				showToast(STRINGS.markdown.pageCreated, 'success')
 				resetMarkdownEditorState()

package/src/shared.ts

@@ -25,3 +25,25 @@ export function slugifyHref(text: string): string {
 		.replace(/[\s_]+/g, '-')
 		.replace(/^-+|-+$/g, '')
 }
+
+/**
+ * Derive the pathname a newly created collection entry will resolve to, from
+ * the pathnames of existing sibling entries. Entries can resolve their own
+ * pathname from a per-entry declared URL field (see `declaredSitePathFromData`
+ * in the source-finder package), so entries in the same collection can live
+ * under different prefixes -- e.g. a collection served under a dynamic
+ * `[topic]/[slug]` route. Only reuse a sibling's prefix when every entry that
+ * has a pathname agrees on the same one; otherwise there's no way to know
+ * which prefix the new entry belongs under, and guessing wrong would send the
+ * user to an unrelated page.
+ */
+export function resolveCreateRedirectUrl(entries: Array<{ pathname?: string }>, slug: string): string | undefined {
+	const prefixes = new Set(
+		entries
+			.map((e) => e.pathname)
+			.filter((p): p is string => !!p)
+			.map((p) => p.slice(0, p.lastIndexOf('/') + 1))
+			.filter((prefix) => prefix.length > 0),
+	)
+	return prefixes.size === 1 ? `${[...prefixes][0]}${slug}` : undefined
+}

package/src/source-finder/cache.ts

@@ -1,3 +1,4 @@
+import path from 'node:path'
 import type { CachedParsedFile, ImageIndexEntry, SearchIndexEntry, SourceLocation } from './types'
 
 // ============================================================================
@@ -113,10 +114,16 @@ export function markFileDirty(absPath: string): void {
 	dirtyFiles.add(absPath)
 	// Also evict the parsed file cache so it's re-read from disk
 	parsedFileCache.delete(absPath)
-	// A changed file may add/remove/alter a declared URL anywhere in its
-	// collection directory — cheaper to drop the whole cache than track
-	// per-directory membership for a rarely-hit index.
-	declaredUrlIndexCache.clear()
+	// A changed file may add/remove/alter its declared URL, so drop the URL→file
+	// index for its collection directory. The index is keyed by collection dir:
+	// for a flat `<dir>/<slug>.md` that's the file's directory; for Hugo-style
+	// `<dir>/<slug>/index.md` it's the parent of the file's directory. Evict both
+	// candidates (deleting a non-existent key is a no-op) instead of clearing the
+	// whole cache, which would rebuild every collection's index on the next
+	// unmatched-page lookup.
+	const fileDir = path.dirname(absPath)
+	declaredUrlIndexCache.delete(fileDir)
+	declaredUrlIndexCache.delete(path.dirname(fileDir))
 }
 
 export function getDirtyFiles(): Set<string> {

package/src/source-finder/collection-finder.ts

@@ -300,7 +300,7 @@ export async function findCollectionSource(
 		// Prefer the entry whose declared canonical URL equals the requested
 		// path. Only kicks in when an entry actually declares a URL, so
 		// URL-less projects fall through to the filename logic unchanged.
-		const byUrl = await resolveByDeclaredUrl(matches, requestedUrl, contentPath)
+		const byUrl = await resolveByDeclaredUrl(matches, requestedUrl, contentPath, pathParts[0])
 		if (byUrl) {
 			// byUrl.file may differ from the file the filename match found
 			// (that's the whole point of this fallback) — its slug must be
@@ -331,6 +331,29 @@ export async function findCollectionSource(
 		}
 	}
 
+	// No filename-based candidate matched any tail slug. The source file may be
+	// named unlike its URL entirely — e.g. people entries stored as
+	// `<role>__<slug>.md` but served at `/<family>/<slug>`, so no tail segment
+	// ever hits a `<slug>.md` file. Fall back to resolving by declared canonical
+	// URL across every collection.
+	//
+	// Guarded to multi-segment paths: the tail-slug loop above only ran for
+	// `pathParts.length >= 2`, so single-segment paths (bare static pages like
+	// `/about`) were never treated as collection pages. Keeping that boundary
+	// avoids both a full declared-URL scan on every such page and the risk of
+	// mis-attributing a static page to a collection entry that happens to
+	// declare the same URL.
+	if (pathParts.length >= 2) {
+		const byDeclaredUrl = await findByDeclaredUrlAcross(collectionDirs, contentPath, requestedUrl, pathParts[0])
+		if (byDeclaredUrl) {
+			return {
+				name: byDeclaredUrl.name,
+				slug: slugFromFilePath(byDeclaredUrl.file),
+				file: path.relative(getProjectRoot(), byDeclaredUrl.file),
+			}
+		}
+	}
+
 	return undefined
 }
 
@@ -342,6 +365,26 @@ function normalizeSitePath(p: string): string {
 	return s
 }
 
+/**
+ * Extract an entry's declared canonical site path from its already-parsed
+ * frontmatter/data object (e.g. `CollectionEntryInfo.data`). Same field set and
+ * rules as {@link readDeclaredPageUrl}, but operates in-memory so callers that
+ * already hold the data don't re-read the file. Returns the normalized
+ * site-absolute path, or undefined when no site-absolute URL field is declared.
+ */
+export function declaredSitePathFromData(data: unknown): string | undefined {
+	if (!data || typeof data !== 'object') return undefined
+	const lowerKeyed = new Map<string, unknown>()
+	for (const [key, value] of Object.entries(data as Record<string, unknown>)) {
+		lowerKeyed.set(key.toLowerCase(), value)
+	}
+	for (const field of DECLARED_URL_FIELDS) {
+		const value = lowerKeyed.get(field)
+		if (typeof value === 'string' && value.startsWith('/')) return normalizeSitePath(value)
+	}
+	return undefined
+}
+
 /**
  * Derive a collection entry's slug from its file path, matching the same
  * convention collection-scanner.ts uses: flat `<slug>.md(x)` files use the
@@ -408,6 +451,7 @@ async function resolveByDeclaredUrl(
 	matches: { name: string; file: string }[],
 	requestedUrl: string,
 	contentPath: string,
+	urlPrefix: string | undefined,
 ): Promise<{ name: string; file: string } | undefined> {
 	let sawDeclaredUrl = false
 	for (const m of matches) {
@@ -421,13 +465,30 @@ async function resolveByDeclaredUrl(
 
 	// Contradiction: the right entry is named differently from its slug. Scan
 	// the collection(s) that produced filename matches for a declared-URL hit.
-	// `matches` (and thus this Set) is built by iterating the sorted
-	// `collectionDirs`, so directory order here is deterministic.
-	for (const dir of new Set(matches.map(m => m.name))) {
+	return findByDeclaredUrlAcross([...new Set(matches.map(m => m.name))], contentPath, requestedUrl, urlPrefix)
+}
+
+/**
+ * Resolve `requestedUrl` to a source file by its declared canonical URL across
+ * the given collection directories, using the cached per-directory URL→file
+ * index. When more than one collection declares the same URL, a directory whose
+ * name equals the URL's first path segment wins; otherwise the sorted-first
+ * match is returned so the result is deterministic regardless of readdir order.
+ */
+async function findByDeclaredUrlAcross(
+	dirs: string[],
+	contentPath: string,
+	requestedUrl: string,
+	urlPrefix: string | undefined,
+): Promise<{ name: string; file: string } | undefined> {
+	let firstHit: { name: string; file: string } | undefined
+	for (const dir of [...dirs].sort()) {
 		const hit = await findFileByDeclaredUrl(path.join(contentPath, dir), requestedUrl)
-		if (hit) return { name: dir, file: hit }
+		if (!hit) continue
+		if (dir === urlPrefix) return { name: dir, file: hit }
+		firstHit ??= { name: dir, file: hit }
 	}
-	return undefined
+	return firstHit
 }
 
 /**

package/src/source-finder/index.ts

@@ -25,6 +25,7 @@ export { findImageSourceLocation } from './image-finder'
 // Collection/markdown finding
 export {
 	buildCollectionTextIndex,
+	declaredSitePathFromData,
 	findCollectionSource,
 	findFieldInCollectionEntry,
 	findMarkdownSourceLocation,