@nuasite/cms 0.40.0 → 0.41.0

package/package.json

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

package/src/collection-scanner.ts

@@ -2,7 +2,7 @@ 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 +213,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 +288,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)
 	}
 
@@ -456,17 +475,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>,

package/src/content-config-ast.ts

@@ -20,6 +20,10 @@ export interface ParsedField {
 	reference?: ParsedReference
 	/** True when the field is `image()` from an Astro callback schema, which routes through `astro:assets`. */
 	astroImage?: boolean
+	/** Element type for `array` fields */
+	itemType?: FieldType
+	/** Nested fields for `object` fields, or per-item fields for `array` of objects */
+	fields?: ParsedField[]
 }
 
 export interface ParsedCollection {
@@ -33,6 +37,7 @@ const FIELD_HELPER_TYPES = new Set([
 	'text',
 	'number',
 	'image',
+	'file',
 	'url',
 	'email',
 	'tel',
@@ -40,6 +45,8 @@ const FIELD_HELPER_TYPES = new Set([
 	'date',
 	'datetime',
 	'time',
+	'year',
+	'month',
 	'textarea',
 ])
 
@@ -56,6 +63,26 @@ const VALID_HINT_KEYS = new Set([
 
 const WRAPPER_METHODS = new Set(['optional', 'nullable', 'nullish', 'default'])
 
+/** Map of top-level `const <name> = <expr>` bindings within a single config file. */
+type Bindings = Map<string, t.Node>
+
+/**
+ * Follow `Identifier` references through same-file `const` bindings until reaching
+ * a non-Identifier node. Cycle-safe via the visited set. Returns the original node
+ * unchanged when the identifier is unbound or already visited.
+ */
+function resolveExpression(node: t.Node, bindings: Bindings, visited: Set<string> = new Set()): t.Node {
+	let current: t.Node = node
+	while (current.type === 'Identifier') {
+		if (visited.has(current.name)) return current
+		visited.add(current.name)
+		const next = bindings.get(current.name)
+		if (!next) return current
+		current = next
+	}
+	return current
+}
+
 /** Cached parse result keyed by absolute path; invalidated by mtime. */
 const parseCache = new Map<string, { mtimeMs: number; parsed: ParsedConfig }>()
 
@@ -95,8 +122,11 @@ export function parseConfigSource(source: string, sourcePath?: string): ParsedCo
 	const ast = parseFrontmatter(source, sourcePath) as unknown as t.File | null
 	if (!ast) return result
 
-	// Collect `const X = defineCollection({...})` declarations and the
-	// `export const collections = { name: X, ... }` mapping, in any order.
+	// Single pass: collect every top-level `const X = <expr>` binding (so we can
+	// later resolve Identifier references like `cs: TestimonialTranslation`),
+	// while also picking out `defineCollection({...})` calls and the
+	// `export const collections = { name: X, ... }` mapping.
+	const bindings: Bindings = new Map()
 	const collectionDecls = new Map<string, t.ObjectExpression>()
 	const exportMap = new Map<string, string>() // varName → collectionName
 
@@ -112,6 +142,8 @@ export function parseConfigSource(source: string, sourcePath?: string): ParsedCo
 			if (decl.id.type !== 'Identifier') continue
 			if (!decl.init) continue
 
+			bindings.set(decl.id.name, decl.init)
+
 			if (decl.id.name === 'collections' && decl.init.type === 'ObjectExpression') {
 				for (const prop of decl.init.properties) {
 					if (prop.type !== 'ObjectProperty') continue
@@ -144,12 +176,12 @@ export function parseConfigSource(source: string, sourcePath?: string): ParsedCo
 		) as t.ObjectProperty | undefined
 		if (!schemaProperty) continue
 
-		const schemaObject = unwrapSchemaToObject(schemaProperty.value)
+		const schemaObject = unwrapSchemaToObject(schemaProperty.value, bindings)
 		if (!schemaObject) continue
 
 		result.set(collectionName, {
 			name: collectionName,
-			fields: parseSchemaFields(schemaObject),
+			fields: parseSchemaFields(schemaObject, bindings),
 		})
 	}
 
@@ -168,24 +200,27 @@ function propertyKeyName(key: t.Node): string | null {
 
 /**
  * Unwrap a `schema:` value down to the top-level (z|n).object({ ... }) ObjectExpression.
- * Handles direct calls and the Astro callback form `({ image }) => z.object({...})`.
+ * Handles direct calls, the Astro callback form `({ image }) => z.object({...})`,
+ * and same-file variable references like `schema: BlogSchema`.
  */
-function unwrapSchemaToObject(node: t.Node): t.ObjectExpression | null {
-	if (node.type === 'ArrowFunctionExpression' || node.type === 'FunctionExpression') {
-		const body = node.body
+function unwrapSchemaToObject(node: t.Node, bindings: Bindings): t.ObjectExpression | null {
+	const resolved = resolveExpression(node, bindings)
+
+	if (resolved.type === 'ArrowFunctionExpression' || resolved.type === 'FunctionExpression') {
+		const body = resolved.body
 		if (body.type === 'BlockStatement') {
 			for (const stmt of body.body) {
 				if (stmt.type === 'ReturnStatement' && stmt.argument) {
-					return unwrapSchemaToObject(stmt.argument)
+					return unwrapSchemaToObject(stmt.argument, bindings)
 				}
 			}
 			return null
 		}
-		return unwrapSchemaToObject(body)
+		return unwrapSchemaToObject(body, bindings)
 	}
 
-	if (node.type === 'CallExpression') {
-		const callee = node.callee
+	if (resolved.type === 'CallExpression') {
+		const callee = resolved.callee
 		if (
 			callee.type === 'MemberExpression'
 			&& callee.object.type === 'Identifier'
@@ -193,15 +228,17 @@ function unwrapSchemaToObject(node: t.Node): t.ObjectExpression | null {
 			&& callee.property.type === 'Identifier'
 			&& callee.property.name === 'object'
 		) {
-			const arg = node.arguments[0]
-			if (arg?.type === 'ObjectExpression') return arg
+			const arg = resolved.arguments[0]
+			if (!arg) return null
+			const resolvedArg = resolveExpression(arg, bindings)
+			if (resolvedArg.type === 'ObjectExpression') return resolvedArg
 		}
 	}
 
 	return null
 }
 
-function parseSchemaFields(schemaObject: t.ObjectExpression): ParsedField[] {
+function parseSchemaFields(schemaObject: t.ObjectExpression, bindings: Bindings): ParsedField[] {
 	const fields: ParsedField[] = []
 	for (const prop of schemaObject.properties) {
 		if (prop.type !== 'ObjectProperty') continue
@@ -209,7 +246,7 @@ function parseSchemaFields(schemaObject: t.ObjectExpression): ParsedField[] {
 		if (!name) continue
 
 		const field: ParsedField = { name, required: true }
-		analyzeFieldExpression(prop.value, field)
+		analyzeFieldExpression(prop.value, field, bindings)
 		fields.push(field)
 	}
 	return fields
@@ -219,14 +256,18 @@ function parseSchemaFields(schemaObject: t.ObjectExpression): ParsedField[] {
  * Walk a field's value expression. Each layer is either a wrapper method call
  * (`.optional()`, `.default()`, `.nullable()`, `.nullish()`, `.orderBy(...)`)
  * or the base call (`n.image()`, `image()`, `z.enum([...])`, `n.array(reference(...))`).
+ *
+ * Resolves same-file `Identifier` references against `bindings` at each layer so
+ * patterns like `cs: TestimonialTranslation` and `en: TestimonialTranslation.optional()`
+ * are followed back to their defining call.
  */
-function analyzeFieldExpression(node: t.Node, field: ParsedField): void {
-	let current: t.Node | null = node
+function analyzeFieldExpression(node: t.Node, field: ParsedField, bindings: Bindings): void {
+	let current: t.Node | null = resolveExpression(node, bindings)
 	while (current) {
 		if (current.type !== 'CallExpression') return
 
 		if (isBaseCall(current)) {
-			analyzeBaseCall(current, field)
+			analyzeBaseCall(current, field, bindings)
 			return
 		}
 
@@ -242,7 +283,7 @@ function analyzeFieldExpression(node: t.Node, field: ParsedField): void {
 			field.orderBy = { direction }
 		}
 
-		current = current.callee.object
+		current = resolveExpression(current.callee.object, bindings)
 	}
 }
 
@@ -262,7 +303,7 @@ function isBaseCall(node: t.CallExpression): boolean {
 	return false
 }
 
-function analyzeBaseCall(node: t.CallExpression, field: ParsedField): void {
+function analyzeBaseCall(node: t.CallExpression, field: ParsedField, bindings: Bindings): void {
 	const callee = node.callee
 
 	// Bare image() / reference() from the schema callback form
@@ -314,11 +355,26 @@ function analyzeBaseCall(node: t.CallExpression, field: ParsedField): void {
 		return
 	}
 
-	// (z|n).array(reference('foo'))  →  array of references
+	// (z|n).object({...})  →  nested object field
+	if ((ns === 'z' || ns === 'n') && fn === 'object') {
+		const arg = node.arguments[0]
+		if (!arg) return
+		const resolved = resolveExpression(arg, bindings)
+		if (resolved.type === 'ObjectExpression') {
+			field.type = 'object'
+			field.fields = parseSchemaFields(resolved, bindings)
+		}
+		return
+	}
+
+	// (z|n).array(<inner>)  →  array; inspect the element type
 	if ((ns === 'z' || ns === 'n') && fn === 'array') {
-		const inner = node.arguments[0]
+		const innerRaw = node.arguments[0]
+		if (!innerRaw) return
+		const inner = resolveExpression(innerRaw, bindings)
+		// Array of references: keep the existing flat shape so detectReferenceFields can wire it up.
 		if (
-			inner?.type === 'CallExpression'
+			inner.type === 'CallExpression'
 			&& inner.callee.type === 'Identifier'
 			&& inner.callee.name === 'reference'
 		) {
@@ -326,7 +382,18 @@ function analyzeBaseCall(node: t.CallExpression, field: ParsedField): void {
 			if (target?.type === 'StringLiteral') {
 				field.reference = { target: target.value, isArray: true }
 			}
+			return
 		}
+		// Array of anything else: analyze the inner expression and lift its type/fields.
+		// Note: nested arrays (`n.array(n.array(...))`) collapse here — `itemType` records
+		// only the outer element type, the inner element shape is lost. No editor flow
+		// currently renders nested arrays, so we don't carry a recursive `itemDefinition`
+		// yet; add one when editor support arrives.
+		const innerField: ParsedField = { name: '__item__', required: true }
+		analyzeFieldExpression(inner, innerField, bindings)
+		field.type = 'array'
+		if (innerField.type) field.itemType = innerField.type
+		if (innerField.fields) field.fields = innerField.fields
 		return
 	}
 }