@nuasite/cms 0.40.0 → 0.42.0

package/src/content-config-ast.ts

@@ -20,11 +20,17 @@ 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 {
 	name: string
 	fields: ParsedField[]
+	loaderPattern?: string
+	loaderBase?: string
 }
 
 export type ParsedConfig = Map<string, ParsedCollection>
@@ -33,6 +39,7 @@ const FIELD_HELPER_TYPES = new Set([
 	'text',
 	'number',
 	'image',
+	'file',
 	'url',
 	'email',
 	'tel',
@@ -40,6 +47,8 @@ const FIELD_HELPER_TYPES = new Set([
 	'date',
 	'datetime',
 	'time',
+	'year',
+	'month',
 	'textarea',
 ])
 
@@ -56,6 +65,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,10 +124,14 @@ 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
+	const inlineCollections = new Map<string, t.ObjectExpression>() // collectionName → defineCollection arg (inline form)
 
 	for (const stmt of ast.program.body) {
 		const varDecl = stmt.type === 'ExportNamedDeclaration' && stmt.declaration?.type === 'VariableDeclaration'
@@ -112,6 +145,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
@@ -119,6 +154,12 @@ export function parseConfigSource(source: string, sourcePath?: string): ParsedCo
 					if (!key) continue
 					if (prop.value.type === 'Identifier') {
 						exportMap.set(prop.value.name, key)
+					} else if (prop.value.type === 'CallExpression' && isDefineCollectionCallee(prop.value.callee)) {
+						// Inline form: `collections = { name: defineCollection({...}) }`
+						const inlineArg = prop.value.arguments[0]
+						if (inlineArg?.type === 'ObjectExpression') {
+							inlineCollections.set(key, inlineArg)
+						}
 					}
 				}
 				continue
@@ -133,23 +174,57 @@ export function parseConfigSource(source: string, sourcePath?: string): ParsedCo
 		}
 	}
 
+	// Unify both styles: inline `name: defineCollection({...})` and the
+	// `const x = defineCollection({...}); collections = { name: x }` reference form.
+	const collectionObjects = new Map<string, t.ObjectExpression>(inlineCollections)
 	for (const [varName, collectionName] of exportMap) {
 		const decl = collectionDecls.get(varName)
-		if (!decl) continue
+		if (decl) collectionObjects.set(collectionName, decl)
+	}
+
+	for (const [collectionName, decl] of collectionObjects) {
+		const loaderProperty = decl.properties.find(
+			p =>
+				p.type === 'ObjectProperty'
+				&& propertyKeyName(p.key) === 'loader',
+		) as t.ObjectProperty | undefined
+		const loaderOptions = loaderProperty ? extractGlobLoaderOptions(loaderProperty.value, bindings) : {}
+		const loaderPattern = loaderOptions.pattern
+		const loaderBase = loaderOptions.base
 
 		const schemaProperty = decl.properties.find(
 			p =>
 				p.type === 'ObjectProperty'
 				&& propertyKeyName(p.key) === 'schema',
 		) as t.ObjectProperty | undefined
-		if (!schemaProperty) continue
+		if (!schemaProperty) {
+			if (!loaderPattern) continue
+			result.set(collectionName, {
+				name: collectionName,
+				fields: [],
+				loaderPattern,
+				loaderBase,
+			})
+			continue
+		}
 
-		const schemaObject = unwrapSchemaToObject(schemaProperty.value)
-		if (!schemaObject) continue
+		const schemaObject = unwrapSchemaToObject(schemaProperty.value, bindings)
+		if (!schemaObject) {
+			if (!loaderPattern) continue
+			result.set(collectionName, {
+				name: collectionName,
+				fields: [],
+				loaderPattern,
+				loaderBase,
+			})
+			continue
+		}
 
 		result.set(collectionName, {
 			name: collectionName,
-			fields: parseSchemaFields(schemaObject),
+			fields: parseSchemaFields(schemaObject, bindings),
+			loaderPattern,
+			loaderBase,
 		})
 	}
 
@@ -166,26 +241,64 @@ function propertyKeyName(key: t.Node): string | null {
 	return null
 }
 
+function extractGlobLoaderOptions(node: t.Node, bindings: Bindings): { pattern?: string; base?: string } {
+	const resolved = resolveExpression(node, bindings)
+	if (resolved.type !== 'CallExpression') return {}
+	if (!isGlobCallee(resolved.callee)) return {}
+
+	const arg = resolved.arguments[0]
+	if (!arg) return {}
+	const options = resolveExpression(arg, bindings)
+	if (options.type !== 'ObjectExpression') return {}
+
+	const result: { pattern?: string; base?: string } = {}
+	for (const prop of options.properties) {
+		if (prop.type !== 'ObjectProperty') continue
+		const key = propertyKeyName(prop.key)
+		if (key !== 'pattern' && key !== 'base') continue
+		const value = extractStaticString(prop.value, bindings)
+		if (value !== undefined) result[key] = value
+	}
+
+	return result
+}
+
+function extractStaticString(node: t.Node, bindings: Bindings): string | undefined {
+	const resolved = resolveExpression(node, bindings)
+	if (resolved.type === 'StringLiteral') return resolved.value
+	if (resolved.type === 'TemplateLiteral' && resolved.expressions.length === 0) {
+		return resolved.quasis[0]?.value.cooked ?? resolved.quasis[0]?.value.raw
+	}
+	return undefined
+}
+
+function isGlobCallee(callee: t.Node): boolean {
+	return callee.type === 'Identifier' && callee.name === 'glob'
+}
+
 /**
  * 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 +306,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 +324,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 +334,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 +361,7 @@ function analyzeFieldExpression(node: t.Node, field: ParsedField): void {
 			field.orderBy = { direction }
 		}
 
-		current = current.callee.object
+		current = resolveExpression(current.callee.object, bindings)
 	}
 }
 
@@ -262,7 +381,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 +433,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 +460,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
 	}
 }

package/src/editor/components/collections-browser.tsx

@@ -1,6 +1,7 @@
 import { signal } from '@preact/signals'
 import { useMemo, useState } from 'preact/hooks'
 import { useSearchFilter } from '../hooks/useSearchFilter'
+import { cn } from '../lib/cn'
 import { deleteMarkdownPage } from '../markdown-api'
 import {
 	closeCollectionsBrowser,
@@ -241,20 +242,35 @@ export function CollectionsBrowser() {
 		)
 	}
 
-	// Collection list
+	// Collection list — group nested (child) collections under their parent
+	const ordered: Array<{ col: typeof collections[number]; nested: boolean }> = []
+	for (const col of collections.filter(c => !c.parentCollection)) {
+		ordered.push({ col, nested: false })
+		for (const child of collections.filter(c => c.parentCollection === col.name)) {
+			ordered.push({ col: child, nested: true })
+		}
+	}
+	// Append any orphaned children whose parent isn't present, so nothing is hidden.
+	for (const col of collections.filter(c => c.parentCollection && !collections.some(p => p.name === c.parentCollection))) {
+		ordered.push({ col, nested: false })
+	}
+
 	return (
 		<ModalBackdrop onClose={handleClose} extraClass="flex flex-col max-h-[80vh]">
 			<ModalHeader title="Collections" onClose={handleClose} />
 			<div class="p-5 space-y-2 overflow-y-auto flex-1 min-h-0">
-				{collections.map((col) => (
+				{ordered.map(({ col, nested }) => (
 					<button
 						key={col.name}
 						type="button"
 						onClick={() => selectBrowserCollection(col.name)}
-						class="group w-full flex items-center gap-4 p-4 bg-white/5 hover:bg-white/10 rounded-cms-lg border border-white/10 hover:border-white/20 transition-colors text-left cursor-pointer"
+						class={cn(
+							'group w-full flex items-center gap-4 p-4 bg-white/5 hover:bg-white/10 rounded-cms-lg border border-white/10 hover:border-white/20 transition-colors text-left cursor-pointer',
+							nested && 'ml-8 w-[calc(100%-2rem)] border-l-2 border-l-cms-primary/40',
+						)}
 						data-cms-ui
 					>
-						<div class="shrink-0 w-10 h-10 bg-cms-primary/20 rounded-cms-sm flex items-center justify-center">
+						<div class={cn('shrink-0 bg-cms-primary/20 rounded-cms-sm flex items-center justify-center', nested ? 'w-8 h-8' : 'w-10 h-10')}>
 							<CollectionIcon />
 						</div>
 						<div class="flex-1 min-w-0">