@nuasite/cms-core 0.43.0-beta.1

package/src/handlers/page-ops.ts

@@ -0,0 +1,203 @@
+import type { CreatePageRequest, DeletePageRequest, DuplicatePageRequest, LayoutInfo, PageOperationResponse } from '@nuasite/cms-types'
+import type { CmsFileSystem } from '../fs/types'
+import { escapeHtml, slugify } from '../shared'
+
+const PAGE_EXTENSIONS = ['.astro', '.md', '.mdx']
+
+export interface PageOpsDeps {
+	fs: CmsFileSystem
+}
+
+function errorMessage(error: unknown): string {
+	return error instanceof Error ? error.message : String(error)
+}
+
+export async function createPage(deps: PageOpsDeps, 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`
+
+	if (await deps.fs.exists(filePath)) {
+		return { success: false, error: `Page already exists: ${filePath}` }
+	}
+
+	const layoutImport = await resolveLayoutImport(deps, request.layoutPath)
+	const content = generatePageContent(title, layoutImport)
+
+	try {
+		await deps.fs.writeFile(filePath, content)
+		const url = normalizedSlug === 'index' ? '/' : `/${normalizedSlug}`
+		return { success: true, filePath, slug: normalizedSlug, url }
+	} catch (error) {
+		return { success: false, error: errorMessage(error) }
+	}
+}
+
+export async function duplicatePage(deps: PageOpsDeps, 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(deps, sourcePagePath)
+	if (!sourceFile) {
+		return { success: false, error: `Source page not found: ${sourcePagePath}` }
+	}
+
+	let content: string
+	try {
+		content = await deps.fs.readFile(sourceFile)
+	} catch {
+		return { success: false, error: `Could not read source file: ${sourceFile}` }
+	}
+
+	if (title) {
+		content = replacePageTitle(content, title)
+	}
+
+	const newFilePath = `src/pages/${normalizedSlug}.astro`
+
+	if (await deps.fs.exists(newFilePath)) {
+		return { success: false, error: `Page already exists: ${newFilePath}` }
+	}
+
+	try {
+		await deps.fs.writeFile(newFilePath, content)
+		const url = normalizedSlug === 'index' ? '/' : `/${normalizedSlug}`
+		return { success: true, filePath: newFilePath, slug: normalizedSlug, url }
+	} catch (error) {
+		return { success: false, error: errorMessage(error) }
+	}
+}
+
+export async function deletePage(deps: PageOpsDeps, request: DeletePageRequest): Promise<PageOperationResponse> {
+	const { pagePath } = request
+
+	const pageFile = await findPageFile(deps, pagePath)
+	if (!pageFile) {
+		return { success: false, error: `Page not found: ${pagePath}` }
+	}
+
+	try {
+		await deps.fs.remove(pageFile)
+		return { success: true, filePath: pageFile, url: pagePath }
+	} catch (error) {
+		return { success: false, error: errorMessage(error) }
+	}
+}
+
+export async function getLayouts(deps: PageOpsDeps): Promise<LayoutInfo[]> {
+	const entries = await deps.fs.list('src/layouts')
+
+	const layouts: LayoutInfo[] = []
+	for (const entry of entries) {
+		if (!entry.isDirectory && entry.name.endsWith('.astro')) {
+			layouts.push({
+				name: entry.name.slice(0, -'.astro'.length),
+				path: `src/layouts/${entry.name}`,
+			})
+		}
+	}
+
+	return layouts.sort((a, b) => a.name.localeCompare(b.name))
+}
+
+export async function checkSlugExists(deps: PageOpsDeps, slug: string): Promise<{ exists: boolean; filePath?: string }> {
+	const normalizedSlug = slugify(slug)
+	if (!normalizedSlug) return { exists: false }
+
+	const found = await findPageFile(deps, `/${normalizedSlug}`)
+	return found ? { exists: true, filePath: found } : { exists: false }
+}
+
+// --- Internal helpers ---
+
+async function findPageFile(deps: PageOpsDeps, 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 deps.fs.exists(direct)) return direct
+	}
+
+	for (const ext of PAGE_EXTENSIONS) {
+		const indexFile = `src/pages/${normalized}/index${ext}`
+		if (await deps.fs.exists(indexFile)) return indexFile
+	}
+
+	return null
+}
+
+async function resolveLayoutImport(deps: PageOpsDeps, layoutPath?: string): Promise<{ importPath: string; componentName: string } | null> {
+	if (layoutPath) {
+		const name = layoutPath.replace(/^.*\//, '').replace(/\.astro$/, '')
+		const importPath = `../${layoutPath.replace(/^src\//, '')}`
+		return { importPath, componentName: pascalCase(name) }
+	}
+
+	const layouts = await getLayouts(deps)
+	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
+}

package/src/handlers/redirect-ops.ts

@@ -0,0 +1,139 @@
+import type {
+	AddRedirectRequest,
+	DeleteRedirectRequest,
+	GetRedirectsResponse,
+	RedirectOperationResponse,
+	RedirectRule,
+	UpdateRedirectRequest,
+} from '@nuasite/cms-types'
+import type { CmsFileSystem } from '../fs/types'
+
+const DEFAULT_STATUS_CODE = 307
+const REDIRECTS_FILE = 'src/_redirects'
+
+export interface RedirectOpsDeps {
+	fs: CmsFileSystem
+}
+
+export async function listRedirects(deps: RedirectOpsDeps): Promise<GetRedirectsResponse> {
+	const lines = await readRedirectsFile(deps)
+	return { rules: parseRedirectLines(lines) }
+}
+
+export async function addRedirect(deps: RedirectOpsDeps, 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 lines = await readRedirectsFile(deps)
+	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(deps, lines)
+	return { success: true }
+}
+
+export async function updateRedirect(deps: RedirectOpsDeps, 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 lines = await readRedirectsFile(deps)
+
+	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(deps, lines)
+	return { success: true }
+}
+
+export async function deleteRedirect(deps: RedirectOpsDeps, request: DeleteRedirectRequest): Promise<RedirectOperationResponse> {
+	const { lineIndex } = request
+
+	const lines = await readRedirectsFile(deps)
+
+	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(deps, lines)
+	return { success: true }
+}
+
+// --- Internal helpers ---
+
+function formatRedirectLine(source: string, destination: string, statusCode: number): string {
+	return statusCode === DEFAULT_STATUS_CODE
+		? `${source} ${destination}`
+		: `${source} ${destination} ${statusCode}`
+}
+
+async function readRedirectsFile(deps: RedirectOpsDeps): Promise<string[]> {
+	if (!(await deps.fs.exists(REDIRECTS_FILE))) return []
+	const content = await deps.fs.readFile(REDIRECTS_FILE)
+	return content.split('\n')
+}
+
+async function writeRedirectsFile(deps: RedirectOpsDeps, lines: string[]): Promise<void> {
+	const trimmed = lines.slice()
+	while (trimmed.length > 0 && trimmed[trimmed.length - 1]!.trim() === '') {
+		trimmed.pop()
+	}
+
+	if (trimmed.length === 0) {
+		await deps.fs.writeFile(REDIRECTS_FILE, '')
+		return
+	}
+
+	await deps.fs.writeFile(REDIRECTS_FILE, trimmed.join('\n') + '\n')
+}
+
+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
+}

package/src/index.ts

@@ -0,0 +1,41 @@
+export { scanCollections } from './collection-scanner'
+export { scanComponentDefinitions } from './component-registry'
+export {
+	type ParseCache,
+	parseConfigSource,
+	parseContentConfig,
+	type ParsedCollection,
+	type ParsedConfig,
+	type ParsedField,
+	type ParsedReference,
+} from './content-config-ast'
+export { createCmsCore } from './core'
+export type { CmsCore, CmsCoreOptions } from './core'
+export { globToRegExp } from './fs/glob'
+export { createNodeFs } from './fs/node-fs'
+export type { CmsFileSystem } from './fs/types'
+export {
+	type AddArrayItemInput,
+	type CreateEntryInput,
+	ensureMdxImports,
+	type EntryOpsDeps,
+	type GetEntryResult,
+	parseFrontmatter,
+	type RemoveArrayItemInput,
+	serializeFrontmatter,
+	type UpdateEntryInput,
+} from './handlers/entry-ops'
+export {
+	type ContemberStorageOptions,
+	createContemberStorageAdapter,
+	createLocalStorageAdapter,
+	createS3StorageAdapter,
+	getFileExtension,
+	listProjectImages,
+	type ListProjectImagesOptions,
+	type LocalStorageOptions,
+	MIME_BY_EXT,
+	mimeFromExt,
+	type S3StorageOptions,
+} from './media/index'
+export { escapeHtml, relativeImportPath, slugify, slugifyHref } from './shared'

package/src/media/contember.ts

@@ -0,0 +1,90 @@
+import type { MediaStorageAdapter } from '@nuasite/cms-types'
+
+export interface ContemberStorageOptions {
+	/** Base URL of the worker API, e.g. 'https://api.example.com' */
+	apiBaseUrl: string
+	/** Project slug used in the API path */
+	projectSlug: string
+	/** Session token for authentication (NUA_SITE_SESSION_TOKEN cookie value) */
+	sessionToken?: string
+}
+
+/**
+ * Media storage adapter that proxies to the Contember worker's CMS media endpoints.
+ * Uses the existing /cms/:projectSlug/media/* API backed by R2 storage + Contember database.
+ *
+ * All connection details (`apiBaseUrl`, `projectSlug`, `sessionToken`) are injected
+ * by the caller — the adapter never reads `process.env`.
+ */
+export function createContemberStorageAdapter(options: ContemberStorageOptions): MediaStorageAdapter {
+	const { apiBaseUrl, projectSlug, sessionToken } = options
+	const base = `${apiBaseUrl.replace(/\/$/, '')}/cms/${projectSlug}/media`
+
+	function headers(): Record<string, string> {
+		const h: Record<string, string> = {}
+		if (sessionToken) {
+			h.Cookie = `NUA_SITE_SESSION_TOKEN=${sessionToken}`
+		}
+		return h
+	}
+
+	return {
+		async list(opts) {
+			const params = new URLSearchParams()
+			if (opts?.limit) params.set('limit', String(opts.limit))
+			if (opts?.cursor) params.set('cursor', opts.cursor)
+
+			const url = `${base}/list${params.toString() ? `?${params}` : ''}`
+			const res = await fetch(url, {
+				method: 'GET',
+				headers: headers(),
+				credentials: 'include',
+			})
+
+			if (!res.ok) {
+				throw new Error(`Failed to list media (${res.status}): ${await res.text()}`)
+			}
+
+			const data: unknown = await res.json()
+			const payload = (data && typeof data === 'object') ? data : {}
+			return { items: [], folders: [], hasMore: false, ...payload }
+		},
+
+		async upload(file, filename, contentType) {
+			const blob = new Blob([new Uint8Array(file)], { type: contentType })
+			const formData = new FormData()
+			formData.append('file', blob, filename)
+
+			const res = await fetch(`${base}/upload`, {
+				method: 'POST',
+				headers: headers(),
+				body: formData,
+				credentials: 'include',
+			})
+
+			if (!res.ok) {
+				const text = await res.text().catch(() => '')
+				return { success: false, error: `Upload failed (${res.status}): ${text}` }
+			}
+
+			const data: unknown = await res.json()
+			const payload = (data && typeof data === 'object') ? data : {}
+			return { success: true, ...payload }
+		},
+
+		async delete(id) {
+			const res = await fetch(`${base}/${encodeURIComponent(id)}`, {
+				method: 'DELETE',
+				headers: headers(),
+				credentials: 'include',
+			})
+
+			if (!res.ok) {
+				const text = await res.text().catch(() => '')
+				return { success: false, error: `Delete failed (${res.status}): ${text}` }
+			}
+
+			return { success: true }
+		},
+	}
+}

package/src/media/index.ts

@@ -0,0 +1,4 @@
+export { type ContemberStorageOptions, createContemberStorageAdapter } from './contember'
+export { createLocalStorageAdapter, getFileExtension, type LocalStorageOptions, MIME_BY_EXT, mimeFromExt } from './local'
+export { listProjectImages, type ListProjectImagesOptions } from './project-images'
+export { createS3StorageAdapter, type S3StorageOptions } from './s3'

package/src/media/local.ts

@@ -0,0 +1,147 @@
+import type { MediaFolderItem, MediaListResult, MediaStorageAdapter, MediaUploadResult } from '@nuasite/cms-types'
+import { randomUUID } from 'node:crypto'
+import fs from 'node:fs/promises'
+import path from 'node:path'
+
+export interface LocalStorageOptions {
+	/** Directory to store media files (relative to project root or absolute). Default: 'public/uploads' */
+	dir?: string
+	/** URL prefix for serving files. Default: '/uploads' */
+	urlPrefix?: string
+}
+
+export function createLocalStorageAdapter(options: LocalStorageOptions = {}): MediaStorageAdapter {
+	const dir = path.resolve(options.dir ?? 'public/uploads')
+	const urlPrefix = (options.urlPrefix ?? '/uploads').replace(/\/$/, '')
+
+	return {
+		staticFiles: { urlPrefix, dir },
+
+		async list(opts) {
+			const limit = opts?.limit ?? 50
+			const offset = opts?.cursor ? parseInt(opts.cursor, 10) : 0
+			const folder = opts?.folder ?? ''
+
+			const targetDir = folder ? path.join(dir, folder) : dir
+			await fs.mkdir(targetDir, { recursive: true })
+
+			const entries = await fs.readdir(targetDir, { withFileTypes: true })
+
+			const folders: MediaFolderItem[] = entries
+				.filter((e) => e.isDirectory() && !e.name.startsWith('.'))
+				.map((e) => ({
+					name: e.name,
+					path: folder ? `${folder}/${e.name}` : e.name,
+				}))
+				.sort((a, b) => a.name.localeCompare(b.name))
+
+			const files = entries.filter((e) => e.isFile() && !e.name.startsWith('.'))
+
+			const withStats = await Promise.all(
+				files.map(async (f) => {
+					const filePath = path.join(targetDir, f.name)
+					const stat = await fs.stat(filePath)
+					return { name: f.name, stat }
+				}),
+			)
+			withStats.sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs)
+
+			const slice = withStats.slice(offset, offset + limit)
+			const hasMore = offset + limit < withStats.length
+
+			const urlFolder = folder ? `/${folder}` : ''
+			const items = slice.map((f) => {
+				const ext = path.extname(f.name).toLowerCase()
+				const contentType = mimeFromExt(ext)
+				return {
+					id: folder ? `${folder}/${f.name}` : f.name,
+					url: `${urlPrefix}${urlFolder}/${f.name}`,
+					filename: f.name,
+					contentType,
+					uploadedAt: f.stat.mtime.toISOString(),
+					folder: folder || undefined,
+				}
+			})
+
+			return {
+				items,
+				folders,
+				hasMore,
+				cursor: hasMore ? String(offset + limit) : undefined,
+			} satisfies MediaListResult
+		},
+
+		async upload(file, filename, contentType, uploadOpts) {
+			const folder = uploadOpts?.folder ?? ''
+			const targetDir = folder ? path.join(dir, folder) : dir
+			await fs.mkdir(targetDir, { recursive: true })
+
+			const ext = getFileExtension(filename)
+			const uuid = randomUUID()
+			const newFilename = `${uuid}${ext ? `.${ext}` : ''}`
+			const filePath = path.join(targetDir, newFilename)
+
+			await fs.writeFile(filePath, file)
+
+			const urlFolder = folder ? `/${folder}` : ''
+			const id = folder ? `${folder}/${newFilename}` : newFilename
+
+			return {
+				success: true,
+				url: `${urlPrefix}${urlFolder}/${newFilename}`,
+				filename: newFilename,
+				id,
+			} satisfies MediaUploadResult
+		},
+
+		async delete(id) {
+			const safePath = id.split('/').map((s) => path.basename(s)).join('/')
+			const filePath = path.join(dir, safePath)
+			try {
+				await fs.unlink(filePath)
+				return { success: true }
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error)
+				return { success: false, error: message }
+			}
+		},
+
+		async createFolder(folder) {
+			const segments = folder.split('/').filter(Boolean)
+			if (segments.some((s) => s === '..' || s === '.')) {
+				return { success: false, error: 'Invalid folder name' }
+			}
+			try {
+				await fs.mkdir(path.join(dir, ...segments), { recursive: true })
+				return { success: true }
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error)
+				return { success: false, error: message }
+			}
+		},
+	}
+}
+
+export function getFileExtension(filename: string): string {
+	const parts = filename.split('.')
+	const ext = parts.length > 1 ? (parts.pop()?.toLowerCase() ?? '') : ''
+	return /^[a-z0-9]+$/.test(ext) ? ext : ''
+}
+
+export const MIME_BY_EXT: Record<string, string> = {
+	'.jpg': 'image/jpeg',
+	'.jpeg': 'image/jpeg',
+	'.png': 'image/png',
+	'.gif': 'image/gif',
+	'.webp': 'image/webp',
+	'.avif': 'image/avif',
+	'.svg': 'image/svg+xml',
+	'.ico': 'image/x-icon',
+	'.mp4': 'video/mp4',
+	'.webm': 'video/webm',
+	'.pdf': 'application/pdf',
+}
+
+export function mimeFromExt(ext: string): string {
+	return MIME_BY_EXT[ext] ?? 'application/octet-stream'
+}