@nuasite/cms 0.42.1 → 0.43.0-beta.1

package/src/media/contember.ts

@@ -1,85 +0,0 @@
-import type { MediaListResult, MediaStorageAdapter, MediaUploadResult } from './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.
- */
-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 = await res.json()
-			return { folders: [], ...data } as MediaListResult
-		},
-
-		async upload(file, filename, contentType) {
-			// Build a FormData with the file buffer
-			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}` }
-			}
-
-			return (await res.json()) as MediaUploadResult
-		},
-
-		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/local.ts

@@ -1,152 +0,0 @@
-import { randomUUID } from 'node:crypto'
-import fs from 'node:fs/promises'
-import path from 'node:path'
-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' */
-	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 })
-
-			// 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(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) {
-			// 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 }
-			} 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() ?? '') : ''
-	// Only allow alphanumeric extensions to prevent injection
-	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'
-}

package/src/media/project-images.ts

@@ -1,81 +0,0 @@
-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,154 +0,0 @@
-import { randomUUID } from 'node:crypto'
-import path from 'node:path'
-import { getFileExtension, mimeFromExt } from './local'
-import type { MediaFolderItem, MediaListResult, MediaStorageAdapter, MediaUploadResult } from './types'
-
-export interface S3StorageOptions {
-	bucket: string
-	region: string
-	accessKeyId?: string
-	secretAccessKey?: string
-	endpoint?: string
-	cdnPrefix?: string
-	prefix?: string
-}
-
-// Dynamic import helper to avoid TS2307 for optional 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 ?? ''
-
-			// 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: delimiterPrefix,
-				Delimiter: '/',
-				MaxKeys: limit + 1,
-				...(opts?.cursor ? { ContinuationToken: opts.cursor } : {}),
-			})
-
-			const result = await client.send(command)
-
-			// 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
-				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 }
-			}
-		},
-	}
-}