emdash 0.32.0 → 0.34.0

package/src/api/handlers/media-usage-work.ts

@@ -0,0 +1,188 @@
+import type { Kysely } from "kysely";
+
+import { MediaUsageWorkRepository } from "../../database/repositories/media-usage-work.js";
+import { InvalidCursorError } from "../../database/repositories/types.js";
+import type { Database } from "../../database/types.js";
+import { MediaUsageCollectionDeletionRepository } from "../../media/usage/collection-deletion.js";
+import { ErrorCode } from "../errors.js";
+import type {
+	MediaUsageWorkListQuery,
+	MediaUsageWorkListResponse,
+	MediaUsageWorkRetryRequest,
+	MediaUsageWorkRetryResponse,
+	MediaUsageCollectionDeletionListQuery,
+	MediaUsageCollectionDeletionListResponse,
+	MediaUsageCollectionDeletionRetryRequest,
+	MediaUsageCollectionDeletionRetryResponse,
+} from "../schemas/media-usage.js";
+import type { ApiResult } from "../types.js";
+
+export type {
+	MediaUsageWorkItem,
+	MediaUsageWorkListQuery,
+	MediaUsageWorkListResponse,
+	MediaUsageWorkRetryRequest,
+	MediaUsageWorkRetryResponse,
+} from "../schemas/media-usage.js";
+
+export async function handleMediaUsageWorkList(
+	db: Kysely<Database>,
+	query: MediaUsageWorkListQuery,
+): Promise<ApiResult<MediaUsageWorkListResponse>> {
+	try {
+		const page = await new MediaUsageWorkRepository(db).findOperatorPage({
+			collectionSlug: query.collection,
+			state: query.state,
+			cursor: query.cursor,
+			limit: query.limit,
+		});
+		if (!page) {
+			return {
+				success: false,
+				error: {
+					code: ErrorCode.COLLECTION_NOT_FOUND,
+					message: "Collection not found",
+				},
+			};
+		}
+		return { success: true, data: page };
+	} catch (error) {
+		if (error instanceof InvalidCursorError) {
+			return {
+				success: false,
+				error: {
+					code: ErrorCode.INVALID_CURSOR,
+					message: "Invalid media usage work cursor",
+				},
+			};
+		}
+		console.error("[media-usage-work] list failed:", error);
+		return {
+			success: false,
+			error: {
+				code: ErrorCode.MEDIA_USAGE_WORK_LIST_ERROR,
+				message: "Failed to list media usage work",
+			},
+		};
+	}
+}
+
+export async function handleMediaUsageCollectionDeletionList(
+	db: Kysely<Database>,
+	query: MediaUsageCollectionDeletionListQuery,
+): Promise<ApiResult<MediaUsageCollectionDeletionListResponse>> {
+	try {
+		return {
+			success: true,
+			data: await new MediaUsageCollectionDeletionRepository(db).findOperatorPage(query),
+		};
+	} catch (error) {
+		if (error instanceof InvalidCursorError) {
+			return {
+				success: false,
+				error: { code: ErrorCode.INVALID_CURSOR, message: "Invalid cursor" },
+			};
+		}
+		console.error("[media-usage:collection-deletion] list failed:", error);
+		return {
+			success: false,
+			error: {
+				code: ErrorCode.MEDIA_USAGE_COLLECTION_DELETION_LIST_ERROR,
+				message: "Failed to list collection deletions",
+			},
+		};
+	}
+}
+
+export async function handleMediaUsageCollectionDeletionRetry(
+	db: Kysely<Database>,
+	input: MediaUsageCollectionDeletionRetryRequest,
+): Promise<ApiResult<MediaUsageCollectionDeletionRetryResponse>> {
+	try {
+		const result = await new MediaUsageCollectionDeletionRepository(db).retryOperatorDeletion(
+			input,
+		);
+		if (result.outcome === "pending") {
+			return { success: true, data: { changed: result.changed, item: result.item } };
+		}
+		if (result.outcome === "lease_active") {
+			return {
+				success: false,
+				error: {
+					code: ErrorCode.WORK_LEASE_ACTIVE,
+					message: "Collection deletion is currently leased",
+					details: { leaseExpiresAt: result.leaseExpiresAt },
+				},
+			};
+		}
+		return {
+			success: false,
+			error: {
+				code: result.outcome === "not_found" ? ErrorCode.NOT_FOUND : ErrorCode.WORK_CHANGED,
+				message:
+					result.outcome === "not_found"
+						? "Collection deletion not found"
+						: "Collection deletion changed",
+			},
+		};
+	} catch (error) {
+		console.error("[media-usage:collection-deletion] retry failed:", error);
+		return {
+			success: false,
+			error: {
+				code: ErrorCode.MEDIA_USAGE_COLLECTION_DELETION_RETRY_ERROR,
+				message: "Failed to retry collection deletion",
+			},
+		};
+	}
+}
+
+export async function handleMediaUsageWorkRetry(
+	db: Kysely<Database>,
+	input: MediaUsageWorkRetryRequest,
+): Promise<ApiResult<MediaUsageWorkRetryResponse>> {
+	try {
+		const result = await new MediaUsageWorkRepository(db).retryOperatorWork(input);
+		switch (result.outcome) {
+			case "pending":
+				return {
+					success: true,
+					data: { changed: result.changed, item: result.work },
+				};
+			case "lease_active":
+				return {
+					success: false,
+					error: {
+						code: ErrorCode.WORK_LEASE_ACTIVE,
+						message: "Media usage work is currently leased",
+						details: { leaseExpiresAt: result.leaseExpiresAt },
+					},
+				};
+			case "collection_not_found":
+				return {
+					success: false,
+					error: {
+						code: ErrorCode.COLLECTION_NOT_FOUND,
+						message: "Collection not found",
+					},
+				};
+			case "conflict":
+				return {
+					success: false,
+					error: {
+						code: ErrorCode.WORK_CHANGED,
+						message: "Media usage work changed; retry the request",
+					},
+				};
+		}
+	} catch (error) {
+		console.error("[media-usage-work] retry failed:", error);
+		return {
+			success: false,
+			error: {
+				code: ErrorCode.MEDIA_USAGE_WORK_RETRY_ERROR,
+				message: "Failed to retry media usage work",
+			},
+		};
+	}
+}

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

@@ -74,9 +74,10 @@ export async function handleMediaUsageSummaries(
 	try {
 		const repository = new MediaUsageRepository(db);
 		const coverage = await loadMediaUsageCoverage(repository);
-		const counts = options.includeCount
-			? await repository.findActiveEntryCountsByMediaIds(mediaIds)
-			: null;
+		const counts =
+			options.includeCount && coverage.status === "complete"
+				? await repository.findActiveEntryCountsByMediaIds(mediaIds)
+				: null;
 		const summaries: Record<string, MediaUsageSummary> = {};
 
 		for (const mediaId of new Set(mediaIds)) {
@@ -212,6 +213,7 @@ function normalizeMediaUsageCoverageStatus(
 ): MediaUsageCoverageStatus {
 	if (scope.status === null) return "never";
 	if (scope.status === "complete") {
+		if (scope.reconciliationRequired) return "stale";
 		return scope.schemaVersion === CONTENT_SOURCE_SCHEMA_VERSION ? "complete" : "stale";
 	}
 	if (

package/src/api/handlers/registry.ts

@@ -49,6 +49,10 @@ import { extractBundle } from "../../plugins/marketplace.js";
 import type { PluginBundle } from "../../plugins/marketplace.js";
 import type { SandboxRunner } from "../../plugins/sandbox/types.js";
 import { PluginStateRepository } from "../../plugins/state.js";
+import {
+	removeAllPluginIndexes,
+	syncDeclaredStorageIndexes,
+} from "../../plugins/storage-indexes.js";
 import { declaredAccessToCapabilities } from "../../plugins/types.js";
 import type { DeclaredAccess } from "../../plugins/types.js";
 import {
@@ -1181,6 +1185,8 @@ export async function handleRegistryInstall(
 			throw stateErr;
 		}
 
+		await syncDeclaredStorageIndexes(db, [bundle.manifest]);
+
 		return {
 			success: true,
 			data: {
@@ -1288,6 +1294,12 @@ export async function handleRegistryUninstall(
 			await deleteBundleFromR2(storage, pluginId, version, "registry");
 		}
 
+		try {
+			await removeAllPluginIndexes(db, pluginId);
+		} catch {
+			// Nothing to drop, or tracking table predates the feature
+		}
+
 		await stateRepo.delete(pluginId);
 
 		return { success: true, data: { pluginId, dataDeleted } };
@@ -1646,6 +1658,8 @@ export async function handleRegistryUpdate(
 			mcpToolsConsent: null,
 		});
 
+		await syncDeclaredStorageIndexes(db, [bundle.manifest]);
+
 		// Best-effort cleanup of the old bundle. Failures here don't roll
 		// back the upgrade (the new bundle is already stored and committed
 		// in the state row); the orphan is just storage we'll pay for.

package/src/api/handlers/revision.ts

@@ -4,6 +4,7 @@
 
 import type { Kysely } from "kysely";
 
+import { after } from "../../after.js";
 import { ContentRepository } from "../../database/repositories/content.js";
 import { RevisionRepository, type Revision } from "../../database/repositories/revision.js";
 import { withTransaction } from "../../database/transaction.js";
@@ -115,7 +116,7 @@ export async function handleRevisionRestore(
 		// Atomically update content and create a new revision to record the restore.
 		// If either operation fails, neither is committed (on engines that support
 		// transactions; on D1, withTransaction falls back to sequential execution).
-		const item = await withTransaction(db, async (trx) => {
+		const { item, queuedRevisionId } = await withTransaction(db, async (trx) => {
 			const trxContentRepo = new ContentRepository(trx);
 			const trxRevisionRepo = new RevisionRepository(trx);
 
@@ -124,19 +125,32 @@ export async function handleRevisionRestore(
 				slug: typeof _slug === "string" ? _slug : undefined,
 			});
 
-			await trxRevisionRepo.create({
+			const queuedRevision = await trxRevisionRepo.create({
 				collection: revision.collection,
 				entryId: revision.entryId,
 				data: revision.data,
 				authorId: callerUserId,
 			});
 
-			return updated;
+			return { item: updated, queuedRevisionId: queuedRevision.id };
 		});
 
-		// Fire-and-forget: prune old revisions to prevent unbounded growth
 		const pruneRepo = new RevisionRepository(db);
-		void pruneRepo.pruneOldRevisions(revision.collection, revision.entryId, 50).catch(() => {});
+		after(async () => {
+			try {
+				await pruneRepo.pruneQueuedEntry(
+					revision.collection,
+					revision.entryId,
+					queuedRevisionId,
+					50,
+				);
+			} catch (error) {
+				console.error(
+					`[revisions] Failed to prune revisions for ${revision.collection}/${revision.entryId}:`,
+					error,
+				);
+			}
+		});
 
 		return {
 			success: true,

package/src/api/handlers/schema.ts

@@ -9,6 +9,7 @@ import { invalidateCollectionCache } from "../../object-cache/index.js";
 import {
 	SchemaRegistry,
 	SchemaError,
+	invalidateSchemaCache,
 	type Collection,
 	type Field,
 	type CreateCollectionInput,
@@ -19,6 +20,11 @@ import {
 } from "../../schema/index.js";
 import type { ApiResult } from "../types.js";
 
+function invalidateFieldCaches(collectionSlug: string): void {
+	invalidateCollectionCache(collectionSlug);
+	invalidateSchemaCache(collectionSlug);
+}
+
 export interface CollectionListResponse {
 	items: Collection[];
 }
@@ -317,7 +323,7 @@ export async function handleSchemaFieldCreate(
 		const item = await registry.createField(collectionSlug, input);
 
 		// Content snapshots embed field values; a column change invalidates them.
-		invalidateCollectionCache(collectionSlug);
+		invalidateFieldCaches(collectionSlug);
 
 		return {
 			success: true,
@@ -357,7 +363,7 @@ export async function handleSchemaFieldUpdate(
 		const registry = new SchemaRegistry(db);
 		const item = await registry.updateField(collectionSlug, fieldSlug, input);
 
-		invalidateCollectionCache(collectionSlug);
+		invalidateFieldCaches(collectionSlug);
 
 		return {
 			success: true,
@@ -396,7 +402,7 @@ export async function handleSchemaFieldDelete(
 		const registry = new SchemaRegistry(db);
 		await registry.deleteField(collectionSlug, fieldSlug);
 
-		invalidateCollectionCache(collectionSlug);
+		invalidateFieldCaches(collectionSlug);
 
 		return {
 			success: true,
@@ -423,6 +429,43 @@ export async function handleSchemaFieldDelete(
 	}
 }
 
+/**
+ * Reorder collections in the admin sidebar
+ */
+export async function handleSchemaCollectionReorder(
+	db: Kysely<Database>,
+	slugs: string[],
+): Promise<ApiResult<{ success: boolean }>> {
+	try {
+		const registry = new SchemaRegistry(db);
+		await registry.reorderCollections(slugs);
+
+		return {
+			success: true,
+			data: { success: true },
+		};
+	} catch (error) {
+		if (error instanceof SchemaError) {
+			return {
+				success: false,
+				error: {
+					code: error.code,
+					message: error.message,
+					details: error.details,
+				},
+			};
+		}
+		console.error("[emdash] Failed to reorder collections:", error);
+		return {
+			success: false,
+			error: {
+				code: "SCHEMA_COLLECTION_REORDER_ERROR",
+				message: "Failed to reorder collections",
+			},
+		};
+	}
+}
+
 /**
  * Reorder fields
  */

package/src/api/handlers/seo.ts

@@ -88,7 +88,7 @@ function toW3CDate(value: string): string {
  * Collect all published, indexable content across SEO-enabled collections
  * for sitemap generation, grouped by collection.
  *
- * Only includes content from collections with `has_seo = 1`.
+ * Only includes content from routable collections with `has_seo = 1`.
  * Excludes content with `seo_no_index = 1` in the `_emdash_seo` table.
  *
  * Returns raw data grouped per collection. The caller (route) is
@@ -105,7 +105,8 @@ export async function handleSitemapData(
 		let query = db
 			.selectFrom("_emdash_collections")
 			.select(["slug", "url_pattern"])
-			.where("has_seo", "=", 1);
+			.where("has_seo", "=", 1)
+			.where("routable", "=", 1);
 
 		if (collectionSlug) {
 			query = query.where("slug", "=", collectionSlug);
@@ -149,6 +150,8 @@ export async function handleSitemapData(
 						AND s.content_id = c.id
 					WHERE c.status = 'published'
 					AND c.deleted_at IS NULL
+					AND c.slug IS NOT NULL
+					AND TRIM(c.slug) <> ''
 					AND (s.seo_no_index IS NULL OR s.seo_no_index = 0)
 					ORDER BY c.updated_at DESC
 					LIMIT ${SITEMAP_MAX_ENTRIES}

package/src/api/handlers/snapshot.ts

@@ -312,7 +312,7 @@ export async function generateSnapshot(
 						await sql<Record<string, unknown>>`
 						SELECT * FROM ${sql.raw(`"${tableName}"`)}
 						WHERE deleted_at IS NULL
-						AND (status = 'published' OR (status = 'scheduled' AND scheduled_at <= strftime('%Y-%m-%dT%H:%M:%fZ', 'now')))
+						AND status = 'published'
 					`.execute(db)
 					).rows;
 				}