fix: skip edge cache invalidate on draft-only content saves (#2279)

* fix: skip edge cache invalidate on draft-only content saves

Pure draft staging on revision collections leaves live public HTML
unchanged; thrashing edge tags can reseed stale Workers Cache entries.

* style(core): drop justification comment on edge invalidate gate

* Update packages/core/src/astro/types.ts

Co-authored-by: emdashbot[bot] <273199577+emdashbot[bot]@users.noreply.github.com>

* fix: keep draft-only saves out of public caches

---------

Co-authored-by: Noah (Nguyen Pham) <137921741+khoinguyenpham04@users.noreply.github.com>
Co-authored-by: emdashbot[bot] <273199577+emdashbot[bot]@users.noreply.github.com>
Co-authored-by: Noah Pham <ptknguyen04@gmail.com>

Author: 3 people

.changeset/draft-save-skip-edge-invalidate.md

@@ -0,0 +1,5 @@
+---
+"emdash": patch
+---
+
+Stops draft-only content saves from purging public caches and removes internal revision IDs from anonymous content query results. Public caches are invalidated when live content changes, while preview and edit requests retain the revision metadata needed to load drafts.

packages/core/src/astro/routes/api/content/[collection]/[id].ts

@@ -126,7 +126,9 @@ export const PUT: APIRoute = async ({ params, request, locals, cache }) => {
 
 	if (!result.success) return unwrapResult(result);
 
-	if (cache?.enabled) await cache.invalidate({ tags: [collection, resolvedId] });
+	if (cache?.enabled && result.liveContentChanged !== false) {
+		await cache.invalidate({ tags: [collection, resolvedId] });
+	}
 
 	return unwrapResult(result);
 };

packages/core/src/astro/types.ts

@@ -210,6 +210,7 @@ export interface EmDashManifest {
 export interface HandlerResponse<T = unknown> {
 	success: boolean;
 	data?: T;
+	liveContentChanged?: boolean;
 	error?: {
 		code: string;
 		message: string;

packages/core/src/database/repositories/content.ts

@@ -660,7 +660,7 @@ export class ContentRepository {
 			await this.restampEntryPivot(type, id);
 		}
 
-		invalidateCollectionCache(type);
+		if (hasColumnWrites) invalidateCollectionCache(type);
 
 		const updated = await this.findById(type, id);
 		if (!updated) {
@@ -1555,8 +1555,6 @@ export class ContentRepository {
 			WHERE id = ${id}
 			AND deleted_at IS NULL
 		`.execute(this.db);
-
-		invalidateCollectionCache(type);
 	}
 
 	/**
@@ -1588,8 +1586,6 @@ export class ContentRepository {
 			AND deleted_at IS NULL
 		`.execute(this.db);
 
-		invalidateCollectionCache(type);
-
 		const updated = await this.findById(type, id);
 		if (!updated) {
 			throw new Error("Content not found");

packages/core/src/emdash-runtime.ts

@@ -225,6 +225,8 @@ const FIELD_TYPE_TO_KIND: Record<FieldType, string> = {
 	repeater: "repeater",
 };
 
+const DRAFT_ONLY_UPDATE_KEYS = new Set(["data", "slug", "locale", "skipRevision"]);
+
 /**
  * Sandboxed plugin entry from virtual module
  */
@@ -2909,6 +2911,14 @@ export class EmDashRuntime {
 			bylines: bodyWithoutRev.bylines,
 		});
 
+		// Public HTML comes from live columns / SEO / taxonomies, not draft revisions.
+		const liveMetaTouched = Object.entries(bodyWithoutRev).some(
+			([key, value]) => value !== undefined && !DRAFT_ONLY_UPDATE_KEYS.has(key),
+		);
+		const liveContentChanged = usesDraftRevisions
+			? liveMetaTouched
+			: Boolean(processedData || bodyWithoutRev.slug !== undefined || liveMetaTouched);
+
 		// Hydrate draft data BEFORE firing afterSave hooks so the hook sees
 		// the same effective data the response surfaces — for revision-
 		// supporting collections, that's the just-saved draft, not the live
@@ -2957,6 +2967,9 @@ export class EmDashRuntime {
 			this.runAfterSaveHooks(contentItemToRecord(hydrated.data.item), collection, false);
 		}
 
+		if (hydrated.success) {
+			return { ...hydrated, liveContentChanged };
+		}
 		return hydrated;
 	}
 

packages/core/src/query.ts

@@ -347,6 +347,23 @@ function entryEditOptions(entry: { data?: unknown }): EditableOptions {
 	return { status, hasDraft };
 }
 
+function stripRevisionMetadata(entry: { data?: unknown }): void {
+	const data = entryData(entry);
+	delete data.draftRevisionId;
+	delete data.liveRevisionId;
+}
+
+function canExposeRevisionMetadata(
+	entry: { id: string; data?: unknown },
+	collection: string,
+): boolean {
+	const ctx = getRequestContext();
+	if (ctx?.editMode) return true;
+	if (ctx?.preview?.collection !== collection) return false;
+	const dbId = entryDatabaseId(entry);
+	return ctx.preview.id === dbId || ctx.preview.id === entry.id;
+}
+
 /**
  * Get all entries of a content type
  *
@@ -441,7 +458,11 @@ async function loadCollectionCached<T extends string, D = InferCollectionData<T>
 		return { entries: [], error: snapshot.error, cacheHint: snapshot.cacheHint };
 	}
 	return {
-		entries: snapshot.value.entries.map((entry) => reviveEntry<D>(entry)),
+		entries: snapshot.value.entries.map((entry) => {
+			const revived = reviveEntry<D>(entry);
+			if (!canExposeRevisionMetadata(revived, type)) stripRevisionMetadata(revived);
+			return revived;
+		}),
 		nextCursor: snapshot.value.nextCursor,
 		hasMore: snapshot.value.hasMore,
 		cacheHint: snapshot.value.cacheHint,
@@ -729,6 +750,9 @@ async function getEmDashCollectionUncached<T extends string, D = InferCollection
 		if (isEditMode) {
 			tagEditableFields(entryData(entry), type, dbId);
 		}
+		if (!canExposeRevisionMetadata(entry, type)) {
+			stripRevisionMetadata(entry);
+		}
 		return {
 			...entry,
 			edit: isEditMode ? createEditable(type, dbId, entryEditOptions(entry)) : createNoop(),
@@ -833,6 +857,7 @@ export async function getEmDashEntry<T extends string, D = InferCollectionData<T
 		wrapped: ContentEntry<D>,
 		opts: { isPreview: boolean; fallbackLocale?: string; cacheHint: CacheHint },
 	): Promise<EntryResult<D>> {
+		if (!opts.isPreview) stripRevisionMetadata(wrapped);
 		// Hydrate terms in the entry's resolved locale (fallback-aware) so a
 		// localized entry never picks up default-locale taxonomy terms (#1441).
 		// When i18n is disabled we leave the locale unset to preserve the
@@ -984,8 +1009,10 @@ export async function getEmDashEntry<T extends string, D = InferCollectionData<T
 	if (!snapshot.ok) {
 		return { entry: null, error: snapshot.error, isPreview: false, cacheHint: snapshot.cacheHint };
 	}
+	const revived = snapshot.value.entry ? reviveEntry<D>(snapshot.value.entry) : null;
+	if (revived && !canExposeRevisionMetadata(revived, type)) stripRevisionMetadata(revived);
 	return {
-		entry: snapshot.value.entry ? reviveEntry<D>(snapshot.value.entry) : null,
+		entry: revived,
 		isPreview: snapshot.value.isPreview,
 		fallbackLocale: snapshot.value.fallbackLocale,
 		cacheHint: snapshot.value.cacheHint,

packages/core/tests/integration/content/draft-save-live-content-changed.test.ts

@@ -0,0 +1,117 @@
+/**
+ * handleContentUpdate reports liveContentChanged so edge invalidation can
+ * skip pure draft staging on revision-supporting collections.
+ */
+
+import type { Kysely } from "kysely";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import type { Database } from "../../../src/database/types.js";
+import type { EmDashRuntime } from "../../../src/emdash-runtime.js";
+import { SchemaRegistry } from "../../../src/schema/registry.js";
+import { createTestRuntime } from "../../utils/mcp-runtime.js";
+import { setupTestDatabase, teardownTestDatabase } from "../../utils/test-db.js";
+
+describe("handleContentUpdate liveContentChanged", () => {
+	let db: Kysely<Database>;
+	let runtime: EmDashRuntime;
+
+	beforeEach(async () => {
+		db = await setupTestDatabase();
+		const registry = new SchemaRegistry(db);
+		await registry.createCollection({ slug: "posts", label: "Posts" });
+		await registry.createField("posts", { slug: "title", label: "Title", type: "string" });
+		await registry.createCollection({
+			slug: "plain_posts",
+			label: "Plain Posts",
+			supports: [],
+		});
+		await registry.createField("plain_posts", {
+			slug: "title",
+			label: "Title",
+			type: "string",
+		});
+		runtime = createTestRuntime(db);
+	});
+
+	afterEach(async () => {
+		await teardownTestDatabase(db);
+	});
+
+	it("is false for draft-only data save on revision collections", async () => {
+		const created = await runtime.handleContentCreate("posts", {
+			data: { title: "Live" },
+			slug: "live",
+		});
+		expect(created.success).toBe(true);
+		const id = created.data!.item.id;
+		await runtime.handleContentPublish("posts", id);
+
+		const saved = await runtime.handleContentUpdate("posts", id, {
+			data: { title: "Draft edit" },
+		});
+		expect(saved.success).toBe(true);
+		expect(saved.success && saved.liveContentChanged).toBe(false);
+	});
+
+	it("is false when data+slug are staged as a draft revision", async () => {
+		const created = await runtime.handleContentCreate("posts", {
+			data: { title: "Live" },
+			slug: "live",
+		});
+		const id = created.data!.item.id;
+		await runtime.handleContentPublish("posts", id);
+
+		const saved = await runtime.handleContentUpdate("posts", id, {
+			data: { title: "Live" },
+			slug: "live-renamed",
+		});
+		expect(saved.success).toBe(true);
+		expect(saved.success && saved.liveContentChanged).toBe(false);
+	});
+
+	it("is true when live metadata changes on a revision collection", async () => {
+		const created = await runtime.handleContentCreate("posts", {
+			data: { title: "Live" },
+			slug: "live-meta",
+		});
+		const id = created.data!.item.id;
+		await runtime.handleContentPublish("posts", id);
+
+		const saved = await runtime.handleContentUpdate("posts", id, {
+			publishedAt: "2020-01-01T00:00:00.000Z",
+		});
+		expect(saved.success).toBe(true);
+		expect(saved.success && saved.liveContentChanged).toBe(true);
+	});
+
+	it("defaults unclassified update fields to live-changing", async () => {
+		const created = await runtime.handleContentCreate("posts", {
+			data: { title: "Live" },
+			slug: "future-meta",
+		});
+		const id = created.data!.item.id;
+		await runtime.handleContentPublish("posts", id);
+
+		const saved = await runtime.handleContentUpdate("posts", id, {
+			// @ts-expect-error - simulates a future live field before it joins the public input type
+			futureLiveField: "changed",
+		});
+		expect(saved.success).toBe(true);
+		expect(saved.success && saved.liveContentChanged).toBe(true);
+	});
+
+	it("is true for data updates on collections without revisions", async () => {
+		const created = await runtime.handleContentCreate("plain_posts", {
+			data: { title: "Plain" },
+			slug: "plain",
+		});
+		const id = created.data!.item.id;
+
+		const updated = await runtime.handleContentUpdate("plain_posts", id, {
+			data: { title: "Plain edited" },
+		});
+		expect(updated.success).toBe(true);
+		expect(updated.success && updated.liveContentChanged).toBe(true);
+	});
+});

packages/core/tests/unit/astro/content-routes-cache-invalidate.test.ts

@@ -0,0 +1,103 @@
+/**
+ * PUT content updates must only purge edge cache tags when live/public
+ * content actually changed. Pure draft staging on revision collections
+ * leaves live columns untouched and must not thrash Workers Cache.
+ */
+
+import { Role } from "@emdash-cms/auth";
+import { describe, it, expect, vi } from "vitest";
+
+import { PUT as updateContent } from "../../../src/astro/routes/api/content/[collection]/[id].js";
+
+describe("PUT content route — edge cache invalidation", () => {
+	const makeUser = () => ({
+		id: "user-1",
+		role: Role.EDITOR,
+	});
+
+	const ownedItem = {
+		success: true as const,
+		data: { item: { id: "c1", authorId: "user-1" }, _rev: "rev1" },
+	};
+
+	async function putWithUpdateResult(
+		updateResult: {
+			success: boolean;
+			data?: unknown;
+			liveContentChanged?: boolean;
+			error?: { code: string; message: string };
+		},
+		body: Record<string, unknown> = { data: { title: "Edited" } },
+	) {
+		const handleContentGet = vi.fn().mockResolvedValue(ownedItem);
+		const handleContentUpdate = vi.fn().mockResolvedValue(updateResult);
+		const invalidate = vi.fn().mockResolvedValue(undefined);
+
+		const request = new Request("http://localhost/_emdash/api/content/posts/c1", {
+			method: "PUT",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(body),
+		});
+
+		const response = await updateContent({
+			params: { collection: "posts", id: "c1" },
+			request,
+			url: new URL(request.url),
+			locals: {
+				emdash: { handleContentUpdate, handleContentGet },
+				user: makeUser(),
+			},
+			cache: { enabled: true, invalidate },
+		} as Parameters<typeof updateContent>[0]);
+
+		return { response, invalidate, handleContentUpdate };
+	}
+
+	it("does not invalidate when liveContentChanged is false (draft-only save)", async () => {
+		const { response, invalidate } = await putWithUpdateResult({
+			success: true,
+			data: { item: { id: "c1" }, _rev: "rev2" },
+			liveContentChanged: false,
+		});
+
+		expect(response.status).toBe(200);
+		expect(invalidate).not.toHaveBeenCalled();
+		const json = await response.json();
+		expect(json).toMatchObject({ success: true, data: { item: { id: "c1" } } });
+		expect(json).not.toHaveProperty("liveContentChanged");
+		expect(json.data).not.toHaveProperty("liveContentChanged");
+	});
+
+	it("invalidates when liveContentChanged is true", async () => {
+		const { response, invalidate } = await putWithUpdateResult({
+			success: true,
+			data: { item: { id: "c1" }, _rev: "rev2" },
+			liveContentChanged: true,
+		});
+
+		expect(response.status).toBe(200);
+		expect(invalidate).toHaveBeenCalledTimes(1);
+		expect(invalidate).toHaveBeenCalledWith({ tags: ["posts", "c1"] });
+	});
+
+	it("invalidates when liveContentChanged is omitted (safe default)", async () => {
+		const { response, invalidate } = await putWithUpdateResult({
+			success: true,
+			data: { item: { id: "c1" }, _rev: "rev2" },
+		});
+
+		expect(response.status).toBe(200);
+		expect(invalidate).toHaveBeenCalledWith({ tags: ["posts", "c1"] });
+	});
+
+	it("does not invalidate on failed updates", async () => {
+		const { response, invalidate } = await putWithUpdateResult({
+			success: false,
+			error: { code: "CONFLICT", message: "stale" },
+			liveContentChanged: true,
+		});
+
+		expect(response.status).toBe(409);
+		expect(invalidate).not.toHaveBeenCalled();
+	});
+});