@nuasite/cms 0.23.1 → 0.25.0

package/package.json

@@ -14,7 +14,7 @@
     "directory": "packages/astro-cms"
   },
   "license": "Apache-2.0",
-  "version": "0.23.1",
+  "version": "0.25.0",
   "module": "src/index.ts",
   "types": "src/index.ts",
   "type": "module",

package/src/build-processor.ts

@@ -24,7 +24,7 @@ import {
 } from './source-finder'
 import type { ComponentInstance } from './types'
 import type { CmsMarkerOptions, CollectionEntry } from './types'
-import { firstNonEmptyLine } from './utils'
+import { firstNonEmptyLine, resolveSourcePath } from './utils'
 
 // Concurrency limit for parallel processing
 const MAX_CONCURRENT = 10
@@ -425,9 +425,7 @@ async function processFile(
 
 			// Update attribute and colorClasses source information if we have an opening tag
 			if (sourceLocation.openingTagSnippet) {
-				const filePath = path.isAbsolute(sourceLocation.file)
-					? sourceLocation.file
-					: path.join(getProjectRoot(), sourceLocation.file)
+				const filePath = resolveSourcePath(sourceLocation.file)
 				try {
 					const content = await fs.readFile(filePath, 'utf-8')
 					const lines = content.split('\n')

package/src/collection-scanner.ts

@@ -500,6 +500,36 @@ function parseContentConfigFieldTypes(
 	return result
 }
 
+/**
+ * Extract all top-level field names from a schema body string.
+ * Matches `fieldName:` patterns at the start of lines within z.object({...}).
+ */
+function extractSchemaFieldNames(schemaBody: string): Set<string> {
+	const names = new Set<string>()
+	for (const m of schemaBody.matchAll(/^\s*(\w+)\s*:/gm)) {
+		names.add(m[1]!)
+	}
+	return names
+}
+
+/**
+ * When a content config schema exists, filter scanned fields to only include
+ * those defined in the schema. This prevents stale or extra frontmatter fields
+ * from appearing in the CMS editor.
+ */
+function filterFieldsBySchema(
+	collections: Record<string, CollectionDefinition>,
+	schemaBlocks: Array<{ collectionName: string; schemaBody: string }>,
+): void {
+	for (const { collectionName, schemaBody } of schemaBlocks) {
+		const def = collections[collectionName]
+		if (!def) continue
+		const schemaNames = extractSchemaFieldNames(schemaBody)
+		if (schemaNames.size === 0) continue
+		def.fields = def.fields.filter(f => schemaNames.has(f.name))
+	}
+}
+
 /**
  * Apply field type overrides from config parsing to scanned collections.
  */
@@ -759,6 +789,7 @@ export async function scanCollections(contentDir: string = 'src/content'): Promi
 
 	// Post-scan: apply explicit type hints, detect references, and derived fields
 	const schemaBlocks = await parseContentConfigSchemaBlocks()
+	filterFieldsBySchema(collections, schemaBlocks)
 	applyConfigFieldTypes(collections, schemaBlocks)
 	await detectReferenceFields(collections, schemaBlocks)
 	detectDerivedHrefFields(collections)

package/src/handlers/markdown-ops.ts

@@ -162,7 +162,6 @@ export async function handleCreateMarkdown(
 		const fullFrontmatter: BlogFrontmatter = {
 			title,
 			date: new Date().toISOString().split('T')[0]!,
-			draft: true,
 			...frontmatter,
 		}
 		fileContent = serializeFrontmatter(fullFrontmatter, content)

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

@@ -575,6 +575,54 @@ export async function findFieldInCollectionEntry(
 	}
 }
 
+/**
+ * Find multiple fields by name in a specific collection entry's data file.
+ * Parses the YAML only once, unlike calling findFieldInCollectionEntry per field.
+ */
+export async function findFieldsInCollectionEntry(
+	fieldNames: Set<string>,
+	collectionName: string,
+	collectionSlug: string,
+	collectionDefinitions: Record<string, CollectionDefinition>,
+): Promise<Map<string, SourceLocation>> {
+	const def = collectionDefinitions[collectionName]
+	if (!def?.entries) return new Map()
+
+	const entry = def.entries.find((e) => e.slug === collectionSlug)
+	if (!entry) return new Map()
+
+	const info: CollectionInfo = { name: collectionName, slug: collectionSlug, file: entry.sourcePath }
+
+	try {
+		const filePath = path.join(getProjectRoot(), entry.sourcePath)
+		const cached = await getCachedMarkdownFile(filePath)
+		if (!cached) return new Map()
+
+		if (def.type === 'data') {
+			return findFieldsByNameInYaml(cached.content, 0, fieldNames, cached.lines, info)
+		}
+
+		// For markdown, search inside frontmatter only
+		const { lines } = cached
+		let fmStart = -1
+		let fmEnd = -1
+		for (let i = 0; i < lines.length; i++) {
+			if (lines[i]?.trim() === '---') {
+				if (fmStart === -1) fmStart = i
+				else {
+					fmEnd = i
+					break
+				}
+			}
+		}
+		if (fmEnd <= 0) return new Map()
+		const yamlStr = lines.slice(fmStart + 1, fmEnd).join('\n')
+		return findFieldsByNameInYaml(yamlStr, fmStart + 1, fieldNames, lines, info)
+	} catch {
+		return new Map()
+	}
+}
+
 /**
  * Walk a YAML AST to find a field by key name (regardless of its value).
  */
@@ -585,13 +633,30 @@ function findFieldByNameInYaml(
 	fileLines: string[],
 	collectionInfo: CollectionInfo,
 ): SourceLocation | undefined {
+	const results = findFieldsByNameInYaml(yamlStr, lineOffset, new Set([fieldName]), fileLines, collectionInfo)
+	return results.get(fieldName)
+}
+
+/**
+ * Walk a YAML AST to find multiple fields by key name in a single parse.
+ * Returns a map of fieldName → SourceLocation for all matched fields.
+ */
+function findFieldsByNameInYaml(
+	yamlStr: string,
+	lineOffset: number,
+	fieldNames: Set<string>,
+	fileLines: string[],
+	collectionInfo: CollectionInfo,
+): Map<string, SourceLocation> {
 	const lineCounter = new LineCounter()
 	const doc = parseDocument(yamlStr, { lineCounter })
-	if (!isMap(doc.contents)) return undefined
+	const results = new Map<string, SourceLocation>()
+	if (!isMap(doc.contents)) return results
 
 	for (const pair of doc.contents.items) {
 		if (!isPair(pair) || !isScalar(pair.key)) continue
-		if (String(pair.key.value) !== fieldName) continue
+		const key = String(pair.key.value)
+		if (!fieldNames.has(key)) continue
 		if (!isScalar(pair.value)) continue
 
 		const keyRange = (pair.key as any).range as [number, number, number] | undefined
@@ -600,17 +665,20 @@ function findFieldByNameInYaml(
 		const endLine = (valRange ? lineCounter.linePos(valRange[1]).line : startLine - lineOffset) + lineOffset
 
 		const snippet = fileLines.slice(startLine - 1, endLine).join('\n')
-		return {
+		results.set(key, {
 			file: collectionInfo.file,
 			line: startLine,
 			snippet,
 			type: 'collection',
-			variableName: fieldName,
+			variableName: key,
 			collectionName: collectionInfo.name,
 			collectionSlug: collectionInfo.slug,
-		}
+		})
+
+		// Early exit if all fields found
+		if (results.size === fieldNames.size) break
 	}
-	return undefined
+	return results
 }
 
 // ============================================================================

package/src/source-finder/cross-file-tracker.ts

@@ -2,7 +2,7 @@ import fs from 'node:fs/promises'
 import path from 'node:path'
 
 import { getProjectRoot } from '../config'
-import { escapeRegex } from '../utils'
+import { escapeRegex, resolveSourcePath } from '../utils'
 import { buildDefinitionPath, parseExpressionPath } from './ast-extractors'
 import { getCachedParsedFile } from './ast-parser'
 import { findComponentProp, findExpressionProp, findSpreadProp } from './element-finder'
@@ -384,9 +384,7 @@ export async function findAttributeSourceLocation(
 	// Get the property name (last part of the expression)
 	const propName = exprPath.includes('.') ? exprPath.split('.').pop()! : exprPath
 
-	const filePath = path.isAbsolute(sourceFilePath)
-		? sourceFilePath
-		: path.join(getProjectRoot(), sourceFilePath)
+	const filePath = resolveSourcePath(sourceFilePath)
 
 	const cached = await getCachedParsedFile(filePath)
 	if (!cached) return undefined

package/src/source-finder/snippet-utils.ts

@@ -4,10 +4,16 @@ import { parse as parseYaml } from 'yaml'
 
 import { getProjectRoot } from '../config'
 import type { Attribute, CollectionDefinition, ManifestEntry } from '../types'
-import { escapeRegex, generateSourceHash } from '../utils'
+import { escapeRegex, generateSourceHash, resolveSourcePath } from '../utils'
 import { buildDefinitionPath } from './ast-extractors'
 import { getCachedParsedFile } from './ast-parser'
-import { buildCollectionTextIndex, findFieldInCollectionEntry, findTextInAnyCollectionFrontmatter, lookupCollectionText } from './collection-finder'
+import {
+	buildCollectionTextIndex,
+	findFieldInCollectionEntry,
+	findFieldsInCollectionEntry,
+	findTextInAnyCollectionFrontmatter,
+	lookupCollectionText,
+} from './collection-finder'
 import { findAttributeSourceLocation, searchForExpressionProp, searchForPropInParents } from './cross-file-tracker'
 import { findImageElementNearLine, findImageSourceLocation } from './image-finder'
 import { initializeSearchIndex } from './search-index'
@@ -444,9 +450,7 @@ export async function extractSourceSnippet(
 	tag: string,
 ): Promise<string | undefined> {
 	try {
-		const filePath = path.isAbsolute(sourceFile)
-			? sourceFile
-			: path.join(getProjectRoot(), sourceFile)
+		const filePath = resolveSourcePath(sourceFile)
 
 		const content = await fs.readFile(filePath, 'utf-8')
 		const lines = content.split('\n')
@@ -583,9 +587,7 @@ export async function enhanceManifestWithSourceSnippets(
 
 				// Also update attribute and colorClasses source info from the opening tag
 				try {
-					const filePath = path.isAbsolute(imageLocation.file)
-						? imageLocation.file
-						: path.join(getProjectRoot(), imageLocation.file)
+					const filePath = resolveSourcePath(imageLocation.file)
 					const { lines } = await readFileWithCache(filePath)
 					const openingTagInfo = extractOpeningTagWithLine(lines, imageLocation.line - 1, entry.tag)
 
@@ -620,9 +622,7 @@ export async function enhanceManifestWithSourceSnippets(
 			// Fallback for expression-based src attributes (src={variable})
 			if (entry.sourcePath && entry.sourceLine) {
 				try {
-					const filePath = path.isAbsolute(entry.sourcePath)
-						? entry.sourcePath
-						: path.join(getProjectRoot(), entry.sourcePath)
+					const filePath = resolveSourcePath(entry.sourcePath)
 					const cached = await getCachedParsedFile(filePath)
 					if (cached) {
 						const nearbyImg = findImageElementNearLine(cached.ast, entry.sourceLine, cached.lines)
@@ -662,6 +662,18 @@ export async function enhanceManifestWithSourceSnippets(
 			return [id, entry] as const
 		}
 
+		// Collection text: resolve directly from the data file
+		if (entry.text?.trim() && entry.collectionName && entry.collectionSlug && collectionDefinitions) {
+			const textLocation = await resolveCollectionTextField(
+				entry,
+				collectionDefinitions,
+				referenceIndex,
+			)
+			if (textLocation) {
+				return [id, textLocation] as const
+			}
+		}
+
 		// Skip if already has sourceSnippet or missing source info
 		if (entry.sourceSnippet || !entry.sourcePath || !entry.sourceLine || !entry.tag) {
 			return [id, entry] as const
@@ -669,9 +681,7 @@ export async function enhanceManifestWithSourceSnippets(
 
 		// Read file once and extract both snippets
 		try {
-			const filePath = path.isAbsolute(entry.sourcePath)
-				? entry.sourcePath
-				: path.join(getProjectRoot(), entry.sourcePath)
+			const filePath = resolveSourcePath(entry.sourcePath)
 
 			const { content, lines } = await readFileWithCache(filePath)
 
@@ -973,36 +983,33 @@ async function resolveCollectionImageField(
 		return undefined
 	}
 
-	// Multiple image fields — try to match the rendered URL to a field value.
+	// Multiple image fields — fetch all in one YAML parse, then match by value
 	const imgSrc = entry.imageMetadata!.src
+	const allResults = await findFieldsInCollectionEntry(
+		new Set(imageFields.map(f => f.name)),
+		entry.collectionName!,
+		entry.collectionSlug!,
+		collectionDefinitions,
+	)
+
 	let firstFieldResult: SourceLocation | undefined
 	for (const field of imageFields) {
-		const fieldResult = await findFieldInCollectionEntry(
-			field.name,
-			entry.collectionName!,
-			entry.collectionSlug!,
-			collectionDefinitions,
-		)
+		const fieldResult = allResults.get(field.name)
 		if (!fieldResult?.snippet) continue
 
-		// Remember the first resolved field as fallback
 		firstFieldResult ??= fieldResult
 
-		// Check if the field's value matches the rendered URL (exact or after Astro processing)
-		const yamlKeyMatch = fieldResult.snippet.match(/^\s*[\w][\w-]*:\s*/)
-		if (yamlKeyMatch) {
-			try {
-				const parsed = parseYaml(fieldResult.snippet)
-				if (parsed && typeof parsed === 'object') {
-					const key = fieldResult.snippet.match(/^\s*([\w][\w-]*):/)?.[1]
-					const value = key ? (parsed as Record<string, unknown>)[key] : undefined
-					if (typeof value === 'string' && (value === imgSrc || imgSrc.includes(value) || value.includes(imgSrc))) {
-						return applyCollectionSource(entry, fieldResult, referenceIndex)
-					}
+		try {
+			const cleaned = fieldResult.snippet.replace(/,\s*$/, '')
+			const parsed = parseYaml(cleaned)
+			if (parsed && typeof parsed === 'object') {
+				const value = (parsed as Record<string, unknown>)[field.name]
+				if (typeof value === 'string' && (value === imgSrc || imgSrc.includes(value) || value.includes(imgSrc))) {
+					return applyCollectionSource(entry, fieldResult, referenceIndex)
 				}
-			} catch {
-				// Not valid YAML
 			}
+		} catch {
+			// Not valid YAML/JSON
 		}
 	}
 
@@ -1014,6 +1021,110 @@ async function resolveCollectionImageField(
 	return undefined
 }
 
+// ============================================================================
+// Collection Text Resolution
+// ============================================================================
+
+/**
+ * Resolve a collection text entry directly from the data file.
+ * Two strategies, tried in order:
+ *
+ * 1. **Source-map** — read the template expression (e.g., {post.data.title}),
+ *    extract the field name, look it up by name in the data file.
+ * 2. **Value match** — iterate over collection fields and compare rendered
+ *    text against field values. Handles static/hardcoded text that exists
+ *    in both the template and a collection data file.
+ */
+async function resolveCollectionTextField(
+	entry: ManifestEntry,
+	collectionDefinitions: Record<string, CollectionDefinition>,
+	referenceIndex?: Map<string, Array<{ collection: string; fieldName: string; isArray?: boolean }>>,
+): Promise<ManifestEntry | undefined> {
+	const colDef = collectionDefinitions[entry.collectionName!]
+	if (!colDef) return undefined
+
+	// Try template expression as source map (e.g., {post.data.title} → "title")
+	const fieldNames = await extractDataFieldNames(entry)
+	if (fieldNames.size === 1) {
+		const fieldResult = await findFieldInCollectionEntry(
+			fieldNames.values().next().value!,
+			entry.collectionName!,
+			entry.collectionSlug!,
+			collectionDefinitions,
+		)
+		if (fieldResult) {
+			return applyCollectionSource(entry, fieldResult, referenceIndex, { allowStyling: false })
+		}
+	} else if (fieldNames.size > 1) {
+		const result = await matchFieldByValue(entry, fieldNames, collectionDefinitions, referenceIndex)
+		if (result) return result
+	}
+
+	// Fallback: match rendered text against all non-image field values
+	const allFieldNames = new Set(colDef.fields.filter(f => f.type !== 'image').map(f => f.name))
+	if (allFieldNames.size > 0) {
+		return matchFieldByValue(entry, allFieldNames, collectionDefinitions, referenceIndex)
+	}
+
+	return undefined
+}
+
+/**
+ * Extract .data.fieldName references from the template expression at the entry's source location.
+ * Returns an empty set if the entry lacks source info or the template has no data field expressions.
+ */
+async function extractDataFieldNames(entry: ManifestEntry): Promise<Set<string>> {
+	const fieldNames = new Set<string>()
+	if (!entry.sourcePath || !entry.sourceLine || !entry.tag) return fieldNames
+
+	const cached = await getCachedParsedFile(resolveSourcePath(entry.sourcePath))
+	if (!cached) return fieldNames
+
+	const snippet = extractCompleteTagSnippet(cached.lines, entry.sourceLine - 1, entry.tag)
+	if (!snippet) return fieldNames
+
+	let match: RegExpExecArray | null
+	const pattern = /\.data\.(\w+)/g
+	while ((match = pattern.exec(snippet)) !== null) {
+		fieldNames.add(match[1]!)
+	}
+	return fieldNames
+}
+
+/** Match entry text against collection field values to find the source field. */
+async function matchFieldByValue(
+	entry: ManifestEntry,
+	fieldNames: Set<string>,
+	collectionDefinitions: Record<string, CollectionDefinition>,
+	referenceIndex?: Map<string, Array<{ collection: string; fieldName: string; isArray?: boolean }>>,
+): Promise<ManifestEntry | undefined> {
+	const normalizedText = normalizeText(entry.text!)
+	const fieldResults = await findFieldsInCollectionEntry(
+		fieldNames,
+		entry.collectionName!,
+		entry.collectionSlug!,
+		collectionDefinitions,
+	)
+
+	for (const [fieldName, fieldResult] of fieldResults) {
+		if (!fieldResult.snippet) continue
+
+		try {
+			const cleaned = fieldResult.snippet.replace(/,\s*$/, '')
+			const parsed = parseYaml(cleaned)
+			if (parsed && typeof parsed === 'object') {
+				const value = (parsed as Record<string, unknown>)[fieldName]
+				if (typeof value === 'string' && normalizeText(value) === normalizedText) {
+					return applyCollectionSource(entry, fieldResult, referenceIndex, { allowStyling: false })
+				}
+			}
+		} catch {
+			// Not valid YAML/JSON
+		}
+	}
+	return undefined
+}
+
 // ============================================================================
 // Image Expression Resolution
 // ============================================================================

package/src/utils.ts

@@ -133,6 +133,19 @@ export function escapeReplacement(str: string): string {
 	return str.replace(/\$/g, '$$$$')
 }
 
+// ============================================================================
+// Path Resolution
+// ============================================================================
+
+/**
+ * Resolve a source path to an absolute filesystem path.
+ * If the path is already absolute it is returned as-is; otherwise it is
+ * joined with the project root directory.
+ */
+export function resolveSourcePath(sourcePath: string): string {
+	return path.isAbsolute(sourcePath) ? sourcePath : path.join(getProjectRoot(), sourcePath)
+}
+
 // ============================================================================
 // Path Validation
 // ============================================================================