emdash 0.35.0 → 0.37.0

package/src/api/errors.ts

@@ -28,6 +28,8 @@ export const ErrorCode = {
 	// Content
 	CONTENT_CREATE_ERROR: "CONTENT_CREATE_ERROR",
 	CONTENT_UPDATE_ERROR: "CONTENT_UPDATE_ERROR",
+	SAVE_REJECTED: "SAVE_REJECTED",
+	CONTENT_HOOK_ERROR: "CONTENT_HOOK_ERROR",
 	CONTENT_DELETE_ERROR: "CONTENT_DELETE_ERROR",
 	CONTENT_LIST_ERROR: "CONTENT_LIST_ERROR",
 	CONTENT_GET_ERROR: "CONTENT_GET_ERROR",
@@ -85,13 +87,28 @@ export const ErrorCode = {
 	MEDIA_GET_ERROR: "MEDIA_GET_ERROR",
 	MEDIA_CREATE_ERROR: "MEDIA_CREATE_ERROR",
 	MEDIA_UPDATE_ERROR: "MEDIA_UPDATE_ERROR",
+	MEDIA_REPLACE_ERROR: "MEDIA_REPLACE_ERROR",
+	MEDIA_REPLACE_METADATA_ERROR: "MEDIA_REPLACE_METADATA_ERROR",
 	MEDIA_DELETE_ERROR: "MEDIA_DELETE_ERROR",
+	MEDIA_FOLDER_LIST_ERROR: "MEDIA_FOLDER_LIST_ERROR",
+	MEDIA_FOLDER_GET_ERROR: "MEDIA_FOLDER_GET_ERROR",
+	MEDIA_FOLDER_CREATE_ERROR: "MEDIA_FOLDER_CREATE_ERROR",
+	MEDIA_FOLDER_UPDATE_ERROR: "MEDIA_FOLDER_UPDATE_ERROR",
+	MEDIA_FOLDER_DELETE_ERROR: "MEDIA_FOLDER_DELETE_ERROR",
 	MEDIA_USAGE_READ_ERROR: "MEDIA_USAGE_READ_ERROR",
 	MEDIA_USAGE_REPAIR_ERROR: "MEDIA_USAGE_REPAIR_ERROR",
+	MEDIA_USAGE_PROGRESS_READ_ERROR: "MEDIA_USAGE_PROGRESS_READ_ERROR",
+	MEDIA_USAGE_PROGRESS_ADVANCE_ERROR: "MEDIA_USAGE_PROGRESS_ADVANCE_ERROR",
+	MEDIA_USAGE_PROGRESS_NOT_ACTIVE: "MEDIA_USAGE_PROGRESS_NOT_ACTIVE",
 	MEDIA_USAGE_WORK_LIST_ERROR: "MEDIA_USAGE_WORK_LIST_ERROR",
 	MEDIA_USAGE_WORK_RETRY_ERROR: "MEDIA_USAGE_WORK_RETRY_ERROR",
 	MEDIA_USAGE_COLLECTION_DELETION_LIST_ERROR: "MEDIA_USAGE_COLLECTION_DELETION_LIST_ERROR",
 	MEDIA_USAGE_COLLECTION_DELETION_RETRY_ERROR: "MEDIA_USAGE_COLLECTION_DELETION_RETRY_ERROR",
+	MEDIA_USAGE_ACTIVATION_VERSION_MISMATCH: "MEDIA_USAGE_ACTIVATION_VERSION_MISMATCH",
+	MEDIA_USAGE_ACTIVATION_READ_ERROR: "MEDIA_USAGE_ACTIVATION_READ_ERROR",
+	MEDIA_USAGE_ACTIVATION_BUSY: "MEDIA_USAGE_ACTIVATION_BUSY",
+	MEDIA_USAGE_ACTIVATION_CONFLICT: "MEDIA_USAGE_ACTIVATION_CONFLICT",
+	MEDIA_USAGE_ACTIVATION_ADVANCE_ERROR: "MEDIA_USAGE_ACTIVATION_ADVANCE_ERROR",
 	WORK_LEASE_ACTIVE: "WORK_LEASE_ACTIVE",
 	WORK_CHANGED: "WORK_CHANGED",
 	NO_STORAGE: "NO_STORAGE",
@@ -461,6 +478,10 @@ export function mapErrorStatus(code: string | undefined): number {
 		case ErrorCode.ENV_INCOMPATIBLE:
 		case ErrorCode.WORK_LEASE_ACTIVE:
 		case ErrorCode.WORK_CHANGED:
+		case ErrorCode.MEDIA_USAGE_ACTIVATION_VERSION_MISMATCH:
+		case ErrorCode.MEDIA_USAGE_ACTIVATION_BUSY:
+		case ErrorCode.MEDIA_USAGE_ACTIVATION_CONFLICT:
+		case ErrorCode.MEDIA_USAGE_PROGRESS_NOT_ACTIVE:
 			return 409;
 
 		// 410 Gone
@@ -468,6 +489,7 @@ export function mapErrorStatus(code: string | undefined): number {
 			return 410;
 
 		// 422 Unprocessable Entity
+		case ErrorCode.SAVE_REJECTED:
 		case ErrorCode.CHECKSUM_MISMATCH:
 		case ErrorCode.INVALID_BUNDLE:
 		case ErrorCode.BUNDLE_EXTRACT_FAILED:

package/src/api/handlers/content.ts

@@ -10,7 +10,11 @@ import { isSqlite } from "../../database/dialect-helpers.js";
 import { BylineRepository } from "../../database/repositories/byline.js";
 import type { ContentBylineInput } from "../../database/repositories/byline.js";
 import { CommentRepository } from "../../database/repositories/comment.js";
-import { ContentRepository, isSystemOrderField } from "../../database/repositories/content.js";
+import {
+	ContentRepository,
+	isSystemOrderField,
+	type ContentRevisionPrecondition,
+} from "../../database/repositories/content.js";
 import { RedirectRepository } from "../../database/repositories/redirect.js";
 import { RevisionRepository } from "../../database/repositories/revision.js";
 import { SeoRepository } from "../../database/repositories/seo.js";
@@ -39,7 +43,7 @@ import { invalidateRedirectCache } from "../../redirects/cache.js";
 import { FTSManager } from "../../search/fts-manager.js";
 import { invalidateTermCache } from "../../taxonomies/index.js";
 import { isMissingColumnError, isMissingTableError } from "../../utils/db-errors.js";
-import { encodeRev, validateRev } from "../rev.js";
+import { decodeRev, encodeRev, validateRev } from "../rev.js";
 import type { ApiResult, ContentListResponse, ContentResponse } from "../types.js";
 import { validateMediaFields } from "./validate-media-fields.js";
 
@@ -59,6 +63,15 @@ function hasApiError(error: unknown): error is Error & { apiError: { code: strin
 	);
 }
 
+function decodeRevisionPrecondition(
+	rev: string | undefined,
+): ContentRevisionPrecondition | undefined {
+	if (rev === undefined) return undefined;
+	const decoded = decodeRev(rev);
+	if (!decoded) throw new ContentMutationConflictError("Revision precondition did not match");
+	return decoded;
+}
+
 /**
  * Extract a slug source (title or name) from content data.
  * Returns null if no suitable string field is found.
@@ -329,6 +342,8 @@ export interface TrashedContentItem {
 	type: string;
 	slug: string | null;
 	status: string;
+	locale: string | null;
+	translationGroup: string | null;
 	data: Record<string, unknown>;
 	authorId: string | null;
 	createdAt: string;
@@ -1406,13 +1421,14 @@ export async function handleContentPermanentDelete(
 export async function handleContentListTrashed(
 	db: Kysely<Database>,
 	collection: string,
-	options: { limit?: number; cursor?: string } = {},
+	options: { limit?: number; cursor?: string; locale?: string } = {},
 ): Promise<ApiResult<{ items: TrashedContentItem[]; nextCursor?: string }>> {
 	try {
 		const repo = new ContentRepository(db);
 		const result = await repo.findTrashed(collection, {
 			limit: options.limit,
 			cursor: options.cursor,
+			where: { locale: options.locale },
 		});
 
 		return {
@@ -1423,6 +1439,8 @@ export async function handleContentListTrashed(
 					type: item.type,
 					slug: item.slug,
 					status: item.status,
+					locale: item.locale,
+					translationGroup: item.translationGroup,
 					data: item.data,
 					authorId: item.authorId,
 					createdAt: item.createdAt,
@@ -1457,10 +1475,11 @@ export async function handleContentListTrashed(
 export async function handleContentCountTrashed(
 	db: Kysely<Database>,
 	collection: string,
+	options: { locale?: string } = {},
 ): Promise<ApiResult<{ count: number }>> {
 	try {
 		const repo = new ContentRepository(db);
-		const count = await repo.countTrashed(collection);
+		const count = await repo.countTrashed(collection, { locale: options.locale });
 
 		return {
 			success: true,
@@ -1504,7 +1523,7 @@ export async function handleContentSchedule(
 
 		return {
 			success: true,
-			data: { item },
+			data: { item, _rev: encodeRev(item) },
 		};
 	} catch (error) {
 		if (error instanceof EmDashValidationError) {
@@ -1547,7 +1566,7 @@ export async function handleContentUnschedule(
 
 		return {
 			success: true,
-			data: { item },
+			data: { item, _rev: encodeRev(item) },
 		};
 	} catch (error) {
 		if (error instanceof EmDashValidationError) {
@@ -1584,9 +1603,11 @@ export async function handleContentPublish(
 		publishedAt?: string;
 		requireScheduledDue?: boolean;
 		expectedScheduledAt?: string;
+		_rev?: string;
 	} = {},
 ): Promise<ApiResult<ContentResponse>> {
 	try {
+		const expectedRevision = decodeRevisionPrecondition(options._rev);
 		const item = await withTransaction(db, async (trx) => {
 			const repo = new ContentRepository(trx);
 			const resolvedId = (await resolveId(repo, collection, id)) ?? id;
@@ -1607,6 +1628,7 @@ export async function handleContentPublish(
 				options.expectedScheduledAt,
 				publishConfig.supportsRevisions,
 				publishConfig.routable,
+				expectedRevision,
 			);
 
 			// Leave a 301 behind when publishing changed the slug of an entry that
@@ -1629,7 +1651,7 @@ export async function handleContentPublish(
 
 		return {
 			success: true,
-			data: { item },
+			data: { item, _rev: encodeRev(item) },
 		};
 	} catch (error) {
 		if (error instanceof ContentMutationConflictError) {
@@ -1707,12 +1729,14 @@ export async function handleContentUnpublish(
 	db: Kysely<Database>,
 	collection: string,
 	id: string,
+	options: { _rev?: string } = {},
 ): Promise<ApiResult<ContentResponse>> {
 	try {
+		const expectedRevision = decodeRevisionPrecondition(options._rev);
 		const item = await withTransaction(db, async (trx) => {
 			const repo = new ContentRepository(trx);
 			const resolvedId = (await resolveId(repo, collection, id)) ?? id;
-			return repo.unpublish(collection, resolvedId);
+			return repo.unpublish(collection, resolvedId, expectedRevision);
 		});
 
 		const hasSeo = await collectionHasSeo(db, collection);
@@ -1720,9 +1744,15 @@ export async function handleContentUnpublish(
 
 		return {
 			success: true,
-			data: { item },
+			data: { item, _rev: encodeRev(item) },
 		};
 	} catch (error) {
+		if (error instanceof ContentMutationConflictError) {
+			return {
+				success: false,
+				error: { code: "CONFLICT", message: error.message },
+			};
+		}
 		if (error instanceof EmDashValidationError) {
 			return {
 				success: false,
@@ -1777,12 +1807,14 @@ export async function handleContentDiscardDraft(
 	db: Kysely<Database>,
 	collection: string,
 	id: string,
+	options: { _rev?: string } = {},
 ): Promise<ApiResult<ContentResponse>> {
 	try {
+		const expectedRevision = decodeRevisionPrecondition(options._rev);
 		const item = await withTransaction(db, async (trx) => {
 			const repo = new ContentRepository(trx);
 			const resolvedId = (await resolveId(repo, collection, id)) ?? id;
-			return repo.discardDraft(collection, resolvedId);
+			return repo.discardDraft(collection, resolvedId, expectedRevision);
 		});
 
 		const hasSeo = await collectionHasSeo(db, collection);
@@ -1790,9 +1822,15 @@ export async function handleContentDiscardDraft(
 
 		return {
 			success: true,
-			data: { item },
+			data: { item, _rev: encodeRev(item) },
 		};
 	} catch (error) {
+		if (error instanceof ContentMutationConflictError) {
+			return {
+				success: false,
+				error: { code: "CONFLICT", message: error.message },
+			};
+		}
 		if (error instanceof EmDashValidationError) {
 			return {
 				success: false,

package/src/api/handlers/index.ts

@@ -56,14 +56,24 @@ export {
 	handleMediaGet,
 	handleMediaCreate,
 	handleMediaUpdate,
+	handleMediaReplaceMetadata,
 	handleMediaDelete,
 	type MediaListResponse,
 	type MediaResponse,
 } from "./media.js";
+export {
+	handleMediaFolderList,
+	handleMediaFolderGet,
+	handleMediaFolderCreate,
+	handleMediaFolderUpdate,
+	handleMediaFolderDelete,
+} from "./media-folders.js";
 
 export {
 	aggregateMediaUsageCoverageStatus,
 	handleMediaUsageDetails,
+	handleMediaUsageProgress,
+	handleMediaUsageProgressAdvance,
 	handleMediaUsageSummaries,
 	handleMediaUsageRepair,
 	toMediaUsageRepairResponse,
@@ -72,11 +82,18 @@ export {
 	type MediaUsageDetailsResponse,
 	type MediaUsageEntryDetail,
 	type MediaUsageOccurrenceDetail,
+	type MediaUsageProgress,
+	type MediaUsageProgressAdvanceResponse,
 	type MediaUsageRepairResponse,
 	type MediaUsageSourceDetail,
 	type MediaUsageSummary,
 } from "./media-usage.js";
 
+export {
+	handleMediaUsageActivationAdvance,
+	handleMediaUsageActivationStatus,
+} from "./media-usage-activation.js";
+
 export {
 	handleMediaUsageWorkList,
 	handleMediaUsageWorkRetry,
@@ -99,6 +116,7 @@ export {
 	handleSchemaFieldCreate,
 	handleSchemaFieldUpdate,
 	handleSchemaFieldDelete,
+	handleSchemaCollectionReorder,
 	handleSchemaFieldReorder,
 	handleOrphanedTableList,
 	handleOrphanedTableRegister,

package/src/api/handlers/manifest.ts

@@ -2,13 +2,57 @@
  * Manifest generation handlers
  */
 
+import type { Kysely } from "kysely";
+
+import type { Database } from "../../database/types.js";
+import { SchemaRegistry } from "../../schema/registry.js";
+import { MAX_COLLECTION_LIST_COLUMNS } from "../../schema/types.js";
+import type { Field, FieldType } from "../../schema/types.js";
 import { hashString } from "../../utils/hash.js";
-import type { ManifestResponse, FieldDescriptor } from "../types.js";
+import type {
+	FieldDescriptor,
+	ManifestCollectionMap,
+	ManifestFieldDescriptor,
+	ManifestResponse,
+} from "../types.js";
 
 /** Pattern to add spaces before capital letters */
 const CAMEL_CASE_PATTERN = /([A-Z])/g;
 const FIRST_CHAR_PATTERN = /^./;
 
+/**
+ * Map schema field types to editor field kinds.
+ */
+/** Field types that can be surfaced as list columns in the admin. */
+const LIST_COLUMN_FIELD_TYPES: ReadonlySet<FieldType> = new Set([
+	"string",
+	"number",
+	"integer",
+	"boolean",
+	"datetime",
+	"select",
+	"multiSelect",
+]);
+
+const FIELD_TYPE_TO_KIND: Record<FieldType, string> = {
+	string: "string",
+	slug: "string",
+	url: "url",
+	text: "richText",
+	number: "number",
+	integer: "number",
+	boolean: "boolean",
+	datetime: "datetime",
+	select: "select",
+	multiSelect: "multiSelect",
+	portableText: "portableText",
+	image: "image",
+	file: "file",
+	reference: "reference",
+	json: "json",
+	repeater: "repeater",
+};
+
 // Collection definition shape for manifest generation
 interface CollectionDefinition {
 	schema: {
@@ -24,6 +68,10 @@ interface CollectionDefinition {
 }
 type CollectionMap = Record<string, CollectionDefinition>;
 
+interface GenerateManifestOptions {
+	db?: Kysely<Database> | null;
+}
+
 /**
  * Generate admin manifest from collections
  */
@@ -36,8 +84,33 @@ export async function generateManifest(
 			widgets?: string[];
 		}
 	> = {},
+	options: GenerateManifestOptions = {},
 ): Promise<ManifestResponse> {
-	const manifestCollections: ManifestResponse["collections"] = {};
+	const manifestCollections = await buildManifestCollections(collections, options.db);
+
+	// Generate hash from collections (for cache invalidation)
+	const hash = await hashString(JSON.stringify(manifestCollections));
+
+	return {
+		version: "0.1.0",
+		hash,
+		collections: manifestCollections,
+		plugins,
+	};
+}
+
+/**
+ * Build collection descriptors from build-time config plus live database rows.
+ *
+ * Config collections are added first and win on slug conflicts. Runtime/manual
+ * collections have no Zod schema to inspect, so their field descriptors are
+ * synthesized from `_emdash_fields`.
+ */
+export async function buildManifestCollections(
+	collections: CollectionMap,
+	db?: Kysely<Database> | null,
+): Promise<ManifestCollectionMap> {
+	const manifestCollections: ManifestCollectionMap = {};
 
 	for (const [name, definition] of Object.entries(collections)) {
 		// Extract field descriptors from Zod schema
@@ -47,20 +120,65 @@ export async function generateManifest(
 			label: definition.admin.label,
 			labelSingular: definition.admin.labelSingular || definition.admin.label,
 			supports: definition.admin.supports || [],
+			hasSeo: (definition.admin.supports || []).includes("seo"),
 			routable: definition.admin.routable ?? true,
 			fields,
 		};
 	}
 
-	// Generate hash from collections (for cache invalidation)
-	const hash = await hashString(JSON.stringify(manifestCollections));
+	if (!db) return manifestCollections;
 
-	return {
-		version: "0.1.0",
-		hash,
-		collections: manifestCollections,
-		plugins,
-	};
+	try {
+		const registry = new SchemaRegistry(db);
+		const dbCollections = await registry.listCollectionsWithFields();
+		for (const collection of dbCollections) {
+			if (manifestCollections[collection.slug]) continue;
+
+			const fields: Record<string, ManifestFieldDescriptor> = {};
+			for (const field of collection.fields) {
+				fields[field.slug] = dbFieldDescriptor(field);
+			}
+
+			const configuredListColumns = collection.admin?.listColumns ?? [];
+			const fieldTypes = new Map(collection.fields.map((field) => [field.slug, field.type]));
+			const listColumns: string[] = [];
+			for (const slug of configuredListColumns) {
+				if (listColumns.includes(slug)) continue;
+				const fieldType = fieldTypes.get(slug);
+				if (!fieldType || !LIST_COLUMN_FIELD_TYPES.has(fieldType)) {
+					console.warn(
+						`EmDash: Ignoring unsupported or unknown list column "${slug}" in collection "${collection.slug}".`,
+					);
+					continue;
+				}
+				if (listColumns.length >= MAX_COLLECTION_LIST_COLUMNS) {
+					console.warn(
+						`EmDash: Collection "${collection.slug}" declares more than ${MAX_COLLECTION_LIST_COLUMNS} list columns; extra columns are ignored.`,
+					);
+					break;
+				}
+				listColumns.push(slug);
+			}
+
+			manifestCollections[collection.slug] = {
+				label: collection.label,
+				labelSingular: collection.labelSingular || collection.label,
+				supports: collection.supports || [],
+				hasSeo: collection.hasSeo,
+				urlPattern: collection.urlPattern,
+				routable: collection.routable !== false,
+				titleField: collection.titleField,
+				dateField: collection.dateField,
+				...(collection.hidden ? { hidden: true } : {}),
+				listColumns: listColumns.length > 0 ? listColumns : undefined,
+				fields,
+			};
+		}
+	} catch (error) {
+		console.debug("EmDash: Could not load database collections for manifest:", error);
+	}
+
+	return manifestCollections;
 }
 
 /**
@@ -70,8 +188,8 @@ export async function generateManifest(
 function extractFieldDescriptors(schema: {
 	_def?: { shape?: () => Record<string, unknown> };
 	shape?: Record<string, unknown>;
-}): Record<string, FieldDescriptor> {
-	const fields: Record<string, FieldDescriptor> = {};
+}): Record<string, ManifestFieldDescriptor> {
+	const fields: Record<string, ManifestFieldDescriptor> = {};
 
 	// Handle Zod object schema
 	const shape = typeof schema._def?.shape === "function" ? schema._def.shape() : schema.shape || {};
@@ -149,6 +267,37 @@ function extractFieldType(name: string, schema: unknown): FieldDescriptor {
 	}
 }
 
+function dbFieldDescriptor(field: Field): ManifestFieldDescriptor {
+	const entry: ManifestFieldDescriptor = {
+		kind: FIELD_TYPE_TO_KIND[field.type] ?? "string",
+		label: field.label,
+		required: field.required,
+		id: field.id,
+	};
+
+	if (field.widget) entry.widget = field.widget;
+	if (field.options) entry.options = field.options;
+
+	// Legacy: select/multiSelect enum options live on `field.validation.options`.
+	// They win over widget options to preserve existing select behavior.
+	if (field.validation?.options) {
+		entry.options = field.validation.options.map((value) => ({
+			value,
+			label: value.charAt(0).toUpperCase() + value.slice(1),
+		}));
+	}
+
+	// Include validation only for field widgets that need it client-side.
+	if (
+		(field.type === "repeater" || field.type === "file" || field.type === "image") &&
+		field.validation
+	) {
+		entry.validation = { ...field.validation };
+	}
+
+	return entry;
+}
+
 /**
  * Format field name as label
  */

package/src/api/handlers/media-allowlist.ts

@@ -21,6 +21,7 @@ export const GLOBAL_UPLOAD_ALLOWLIST: readonly string[] = [
 	"image/jpeg",
 	"image/gif",
 	"image/webp",
+	"image/avif",
 	"video/",
 	"audio/",
 	"application/pdf",

package/src/api/handlers/media-folders.ts

@@ -0,0 +1,130 @@
+import type { Kysely } from "kysely";
+
+import {
+	MediaFolderRepository,
+	type MediaFolder,
+} from "../../database/repositories/media-folders.js";
+import { EmDashValidationError, InvalidCursorError } from "../../database/repositories/types.js";
+import type { Database } from "../../database/types.js";
+import type { ApiResult } from "../types.js";
+
+const UNIQUE_VIOLATION_RE =
+	/unique constraint failed|duplicate key value violates unique constraint/i;
+
+export async function handleMediaFolderList(
+	db: Kysely<Database>,
+	options: { limit?: number; cursor?: string; q?: string } = {},
+): Promise<ApiResult<{ items: MediaFolder[]; nextCursor?: string }>> {
+	try {
+		const result = await new MediaFolderRepository(db).findMany(options);
+		return { success: true, data: result };
+	} catch (error) {
+		if (error instanceof InvalidCursorError) {
+			return { success: false, error: { code: "INVALID_CURSOR", message: error.message } };
+		}
+		return {
+			success: false,
+			error: { code: "MEDIA_FOLDER_LIST_ERROR", message: "Failed to list media folders" },
+		};
+	}
+}
+
+export async function handleMediaFolderGet(
+	db: Kysely<Database>,
+	id: string,
+): Promise<ApiResult<{ item: MediaFolder }>> {
+	try {
+		const item = await new MediaFolderRepository(db).findById(id);
+		if (!item) {
+			return { success: false, error: { code: "NOT_FOUND", message: "Media folder not found" } };
+		}
+		return { success: true, data: { item } };
+	} catch {
+		return {
+			success: false,
+			error: { code: "MEDIA_FOLDER_GET_ERROR", message: "Failed to get media folder" },
+		};
+	}
+}
+
+export async function handleMediaFolderCreate(
+	db: Kysely<Database>,
+	input: { name: string },
+): Promise<ApiResult<{ item: MediaFolder }>> {
+	try {
+		const item = await new MediaFolderRepository(db).create(input.name);
+		return { success: true, data: { item } };
+	} catch (error) {
+		return mediaFolderWriteError(
+			error,
+			"MEDIA_FOLDER_CREATE_ERROR",
+			"Failed to create media folder",
+		);
+	}
+}
+
+export async function handleMediaFolderUpdate(
+	db: Kysely<Database>,
+	id: string,
+	input: { name: string },
+): Promise<ApiResult<{ item: MediaFolder }>> {
+	try {
+		const item = await new MediaFolderRepository(db).update(id, input.name);
+		if (!item) {
+			return { success: false, error: { code: "NOT_FOUND", message: "Media folder not found" } };
+		}
+		return { success: true, data: { item } };
+	} catch (error) {
+		return mediaFolderWriteError(
+			error,
+			"MEDIA_FOLDER_UPDATE_ERROR",
+			"Failed to update media folder",
+		);
+	}
+}
+
+export async function handleMediaFolderDelete(
+	db: Kysely<Database>,
+	id: string,
+): Promise<ApiResult<{ deleted: true }>> {
+	try {
+		const deleted = await new MediaFolderRepository(db).delete(id);
+		if (!deleted) {
+			return { success: false, error: { code: "NOT_FOUND", message: "Media folder not found" } };
+		}
+		return { success: true, data: { deleted: true } };
+	} catch {
+		return {
+			success: false,
+			error: { code: "MEDIA_FOLDER_DELETE_ERROR", message: "Failed to delete media folder" },
+		};
+	}
+}
+
+function mediaFolderWriteError(
+	error: unknown,
+	code: "MEDIA_FOLDER_CREATE_ERROR" | "MEDIA_FOLDER_UPDATE_ERROR",
+	message: string,
+): ApiResult<never> {
+	if (error instanceof EmDashValidationError) {
+		return { success: false, error: { code: "VALIDATION_ERROR", message: error.message } };
+	}
+	if (isUniqueViolation(error)) {
+		return {
+			success: false,
+			error: { code: "CONFLICT", message: "A media folder with this name already exists" },
+		};
+	}
+	return { success: false, error: { code, message } };
+}
+
+function isUniqueViolation(error: unknown): boolean {
+	if (error && typeof error === "object") {
+		if ("code" in error && error.code === "23505") return true;
+	}
+	const message = error instanceof Error ? error.message : "";
+	if (UNIQUE_VIOLATION_RE.test(message)) return true;
+	return Boolean(
+		error && typeof error === "object" && "cause" in error && isUniqueViolation(error.cause),
+	);
+}