@nuasite/cms 0.46.5 → 0.47.0

package/src/dev-middleware.ts

@@ -1,4 +1,4 @@
-import { createCmsCore, createNodeFs } from '@nuasite/cms-core'
+import { createCmsCore, createNodeFs, resolvePathnameFromSpec } from '@nuasite/cms-core'
 import fs from 'node:fs/promises'
 import type { IncomingMessage, ServerResponse } from 'node:http'
 import path from 'node:path'
@@ -193,23 +193,33 @@ export function createDevMiddleware(
 
 			for (const [name, def] of Object.entries(collectionDefs)) {
 				const routeInfo = collectionRoutes.get(def.name)
-
-				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 {
-					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: resolvePathname(e) ?? e.pathname }),
-					}
-				}
+				const routePrefix = typeof routeInfo === 'string' ? routeInfo : undefined
+				// Whether any page route renders this collection. The heuristic fallbacks
+				// below (a frontmatter-declared site path, or the discovered route prefix)
+				// only apply to routed collections — otherwise a declared `cms.pathname`
+				// spec whose fields are missing for an entry would fabricate a URL from an
+				// unrelated frontmatter field (e.g. a data collection's own `url`).
+				const routed = routeInfo !== undefined
+
+				// A declarative `cms.pathname` rule is the highest-priority source: it wins
+				// over the rendered-route pathname (addPage set entry.pathname to the page
+				// URL). resolvePathnameFromSpec is the same resolver manifest-writer uses at
+				// build, so dev-preview and the built manifest agree on the entry's URL.
+				const resolvePathname = (entry: CollectionEntryInfo): string | undefined =>
+					resolvePathnameFromSpec(def, entry.data)
+						?? entry.pathname
+						?? (routed ? declaredSitePathFromData(entry.data) : undefined)
+						?? (routePrefix ? `${routePrefix}${entry.slug}` : undefined)
+
+				// Build patched copies rather than mutating the originals so heuristic
+				// pathnames don't persist if the route file is later removed. Only patch
+				// entries whose resolved pathname differs from what they already have.
+				const patchedEntries = def.entries?.map(e => {
+					const pathname = resolvePathname(e)
+					return pathname && pathname !== e.pathname ? { ...e, pathname } : e
+				})
+				const changed = patchedEntries?.some((e, i) => e !== def.entries![i]) ?? false
+				responseCollectionDefs[name] = changed ? { ...def, entries: patchedEntries! } : def
 
 				const entries = responseCollectionDefs[name].entries
 				if (entries) {
@@ -440,7 +450,7 @@ async function markHtmlForDev(
 	const idGenerator = () => `cms-${pageCounter++}`
 
 	// Check if this is a collection page
-	const collectionInfo = await findCollectionSource(pagePath, config.contentDir)
+	const collectionInfo = await findCollectionSource(pagePath, config.contentDir, manifestWriter.getCollectionDefinitions())
 	const isCollectionPage = !!collectionInfo
 
 	let mdContent: Awaited<ReturnType<typeof parseMarkdownContent>> | undefined

package/src/handlers/api-routes.ts

@@ -2,11 +2,11 @@ import type { CmsCore, CmsFileSystem } from '@nuasite/cms-core'
 import { listProjectImages } from '@nuasite/cms-core'
 import type { IncomingMessage, ServerResponse } from 'node:http'
 import path from 'node:path'
-import { scanCollections } from '../collection-scanner'
 import { getProjectRoot } from '../config'
 import { expectedDeletions } from '../dev-middleware'
 import type { ManifestWriter } from '../manifest-writer'
 import type { MediaStorageAdapter } from '../media/types'
+import { scanCollections } from '../scan-cache'
 import { handleAddArrayItem, handleRemoveArrayItem } from './array-ops'
 import { tryAstroImageUpload } from './astro-image-upload'
 import { handleInsertComponent, handleRemoveComponent } from './component-ops'

package/src/index.ts

@@ -7,9 +7,8 @@ import { fileURLToPath } from 'node:url'
 import { createLocalStorageAdapter } from '@nuasite/cms-core'
 import remarkDirective from 'remark-directive'
 import { processBuildOutput } from './build-processor'
-import { scanCollections } from './collection-scanner'
 import { ComponentRegistry } from './component-registry'
-import { resetProjectRoot } from './config'
+import { getProjectRoot, resetProjectRoot } from './config'
 import { createDevMiddleware } from './dev-middleware'
 import { getErrorCollector, resetErrorCollector } from './error-collector'
 import { ADMIN_ROUTE, createLocalAdminMiddleware } from './local-admin'
@@ -18,6 +17,7 @@ import type { MediaStorageAdapter } from './media/types'
 import { type CmsMode, resolveCmsMode } from './mode'
 import { rehypeCmsMarker } from './rehype-cms-marker'
 import { remarkListDirective } from './remark-list-directive'
+import { scanCollections } from './scan-cache'
 import type { CmsFeatures, CmsMarkerOptions, ComponentDefinition } from './types'
 import { createPublicStaticFileChecker } from './utils'
 import { createVitePlugin } from './vite-plugin'
@@ -482,14 +482,14 @@ export {
 	createS3StorageAdapter as s3Media,
 } from '@nuasite/cms-core'
 export { FIELD_TYPES, isFieldType } from '@nuasite/cms-types'
-export type { CollectionLayout, CollectionLayoutSection } from '@nuasite/cms-types'
+export type { CollectionLayout, CollectionLayoutSection, PathnameSegment, PathnameSpec } from '@nuasite/cms-types'
 export { defineCmsCollection, n } from './field-types'
 export type { DateHints, FileHints, ImageHints, LayoutHints, NumberHints, TextareaHints, TextHints } from './field-types'
 export type { MediaFolderItem, MediaItem, MediaListOptions, MediaListResult, MediaStorageAdapter, MediaTypeFilter } from './media/types'
 export { type CmsMode, detectHostedFromEnv, resolveCmsMode } from './mode'
 export type { Color, Date, DateTime, Email, Image, Reference, Textarea, Time, Url } from './prop-types'
 
-export { scanCollections } from './collection-scanner'
+export { scanCollections } from '@nuasite/cms-core'
 export { getProjectRoot, resetProjectRoot, setProjectRoot } from './config'
 export { type FieldMigration, migrateAstroImages, type MigrationOptions, type MigrationResult } from './migrate-astro-image'
 export { rehypeCmsMarker } from './rehype-cms-marker'

package/src/manifest-writer.ts

@@ -1,3 +1,4 @@
+import { resolvePathnameFromSpec } from '@nuasite/cms-core'
 import fs from 'node:fs/promises'
 import path from 'node:path'
 import { getProjectRoot } from './config'
@@ -279,12 +280,19 @@ export class ManifestWriter {
 
 		// Populate pathname on collection definition entries
 		for (const def of Object.values(this.collectionDefinitions)) {
-			if (def.entries) {
-				for (const entry of def.entries) {
-					const pathname = collectionPathMap.get(`${def.name}/${entry.slug}`)
-					if (pathname) {
-						entry.pathname = pathname
-					}
+			if (!def.entries) continue
+			for (const entry of def.entries) {
+				// A declarative `cms.pathname` rule is the highest-priority source: it
+				// wins over the rendered-page pathname. resolvePathnameFromSpec is the
+				// same resolver the dev middleware uses, so dev and build agree.
+				const fromSpec = resolvePathnameFromSpec(def, entry.data)
+				if (fromSpec) {
+					entry.pathname = fromSpec
+					continue
+				}
+				const pathname = collectionPathMap.get(`${def.name}/${entry.slug}`)
+				if (pathname) {
+					entry.pathname = pathname
 				}
 			}
 		}

package/src/migrate-astro-image.ts

@@ -1,8 +1,8 @@
+import { createNodeFs, scanCollections } from '@nuasite/cms-core'
 import fs from 'node:fs/promises'
 import path from 'node:path'
 import { parseDocument } from 'yaml'
 import { pickAstroImageTarget } from './astro-image-paths'
-import { scanCollections } from './collection-scanner'
 import { getProjectRoot } from './config'
 
 export interface MigrationOptions {
@@ -33,7 +33,7 @@ export async function migrateAstroImages(options: MigrationOptions = {}): Promis
 	const projectRoot = options.projectRoot ?? getProjectRoot()
 	const dryRun = options.dryRun ?? false
 
-	const collections = await scanCollections()
+	const collections = await scanCollections(createNodeFs(projectRoot))
 	const migrations: FieldMigration[] = []
 	const skipped: MigrationResult['skipped'] = []
 

package/src/scan-cache.ts

@@ -0,0 +1,22 @@
+import { createNodeFs, type ParseCache, scanCollections as coreScanCollections } from '@nuasite/cms-core'
+import type { CollectionDefinition } from '@nuasite/cms-types'
+import { getProjectRoot } from './config'
+
+/**
+ * Process-persistent content-config parse cache shared across every standalone
+ * collection scan (server setup + each entry create/delete). cms-core's
+ * `parseContentConfig` is mtime-keyed, so threading one cache here lets repeated
+ * scans skip re-reading and re-Babel-parsing `content.config.ts` when it hasn't
+ * changed — the CmsCore instance keeps its own cache the same way, but these
+ * top-level call sites bypass it.
+ */
+const parseCache: ParseCache = new Map()
+
+/**
+ * Scan all content collections against the current project root, reusing the
+ * shared {@link parseCache}. Drop-in replacement for cms-core's `scanCollections`
+ * for the dev-server call sites that would otherwise each allocate a fresh cache.
+ */
+export function scanCollections(contentDir?: string): Promise<Record<string, CollectionDefinition>> {
+	return coreScanCollections(createNodeFs(getProjectRoot()), contentDir, parseCache)
+}

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

@@ -1,8 +1,10 @@
+import { resolvePathnameFromSpec } from '@nuasite/cms-core'
 import fs from 'node:fs/promises'
 import path from 'node:path'
 import { isMap, isPair, isScalar, isSeq, LineCounter, parseDocument } from 'yaml'
 
 import { getProjectRoot } from '../config'
+import { scanCollections } from '../scan-cache'
 import type { CollectionDefinition } from '../types'
 import { getCollectionTextIndex, getDeclaredUrlIndexCache, getMarkdownFileCache, setCollectionTextIndex } from './cache'
 import { normalizeText } from './snippet-utils'
@@ -249,6 +251,7 @@ const DECLARED_URL_FIELDS = ['urlpath', 'permalink', 'pathname', 'route', 'url']
 export async function findCollectionSource(
 	pagePath: string,
 	contentDir: string = 'src/content',
+	collections?: Record<string, CollectionDefinition>,
 ): Promise<CollectionInfo | undefined> {
 	// Remove leading/trailing slashes
 	const cleanPath = pagePath.replace(/^\/+|\/+$/g, '')
@@ -259,6 +262,18 @@ export async function findCollectionSource(
 	}
 
 	const requestedUrl = normalizeSitePath(`/${cleanPath}`)
+
+	// Highest priority: derive each entry's canonical URL from its collection's
+	// declarative `cms.pathname` rule (the same spec the forward resolver/manifest
+	// use) and match. This keeps reverse resolution (URL → source file) consistent
+	// with forward resolution without the entry needing a redundant `urlPath`
+	// frontmatter field, and correctly resolves entries whose filename differs
+	// from their URL slug (e.g. people stored as `<role>__<slug>.md` served at
+	// `/<family>/<slug>`). Collections without a `cms.pathname` rule contribute
+	// nothing here and fall through to the filename/declared-URL logic below.
+	const bySpec = await resolveBySpec(requestedUrl, contentDir, collections)
+	if (bySpec) return bySpec
+
 	const contentPath = path.join(getProjectRoot(), contentDir)
 
 	try {
@@ -357,6 +372,67 @@ export async function findCollectionSource(
 	return undefined
 }
 
+// Reverse index (computed spec URL → source) cached per scanned-collections
+// object. The scan cache hands back a fresh object identity whenever the
+// content config or any entry changes, so a WeakMap keyed on it rebuilds the
+// index exactly when the underlying data changes and never goes stale.
+const specPathnameIndexCache = new WeakMap<object, Map<string, CollectionInfo>>()
+
+/**
+ * Resolve `requestedUrl` to a source file by applying each collection's
+ * declarative `cms.pathname` rule to its entries' frontmatter data. Returns
+ * undefined when no collection declares a rule or none produces `requestedUrl`.
+ *
+ * `collections` should be the definitions already scanned once at plugin setup
+ * (`manifestWriter.getCollectionDefinitions()`) — passing them keeps this off the
+ * hot per-page path with no rescans and guarantees the reverse index matches the
+ * forward resolver's specs exactly. When omitted (tests, misc callers) it falls
+ * back to a self-contained scan.
+ */
+async function resolveBySpec(
+	requestedUrl: string,
+	contentDir: string,
+	collections: Record<string, CollectionDefinition> | undefined,
+): Promise<CollectionInfo | undefined> {
+	let defs = collections
+	if (!defs) {
+		try {
+			defs = await scanCollections(contentDir)
+		} catch {
+			return undefined
+		}
+	}
+
+	let index = specPathnameIndexCache.get(defs)
+	if (!index) {
+		index = buildSpecPathnameIndex(defs)
+		specPathnameIndexCache.set(defs, index)
+	}
+	return index.get(requestedUrl)
+}
+
+/**
+ * Build a `computed-URL → CollectionInfo` map from every collection that
+ * declares a `cms.pathname` rule. Collections and entries are visited in sorted
+ * order and the first writer of a URL wins, so a URL collision (a content bug)
+ * resolves deterministically rather than depending on scan/readdir order.
+ */
+function buildSpecPathnameIndex(collections: Record<string, CollectionDefinition>): Map<string, CollectionInfo> {
+	const index = new Map<string, CollectionInfo>()
+	for (const name of Object.keys(collections).sort()) {
+		const def = collections[name]
+		if (!def?.pathname || !def.entries) continue
+		const entries = [...def.entries].sort((a, b) => a.slug.localeCompare(b.slug))
+		for (const entry of entries) {
+			if (!entry.data) continue
+			const url = resolvePathnameFromSpec(def, entry.data)
+			if (!url || index.has(url)) continue
+			index.set(url, { name: def.name, slug: entry.slug, file: entry.sourcePath })
+		}
+	}
+	return index
+}
+
 /** Normalize a site-absolute path: ensure a leading slash, drop query/hash and any trailing slash. */
 function normalizeSitePath(p: string): string {
 	let s = p.split('?')[0]?.split('#')[0] ?? p

package/src/types.ts

@@ -24,6 +24,8 @@ export type {
 	FieldHints,
 	FieldType,
 	MutationResult,
+	PathnameSegment,
+	PathnameSpec,
 } from '@nuasite/cms-types'
 export type {
 	AddRedirectRequest,