@nuasite/cms 0.18.1 → 0.19.1

package/src/handlers/component-ops.ts

@@ -3,7 +3,7 @@ import path from 'node:path'
 import { getProjectRoot } from '../config'
 import type { ManifestWriter } from '../manifest-writer'
 import type { CmsManifest, ComponentDefinition, ComponentInstance } from '../types'
-import { acquireFileLock, escapeRegex, normalizePagePath, resolveAndValidatePath } from '../utils'
+import { acquireFileLock, escapeHtml, escapeRegex, normalizePagePath, relativeImportPath, resolveAndValidatePath } from '../utils'
 
 export type InsertPosition = 'before' | 'after'
 
@@ -455,15 +455,6 @@ function generateComponentJsx(
 	return `<${componentName} />`
 }
 
-function escapeHtml(str: string): string {
-	return str
-		.replace(/&/g, '&amp;')
-		.replace(/"/g, '&quot;')
-		.replace(/'/g, '&#39;')
-		.replace(/</g, '&lt;')
-		.replace(/>/g, '&gt;')
-}
-
 export function getIndentation(line: string): string {
 	const match = line.match(/^(\s*)/)
 	return match ? match[1]! : ''
@@ -688,14 +679,7 @@ export function ensureComponentImport(
 		}
 	}
 
-	// Compute relative import path from target file to component file
-	const targetDir = path.dirname(targetFile)
-	let relativePath = path.relative(targetDir, componentFile)
-	if (!relativePath.startsWith('.')) {
-		relativePath = './' + relativePath
-	}
-
-	const importStatement = `import ${componentName} from '${relativePath}'`
+	const importStatement = `import ${componentName} from '${relativeImportPath(targetFile, componentFile)}'`
 
 	if (frontmatterEnd > 0) {
 		// Has frontmatter — insert import before the closing ---

package/src/handlers/markdown-ops.ts

@@ -2,7 +2,8 @@ import fs from 'node:fs/promises'
 import path from 'node:path'
 import yaml from 'yaml'
 import { getProjectRoot } from '../config'
-import { acquireFileLock } from '../utils'
+import type { ComponentDefinition } from '../types'
+import { acquireFileLock, isNodeError, relativeImportPath, resolveAndValidatePath, slugify } from '../utils'
 
 export interface BlogFrontmatter {
 	title: string
@@ -21,6 +22,8 @@ export interface CreateMarkdownRequest {
 	slug: string
 	frontmatter?: Partial<BlogFrontmatter>
 	content?: string
+	/** File extension override for data collections (e.g. 'json', 'yaml') */
+	fileExtension?: string
 }
 
 export interface CreateMarkdownResponse {
@@ -62,8 +65,17 @@ export async function handleGetMarkdownContent(
 	try {
 		const fullPath = resolveAndValidatePath(filePath)
 		const raw = await fs.readFile(fullPath, 'utf-8')
-		const { frontmatter, content } = parseFrontmatter(raw)
 
+		if (isDataFile(filePath)) {
+			const data = filePath.endsWith('.json') ? JSON.parse(raw) : yaml.parse(raw)
+			return {
+				content: '',
+				frontmatter: (data && typeof data === 'object' ? data : {}) as BlogFrontmatter,
+				filePath,
+			}
+		}
+
+		const { frontmatter, content } = parseFrontmatter(raw)
 		return {
 			content,
 			frontmatter: frontmatter as BlogFrontmatter,
@@ -76,24 +88,41 @@ export async function handleGetMarkdownContent(
 
 export async function handleUpdateMarkdown(
 	request: UpdateMarkdownRequest,
+	componentDefinitions?: Record<string, ComponentDefinition>,
 ): Promise<UpdateMarkdownResponse> {
 	try {
 		const fullPath = resolveAndValidatePath(request.filePath)
 		const release = await acquireFileLock(fullPath)
 		try {
-			const raw = await fs.readFile(fullPath, 'utf-8')
-			const existing = parseFrontmatter(raw)
-
-			const mergedFrontmatter: BlogFrontmatter = {
-				...(existing.frontmatter as BlogFrontmatter),
-				...request.frontmatter,
+			if (isDataFile(request.filePath)) {
+				// Data collections: merge and write JSON/YAML directly
+				const raw = await fs.readFile(fullPath, 'utf-8')
+				const existing = request.filePath.endsWith('.json') ? JSON.parse(raw) : yaml.parse(raw)
+				const merged = { ...(existing ?? {}), ...request.frontmatter }
+
+				const output = request.filePath.endsWith('.json')
+					? JSON.stringify(merged, null, 2) + '\n'
+					: yaml.stringify(merged)
+				await fs.writeFile(fullPath, output, 'utf-8')
+			} else {
+				const raw = await fs.readFile(fullPath, 'utf-8')
+				const existing = parseFrontmatter(raw)
+
+				const mergedFrontmatter: BlogFrontmatter = {
+					...(existing.frontmatter as BlogFrontmatter),
+					...request.frontmatter,
+				}
+
+				let finalContent = request.content ?? existing.content
+
+				if (request.filePath.endsWith('.mdx') && componentDefinitions) {
+					finalContent = ensureMdxImports(finalContent, request.filePath, componentDefinitions)
+				}
+
+				const markdownContent = serializeFrontmatter(mergedFrontmatter, finalContent)
+				await fs.writeFile(fullPath, markdownContent, 'utf-8')
 			}
 
-			const finalContent = request.content ?? existing.content
-			const markdownContent = serializeFrontmatter(mergedFrontmatter, finalContent)
-
-			await fs.writeFile(fullPath, markdownContent, 'utf-8')
-
 			return { success: true }
 		} finally {
 			release()
@@ -113,22 +142,35 @@ export async function handleCreateMarkdown(
 	if (!normalizedSlug) {
 		return { success: false, error: 'Could not generate a valid slug from the provided title/slug' }
 	}
-	const filePath = `src/content/${collection}/${normalizedSlug}.md`
-	const fullPath = resolveAndValidatePath(filePath)
 
-	const fullFrontmatter: BlogFrontmatter = {
-		title,
-		date: new Date().toISOString().split('T')[0]!,
-		draft: true,
-		...frontmatter,
+	const allowedExtensions = ['md', 'mdx', 'json', 'yaml', 'yml']
+	const ext = request.fileExtension ?? 'md'
+	if (!allowedExtensions.includes(ext)) {
+		return { success: false, error: `Invalid file extension "${ext}". Allowed: ${allowedExtensions.join(', ')}` }
 	}
+	const isData = ext === 'json' || ext === 'yaml' || ext === 'yml'
+	const filePath = `src/content/${collection}/${normalizedSlug}.${ext}`
+	const fullPath = resolveAndValidatePath(filePath)
 
-	const markdownContent = serializeFrontmatter(fullFrontmatter, content)
+	let fileContent: string
+	if (isData) {
+		const data = { ...frontmatter }
+		fileContent = ext === 'json'
+			? JSON.stringify(data, null, 2) + '\n'
+			: yaml.stringify(data)
+	} else {
+		const fullFrontmatter: BlogFrontmatter = {
+			title,
+			date: new Date().toISOString().split('T')[0]!,
+			draft: true,
+			...frontmatter,
+		}
+		fileContent = serializeFrontmatter(fullFrontmatter, content)
+	}
 
 	try {
 		await fs.mkdir(path.dirname(fullPath), { recursive: true })
-		// Use 'wx' flag for atomic exclusive create — fails if file already exists
-		await fs.writeFile(fullPath, markdownContent, { encoding: 'utf-8', flag: 'wx' })
+		await fs.writeFile(fullPath, fileContent, { encoding: 'utf-8', flag: 'wx' })
 
 		return {
 			success: true,
@@ -164,27 +206,74 @@ export async function handleDeleteMarkdown(
 	}
 }
 
-// --- Internal helpers ---
+export interface RenameMarkdownRequest {
+	filePath: string
+	newSlug: string
+}
 
-/**
- * Resolve a user-provided file path and ensure it stays within the project root.
- * Throws if the resolved path escapes the project boundary.
- */
-function resolveAndValidatePath(filePath: string): string {
-	const projectRoot = getProjectRoot()
-	const resolvedRoot = path.resolve(projectRoot)
-	// Absolute filesystem paths (e.g. /Users/...) stay intact;
-	// project-relative paths with a leading slash (e.g. /src/content/...) get it stripped
-	const isAbsoluteFs = filePath.startsWith(resolvedRoot)
-	const normalizedPath = (!isAbsoluteFs && filePath.startsWith('/')) ? filePath.slice(1) : filePath
-	const fullPath = path.isAbsolute(normalizedPath) ? path.resolve(normalizedPath) : path.resolve(projectRoot, normalizedPath)
+export interface RenameMarkdownResponse {
+	success: boolean
+	newFilePath?: string
+	newSlug?: string
+	error?: string
+}
 
-	// Ensure the resolved path is within the project root
-	if (!fullPath.startsWith(resolvedRoot + path.sep) && fullPath !== resolvedRoot) {
-		throw new Error(`Path traversal detected: ${filePath}`)
+export async function handleRenameMarkdown(
+	request: RenameMarkdownRequest,
+): Promise<RenameMarkdownResponse> {
+	try {
+		const fullPath = resolveAndValidatePath(request.filePath)
+		const normalizedSlug = slugify(request.newSlug)
+		if (!normalizedSlug) {
+			return { success: false, error: 'Invalid slug' }
+		}
+
+		const dir = path.dirname(fullPath)
+		const ext = path.extname(fullPath)
+		const newFullPath = path.join(dir, `${normalizedSlug}${ext}`)
+
+		if (fullPath === newFullPath) {
+			return { success: true, newFilePath: request.filePath, newSlug: normalizedSlug }
+		}
+
+		// Acquire lock to prevent concurrent access during rename
+		const release = await acquireFileLock(fullPath)
+		try {
+			// Use link+unlink for atomic rename that fails if target exists
+			try {
+				await fs.link(fullPath, newFullPath)
+			} catch (err) {
+				if (isNodeError(err, 'EEXIST')) {
+					return { success: false, error: `File already exists: ${normalizedSlug}${ext}` }
+				}
+				throw err
+			}
+			try {
+				await fs.unlink(fullPath)
+			} catch (err) {
+				// Clean up the new file if unlink of original fails
+				await fs.unlink(newFullPath).catch(() => {})
+				throw err
+			}
+		} finally {
+			release()
+		}
+
+		// Build project-relative path (normalize to forward slashes)
+		const projectRoot = getProjectRoot()
+		const newFilePath = path.relative(projectRoot, newFullPath).split(path.sep).join('/')
+
+		return { success: true, newFilePath, newSlug: normalizedSlug }
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error)
+		return { success: false, error: message }
 	}
+}
+
+// --- Internal helpers ---
 
-	return fullPath
+function isDataFile(filePath: string): boolean {
+	return filePath.endsWith('.json') || filePath.endsWith('.yaml') || filePath.endsWith('.yml')
 }
 
 function parseFrontmatter(raw: string): { frontmatter: Record<string, unknown>; content: string } {
@@ -224,11 +313,77 @@ function serializeFrontmatter(frontmatter: Record<string, unknown>, content: str
 	return `---\n${yamlStr}\n---\n${content}`
 }
 
-function slugify(text: string): string {
-	return text
-		.toLowerCase()
-		.trim()
-		.replace(/[^\w\s-]/g, '')
-		.replace(/[\s_-]+/g, '-')
-		.replace(/^-+|-+$/g, '')
+/**
+ * Ensure MDX content has import statements for all components used in the body.
+ * Scans for `<ComponentName` tags, checks for existing imports, and prepends missing ones.
+ */
+/** @internal Exported for testing */
+export function ensureMdxImports(
+	content: string,
+	filePath: string,
+	componentDefinitions: Record<string, ComponentDefinition>,
+): string {
+	// Find all component-like tags (capitalized names)
+	const usedComponents = new Set<string>()
+	const tagRegex = /<([A-Z][A-Za-z0-9]*)\b/g
+	let match
+	while ((match = tagRegex.exec(content)) !== null) {
+		if (match[1]) usedComponents.add(match[1])
+	}
+	if (usedComponents.size === 0) return content
+
+	// Find already-imported names and track the last import position in a single pass
+	const importedNames = new Set<string>()
+	const importLineRegex = /^import\s+(.+)\s+from\s+/gm
+	let lastImportEnd = -1
+	while ((match = importLineRegex.exec(content)) !== null) {
+		lastImportEnd = match.index + match[0].length
+		// Advance past the `from '...'` portion to find the true line end
+		const fromRest = content.slice(lastImportEnd)
+		const lineEnd = fromRest.indexOf('\n')
+		if (lineEnd >= 0) lastImportEnd += lineEnd
+		else lastImportEnd = content.length
+
+		const clause = match[1]!
+		// Extract named imports from braces: { A, B as C }
+		const braceMatch = clause.match(/\{([^}]+)\}/)
+		if (braceMatch?.[1]) {
+			for (const name of braceMatch[1].split(',')) {
+				const parts = name.trim().split(/\s+as\s+/)
+				const imported = (parts[1] ?? parts[0])?.trim()
+				if (imported) importedNames.add(imported)
+			}
+		}
+		// Extract default import and namespace import (* as X)
+		const withoutBraces = clause.replace(/\{[^}]*\}/, '').replace(/,/g, ' ').trim()
+		for (const token of withoutBraces.split(/\s+/)) {
+			if (token === '*' || token === 'as' || token === '') continue
+			importedNames.add(token)
+		}
+	}
+
+	const root = getProjectRoot()
+	const mdxFullPath = path.join(root, filePath)
+	const missingImports: string[] = []
+
+	for (const name of usedComponents) {
+		if (importedNames.has(name)) continue
+		const def = componentDefinitions[name]
+		if (!def) continue
+
+		const componentAbsPath = path.join(root, def.file)
+		const rel = relativeImportPath(mdxFullPath, componentAbsPath)
+		missingImports.push(`import ${name} from '${rel}'`)
+	}
+
+	if (missingImports.length === 0) return content
+
+	// Place after any existing import block, or at the top
+	const importBlock = missingImports.join('\n')
+
+	if (lastImportEnd >= 0) {
+		return content.slice(0, lastImportEnd) + '\n' + importBlock + content.slice(lastImportEnd)
+	}
+
+	return importBlock + '\n\n' + content
 }

package/src/handlers/page-ops.ts

@@ -0,0 +1,229 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { getProjectRoot } from '../config'
+import type { CreatePageRequest, DeletePageRequest, DuplicatePageRequest, LayoutInfo, PageOperationResponse } from '../types'
+import { escapeHtml, isNodeError, resolveAndValidatePath, slugify } from '../utils'
+
+const PAGE_EXTENSIONS = ['.astro', '.md', '.mdx']
+
+export async function handleCreatePage(request: CreatePageRequest): Promise<PageOperationResponse> {
+	const { title, slug } = request
+	const normalizedSlug = slugify(slug || title)
+
+	if (!normalizedSlug) {
+		return { success: false, error: 'Could not generate a valid slug from the provided title/slug' }
+	}
+
+	const filePath = `src/pages/${normalizedSlug}.astro`
+	const fullPath = resolveAndValidatePath(filePath)
+
+	const layoutImport = await resolveLayoutImport(request.layoutPath)
+	const content = generatePageContent(title, layoutImport)
+
+	try {
+		await fs.mkdir(path.dirname(fullPath), { recursive: true })
+		// 'wx' flag atomically fails if file exists — no pre-check needed
+		await fs.writeFile(fullPath, content, { encoding: 'utf-8', flag: 'wx' })
+
+		const url = normalizedSlug === 'index' ? '/' : `/${normalizedSlug}`
+		return { success: true, filePath, slug: normalizedSlug, url }
+	} catch (error) {
+		if (isNodeError(error, 'EEXIST')) {
+			return { success: false, error: `Page already exists: ${filePath}` }
+		}
+		return { success: false, error: errorMessage(error) }
+	}
+}
+
+export async function handleDuplicatePage(request: DuplicatePageRequest): Promise<PageOperationResponse> {
+	const { sourcePagePath, slug, title } = request
+	const normalizedSlug = slugify(slug)
+
+	if (!normalizedSlug) {
+		return { success: false, error: 'Could not generate a valid slug' }
+	}
+
+	const sourceFile = await findPageFile(sourcePagePath)
+	if (!sourceFile) {
+		return { success: false, error: `Source page not found: ${sourcePagePath}` }
+	}
+
+	let content: string
+	try {
+		content = await fs.readFile(resolveAndValidatePath(sourceFile), 'utf-8')
+	} catch {
+		return { success: false, error: `Could not read source file: ${sourceFile}` }
+	}
+
+	if (title) {
+		content = replacePageTitle(content, title)
+	}
+
+	const newFilePath = `src/pages/${normalizedSlug}.astro`
+	const newFullPath = resolveAndValidatePath(newFilePath)
+
+	try {
+		await fs.mkdir(path.dirname(newFullPath), { recursive: true })
+		await fs.writeFile(newFullPath, content, { encoding: 'utf-8', flag: 'wx' })
+
+		const url = normalizedSlug === 'index' ? '/' : `/${normalizedSlug}`
+		return { success: true, filePath: newFilePath, slug: normalizedSlug, url }
+	} catch (error) {
+		if (isNodeError(error, 'EEXIST')) {
+			return { success: false, error: `Page already exists: ${newFilePath}` }
+		}
+		return { success: false, error: errorMessage(error) }
+	}
+}
+
+export async function handleDeletePage(request: DeletePageRequest): Promise<PageOperationResponse> {
+	const { pagePath } = request
+
+	const pageFile = await findPageFile(pagePath)
+	if (!pageFile) {
+		return { success: false, error: `Page not found: ${pagePath}` }
+	}
+
+	try {
+		// No pre-check — just unlink and handle ENOENT
+		await fs.unlink(resolveAndValidatePath(pageFile))
+		return { success: true, filePath: pageFile, url: pagePath }
+	} catch (error) {
+		if (isNodeError(error, 'ENOENT')) {
+			return { success: false, error: `File not found: ${pageFile}` }
+		}
+		return { success: false, error: errorMessage(error) }
+	}
+}
+
+/**
+ * Reuses findPageFile to check whether a slug is already taken.
+ */
+export async function handleCheckSlugExists(slug: string): Promise<{ exists: boolean; filePath?: string }> {
+	const normalizedSlug = slugify(slug)
+	if (!normalizedSlug) return { exists: false }
+
+	const found = await findPageFile(`/${normalizedSlug}`)
+	return found ? { exists: true, filePath: found } : { exists: false }
+}
+
+export async function handleGetLayouts(): Promise<LayoutInfo[]> {
+	const layoutsDir = path.join(getProjectRoot(), 'src', 'layouts')
+
+	let entries
+	try {
+		entries = await fs.readdir(layoutsDir, { withFileTypes: true })
+	} catch {
+		return []
+	}
+
+	const layouts: LayoutInfo[] = []
+	for (const entry of entries) {
+		if (entry.isFile() && entry.name.endsWith('.astro')) {
+			layouts.push({
+				name: path.basename(entry.name, '.astro'),
+				path: `src/layouts/${entry.name}`,
+			})
+		}
+	}
+
+	return layouts.sort((a, b) => a.name.localeCompare(b.name))
+}
+
+// --- Internal helpers ---
+
+function errorMessage(error: unknown): string {
+	return error instanceof Error ? error.message : String(error)
+}
+
+async function fileExists(fullPath: string): Promise<boolean> {
+	try {
+		await fs.access(fullPath)
+		return true
+	} catch {
+		return false
+	}
+}
+
+async function findPageFile(pagePath: string): Promise<string | null> {
+	const normalized = pagePath.replace(/^\//, '').replace(/\/$/, '') || 'index'
+
+	for (const ext of PAGE_EXTENSIONS) {
+		const direct = `src/pages/${normalized}${ext}`
+		if (await fileExists(resolveAndValidatePath(direct))) return direct
+	}
+
+	for (const ext of PAGE_EXTENSIONS) {
+		const indexFile = `src/pages/${normalized}/index${ext}`
+		if (await fileExists(resolveAndValidatePath(indexFile))) return indexFile
+	}
+
+	return null
+}
+
+async function resolveLayoutImport(layoutPath?: string): Promise<{ importPath: string; componentName: string } | null> {
+	if (layoutPath) {
+		const name = path.basename(layoutPath, '.astro')
+		const importPath = `../${layoutPath.replace(/^src\//, '')}`
+		return { importPath, componentName: pascalCase(name) }
+	}
+
+	const layouts = await handleGetLayouts()
+	if (layouts.length === 0) return null
+
+	const layout = layouts[0]!
+	const importPath = `../${layout.path.replace(/^src\//, '')}`
+	return { importPath, componentName: pascalCase(layout.name) }
+}
+
+function pascalCase(name: string): string {
+	return name.replace(/(^|[-_])(\w)/g, (_, _sep, char) => char.toUpperCase())
+}
+
+function generatePageContent(
+	title: string,
+	layoutImport: { importPath: string; componentName: string } | null,
+): string {
+	const escapedTitle = title.replace(/'/g, "\\'").replace(/`/g, '\\`')
+	const htmlTitle = escapeHtml(title)
+
+	if (layoutImport) {
+		const { importPath, componentName } = layoutImport
+		return `---
+import ${componentName} from '${importPath}'
+---
+
+<${componentName} title="${escapedTitle}" description="">
+\t<main>
+\t\t<h1>${htmlTitle}</h1>
+\t</main>
+</${componentName}>
+`
+	}
+
+	return `---
+
+---
+
+<html lang="en">
+\t<head>
+\t\t<meta charset="utf-8" />
+\t\t<meta name="viewport" content="width=device-width" />
+\t\t<title>${escapedTitle}</title>
+\t</head>
+\t<body>
+\t\t<main>
+\t\t\t<h1>${htmlTitle}</h1>
+\t\t</main>
+\t</body>
+</html>
+`
+}
+
+function replacePageTitle(content: string, newTitle: string): string {
+	let result = content
+	result = result.replace(/(title\s*=\s*")([^"]*)(")/, `$1${newTitle}$3`)
+	result = result.replace(/(<title>)([^<]*)(<\/title>)/, `$1${newTitle}$3`)
+	result = result.replace(/(<h1[^>]*>)([^<]*)(<\/h1>)/, `$1${escapeHtml(newTitle)}$3`)
+	return result
+}