@nuasite/cms-core 0.43.0-beta.1

package/src/media/project-images.ts

@@ -0,0 +1,82 @@
+import type { MediaItem } from '@nuasite/cms-types'
+import type { CmsFileSystem } from '../fs/types'
+import { MIME_BY_EXT, mimeFromExt } from './local'
+
+const IMAGE_EXTENSIONS = new Set(Object.entries(MIME_BY_EXT).filter(([, mime]) => mime.startsWith('image/')).map(([ext]) => ext))
+
+export interface ListProjectImagesOptions {
+	/** Root-relative directory to exclude (e.g. the media uploads dir), to avoid duplicates. */
+	excludeDir?: string
+}
+
+/**
+ * Scan the project for image files in `public/` and `src/` directories,
+ * excluding the media uploads directory, over the FileSystem port.
+ *
+ * - `public/` files are served from `/<path-relative-to-public>`.
+ * - `src/` files are served from `/<path-relative-to-project-root>`.
+ */
+export async function listProjectImages(fs: CmsFileSystem, options?: ListProjectImagesOptions): Promise<MediaItem[]> {
+	const excludeDir = options?.excludeDir ? normalizeDir(options.excludeDir) : null
+
+	const scanDirs: Array<{ dir: string; relativeToRoot: boolean }> = [
+		{ dir: 'public', relativeToRoot: false },
+		{ dir: 'src', relativeToRoot: true },
+	]
+
+	const results = await Promise.all(
+		scanDirs.map(async ({ dir, relativeToRoot }) => {
+			const items: MediaItem[] = []
+			await scanDirectory(fs, dir, dir, relativeToRoot, excludeDir, items)
+			return items
+		}),
+	)
+
+	const items = results.flat()
+	items.sort((a, b) => a.filename.localeCompare(b.filename))
+	return items
+}
+
+function normalizeDir(dir: string): string {
+	return dir.replace(/^\/+/, '').replace(/\/+$/, '')
+}
+
+async function scanDirectory(
+	fs: CmsFileSystem,
+	currentDir: string,
+	baseDir: string,
+	relativeToRoot: boolean,
+	excludeDir: string | null,
+	items: MediaItem[],
+): Promise<void> {
+	if (excludeDir && normalizeDir(currentDir) === excludeDir) return
+
+	const entries = await fs.list(currentDir)
+	const subdirs: Promise<void>[] = []
+
+	for (const entry of entries) {
+		if (entry.name.startsWith('.') || entry.name === 'node_modules') continue
+		const fullPath = `${currentDir}/${entry.name}`
+
+		if (entry.isDirectory) {
+			subdirs.push(scanDirectory(fs, fullPath, baseDir, relativeToRoot, excludeDir, items))
+		} else {
+			const dotIdx = entry.name.lastIndexOf('.')
+			const ext = dotIdx >= 0 ? entry.name.slice(dotIdx).toLowerCase() : ''
+			if (!IMAGE_EXTENSIONS.has(ext)) continue
+
+			const url = relativeToRoot
+				? `/${fullPath}`
+				: `/${fullPath.slice(baseDir.length + 1)}`
+
+			items.push({
+				id: `project:${url}`,
+				url,
+				filename: entry.name,
+				contentType: mimeFromExt(ext),
+			})
+		}
+	}
+
+	await Promise.all(subdirs)
+}

package/src/media/s3.ts

@@ -0,0 +1,151 @@
+import type { MediaFolderItem, MediaListResult, MediaStorageAdapter, MediaUploadResult } from '@nuasite/cms-types'
+import { randomUUID } from 'node:crypto'
+import path from 'node:path'
+import { getFileExtension, mimeFromExt } from './local'
+
+export interface S3StorageOptions {
+	bucket: string
+	region: string
+	accessKeyId?: string
+	secretAccessKey?: string
+	endpoint?: string
+	cdnPrefix?: string
+	prefix?: string
+}
+
+// Dynamic import helper to avoid TS2307 for the optional `@aws-sdk/client-s3` peer dependency.
+const s3Module = '@aws-sdk/client-s3'
+async function loadS3(): Promise<any> {
+	return import(/* @vite-ignore */ s3Module)
+}
+
+export function createS3StorageAdapter(options: S3StorageOptions): MediaStorageAdapter {
+	const { bucket, region, accessKeyId, secretAccessKey, endpoint, cdnPrefix, prefix = 'uploads' } = options
+
+	let s3Client: any = null
+
+	async function getClient() {
+		if (s3Client) return s3Client
+		const { S3Client } = await loadS3()
+		s3Client = new S3Client({
+			region,
+			...(endpoint ? { endpoint } : {}),
+			...(accessKeyId && secretAccessKey
+				? { credentials: { accessKeyId, secretAccessKey } }
+				: {}),
+		})
+		return s3Client
+	}
+
+	function getUrl(key: string): string {
+		if (cdnPrefix) {
+			return `${cdnPrefix.replace(/\/$/, '')}/${key}`
+		}
+		if (endpoint) {
+			return `${endpoint.replace(/\/$/, '')}/${bucket}/${key}`
+		}
+		return `https://${bucket}.s3.${region}.amazonaws.com/${key}`
+	}
+
+	return {
+		async list(opts) {
+			const { ListObjectsV2Command } = await loadS3()
+			const client = await getClient()
+
+			const limit = opts?.limit ?? 50
+			const folder = opts?.folder ?? ''
+
+			const listPrefix = [prefix, folder].filter(Boolean).join('/')
+			const delimiterPrefix = listPrefix ? `${listPrefix}/` : ''
+
+			const command = new ListObjectsV2Command({
+				Bucket: bucket,
+				Prefix: delimiterPrefix,
+				Delimiter: '/',
+				MaxKeys: limit + 1,
+				...(opts?.cursor ? { ContinuationToken: opts.cursor } : {}),
+			})
+
+			const result = await client.send(command)
+
+			const folders: MediaFolderItem[] = (result.CommonPrefixes ?? []).map((cp: any) => {
+				const fullPrefix = String(cp.Prefix).replace(/\/$/, '')
+				const name = fullPrefix.split('/').pop() ?? fullPrefix
+				const relativePath = prefix ? fullPrefix.slice(prefix.length + 1) : fullPrefix
+				return { name, path: relativePath }
+			})
+
+			const contents = (result.Contents ?? []).filter((obj: any) => {
+				const key: string = obj.Key
+				return key !== delimiterPrefix
+			})
+
+			const hasMore = contents.length > limit
+			const items = contents.slice(0, limit).map((obj: any) => {
+				const key: string = obj.Key
+				const filename = key.split('/').pop() ?? key
+				return {
+					id: key,
+					url: getUrl(key),
+					filename,
+					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, uploadOpts) {
+			const { PutObjectCommand } = await loadS3()
+			const client = await getClient()
+
+			const ext = getFileExtension(filename)
+			const uuid = randomUUID()
+			const newFilename = `${uuid}${ext ? `.${ext}` : ''}`
+			const folder = uploadOpts?.folder ?? ''
+			const keyParts = [prefix, folder, newFilename].filter(Boolean)
+			const key = keyParts.join('/')
+
+			const command = new PutObjectCommand({
+				Bucket: bucket,
+				Key: key,
+				Body: file,
+				ContentType: contentType,
+			})
+
+			await client.send(command)
+
+			return {
+				success: true,
+				url: getUrl(key),
+				filename: newFilename,
+				id: key,
+			} satisfies MediaUploadResult
+		},
+
+		async delete(id) {
+			try {
+				const { DeleteObjectCommand } = await loadS3()
+				const client = await getClient()
+
+				const command = new DeleteObjectCommand({
+					Bucket: bucket,
+					Key: id,
+				})
+
+				await client.send(command)
+				return { success: true }
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error)
+				return { success: false, error: message }
+			}
+		},
+	}
+}

package/src/shared.ts

@@ -0,0 +1,65 @@
+/**
+ * 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, '')
+}
+
+/** Runtime guard: a non-null, non-array object usable as a string-keyed record. */
+export function isPlainRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+/**
+ * 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, '')
+}
+
+/**
+ * Escape HTML special characters to prevent injection.
+ * Covers &, <, >, ", and ' — the full set needed for both text content and attribute values.
+ */
+export function escapeHtml(text: string): string {
+	return text
+		.replace(/&/g, '&amp;')
+		.replace(/</g, '&lt;')
+		.replace(/>/g, '&gt;')
+		.replace(/"/g, '&quot;')
+		.replace(/'/g, '&#39;')
+}
+
+/**
+ * Compute a POSIX-style relative import path from one root-relative file to another.
+ * Both paths are forward-slash POSIX paths relative to the project root. Ensures
+ * the result starts with `./` or `../`.
+ */
+export function relativeImportPath(fromFile: string, toFile: string): string {
+	const fromSegments = fromFile.split('/').slice(0, -1)
+	const toSegments = toFile.split('/')
+
+	let common = 0
+	while (common < fromSegments.length && common < toSegments.length - 1 && fromSegments[common] === toSegments[common]) {
+		common++
+	}
+
+	const up = fromSegments.slice(common).map(() => '..')
+	const down = toSegments.slice(common)
+	const joined = [...up, ...down].join('/')
+	return joined.startsWith('.') ? joined : `./${joined}`
+}

package/src/tsconfig.json

@@ -0,0 +1,9 @@
+{
+	"extends": "../tsconfig.settings.json",
+	"compilerOptions": {
+		"outDir": "../dist/types"
+	},
+	"references": [
+		{ "path": "../../cms-types/src" }
+	]
+}