@nuasite/cms 0.18.1 → 0.19.0

package/src/media/local.ts

@@ -1,7 +1,7 @@
 import { randomUUID } from 'node:crypto'
 import fs from 'node:fs/promises'
 import path from 'node:path'
-import type { MediaListResult, MediaStorageAdapter, MediaUploadResult } from './types'
+import type { MediaFolderItem, MediaListResult, MediaStorageAdapter, MediaUploadResult } from './types'
 
 export interface LocalStorageOptions {
 	/** Directory to store media files (relative to project root or absolute). Default: 'public/uploads' */
@@ -20,16 +20,29 @@ export function createLocalStorageAdapter(options: LocalStorageOptions = {}): Me
 		async list(opts) {
 			const limit = opts?.limit ?? 50
 			const offset = opts?.cursor ? parseInt(opts.cursor, 10) : 0
+			const folder = opts?.folder ?? ''
 
-			await fs.mkdir(dir, { recursive: true })
+			const targetDir = folder ? path.join(dir, folder) : dir
+			await fs.mkdir(targetDir, { recursive: true })
 
-			const entries = await fs.readdir(dir, { withFileTypes: true })
+			const entries = await fs.readdir(targetDir, { withFileTypes: true })
+
+			// Collect subfolders
+			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))
+
+			// Collect files
 			const files = entries.filter((e) => e.isFile() && !e.name.startsWith('.'))
 
 			// Get stats for sorting by mtime desc
 			const withStats = await Promise.all(
 				files.map(async (f) => {
-					const filePath = path.join(dir, f.name)
+					const filePath = path.join(targetDir, f.name)
 					const stat = await fs.stat(filePath)
 					return { name: f.name, stat }
 				}),
@@ -39,45 +52,55 @@ export function createLocalStorageAdapter(options: LocalStorageOptions = {}): Me
 			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: f.name,
-					url: `${urlPrefix}/${f.name}`,
+					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) {
-			await fs.mkdir(dir, { recursive: true })
+		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(dir, newFilename)
+			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}/${newFilename}`,
+				url: `${urlPrefix}${urlFolder}/${newFilename}`,
 				filename: newFilename,
-				id: newFilename,
+				id,
 			} satisfies MediaUploadResult
 		},
 
 		async delete(id) {
-			const filePath = path.join(dir, path.basename(id))
+			// id may contain folder path — resolve safely within dir
+			const safePath = id.split('/').map((s) => path.basename(s)).join('/')
+			const filePath = path.join(dir, safePath)
 			try {
 				await fs.unlink(filePath)
 				return { success: true }
@@ -86,29 +109,44 @@ export function createLocalStorageAdapter(options: LocalStorageOptions = {}): Me
 				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 }
+			}
+		},
 	}
 }
 
-function getFileExtension(filename: string): string {
+export function getFileExtension(filename: string): string {
 	const parts = filename.split('.')
 	const ext = parts.length > 1 ? (parts.pop()?.toLowerCase() ?? '') : ''
 	// Only allow alphanumeric extensions to prevent injection
 	return /^[a-z0-9]+$/.test(ext) ? ext : ''
 }
 
-function mimeFromExt(ext: string): string {
-	const map: 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',
-	}
-	return map[ext] ?? 'application/octet-stream'
+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'
 }

package/src/media/project-images.ts

@@ -0,0 +1,81 @@
+import type { Dirent } from 'node:fs'
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { getProjectRoot } from '../config'
+import { MIME_BY_EXT, mimeFromExt } from './local'
+import type { MediaItem } from './types'
+
+const IMAGE_EXTENSIONS = new Set(Object.entries(MIME_BY_EXT).filter(([, mime]) => mime.startsWith('image/')).map(([ext]) => ext))
+
+/**
+ * Scan the project for image files in `public/` and `src/` directories,
+ * excluding the media uploads directory to avoid duplicates.
+ */
+export async function listProjectImages(options?: {
+	excludeDir?: string
+}): Promise<MediaItem[]> {
+	const root = getProjectRoot()
+	const excludeDir = options?.excludeDir ? path.resolve(options.excludeDir) : null
+
+	const scanDirs = [
+		{ dir: path.join(root, 'public'), urlPrefix: '' },
+		{ dir: path.join(root, 'src'), urlPrefix: null },
+	]
+
+	const results = await Promise.all(
+		scanDirs.map(({ dir, urlPrefix }) => {
+			const items: MediaItem[] = []
+			return scanDirectory(dir, dir, urlPrefix, excludeDir, items).then(() => items)
+		}),
+	)
+
+	const items = results.flat()
+	items.sort((a, b) => a.filename.localeCompare(b.filename))
+	return items
+}
+
+async function scanDirectory(
+	currentDir: string,
+	baseDir: string,
+	urlPrefix: string | null,
+	excludeDir: string | null,
+	items: MediaItem[],
+): Promise<void> {
+	if (excludeDir && path.resolve(currentDir) === excludeDir) return
+
+	let entries: Dirent[]
+	try {
+		entries = await fs.readdir(currentDir, { withFileTypes: true }) as Dirent[]
+	} catch {
+		return
+	}
+
+	const subdirs: Promise<void>[] = []
+
+	for (const entry of entries) {
+		const name = String(entry.name)
+		if (name.startsWith('.') || name === 'node_modules') continue
+		const fullPath = path.join(currentDir, name)
+
+		if (entry.isDirectory()) {
+			subdirs.push(scanDirectory(fullPath, baseDir, urlPrefix, excludeDir, items))
+		} else if (entry.isFile()) {
+			const ext = path.extname(name).toLowerCase()
+			if (!IMAGE_EXTENSIONS.has(ext)) continue
+
+			const relativePath = path.relative(baseDir, fullPath).split(path.sep).join('/')
+			const url = urlPrefix !== null
+				? `/${relativePath}`
+				: `/${path.relative(getProjectRoot(), fullPath).split(path.sep).join('/')}`
+
+			items.push({
+				id: `project:${url}`,
+				url,
+				filename: name,
+				contentType: mimeFromExt(ext),
+			})
+		}
+	}
+
+	await Promise.all(subdirs)
+}

package/src/media/s3.ts

@@ -1,6 +1,7 @@
 import { randomUUID } from 'node:crypto'
 import path from 'node:path'
-import type { MediaListResult, MediaStorageAdapter, MediaUploadResult } from './types'
+import { getFileExtension, mimeFromExt } from './local'
+import type { MediaFolderItem, MediaListResult, MediaStorageAdapter, MediaUploadResult } from './types'
 
 export interface S3StorageOptions {
 	bucket: string
@@ -52,15 +53,36 @@ export function createS3StorageAdapter(options: S3StorageOptions): MediaStorageA
 			const client = await getClient()
 
 			const limit = opts?.limit ?? 50
+			const folder = opts?.folder ?? ''
+
+			// Build the S3 prefix: base prefix + subfolder
+			const listPrefix = [prefix, folder].filter(Boolean).join('/')
+			const delimiterPrefix = listPrefix ? `${listPrefix}/` : ''
+
 			const command = new ListObjectsV2Command({
 				Bucket: bucket,
-				Prefix: prefix,
+				Prefix: delimiterPrefix,
+				Delimiter: '/',
 				MaxKeys: limit + 1,
 				...(opts?.cursor ? { ContinuationToken: opts.cursor } : {}),
 			})
 
 			const result = await client.send(command)
-			const contents = result.Contents ?? []
+
+			// Extract subfolders from CommonPrefixes
+			const folders: MediaFolderItem[] = (result.CommonPrefixes ?? []).map((cp: any) => {
+				const fullPrefix = (cp.Prefix as string).replace(/\/$/, '')
+				const name = fullPrefix.split('/').pop() ?? fullPrefix
+				const relativePath = prefix ? fullPrefix.slice(prefix.length + 1) : fullPrefix
+				return { name, path: relativePath }
+			})
+
+			// Extract files (exclude folder marker keys)
+			const contents = (result.Contents ?? []).filter((obj: any) => {
+				const key = obj.Key as string
+				return key !== delimiterPrefix
+			})
+
 			const hasMore = contents.length > limit
 			const items = contents.slice(0, limit).map((obj: any) => {
 				const key = obj.Key as string
@@ -69,26 +91,30 @@ export function createS3StorageAdapter(options: S3StorageOptions): MediaStorageA
 					id: key,
 					url: getUrl(key),
 					filename,
-					contentType: 'application/octet-stream',
+					contentType: mimeFromExt(path.extname(key).toLowerCase()),
 					uploadedAt: obj.LastModified?.toISOString(),
+					folder: folder || undefined,
 				}
 			})
 
 			return {
 				items,
+				folders,
 				hasMore,
 				cursor: hasMore ? result.NextContinuationToken : undefined,
 			} satisfies MediaListResult
 		},
 
-		async upload(file, filename, contentType) {
+		async upload(file, filename, contentType, uploadOpts) {
 			const { PutObjectCommand } = await loadS3()
 			const client = await getClient()
 
 			const ext = getFileExtension(filename)
 			const uuid = randomUUID()
 			const newFilename = `${uuid}${ext ? `.${ext}` : ''}`
-			const key = prefix ? `${prefix}/${newFilename}` : newFilename
+			const folder = uploadOpts?.folder ?? ''
+			const keyParts = [prefix, folder, newFilename].filter(Boolean)
+			const key = keyParts.join('/')
 
 			const command = new PutObjectCommand({
 				Bucket: bucket,
@@ -126,8 +152,3 @@ export function createS3StorageAdapter(options: S3StorageOptions): MediaStorageA
 		},
 	}
 }
-
-function getFileExtension(filename: string): string {
-	const parts = filename.split('.')
-	return parts.length > 1 ? (parts.pop()?.toLowerCase() ?? '') : ''
-}

package/src/media/types.ts

@@ -7,10 +7,30 @@ export interface MediaItem {
 	width?: number
 	height?: number
 	uploadedAt?: string
+	/** Folder path relative to media root (e.g. 'photos') */
+	folder?: string
+}
+
+export interface MediaFolderItem {
+	/** Folder name (last segment) */
+	name: string
+	/** Full relative path from media root (e.g. 'photos/vacation') */
+	path: string
+}
+
+export type MediaTypeFilter = 'all' | 'photo' | 'graphic' | 'video' | 'document'
+
+export interface MediaListOptions {
+	limit?: number
+	cursor?: string
+	/** List contents of this subfolder (relative to media root) */
+	folder?: string
 }
 
 export interface MediaListResult {
 	items: MediaItem[]
+	/** Subfolders in the current directory */
+	folders: MediaFolderItem[]
 	hasMore: boolean
 	cursor?: string
 }
@@ -25,9 +45,11 @@ export interface MediaUploadResult {
 }
 
 export interface MediaStorageAdapter {
-	list(options?: { limit?: number; cursor?: string }): Promise<MediaListResult>
-	upload(file: Buffer, filename: string, contentType: string): Promise<MediaUploadResult>
+	list(options?: MediaListOptions): Promise<MediaListResult>
+	upload(file: Buffer, filename: string, contentType: string, options?: { folder?: string }): Promise<MediaUploadResult>
 	delete(id: string): Promise<{ success: boolean; error?: string }>
+	/** Create an empty folder. Folders are also created implicitly on upload. */
+	createFolder?(folder: string): Promise<{ success: boolean; error?: string }>
 	/** Local filesystem info for direct file serving in dev (bypasses Vite's public dir cache) */
 	staticFiles?: { urlPrefix: string; dir: string }
 }

package/src/shared.ts

@@ -0,0 +1,27 @@
+/**
+ * Slugify text for URL paths.
+ * Lowercases, strips non-word characters, collapses whitespace/underscores to hyphens.
+ */
+export function slugify(text: string): string {
+	return text
+		.toLowerCase()
+		.trim()
+		.replace(/[^\w\s\-/]/g, '')
+		.replace(/[\s_]+/g, '-')
+		.replace(/^[-/]+|[-/]+$/g, '')
+}
+
+/**
+ * Slugify with diacritics normalization for href paths.
+ * "Lidé" → "lide", "Aktuálně z nezisku" → "aktualne-z-nezisku"
+ */
+export function slugifyHref(text: string): string {
+	return '/' + text
+		.normalize('NFD')
+		.replace(/[\u0300-\u036f]/g, '')
+		.toLowerCase()
+		.trim()
+		.replace(/[^\w\s-]/g, '')
+		.replace(/[\s_]+/g, '-')
+		.replace(/^-+|-+$/g, '')
+}