@nuasite/cms 0.42.1 → 0.43.0-beta.1

package/src/handlers/markdown-ops.ts

@@ -1,474 +0,0 @@
-import type { Dirent } from 'node:fs'
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import yaml from 'yaml'
-import { getProjectRoot } from '../config'
-import { parseContentConfig } from '../content-config-ast'
-import type { ComponentDefinition } from '../types'
-import { acquireFileLock, isNodeError, relativeImportPath, resolveAndValidatePath, slugify } from '../utils'
-
-export interface BlogFrontmatter {
-	title: string
-	date: string
-	author?: string
-	categories?: string[]
-	excerpt?: string
-	featuredImage?: string
-	draft?: boolean
-	[key: string]: unknown
-}
-
-export interface CreateMarkdownRequest {
-	collection: string
-	title: string
-	slug: string
-	frontmatter?: Partial<BlogFrontmatter>
-	content?: string
-	/** File extension override for data collections (e.g. 'json', 'yaml') */
-	fileExtension?: string
-}
-
-export interface CreateMarkdownResponse {
-	success: boolean
-	filePath?: string
-	slug?: string
-	error?: string
-}
-
-export interface UpdateMarkdownRequest {
-	filePath: string
-	frontmatter?: Partial<BlogFrontmatter>
-	content?: string
-}
-
-export interface UpdateMarkdownResponse {
-	success: boolean
-	error?: string
-}
-
-export interface DeleteMarkdownRequest {
-	filePath: string
-}
-
-export interface DeleteMarkdownResponse {
-	success: boolean
-	error?: string
-}
-
-export interface GetMarkdownContentResponse {
-	content: string
-	frontmatter: BlogFrontmatter
-	filePath: string
-}
-
-export async function handleGetMarkdownContent(
-	filePath: string,
-): Promise<GetMarkdownContentResponse | null> {
-	try {
-		const fullPath = resolveAndValidatePath(filePath)
-		const raw = await fs.readFile(fullPath, 'utf-8')
-
-		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,
-			filePath,
-		}
-	} catch {
-		return null
-	}
-}
-
-export async function handleUpdateMarkdown(
-	request: UpdateMarkdownRequest,
-	componentDefinitions?: Record<string, ComponentDefinition>,
-): Promise<UpdateMarkdownResponse> {
-	try {
-		const fullPath = resolveAndValidatePath(request.filePath)
-		const release = await acquireFileLock(fullPath)
-		try {
-			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')
-			}
-
-			return { success: true }
-		} finally {
-			release()
-		}
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error)
-		return { success: false, error: message }
-	}
-}
-
-export async function handleCreateMarkdown(
-	request: CreateMarkdownRequest,
-): Promise<CreateMarkdownResponse> {
-	const { collection, title, slug, frontmatter = {}, content = '' } = request
-
-	const normalizedSlug = slugify(slug || title)
-	if (!normalizedSlug) {
-		return { success: false, error: 'Could not generate a valid slug from the provided title/slug' }
-	}
-
-	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 layout = isData ? 'flat' : await detectCollectionMarkdownLayout(collection)
-	const filePath = layout === 'index'
-		? `src/content/${collection}/${normalizedSlug}/index.${ext}`
-		: `src/content/${collection}/${normalizedSlug}.${ext}`
-	const fullPath = resolveAndValidatePath(filePath)
-
-	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]!,
-			...frontmatter,
-		}
-		fileContent = serializeFrontmatter(fullFrontmatter, content)
-	}
-
-	try {
-		await fs.mkdir(path.dirname(fullPath), { recursive: true })
-		await fs.writeFile(fullPath, fileContent, { encoding: 'utf-8', flag: 'wx' })
-
-		return {
-			success: true,
-			filePath,
-			slug: normalizedSlug,
-		}
-	} catch (error) {
-		if (error instanceof Error && 'code' in error && (error as NodeJS.ErrnoException).code === 'EEXIST') {
-			return { success: false, error: `File already exists: ${filePath}` }
-		}
-		const message = error instanceof Error ? error.message : String(error)
-		return { success: false, error: message }
-	}
-}
-
-export async function handleDeleteMarkdown(
-	request: DeleteMarkdownRequest,
-): Promise<DeleteMarkdownResponse> {
-	try {
-		const fullPath = resolveAndValidatePath(request.filePath)
-
-		// Verify the file exists before deleting
-		await fs.access(fullPath)
-		await fs.unlink(fullPath)
-
-		return { success: true }
-	} catch (error) {
-		if (error instanceof Error && 'code' in error && (error as NodeJS.ErrnoException).code === 'ENOENT') {
-			return { success: false, error: `File not found: ${request.filePath}` }
-		}
-		const message = error instanceof Error ? error.message : String(error)
-		return { success: false, error: message }
-	}
-}
-
-export interface RenameMarkdownRequest {
-	filePath: string
-	newSlug: string
-}
-
-export interface RenameMarkdownResponse {
-	success: boolean
-	newFilePath?: string
-	newSlug?: string
-	error?: string
-}
-
-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 ---
-
-function isDataFile(filePath: string): boolean {
-	return filePath.endsWith('.json') || filePath.endsWith('.yaml') || filePath.endsWith('.yml')
-}
-
-type MarkdownCollectionLayout = 'flat' | 'index'
-
-async function detectCollectionMarkdownLayout(collection: string): Promise<MarkdownCollectionLayout> {
-	const existingLayout = await inferLayoutFromExistingEntries(collection)
-	if (existingLayout) return existingLayout
-
-	const configLayout = await inferLayoutFromContentConfig(collection)
-	if (configLayout) return configLayout
-
-	return 'flat'
-}
-
-async function inferLayoutFromExistingEntries(collection: string): Promise<MarkdownCollectionLayout | null> {
-	const collectionPath = path.join(getProjectRoot(), 'src', 'content', collection)
-
-	let dirEntries: Dirent[]
-	try {
-		dirEntries = await fs.readdir(collectionPath, { withFileTypes: true })
-	} catch {
-		return null
-	}
-
-	let flatCount = 0
-	let indexCount = 0
-	const flatSlugs = new Set<string>()
-
-	for (const entry of dirEntries) {
-		if (!entry.isFile()) continue
-		const match = entry.name.match(/^(.+)\.(md|mdx)$/)
-		if (!match) continue
-		flatCount++
-		flatSlugs.add(match[1]!)
-	}
-
-	const subdirs = dirEntries.filter(entry => entry.isDirectory() && !entry.name.startsWith('_') && !entry.name.startsWith('.'))
-	const indexLookups = await Promise.all(subdirs.map(async dir => {
-		if (flatSlugs.has(dir.name)) return false
-		for (const ext of ['md', 'mdx'] as const) {
-			try {
-				await fs.access(path.join(collectionPath, dir.name, `index.${ext}`))
-				return true
-			} catch {
-				// try next extension
-			}
-		}
-		return false
-	}))
-	indexCount = indexLookups.filter(Boolean).length
-
-	if (indexCount > flatCount) return 'index'
-	if (flatCount > 0) return 'flat'
-	return null
-}
-
-async function inferLayoutFromContentConfig(collection: string): Promise<MarkdownCollectionLayout | null> {
-	try {
-		const parsed = await parseContentConfig()
-		const pattern = parsed.get(collection)?.loaderPattern
-		if (!pattern) return null
-		return isIndexStyleGlobPattern(pattern) ? 'index' : 'flat'
-	} catch {
-		return null
-	}
-}
-
-function isIndexStyleGlobPattern(pattern: string): boolean {
-	return pattern.includes('index.{') || pattern.includes('*/index') || pattern.includes('**/index')
-}
-
-function parseFrontmatter(raw: string): { frontmatter: Record<string, unknown>; content: string } {
-	const trimmed = raw.trimStart()
-	if (!trimmed.startsWith('---')) {
-		return { frontmatter: {}, content: raw }
-	}
-
-	// Find closing --- on its own line (not inside YAML values)
-	const lines = trimmed.split('\n')
-	let endLineIndex = -1
-	for (let i = 1; i < lines.length; i++) {
-		if (lines[i]!.trimEnd() === '---') {
-			endLineIndex = i
-			break
-		}
-	}
-	if (endLineIndex === -1) {
-		return { frontmatter: {}, content: raw }
-	}
-
-	const yamlStr = lines.slice(1, endLineIndex).join('\n').trim()
-	const content = lines.slice(endLineIndex + 1).join('\n').replace(/^\r?\n/, '')
-
-	let frontmatter: Record<string, unknown> = {}
-	try {
-		frontmatter = (yaml.parse(yamlStr) as Record<string, unknown>) ?? {}
-	} catch {
-		// Invalid YAML, return empty frontmatter
-	}
-
-	return { frontmatter, content }
-}
-
-/** Pattern for strings that YAML auto-parses as Date objects */
-const YAML_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}/
-
-function serializeFrontmatter(frontmatter: Record<string, unknown>, content: string): string {
-	const doc = new yaml.Document(frontmatter)
-	// Force-quote strings that YAML would auto-parse as dates
-	yaml.visit(doc, {
-		Scalar(_key, node) {
-			if (typeof node.value === 'string' && YAML_DATE_PATTERN.test(node.value)) {
-				node.type = yaml.Scalar.QUOTE_SINGLE
-			}
-		},
-	})
-	const yamlStr = doc.toString().trim()
-	return `---\n${yamlStr}\n---\n${content}`
-}
-
-/**
- * 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/redirect-ops.ts

@@ -1,163 +0,0 @@
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import { getProjectRoot } from '../config'
-import type { AddRedirectRequest, DeleteRedirectRequest, RedirectOperationResponse, RedirectRule, UpdateRedirectRequest } from '../types'
-import { acquireFileLock, isNodeError } from '../utils'
-
-const DEFAULT_STATUS_CODE = 307
-const REDIRECTS_FILE = 'src/_redirects'
-
-function getRedirectsFilePath(): string {
-	return path.join(getProjectRoot(), REDIRECTS_FILE)
-}
-
-export async function handleGetRedirects(): Promise<{ rules: RedirectRule[] }> {
-	const lines = await readRedirectsFile(getRedirectsFilePath())
-	return { rules: parseRedirectLines(lines) }
-}
-
-export async function handleAddRedirect(request: AddRedirectRequest): Promise<RedirectOperationResponse> {
-	const { source, destination, statusCode = DEFAULT_STATUS_CODE } = request
-
-	if (!source || !destination) {
-		return { success: false, error: 'Source and destination are required' }
-	}
-	if (!source.startsWith('/')) {
-		return { success: false, error: 'Source must start with /' }
-	}
-	if (!destination.startsWith('/') && !destination.startsWith('http')) {
-		return { success: false, error: 'Destination must start with / or http' }
-	}
-
-	const filePath = getRedirectsFilePath()
-	const release = await acquireFileLock(filePath)
-
-	try {
-		const lines = await readRedirectsFile(filePath)
-		const existing = parseRedirectLines(lines)
-
-		if (existing.some(r => r.source === source)) {
-			return { success: false, error: `Redirect already exists for ${source}` }
-		}
-
-		lines.push(formatRedirectLine(source, destination, statusCode))
-		await writeRedirectsFile(filePath, lines)
-		return { success: true }
-	} finally {
-		release()
-	}
-}
-
-export async function handleUpdateRedirect(request: UpdateRedirectRequest): Promise<RedirectOperationResponse> {
-	const { lineIndex, source, destination, statusCode = DEFAULT_STATUS_CODE } = request
-
-	if (!source || !destination) {
-		return { success: false, error: 'Source and destination are required' }
-	}
-
-	const filePath = getRedirectsFilePath()
-	const release = await acquireFileLock(filePath)
-
-	try {
-		const lines = await readRedirectsFile(filePath)
-
-		// Guard against stale line index
-		const currentLine = lines[lineIndex]?.trim()
-		if (!currentLine || currentLine.startsWith('#')) {
-			return { success: false, error: 'Line at index is no longer a redirect rule — please refresh and try again' }
-		}
-
-		lines[lineIndex] = formatRedirectLine(source, destination, statusCode)
-		await writeRedirectsFile(filePath, lines)
-		return { success: true }
-	} finally {
-		release()
-	}
-}
-
-export async function handleDeleteRedirect(request: DeleteRedirectRequest): Promise<RedirectOperationResponse> {
-	const { lineIndex } = request
-
-	const filePath = getRedirectsFilePath()
-	const release = await acquireFileLock(filePath)
-
-	try {
-		const lines = await readRedirectsFile(filePath)
-
-		if (lineIndex < 0 || lineIndex >= lines.length) {
-			return { success: false, error: `Invalid line index: ${lineIndex}` }
-		}
-
-		const line = lines[lineIndex]!.trim()
-		if (!line || line.startsWith('#')) {
-			return { success: false, error: 'Line is not a redirect rule' }
-		}
-
-		lines.splice(lineIndex, 1)
-		await writeRedirectsFile(filePath, lines)
-		return { success: true }
-	} finally {
-		release()
-	}
-}
-
-// --- Internal helpers ---
-
-function formatRedirectLine(source: string, destination: string, statusCode: number): string {
-	return statusCode === DEFAULT_STATUS_CODE
-		? `${source} ${destination}`
-		: `${source} ${destination} ${statusCode}`
-}
-
-async function readRedirectsFile(filePath: string): Promise<string[]> {
-	try {
-		const content = await fs.readFile(filePath, 'utf-8')
-		return content.split('\n')
-	} catch (error) {
-		if (isNodeError(error, 'ENOENT')) return []
-		throw error
-	}
-}
-
-async function writeRedirectsFile(filePath: string, lines: string[]): Promise<void> {
-	await fs.mkdir(path.dirname(filePath), { recursive: true })
-
-	const trimmed = lines.slice()
-	while (trimmed.length > 0 && trimmed[trimmed.length - 1]!.trim() === '') {
-		trimmed.pop()
-	}
-
-	if (trimmed.length === 0) {
-		await fs.writeFile(filePath, '', 'utf-8')
-		return
-	}
-
-	await fs.writeFile(filePath, trimmed.join('\n') + '\n', 'utf-8')
-}
-
-function parseRedirectLines(lines: string[]): RedirectRule[] {
-	const rules: RedirectRule[] = []
-
-	for (let i = 0; i < lines.length; i++) {
-		const line = lines[i]!.trim()
-		if (!line || line.startsWith('#')) continue
-
-		const parts = line.split(/\s+/)
-		if (parts.length < 2) continue
-
-		const source = parts[0]!
-		if (!source.startsWith('/')) continue
-
-		const destination = parts[1]!
-		const statusCode = parts[2] ? parseInt(parts[2], 10) : DEFAULT_STATUS_CODE
-
-		rules.push({
-			source,
-			destination,
-			statusCode: Number.isNaN(statusCode) ? DEFAULT_STATUS_CODE : statusCode,
-			lineIndex: i,
-		})
-	}
-
-	return rules
-}