@nuasite/cms 0.32.0 → 0.35.0

package/src/content-config-ast.ts

@@ -0,0 +1,356 @@
+import type * as t from '@babel/types'
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { getProjectRoot } from './config'
+import { parseFrontmatter } from './source-finder/ast-parser'
+import type { FieldHints, FieldType } from './types'
+
+export interface ParsedReference {
+	target: string
+	isArray: boolean
+}
+
+export interface ParsedField {
+	name: string
+	type?: FieldType
+	options?: string[]
+	hints?: FieldHints
+	required: boolean
+	orderBy?: { direction: 'asc' | 'desc' }
+	reference?: ParsedReference
+	/** True when the field is `image()` from an Astro callback schema, which routes through `astro:assets`. */
+	astroImage?: boolean
+}
+
+export interface ParsedCollection {
+	name: string
+	fields: ParsedField[]
+}
+
+export type ParsedConfig = Map<string, ParsedCollection>
+
+const FIELD_HELPER_TYPES = new Set([
+	'text',
+	'number',
+	'image',
+	'url',
+	'email',
+	'tel',
+	'color',
+	'date',
+	'datetime',
+	'time',
+	'textarea',
+])
+
+const VALID_HINT_KEYS = new Set([
+	'min',
+	'max',
+	'step',
+	'placeholder',
+	'maxLength',
+	'minLength',
+	'rows',
+	'accept',
+])
+
+const WRAPPER_METHODS = new Set(['optional', 'nullable', 'nullish', 'default'])
+
+/** Cached parse result keyed by absolute path; invalidated by mtime. */
+const parseCache = new Map<string, { mtimeMs: number; parsed: ParsedConfig }>()
+
+/**
+ * Parse the project's Astro content config file (TypeScript) into a structured
+ * representation of each collection's schema. Returns an empty map if no config
+ * file exists or parsing fails.
+ */
+export async function parseContentConfig(): Promise<ParsedConfig> {
+	const projectRoot = getProjectRoot()
+	for (const configPath of ['src/content/config.ts', 'src/content.config.ts']) {
+		const fullPath = path.join(projectRoot, configPath)
+		let stat: Awaited<ReturnType<typeof fs.stat>>
+		try {
+			stat = await fs.stat(fullPath)
+		} catch {
+			continue
+		}
+
+		const cached = parseCache.get(fullPath)
+		if (cached && cached.mtimeMs === stat.mtimeMs) {
+			if (cached.parsed.size > 0) return cached.parsed
+			continue
+		}
+
+		const content = await fs.readFile(fullPath, 'utf-8')
+		const parsed = parseConfigSource(content, configPath)
+		parseCache.set(fullPath, { mtimeMs: stat.mtimeMs, parsed })
+		if (parsed.size > 0) return parsed
+	}
+	return new Map()
+}
+
+/** Exported for unit testing — operates on a source string directly. */
+export function parseConfigSource(source: string, sourcePath?: string): ParsedConfig {
+	const result: ParsedConfig = new Map()
+	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.
+	const collectionDecls = new Map<string, t.ObjectExpression>()
+	const exportMap = new Map<string, string>() // varName → collectionName
+
+	for (const stmt of ast.program.body) {
+		const varDecl = stmt.type === 'ExportNamedDeclaration' && stmt.declaration?.type === 'VariableDeclaration'
+			? stmt.declaration
+			: stmt.type === 'VariableDeclaration'
+			? stmt
+			: null
+		if (!varDecl) continue
+
+		for (const decl of varDecl.declarations) {
+			if (decl.id.type !== 'Identifier') continue
+			if (!decl.init) continue
+
+			if (decl.id.name === 'collections' && decl.init.type === 'ObjectExpression') {
+				for (const prop of decl.init.properties) {
+					if (prop.type !== 'ObjectProperty') continue
+					const key = propertyKeyName(prop.key)
+					if (!key) continue
+					if (prop.value.type === 'Identifier') {
+						exportMap.set(prop.value.name, key)
+					}
+				}
+				continue
+			}
+
+			if (decl.init.type === 'CallExpression' && isDefineCollectionCallee(decl.init.callee)) {
+				const arg = decl.init.arguments[0]
+				if (arg?.type === 'ObjectExpression') {
+					collectionDecls.set(decl.id.name, arg)
+				}
+			}
+		}
+	}
+
+	for (const [varName, collectionName] of exportMap) {
+		const decl = collectionDecls.get(varName)
+		if (!decl) continue
+
+		const schemaProperty = decl.properties.find(
+			p =>
+				p.type === 'ObjectProperty'
+				&& propertyKeyName(p.key) === 'schema',
+		) as t.ObjectProperty | undefined
+		if (!schemaProperty) continue
+
+		const schemaObject = unwrapSchemaToObject(schemaProperty.value)
+		if (!schemaObject) continue
+
+		result.set(collectionName, {
+			name: collectionName,
+			fields: parseSchemaFields(schemaObject),
+		})
+	}
+
+	return result
+}
+
+function isDefineCollectionCallee(callee: t.Node): boolean {
+	return callee.type === 'Identifier' && callee.name === 'defineCollection'
+}
+
+function propertyKeyName(key: t.Node): string | null {
+	if (key.type === 'Identifier') return key.name
+	if (key.type === 'StringLiteral') return key.value
+	return 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({...})`.
+ */
+function unwrapSchemaToObject(node: t.Node): t.ObjectExpression | null {
+	if (node.type === 'ArrowFunctionExpression' || node.type === 'FunctionExpression') {
+		const body = node.body
+		if (body.type === 'BlockStatement') {
+			for (const stmt of body.body) {
+				if (stmt.type === 'ReturnStatement' && stmt.argument) {
+					return unwrapSchemaToObject(stmt.argument)
+				}
+			}
+			return null
+		}
+		return unwrapSchemaToObject(body)
+	}
+
+	if (node.type === 'CallExpression') {
+		const callee = node.callee
+		if (
+			callee.type === 'MemberExpression'
+			&& callee.object.type === 'Identifier'
+			&& (callee.object.name === 'z' || callee.object.name === 'n')
+			&& callee.property.type === 'Identifier'
+			&& callee.property.name === 'object'
+		) {
+			const arg = node.arguments[0]
+			if (arg?.type === 'ObjectExpression') return arg
+		}
+	}
+
+	return null
+}
+
+function parseSchemaFields(schemaObject: t.ObjectExpression): ParsedField[] {
+	const fields: ParsedField[] = []
+	for (const prop of schemaObject.properties) {
+		if (prop.type !== 'ObjectProperty') continue
+		const name = propertyKeyName(prop.key)
+		if (!name) continue
+
+		const field: ParsedField = { name, required: true }
+		analyzeFieldExpression(prop.value, field)
+		fields.push(field)
+	}
+	return fields
+}
+
+/**
+ * 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(...))`).
+ */
+function analyzeFieldExpression(node: t.Node, field: ParsedField): void {
+	let current: t.Node | null = node
+	while (current) {
+		if (current.type !== 'CallExpression') return
+
+		if (isBaseCall(current)) {
+			analyzeBaseCall(current, field)
+			return
+		}
+
+		if (current.callee.type !== 'MemberExpression') return
+		const property = current.callee.property
+		const methodName = property.type === 'Identifier' ? property.name : ''
+
+		if (WRAPPER_METHODS.has(methodName)) {
+			field.required = false
+		} else if (methodName === 'orderBy') {
+			const arg = current.arguments[0]
+			const direction = arg?.type === 'StringLiteral' && arg.value === 'desc' ? 'desc' : 'asc'
+			field.orderBy = { direction }
+		}
+
+		current = current.callee.object
+	}
+}
+
+/**
+ * A "base call" is the innermost call that defines the field's type: a Zod/n
+ * helper invocation or a bare `image()` / `reference()` from a callback param.
+ */
+function isBaseCall(node: t.CallExpression): boolean {
+	const callee = node.callee
+	if (callee.type === 'Identifier') {
+		return callee.name === 'image' || callee.name === 'reference'
+	}
+	if (callee.type === 'MemberExpression') {
+		return callee.object.type === 'Identifier'
+			&& (callee.object.name === 'n' || callee.object.name === 'z')
+	}
+	return false
+}
+
+function analyzeBaseCall(node: t.CallExpression, field: ParsedField): void {
+	const callee = node.callee
+
+	// Bare image() / reference() from the schema callback form
+	if (callee.type === 'Identifier') {
+		if (callee.name === 'image') {
+			field.type = 'image'
+			field.astroImage = true
+			return
+		}
+		if (callee.name === 'reference') {
+			const arg = node.arguments[0]
+			if (arg?.type === 'StringLiteral') {
+				field.reference = { target: arg.value, isArray: false }
+			}
+			return
+		}
+		return
+	}
+
+	if (callee.type !== 'MemberExpression') return
+	if (callee.object.type !== 'Identifier' || callee.property.type !== 'Identifier') return
+	const ns = callee.object.name
+	const fn = callee.property.name
+
+	// n.image(), n.url(), n.text(...), etc. — semantic field types from @nuasite/cms
+	if (ns === 'n' && FIELD_HELPER_TYPES.has(fn)) {
+		field.type = fn as FieldType
+		const firstArg = node.arguments[0]
+		if (firstArg?.type === 'ObjectExpression') {
+			const hints = parseHintsFromObject(firstArg)
+			if (hints) field.hints = hints
+		}
+		return
+	}
+
+	// (z|n).enum([...])  →  select with options
+	if ((ns === 'z' || ns === 'n') && fn === 'enum') {
+		const arg = node.arguments[0]
+		if (arg?.type === 'ArrayExpression') {
+			const options: string[] = []
+			for (const el of arg.elements) {
+				if (el?.type === 'StringLiteral') options.push(el.value)
+			}
+			if (options.length > 0) {
+				field.type = 'select'
+				field.options = options
+			}
+		}
+		return
+	}
+
+	// (z|n).array(reference('foo'))  →  array of references
+	if ((ns === 'z' || ns === 'n') && fn === 'array') {
+		const inner = node.arguments[0]
+		if (
+			inner?.type === 'CallExpression'
+			&& inner.callee.type === 'Identifier'
+			&& inner.callee.name === 'reference'
+		) {
+			const target = inner.arguments[0]
+			if (target?.type === 'StringLiteral') {
+				field.reference = { target: target.value, isArray: true }
+			}
+		}
+		return
+	}
+}
+
+function parseHintsFromObject(obj: t.ObjectExpression): FieldHints | undefined {
+	const raw: Record<string, string | number> = {}
+	for (const prop of obj.properties) {
+		if (prop.type !== 'ObjectProperty') continue
+		const key = propertyKeyName(prop.key)
+		if (!key || !VALID_HINT_KEYS.has(key)) continue
+
+		const value = prop.value
+		if (value.type === 'NumericLiteral') {
+			raw[key] = value.value
+		} else if (
+			value.type === 'UnaryExpression'
+			&& value.operator === '-'
+			&& value.argument.type === 'NumericLiteral'
+		) {
+			raw[key] = -value.argument.value
+		} else if (value.type === 'StringLiteral') {
+			raw[key] = value.value
+		}
+	}
+	if (Object.keys(raw).length === 0) return undefined
+	return raw as FieldHints
+}

package/src/editor/components/frontmatter-fields.tsx

@@ -1,6 +1,6 @@
 import type { ComponentChildren } from 'preact'
 import { useEffect, useState } from 'preact/hooks'
-import { getCollectionEntryOptions } from '../manifest'
+import { buildAstroUploadContext, getCollectionEntryOptions } from '../manifest'
 import { renameMarkdownPage } from '../markdown-api'
 import {
 	config,
@@ -234,6 +234,8 @@ export function CreateModeFrontmatter({
 								field={field}
 								value={page.frontmatter[field.name]}
 								onChange={(newValue) => updateMarkdownFrontmatter({ [field.name]: newValue })}
+								collection={collectionDefinition.name}
+								entrySlug={page.slug}
 							/>
 						))}
 					</FieldGroupHeader>
@@ -348,6 +350,8 @@ export function EditModeFrontmatter({
 											field={field}
 											value={page.frontmatter[field.name]}
 											onChange={(newValue) => updateMarkdownFrontmatter({ [field.name]: newValue })}
+											collection={collectionDefinition.name}
+											entrySlug={page.slug}
 										/>
 									))}
 								</FieldGroupHeader>
@@ -387,12 +391,17 @@ interface SchemaFrontmatterFieldProps {
 	field: FieldDefinition
 	value: unknown
 	onChange: (value: unknown) => void
+	/** Required when editing an `astroImage` field — routes uploads to the entry's directory. */
+	collection?: string
+	entrySlug?: string
 }
 
 export function SchemaFrontmatterField({
 	field,
 	value,
 	onChange,
+	collection,
+	entrySlug,
 }: SchemaFrontmatterFieldProps) {
 	const label = field.required ? `${formatFieldLabel(field.name)} *` : formatFieldLabel(field.name)
 	const hints = field.hints
@@ -414,7 +423,8 @@ export function SchemaFrontmatterField({
 				/>
 			)
 
-		case 'image':
+		case 'image': {
+			const astroContext = buildAstroUploadContext(field, collection, entrySlug)
 			return (
 				<ImageField
 					label={label}
@@ -424,11 +434,12 @@ export function SchemaFrontmatterField({
 					onBrowse={() => {
 						openMediaLibraryWithCallback((url: string) => {
 							onChange(url)
-						})
+						}, astroContext)
 					}}
 					required={field.required}
 				/>
 			)
+		}
 
 		case 'color':
 			return (

package/src/editor/components/frontmatter-sidebar.tsx

@@ -201,6 +201,8 @@ export function FrontmatterSidebar({ fields, page, collectionDefinition }: Front
 														field={field}
 														value={page.frontmatter[field.name]}
 														onChange={(newValue) => updateMarkdownFrontmatter({ [field.name]: newValue })}
+														collection={collectionDefinition?.name}
+														entrySlug={page.slug}
 													/>
 												)
 												: (

package/src/editor/components/image-overlay.tsx

@@ -1,6 +1,7 @@
 import { useEffect, useRef } from 'preact/hooks'
 import { Z_INDEX } from '../constants'
 import { getCaretRangeFromPoint } from '../dom'
+import { getAstroUploadContextForCmsId } from '../manifest'
 import * as signals from '../signals'
 
 export interface ImageOverlayProps {
@@ -139,6 +140,10 @@ export function ImageOverlay({ visible, rect, element, cmsId }: ImageOverlayProp
 			e.preventDefault()
 			e.stopPropagation()
 
+			// If this image came from a collection's astroImage field, route the upload
+			// to the entry's directory so Astro's asset pipeline can resize it.
+			const astroContext = getAstroUploadContextForCmsId(signals.manifest.value, cmsId)
+
 			// Open media library with callback to replace the image
 			signals.openMediaLibraryWithCallback((url: string, alt: string) => {
 				// Track the change BEFORE modifying element.src
@@ -148,12 +153,16 @@ export function ImageOverlay({ visible, rect, element, cmsId }: ImageOverlayProp
 				const originalSrcSet = currentChange?.originalSrcSet ?? element.getAttribute('srcset') ?? ''
 				const isDirty = url !== originalSrc
 
-				// Update the image element
-				element.src = url
-				// Clear srcset so browser uses the new src
-				element.removeAttribute('srcset')
-				if (alt) {
-					element.alt = alt
+				// Update the image element. Skip for astroImage uploads — the returned
+				// path (`./file.jpg`) is entry-relative and won't resolve against the
+				// page URL. The new image becomes visible after save when Astro reloads.
+				if (!astroContext) {
+					element.src = url
+					// Clear srcset so browser uses the new src
+					element.removeAttribute('srcset')
+					if (alt) {
+						element.alt = alt
+					}
 				}
 
 				if (currentChange) {
@@ -175,7 +184,7 @@ export function ImageOverlay({ visible, rect, element, cmsId }: ImageOverlayProp
 						isDirty,
 					})
 				}
-			})
+			}, astroContext)
 		}
 
 		overlayRef.current.addEventListener('click', handleClick)

package/src/editor/components/media-library.tsx

@@ -117,11 +117,22 @@ export function MediaLibrary() {
 	const handleUploadFile = async (file: File) => {
 		setUploadProgress(0)
 		try {
+			const uploadContext = mediaLibraryState.value.uploadContext ?? undefined
 			const result = await uploadMedia(config.value, file, (percent) => {
 				setUploadProgress(percent)
-			}, { folder: currentFolder || undefined })
+			}, { folder: currentFolder || undefined, context: uploadContext })
 
 			if (result.success && result.url) {
+				// Astro image() uploads return entry-relative paths (`./foo.jpg`); skip adding
+				// to the library list (the file lives under src/content/, not in the media adapter)
+				// and call the callback directly so the field gets the relative value.
+				if (uploadContext && result.url.startsWith('./')) {
+					insertCallback?.(result.url, '')
+					handleClose()
+					showToast('Uploaded next to entry', 'success')
+					return
+				}
+
 				const newItem: MediaItem = {
 					id: result.id || crypto.randomUUID(),
 					url: result.url,

package/src/editor/manifest.ts

@@ -1,4 +1,5 @@
-import type { CmsManifest, ComponentDefinition, ComponentInstance, ManifestEntry } from './types'
+import type { MediaUploadContext } from '../types'
+import type { CmsManifest, ComponentDefinition, ComponentInstance, FieldDefinition, ManifestEntry } from './types'
 
 type GetManifestEntry = (manifest: CmsManifest, id: string) => ManifestEntry | undefined
 export const getManifestEntry: GetManifestEntry = (manifest, id) => manifest.entries[id]
@@ -24,6 +25,41 @@ export const getManifestEntryCount: GetManifestEntryCount = (manifest: CmsManife
 type GetAvailableComponentNames = (manifest: CmsManifest) => string[]
 export const getAvailableComponentNames: GetAvailableComponentNames = manifest => Object.keys(getComponentDefinitions(manifest))
 
+export function getCollectionField(
+	manifest: CmsManifest,
+	collectionName: string | undefined,
+	fieldName: string | undefined,
+): FieldDefinition | undefined {
+	if (!collectionName || !fieldName) return undefined
+	return manifest.collectionDefinitions?.[collectionName]?.fields.find(f => f.name === fieldName)
+}
+
+/**
+ * Build the upload context that routes a media upload to an Astro `image()`
+ * field's entry-relative location. Returns undefined when the field isn't
+ * astroImage or any piece of the (collection, slug, field) triple is missing.
+ */
+export function buildAstroUploadContext(
+	field: FieldDefinition | undefined,
+	collection: string | undefined,
+	slug: string | undefined,
+): MediaUploadContext | undefined {
+	if (!field?.astroImage || !collection || !slug) return undefined
+	return { collection, entry: slug, field: field.name }
+}
+
+/** Look up the upload context for a CMS-marked element via its manifest entry. */
+export function getAstroUploadContextForCmsId(
+	manifest: CmsManifest,
+	cmsId: string | null,
+): MediaUploadContext | undefined {
+	if (!cmsId) return undefined
+	const entry = getManifestEntry(manifest, cmsId)
+	if (!entry) return undefined
+	const field = getCollectionField(manifest, entry.collectionName, entry.collectionFieldName)
+	return buildAstroUploadContext(field, entry.collectionName, entry.collectionSlug)
+}
+
 export function getCollectionEntryOptions(manifest: CmsManifest, collectionName?: string): Array<{ value: string; label: string }> {
 	if (!collectionName) return []
 	const def = manifest.collectionDefinitions?.[collectionName]

package/src/editor/markdown-api.ts

@@ -1,3 +1,4 @@
+import type { MediaUploadContext } from '../types'
 import { API } from './constants'
 import { fetchWithTimeout, getJson, postJson } from './fetch'
 import type {
@@ -73,13 +74,16 @@ export function uploadMedia(
 	config: CmsConfig,
 	file: File,
 	onProgress?: (percent: number) => void,
-	options?: { folder?: string },
+	options?: { folder?: string; context?: MediaUploadContext },
 ): Promise<MediaUploadResponse> {
 	const formData = new FormData()
 	formData.append('file', file)
 
 	const params = new URLSearchParams()
 	if (options?.folder) params.set('folder', options.folder)
+	if (options?.context?.collection) params.set('collection', options.context.collection)
+	if (options?.context?.entry) params.set('entry', options.context.entry)
+	if (options?.context?.field) params.set('field', options.context.field)
 	const qs = params.toString()
 
 	return new Promise((resolve) => {

package/src/editor/signals.ts

@@ -23,6 +23,7 @@ import type {
 	MarkdownPageEntry,
 	MediaItem,
 	MediaLibraryState,
+	MediaUploadContext,
 	PendingAttributeChange,
 	PendingBackgroundImageChange,
 	PendingChange,
@@ -122,6 +123,7 @@ function createInitialMediaLibraryState(): MediaLibraryState {
 		isLoading: false,
 		selectedItem: null,
 		insertCallback: null,
+		uploadContext: null,
 	}
 }
 
@@ -987,11 +989,13 @@ export function setMediaLibraryInsertCallback(
 
 export function openMediaLibraryWithCallback(
 	callback: (url: string, alt: string) => void,
+	uploadContext?: MediaUploadContext,
 ): void {
 	mediaLibraryState.value = {
 		...mediaLibraryState.value,
 		isOpen: true,
 		insertCallback: callback,
+		uploadContext: uploadContext ?? null,
 	}
 }
 

package/src/editor/types.ts

@@ -1,4 +1,4 @@
-import type { Attribute, CmsFeatures, CmsManifest, CollectionDefinition, ComponentInstance, RedirectRule } from '../types'
+import type { Attribute, CmsFeatures, CmsManifest, CollectionDefinition, ComponentInstance, MediaUploadContext, RedirectRule } from '../types'
 
 // Re-export shared types from @nuasite/cms-marker (source of truth)
 export type {
@@ -17,6 +17,7 @@ export type {
 	FieldType,
 	JsonLdEntry,
 	ManifestEntry,
+	MediaUploadContext,
 	OpenGraphData,
 	PageSeoData,
 	SeoFavicon,
@@ -361,6 +362,8 @@ export interface MediaLibraryState {
 	isLoading: boolean
 	selectedItem: MediaItem | null
 	insertCallback: ((url: string, alt: string) => void) | null
+	/** When set, uploads inside the media library route to an Astro `image()` field's entry directory. */
+	uploadContext: MediaUploadContext | null
 }
 
 export interface CreatePageState {

package/src/handlers/api-routes.ts

@@ -7,6 +7,7 @@ import type { ManifestWriter } from '../manifest-writer'
 import { listProjectImages } from '../media/project-images'
 import type { MediaStorageAdapter } from '../media/types'
 import { handleAddArrayItem, handleRemoveArrayItem } from './array-ops'
+import { tryAstroImageUpload } from './astro-image-upload'
 import { handleInsertComponent, handleRemoveComponent } from './component-ops'
 import { handleCreateMarkdown, handleDeleteMarkdown, handleGetMarkdownContent, handleRenameMarkdown, handleUpdateMarkdown } from './markdown-ops'
 import { handleCheckSlugExists, handleCreatePage, handleDeletePage, handleDuplicatePage, handleGetLayouts } from './page-ops'
@@ -146,13 +147,12 @@ const routeMap = new Map<string, RouteHandler>([
 		sendJson(ctx.res, { items })
 	}),
 	custom('POST', 'media/upload', async (ctx) => {
-		if (!requireMedia(ctx)) return
 		const contentType = ctx.req.headers['content-type'] ?? ''
 		if (!contentType.includes('multipart/form-data')) {
 			sendError(ctx.res, 'Expected multipart/form-data')
 			return
 		}
-		const folder = getQuery(ctx).get('folder') ?? undefined
+		const query = getQuery(ctx)
 		const body = await readBody(ctx.req, 50 * 1024 * 1024)
 		const file = parseMultipartFile(body, contentType)
 		if (!file) {
@@ -164,6 +164,26 @@ const routeMap = new Map<string, RouteHandler>([
 			sendError(ctx.res, `File type not allowed: ${file.contentType}`)
 			return
 		}
+
+		// Astro image() fields write entry-relative — bypasses the media adapter so
+		// the file lands in src/content where astro:assets can pick it up.
+		const astroResult = await tryAstroImageUpload({
+			context: {
+				collection: query.get('collection') ?? undefined,
+				entry: query.get('entry') ?? undefined,
+				field: query.get('field') ?? undefined,
+			},
+			manifestWriter: ctx.manifestWriter,
+			fileBuffer: file.buffer,
+			originalFilename: file.filename,
+		})
+		if (astroResult) {
+			sendJson(ctx.res, astroResult, astroResult.success ? 200 : 400)
+			return
+		}
+
+		if (!requireMedia(ctx)) return
+		const folder = query.get('folder') ?? undefined
 		sendJson(ctx.res, await ctx.mediaAdapter.upload(file.buffer, file.filename, file.contentType, { folder }))
 	}),
 	custom('POST', 'media/folder', async (ctx) => {