@nuasite/cms 0.46.2 → 0.46.3

package/package.json

@@ -14,7 +14,7 @@
     "directory": "packages/astro-cms"
   },
   "license": "Apache-2.0",
-  "version": "0.46.2",
+  "version": "0.46.3",
   "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.3",
+    "@nuasite/cms-types": "0.46.3",
     "@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.3",
+    "@nuasite/collections-admin": "0.46.3",
     "@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.3",
+    "@nuasite/collections-admin": "0.46.3",
     "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/collection-finder.ts

@@ -342,6 +342,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

package/src/source-finder/index.ts

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