emdash 0.31.1 → 0.33.0

package/src/astro/routes/api/schema/collections/reorder.ts

@@ -0,0 +1,31 @@
+/**
+ * Collection reorder endpoint
+ *
+ * POST /_emdash/api/schema/collections/reorder - Set the admin sidebar order
+ */
+
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { requireDb, unwrapResult } from "#api/error.js";
+import { handleSchemaCollectionReorder } from "#api/index.js";
+import { parseBody, isParseError } from "#api/parse.js";
+import { collectionReorderBody } from "#api/schemas.js";
+
+export const prerender = false;
+
+export const POST: APIRoute = async ({ request, locals }) => {
+	const { emdash, user } = locals;
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "schema:manage");
+	if (denied) return denied;
+
+	const body = await parseBody(request, collectionReorderBody);
+	if (isParseError(body)) return body;
+
+	const result = await handleSchemaCollectionReorder(emdash.db, body.slugs);
+	return unwrapResult(result);
+};

package/src/astro/routes/api/schema/index.ts

@@ -79,6 +79,8 @@ import type { PortableTextBlock } from "emdash";
 				description: c.description,
 				icon: c.icon,
 				supports: c.supports,
+				hidden: c.hidden,
+				sortOrder: c.sortOrder,
 				fields: c.fields.map((f) => ({
 					slug: f.slug,
 					label: f.label,

package/src/astro/routes/api/search/enable.ts

@@ -21,6 +21,7 @@ export const prerender = false;
  * - collection: Collection slug (required)
  * - enabled: boolean (required)
  * - weights: Optional field weights for ranking
+ * - tokenize: Optional FTS5 tokenizer configuration
  */
 export const POST: APIRoute = async ({ request, locals }) => {
 	const { emdash, user } = locals;
@@ -40,7 +41,10 @@ export const POST: APIRoute = async ({ request, locals }) => {
 	try {
 		if (body.enabled) {
 			// Enable search - creates FTS table, triggers, and populates index
-			await ftsManager.enableSearch(body.collection, { weights: body.weights });
+			await ftsManager.enableSearch(body.collection, {
+				weights: body.weights,
+				tokenize: body.tokenize,
+			});
 
 			const stats = await ftsManager.getIndexStats(body.collection);
 

package/src/astro/routes/api/search/rebuild.ts

@@ -57,7 +57,12 @@ export const POST: APIRoute = async ({ request, locals }) => {
 		}
 
 		// Rebuild the index
-		await ftsManager.rebuildIndex(body.collection, searchableFields, config.weights);
+		await ftsManager.rebuildIndex(
+			body.collection,
+			searchableFields,
+			config.weights,
+			config.tokenize,
+		);
 
 		// Get stats after rebuild
 		const stats = await ftsManager.getIndexStats(body.collection);

package/src/astro/routes/api/taxonomies/[name]/reorder.ts

@@ -0,0 +1,41 @@
+/**
+ * Taxonomy term reorder endpoint
+ *
+ * POST /_emdash/api/taxonomies/:name/reorder
+ *   body: { parentId?, ids }
+ *
+ * Sets the manual order of one sibling group. There is no `locale`: a term
+ * holds one position across every locale it is translated into.
+ */
+
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { apiError, handleError, requireDb, unwrapResult } from "#api/error.js";
+import { handleTermReorder } from "#api/handlers/taxonomies.js";
+import { isParseError, parseBody } from "#api/parse.js";
+import { reorderTermsBody } from "#api/schemas.js";
+
+export const prerender = false;
+
+export const POST: APIRoute = async ({ params, request, locals }) => {
+	const { emdash, user } = locals;
+	const { name } = params;
+	if (!name) return apiError("VALIDATION_ERROR", "Taxonomy name required", 400);
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "taxonomies:manage");
+	if (denied) return denied;
+
+	try {
+		const body = await parseBody(request, reorderTermsBody);
+		if (isParseError(body)) return body;
+
+		const result = await handleTermReorder(emdash.db, name, body);
+		return unwrapResult(result);
+	} catch (error) {
+		return handleError(error, "Failed to reorder terms", "TERM_REORDER_ERROR");
+	}
+};

package/src/astro/routes/api/taxonomies/[name]/terms/index.ts

@@ -11,7 +11,7 @@ import { requirePerm } from "#api/authorize.js";
 import { apiError, handleError, requireDb, unwrapResult } from "#api/error.js";
 import { handleTermCreate, handleTermList } from "#api/handlers/taxonomies.js";
 import { isParseError, parseBody, parseQuery } from "#api/parse.js";
-import { createTermBody, localeFilterQuery } from "#api/schemas.js";
+import { createTermBody, termListQuery } from "#api/schemas.js";
 
 export const prerender = false;
 
@@ -29,11 +29,14 @@ export const GET: APIRoute = async ({ params, request, locals }) => {
 	const denied = requirePerm(user, "taxonomies:read");
 	if (denied) return denied;
 
-	const query = parseQuery(new URL(request.url), localeFilterQuery);
+	const query = parseQuery(new URL(request.url), termListQuery);
 	if (isParseError(query)) return query;
 
 	try {
-		const result = await handleTermList(emdash.db, name, { locale: query.locale });
+		const result = await handleTermList(emdash.db, name, {
+			locale: query.locale,
+			includeCounts: query.includeCounts,
+		});
 		return unwrapResult(result);
 	} catch (error) {
 		return handleError(error, "Failed to list terms", "TERM_LIST_ERROR");

package/src/astro/types.ts

@@ -31,6 +31,12 @@ export interface ManifestCollection {
 	supports: string[];
 	hasSeo: boolean;
 	urlPattern?: string;
+	/**
+	 * Omit the auto-generated sidebar entry in the admin. The collection is
+	 * still listed in the manifest so its routes, editor, and API keep working
+	 * — only the navigation link is dropped.
+	 */
+	hidden?: boolean;
 	fields: Record<
 		string,
 		{
@@ -210,6 +216,7 @@ export interface EmDashManifest {
 export interface HandlerResponse<T = unknown> {
 	success: boolean;
 	data?: T;
+	liveContentChanged?: boolean;
 	error?: {
 		code: string;
 		message: string;

package/src/cleanup.ts

@@ -10,12 +10,14 @@
  */
 
 import { createKyselyAdapter, type AuthTables } from "@emdash-cms/auth/adapters/kysely";
-import { sql, type Kysely } from "kysely";
+import type { Kysely } from "kysely";
 
 import { cleanupExpiredChallenges } from "./auth/challenge-store.js";
 import { MediaRepository } from "./database/repositories/media.js";
 import { RevisionRepository } from "./database/repositories/revision.js";
 import type { Database } from "./database/types.js";
+import { removeUploadAttempt } from "./media/upload-attempts.js";
+import { cleanupMediaUsageGenerations } from "./media/usage/gc.js";
 import type { Storage } from "./storage/types.js";
 
 /**
@@ -27,20 +29,21 @@ export interface CleanupResult {
 	expiredTokens: number;
 	pendingUploads: number;
 	pendingUploadFiles: number;
+	uploadAttempts: number;
 	revisionsPruned: number;
+	mediaUsageStaleGenerations: number;
+	mediaUsageAbandonedGenerations: number;
+	mediaUsageOrphanOccurrences: number;
 }
 
-/** Max revisions to keep per entry during periodic pruning */
 const REVISION_KEEP_COUNT = 50;
-
-/** Only prune entries that exceed this threshold */
-const REVISION_PRUNE_THRESHOLD = REVISION_KEEP_COUNT;
+const REVISION_PRUNE_BATCH_SIZE = 10;
 
 /**
  * Run all system cleanup tasks.
  *
- * Safe to call frequently -- each task is a single DELETE with a WHERE clause,
- * so repeated calls with nothing to clean are cheap (no-op queries).
+ * Safe to call frequently -- each subsystem tolerates repeated calls, and
+ * repeated calls with nothing to clean are cheap.
  *
  * @param db - The database instance
  * @param storage - Optional storage backend for deleting orphaned files.
@@ -56,7 +59,11 @@ export async function runSystemCleanup(
 		expiredTokens: -1,
 		pendingUploads: -1,
 		pendingUploadFiles: -1,
+		uploadAttempts: -1,
 		revisionsPruned: -1,
+		mediaUsageStaleGenerations: -1,
+		mediaUsageAbandonedGenerations: -1,
+		mediaUsageOrphanOccurrences: -1,
 	};
 
 	// 1. Passkey challenges (expire after 60s, clean anything past 5 min)
@@ -106,41 +113,62 @@ export async function runSystemCleanup(
 		console.error("[cleanup] Failed to clean pending uploads:", error);
 	}
 
-	// 4. Revision pruning -- trim entries with excessive revision counts
+	// 4. Uploaded objects that lost publication races or outlived their media row
+	try {
+		const mediaRepo = new MediaRepository(db);
+		const completedAttemptsDeleted = await mediaRepo.deleteCompletedUploadAttempts();
+		if (!storage) {
+			result.uploadAttempts = completedAttemptsDeleted;
+		} else {
+			const storageKeys = await mediaRepo.findUploadAttemptsForCleanup();
+			let attemptsDeleted = completedAttemptsDeleted;
+			for (const storageKey of storageKeys) {
+				if (await removeUploadAttempt(storage, mediaRepo, storageKey)) {
+					attemptsDeleted++;
+				}
+			}
+			result.uploadAttempts = attemptsDeleted;
+		}
+	} catch (error) {
+		console.error("[cleanup] Failed to clean media upload attempts:", error);
+	}
+
 	try {
-		result.revisionsPruned = await pruneExcessiveRevisions(db);
+		result.revisionsPruned = await pruneQueuedRevisions(db);
 	} catch (error) {
 		console.error("[cleanup] Failed to prune revisions:", error);
 	}
 
+	try {
+		const usage = await cleanupMediaUsageGenerations(db);
+		result.mediaUsageStaleGenerations = usage.staleGenerations;
+		result.mediaUsageAbandonedGenerations = usage.abandonedGenerations;
+		result.mediaUsageOrphanOccurrences = usage.orphanOccurrences;
+	} catch (error) {
+		console.error("[cleanup] Failed to clean media-usage generations:", error);
+	}
+
 	return result;
 }
 
-/**
- * Find entries with more than REVISION_PRUNE_THRESHOLD revisions and prune
- * them down to REVISION_KEEP_COUNT.
- */
-async function pruneExcessiveRevisions(db: Kysely<Database>): Promise<number> {
-	const entries = await sql<{ collection: string; entry_id: string }>`
-		SELECT collection, entry_id
-		FROM revisions
-		GROUP BY collection, entry_id
-		HAVING COUNT(*) > ${REVISION_PRUNE_THRESHOLD}
-	`.execute(db);
-
-	if (entries.rows.length === 0) return 0;
-
+async function pruneQueuedRevisions(db: Kysely<Database>): Promise<number> {
+	const queued = await db
+		.selectFrom("_emdash_revision_prune_queue")
+		.selectAll()
+		.orderBy("revision_id")
+		.limit(REVISION_PRUNE_BATCH_SIZE)
+		.execute();
 	const revisionRepo = new RevisionRepository(db);
 	let totalPruned = 0;
 
-	for (const row of entries.rows) {
+	for (const row of queued) {
 		try {
-			const pruned = await revisionRepo.pruneOldRevisions(
+			totalPruned += await revisionRepo.pruneQueuedEntry(
 				row.collection,
 				row.entry_id,
+				row.revision_id,
 				REVISION_KEEP_COUNT,
 			);
-			totalPruned += pruned;
 		} catch (error) {
 			console.error(
 				`[cleanup] Failed to prune revisions for ${row.collection}/${row.entry_id}:`,

package/src/cli/commands/dev.ts

@@ -5,7 +5,7 @@
  */
 
 import { spawn } from "node:child_process";
-import { readFile, access } from "node:fs/promises";
+import { access, readFile } from "node:fs/promises";
 import { resolve } from "node:path";
 
 import { defineCommand } from "citty";
@@ -42,10 +42,15 @@ async function fileExists(path: string): Promise<boolean> {
 	}
 }
 
+export const DEV_DEPRECATION_MESSAGE =
+	"`emdash dev` is deprecated and will be removed in a future release.\n\n" +
+	"Use your project's dev script instead (for example, `pnpm dev`), or run `astro dev` directly.";
+
 export const devCommand = defineCommand({
 	meta: {
 		name: "dev",
 		description: "Start dev server with local database",
+		hidden: true,
 	},
 	args: {
 		database: {
@@ -73,6 +78,11 @@ export const devCommand = defineCommand({
 		},
 	},
 	async run({ args }) {
+		consola.box({
+			title: "DEPRECATED COMMAND",
+			message: DEV_DEPRECATION_MESSAGE,
+		});
+
 		const cwd = resolve(args.cwd);
 		const pkg = await readPackageJson(cwd);
 
@@ -119,8 +129,8 @@ export const devCommand = defineCommand({
 					const schema = await client.schemaExport();
 					const types = await client.schemaTypes();
 
-					const { writeFile, mkdir } = await import("node:fs/promises");
-					const { resolve: resolvePath, dirname } = await import("node:path");
+					const { mkdir, writeFile } = await import("node:fs/promises");
+					const { dirname, resolve: resolvePath } = await import("node:path");
 					const outputPath = resolvePath(cwd, ".emdash/types.ts");
 					await mkdir(dirname(outputPath), { recursive: true });
 					await writeFile(outputPath, types, "utf-8");

package/src/cli/commands/export-seed.ts

@@ -316,6 +316,8 @@ async function exportCollections(db: Kysely<Database>): Promise<SeedCollection[]
 			icon: collection.icon || undefined,
 			supports: collection.supports.length > 0 ? collection.supports : undefined,
 			urlPattern: collection.urlPattern || undefined,
+			hidden: collection.hidden || undefined,
+			sortOrder: collection.sortOrder,
 			fields: fields.map(
 				(field): SeedField => ({
 					slug: field.slug,

package/src/cli/index.ts

@@ -8,7 +8,7 @@
  * Commands:
  * - init: Bootstrap database from template config, or interactive setup
  * - types: Generate TypeScript types from schema
- * - dev: Run dev server with local D1
+ * - dev: [DEPRECATED, hidden] Run dev server with a local SQLite database
  * - seed: Apply a seed file to the database
  * - export-seed: Export database schema and content as a seed file
  * - secrets: Generate and inspect EmDash secrets (encryption keys, etc.)

package/src/components/CommentForm.astro

@@ -11,7 +11,7 @@
  * @example
  * ```astro
  * ---
- * import { CommentForm } from "emdash/ui";
+ * import { CommentForm } from "emdash/ui/comments";
  * ---
  * <CommentForm collection="posts" contentId={post.id} />
  * ```

package/src/components/Comments.astro

@@ -8,7 +8,7 @@
  * @example
  * ```astro
  * ---
- * import { Comments } from "emdash/ui";
+ * import { Comments } from "emdash/ui/comments";
  * ---
  * <Comments collection="posts" contentId={post.id} threaded />
  * ```