@nuasite/cms 0.40.0 → 0.42.0

package/package.json

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

package/src/collection-scanner.ts

@@ -1,8 +1,9 @@
+import type { Dirent } from 'node:fs'
 import fs from 'node:fs/promises'
 import path from 'node:path'
 import { isMap, isPair, isScalar, parse as parseYaml, parseDocument } from 'yaml'
 import { getProjectRoot } from './config'
-import { parseContentConfig, type ParsedConfig } from './content-config-ast'
+import { parseContentConfig, type ParsedConfig, type ParsedField } from './content-config-ast'
 import { slugifyHref } from './shared'
 import type { CollectionDefinition, CollectionEntryInfo, FieldDefinition, FieldType } from './types'
 
@@ -213,9 +214,14 @@ function inferFieldType(value: unknown, key: string): FieldType {
 }
 
 /**
- * Merge field observations from multiple files to determine final field definition
+ * Merge field observations from multiple files to determine final field definition.
+ * `depth` guards against pathological deeply-nested content blowing the stack —
+ * real-world YAML/JSON rarely exceeds 5 levels, so the cap is well above realistic use.
  */
-function mergeFieldObservations(observations: FieldObservation[]): FieldDefinition[] {
+const MAX_NESTED_FIELD_DEPTH = 16
+
+function mergeFieldObservations(observations: FieldObservation[], depth: number = 0): FieldDefinition[] {
+	if (depth >= MAX_NESTED_FIELD_DEPTH) return []
 	const fields: FieldDefinition[] = []
 
 	for (const obs of observations) {
@@ -283,12 +289,26 @@ function mergeFieldObservations(observations: FieldObservation[]): FieldDefiniti
 						for (const item of objectItems) {
 							collectFieldObservations(subFieldMap, item, objectItems.length)
 						}
-						field.fields = mergeFieldObservations(Array.from(subFieldMap.values()))
+						field.fields = mergeFieldObservations(Array.from(subFieldMap.values()), depth + 1)
 					}
 				}
 			}
 		}
 
+		// For plain object values, recurse into sub-fields so the editor can render them.
+		if (fieldType === 'object') {
+			const objectValues = nonNullValues.filter(
+				(v): v is Record<string, unknown> => typeof v === 'object' && v !== null && !Array.isArray(v),
+			)
+			if (objectValues.length > 0) {
+				const subFieldMap = new Map<string, FieldObservation>()
+				for (const item of objectValues) {
+					collectFieldObservations(subFieldMap, item, objectValues.length)
+				}
+				field.fields = mergeFieldObservations(Array.from(subFieldMap.values()), depth + 1)
+			}
+		}
+
 		fields.push(field)
 	}
 
@@ -311,7 +331,7 @@ function collectFieldObservations(
 	}
 }
 
-function buildCollectionDefinition(
+function assembleCollectionDefinition(
 	collectionName: string,
 	contentDir: string,
 	fieldMap: Map<string, FieldObservation>,
@@ -340,6 +360,84 @@ function buildCollectionDefinition(
 	}
 }
 
+function getCollectionSourceBasePath(basePath: string, collectionName: string, contentDir: string): string {
+	const projectRoot = getProjectRoot()
+	const defaultContentDir = path.isAbsolute(contentDir) ? contentDir : path.join(projectRoot, contentDir)
+	const defaultCollectionPath = path.join(defaultContentDir, collectionName)
+	if (path.resolve(basePath) === path.resolve(defaultCollectionPath)) {
+		return path.join(contentDir, collectionName)
+	}
+
+	const relativeBase = path.relative(projectRoot, basePath)
+	if (relativeBase && !relativeBase.startsWith('..') && !path.isAbsolute(relativeBase)) {
+		return relativeBase
+	}
+	return basePath
+}
+
+async function buildCollectionDefinition(
+	basePath: string,
+	sources: Array<{ slug: string; relPath: string }>,
+	collectionName: string,
+	contentDir: string,
+): Promise<CollectionDefinition | null> {
+	if (sources.length === 0) return null
+
+	const sourceBasePath = getCollectionSourceBasePath(basePath, collectionName, contentDir)
+	const hasMd = sources.some(s => s.relPath.endsWith('.md'))
+	const fileExtension: 'md' | 'mdx' = hasMd ? 'md' : 'mdx'
+
+	const fieldMap = new Map<string, FieldObservation>()
+	const allDirectives: Record<string, { position?: 'sidebar' | 'header'; group?: string }> = {}
+	const entryInfos: CollectionEntryInfo[] = []
+	let hasDraft = false
+
+	const fileContents = await Promise.all(
+		sources.map(s => fs.readFile(path.join(basePath, s.relPath), 'utf-8')),
+	)
+
+	for (let i = 0; i < sources.length; i++) {
+		const source = sources[i]!
+		const content = fileContents[i]!
+		const frontmatter = parseFrontmatter(content)
+
+		const directives = parseFieldDirectives(content)
+		for (const [key, value] of Object.entries(directives)) {
+			if (!allDirectives[key]) {
+				allDirectives[key] = value
+			}
+		}
+
+		const entryInfo: CollectionEntryInfo = {
+			slug: source.slug,
+			sourcePath: path.join(sourceBasePath, source.relPath),
+		}
+		if (frontmatter) {
+			if (typeof frontmatter.title === 'string') {
+				entryInfo.title = frontmatter.title
+			}
+			if (typeof frontmatter.draft === 'boolean' && frontmatter.draft) {
+				entryInfo.draft = true
+			}
+			entryInfo.data = frontmatter
+		}
+		entryInfos.push(entryInfo)
+
+		if (!frontmatter) continue
+
+		if (frontmatter.draft === true) hasDraft = true
+		collectFieldObservations(fieldMap, frontmatter, sources.length)
+	}
+
+	const def = assembleCollectionDefinition(collectionName, contentDir, fieldMap, entryInfos, sources.length, {
+		path: sourceBasePath,
+		supportsDraft: hasDraft,
+		fileExtension,
+	})
+	assignFieldMetadata(def.fields, allDirectives)
+	return def
+}
+
 /**
  * Scan a single collection directory and infer its schema
  */
@@ -378,58 +476,86 @@ async function scanCollection(collectionPath: string, collectionName: string, co
 		}
 
 		if (sources.length === 0) return null
+		return await buildCollectionDefinition(collectionPath, sources, collectionName, contentDir)
+	} catch {
+		return null
+	}
+}
 
-		const hasMd = sources.some(s => s.relPath.endsWith('.md'))
-		const fileExtension: 'md' | 'mdx' = hasMd ? 'md' : 'mdx'
-
-		const fieldMap = new Map<string, FieldObservation>()
-		const allDirectives: Record<string, { position?: 'sidebar' | 'header'; group?: string }> = {}
-		const entryInfos: CollectionEntryInfo[] = []
-		let hasDraft = false
-
-		const fileContents = await Promise.all(
-			sources.map(s => fs.readFile(path.join(collectionPath, s.relPath), 'utf-8')),
-		)
-
-		for (let i = 0; i < sources.length; i++) {
-			const source = sources[i]!
-			const content = fileContents[i]!
-			const frontmatter = parseFrontmatter(content)
-
-			const directives = parseFieldDirectives(content)
-			for (const [key, value] of Object.entries(directives)) {
-				if (!allDirectives[key]) {
-					allDirectives[key] = value
-				}
-			}
-
-			const entryInfo: CollectionEntryInfo = {
-				slug: source.slug,
-				sourcePath: path.join(contentDir, collectionName, source.relPath),
+/** Convert a glob pattern (supports `*`, `**`, `?`, `{a,b}`) to an anchored RegExp. */
+function globToRegExp(glob: string): RegExp {
+	let re = ''
+	for (let i = 0; i < glob.length; i++) {
+		const c = glob[i]!
+		if (c === '*') {
+			if (glob[i + 1] === '*') {
+				re += '.*'
+				i++
+				if (glob[i + 1] === '/') i++
+			} else {
+				re += '[^/]*'
 			}
-			if (frontmatter) {
-				if (typeof frontmatter.title === 'string') {
-					entryInfo.title = frontmatter.title
-				}
-				if (typeof frontmatter.draft === 'boolean' && frontmatter.draft) {
-					entryInfo.draft = true
-				}
-				entryInfo.data = frontmatter
+		} else if (c === '?') {
+			re += '[^/]'
+		} else if (c === '{') {
+			const end = glob.indexOf('}', i)
+			if (end === -1) {
+				re += '\\{'
+			} else {
+				const opts = glob.slice(i + 1, end).split(',').map(s => s.replace(/[.+^${}()|[\]\\]/g, '\\$&'))
+				re += `(?:${opts.join('|')})`
+				i = end
 			}
-			entryInfos.push(entryInfo)
-
-			if (!frontmatter) continue
+		} else if ('.+^$()|[]\\'.includes(c)) {
+			re += `\\${c}`
+		} else {
+			re += c
+		}
+	}
+	return new RegExp(`^${re}$`)
+}
 
-			if (frontmatter.draft === true) hasDraft = true
-			collectFieldObservations(fieldMap, frontmatter, sources.length)
+/** Recursively list files under `dir`, returning forward-slash paths relative to `dir`. */
+async function walkFiles(dir: string, prefix = ''): Promise<string[]> {
+	let dirEntries: Dirent[]
+	try {
+		dirEntries = await fs.readdir(dir, { withFileTypes: true })
+	} catch {
+		return []
+	}
+	const out: string[] = []
+	for (const entry of dirEntries) {
+		if (entry.name.startsWith('_') || entry.name.startsWith('.')) continue
+		const rel = prefix ? `${prefix}/${entry.name}` : entry.name
+		if (entry.isDirectory()) {
+			out.push(...await walkFiles(path.join(dir, entry.name), rel))
+		} else if (entry.isFile()) {
+			out.push(rel)
 		}
+	}
+	return out
+}
 
-		const def = buildCollectionDefinition(collectionName, contentDir, fieldMap, entryInfos, sources.length, {
-			supportsDraft: hasDraft,
-			fileExtension,
-		})
-		assignFieldMetadata(def.fields, allDirectives)
-		return def
+/**
+ * Scan a collection declared in content config via a glob loader (base + pattern),
+ * which may share a base directory with another collection (nested layout).
+ * Runtime-agnostic: walks the filesystem and matches the glob (no Bun.Glob dependency).
+ */
+async function scanGlobCollection(
+	collectionName: string,
+	baseRel: string,
+	pattern: string,
+	contentDir: string,
+): Promise<CollectionDefinition | null> {
+	try {
+		const absBase = path.join(getProjectRoot(), baseRel)
+		const matcher = globToRegExp(pattern)
+		const sources = (await walkFiles(absBase))
+			.filter(rel => (rel.endsWith('.md') || rel.endsWith('.mdx')) && matcher.test(rel))
+			.map(rel => ({ slug: rel.replace(/\.(md|mdx)$/, ''), relPath: rel }))
+
+		if (sources.length === 0) return null
+		return await buildCollectionDefinition(absBase, sources, collectionName, contentDir)
 	} catch {
 		return null
 	}
@@ -456,17 +582,65 @@ function applyParsedConfig(
 		for (const pf of parsedColl.fields) {
 			const field = fieldsByName.get(pf.name)
 			if (!field) continue
-			if (pf.type) {
-				field.type = pf.type
-				if (pf.options) field.options = pf.options
-			}
-			if (pf.hints) field.hints = pf.hints
-			if (pf.astroImage) field.astroImage = true
-			field.required = pf.required
+			applyParsedFieldOverrides(field, pf)
 		}
 	}
 }
 
+/**
+ * Apply parsed schema overrides to an inferred field, recursing into nested object/array fields.
+ *
+ * Note on schema-vs-inferred merging at nested levels: schema-declared sub-fields replace
+ * the inferred list rather than merging. Inferred-only sub-fields are *not* lost — the
+ * editor's `ObjectFields` recovers them via its `extraKeys` calculation (field value keys
+ * minus schemaNames), routes them through `FrontmatterField` (value-based auto-detect),
+ * and offers a remove button. Merging here would defeat that.
+ */
+function applyParsedFieldOverrides(field: FieldDefinition, pf: ParsedField): void {
+	if (pf.type) {
+		field.type = pf.type
+		if (pf.options) field.options = pf.options
+	}
+	if (pf.itemType) field.itemType = pf.itemType
+	if (pf.hints) field.hints = pf.hints
+	if (pf.astroImage) field.astroImage = true
+	field.required = pf.required
+
+	if (pf.fields) {
+		const existingByName = new Map((field.fields ?? []).map(f => [f.name, f]))
+		field.fields = pf.fields.map((subPf) => {
+			const existing = existingByName.get(subPf.name)
+			if (existing) {
+				applyParsedFieldOverrides(existing, subPf)
+				return existing
+			}
+			return parsedFieldToFieldDefinition(subPf)
+		})
+	}
+}
+
+/**
+ * Build a FieldDefinition from a parsed schema field when no inferred counterpart exists.
+ * Falls back to `'text'` when the parser couldn't pin a type — keeps the field visible
+ * and editable. Schema-declared-but-data-absent fields would otherwise vanish.
+ */
+function parsedFieldToFieldDefinition(pf: ParsedField): FieldDefinition {
+	const fd: FieldDefinition = {
+		name: pf.name,
+		// A parsed field with nested children but no explicit type is necessarily an object.
+		// Otherwise default to 'text' so users can still fill in schema-declared fields
+		// whose helper the parser didn't recognize.
+		type: pf.type ?? (pf.fields ? 'object' : 'text'),
+		required: pf.required,
+	}
+	if (pf.options) fd.options = pf.options
+	if (pf.itemType) fd.itemType = pf.itemType
+	if (pf.hints) fd.hints = pf.hints
+	if (pf.astroImage) fd.astroImage = true
+	if (pf.fields) fd.fields = pf.fields.map(parsedFieldToFieldDefinition)
+	return fd
+}
+
 /** Apply orderBy configuration: set the field name and direction on the definition, then re-sort entries. */
 function applyCollectionOrderBy(
 	collections: Record<string, CollectionDefinition>,
@@ -753,7 +927,7 @@ async function scanDataCollection(collectionPath: string, collectionName: string
 			collectFieldObservations(fieldMap, data, sources.length)
 		}
 
-		return buildCollectionDefinition(collectionName, contentDir, fieldMap, entryInfos, sources.length, {
+		return assembleCollectionDefinition(collectionName, contentDir, fieldMap, entryInfos, sources.length, {
 			type: 'data',
 			fileExtension: ext,
 		})
@@ -792,6 +966,20 @@ export async function scanCollections(contentDir: string = 'src/content'): Promi
 
 	// Post-scan: apply schema-driven field config, detect references, derived fields, and ordering
 	const parsed = await parseContentConfig()
+	for (const [collectionName, parsedCollection] of parsed) {
+		if (collections[collectionName]) continue
+		if (!parsedCollection.loaderBase || !parsedCollection.loaderPattern) continue
+		const definition = await scanGlobCollection(collectionName, parsedCollection.loaderBase, parsedCollection.loaderPattern, contentDir)
+		if (!definition) continue
+		// Nest under the collection that owns the shared base directory (e.g. jsem-otazky -> jsem),
+		// so the CMS browser can group it under its parent page instead of listing it flat.
+		const baseName = parsedCollection.loaderBase.replace(/[/\\]+$/, '').split(/[/\\]/).pop()
+		if (baseName && baseName !== collectionName && collections[baseName]) {
+			definition.parentCollection = baseName
+		}
+		collections[collectionName] = definition
+	}
+
 	applyParsedConfig(collections, parsed)
 	detectReferenceFields(collections, parsed)
 	detectDerivedHrefFields(collections)