emdash 0.37.0 → 0.39.0

package/src/api/handlers/content.ts

@@ -15,6 +15,8 @@ import {
 	isSystemOrderField,
 	type ContentRevisionPrecondition,
 } from "../../database/repositories/content.js";
+import { EntryLockRepository } from "../../database/repositories/entry-locks.js";
+import { OptionsRepository } from "../../database/repositories/options.js";
 import { RedirectRepository } from "../../database/repositories/redirect.js";
 import { RevisionRepository } from "../../database/repositories/revision.js";
 import { SeoRepository } from "../../database/repositories/seo.js";
@@ -39,6 +41,10 @@ import { withTransaction } from "../../database/transaction.js";
 import type { Database } from "../../database/types.js";
 import { validateIdentifier } from "../../database/validate.js";
 import { getI18nConfig, isI18nEnabled, resolveConfiguredLocale } from "../../i18n/config.js";
+import {
+	scheduledPolicyRejectionKey,
+	type ScheduledPolicyRejection,
+} from "../../plugins/content-policy.js";
 import { invalidateRedirectCache } from "../../redirects/cache.js";
 import { FTSManager } from "../../search/fts-manager.js";
 import { invalidateTermCache } from "../../taxonomies/index.js";
@@ -63,6 +69,18 @@ function hasApiError(error: unknown): error is Error & { apiError: { code: strin
 	);
 }
 
+function isTranslationLocaleConflict(error: unknown, collection: string): boolean {
+	if (!(error instanceof Error)) return false;
+	const message = error.message.toLowerCase();
+	const storedIndexName = `uidx_ec_${collection}_active_tg_locale`.slice(0, 63).toLowerCase();
+	return (
+		message.includes(storedIndexName) ||
+		(message.includes("unique constraint failed") &&
+			message.includes("translation_group") &&
+			message.includes("locale"))
+	);
+}
+
 function decodeRevisionPrecondition(
 	rev: string | undefined,
 ): ContentRevisionPrecondition | undefined {
@@ -425,6 +443,8 @@ async function createSlugChangeRedirect(
 	oldSlug: string,
 	newSlug: string,
 	contentId: string,
+	oldPublishedAt: string | null,
+	newPublishedAt: string | null,
 ): Promise<void> {
 	// A URL pattern has no locale token, so every locale variant of an entry
 	// generates the same URL, and slugs are unique per (slug, locale) — a
@@ -448,6 +468,8 @@ async function createSlugChangeRedirect(
 		newSlug,
 		contentId,
 		collectionRow?.url_pattern ?? null,
+		oldPublishedAt,
+		newPublishedAt,
 	);
 	invalidateRedirectCache();
 }
@@ -484,7 +506,7 @@ const DATE_ONLY_RE = /^\d{4}-\d{2}-\d{2}$/;
  */
 function normalizeDateBound(value: string | undefined, edge: "start" | "end"): string | undefined {
 	if (!value) return undefined;
-	if (!DATE_ONLY_RE.test(value)) return value;
+	if (!DATE_ONLY_RE.test(value)) return new Date(value).toISOString();
 	return edge === "start" ? `${value}T00:00:00.000Z` : `${value}T23:59:59.999Z`;
 }
 
@@ -843,6 +865,21 @@ export async function handleContentCreate(
 		const item = await withTransaction(db, async (trx) => {
 			const repo = new ContentRepository(trx);
 			const bylineRepo = new BylineRepository(trx);
+			const inheritedFields = body.translationOf
+				? (
+						await trx
+							.selectFrom("_emdash_fields as field")
+							.innerJoin(
+								"_emdash_collections as collection",
+								"collection.id",
+								"field.collection_id",
+							)
+							.select("field.slug")
+							.where("collection.slug", "=", collection)
+							.where("field.translatable", "=", 0)
+							.execute()
+					).map((field) => field.slug)
+				: [];
 
 			// Default to the configured site locale rather than the repo's
 			// hard-coded "en" — otherwise non-English default-locale sites
@@ -871,6 +908,7 @@ export async function handleContentCreate(
 				authorId: body.authorId,
 				locale: effectiveLocale,
 				translationOf: body.translationOf,
+				inheritFields: inheritedFields,
 				createdAt: body.createdAt,
 				publishedAt: body.publishedAt,
 			});
@@ -942,6 +980,12 @@ export async function handleContentCreate(
 			};
 		}
 		if (error instanceof EmDashValidationError) {
+			if (error.message === "Translation source content not found") {
+				return {
+					success: false,
+					error: { code: "NOT_FOUND", message: error.message },
+				};
+			}
 			return {
 				success: false,
 				error: { code: "VALIDATION_ERROR", message: error.message },
@@ -954,6 +998,19 @@ export async function handleContentCreate(
 		// messages also contain "constraint failed".
 		const message = error instanceof Error ? error.message.toLowerCase() : "";
 		if (message.includes("unique constraint failed") || message.includes("duplicate key")) {
+			if (
+				message.includes("active_tg_locale") ||
+				(message.includes("translation_group") && message.includes("locale"))
+			) {
+				const locale = body.locale ?? getI18nConfig()?.defaultLocale ?? "en";
+				return {
+					success: false,
+					error: {
+						code: "CONFLICT",
+						message: `Translation already exists in locale "${locale}" for this content item`,
+					},
+				};
+			}
 			// Detect slug-specific collisions by message fingerprint
 			if (message.includes("slug")) {
 				return {
@@ -1095,17 +1152,27 @@ export async function handleContentUpdate(
 				updated.primaryBylineId = credits[0]?.byline.translationGroup ?? null;
 			}
 
-			// Create auto-redirect when slug changes
+			// Create auto-redirect when slug changes. Date tokens in the URL
+			// pattern resolve from the publish date, so the old URL uses the
+			// pre-update date (the URL that was actually live) and the new URL
+			// the post-update one.
 			if (oldSlug && body.slug) {
-				await createSlugChangeRedirect(trx, collection, oldSlug, body.slug, resolvedId);
+				await createSlugChangeRedirect(
+					trx,
+					collection,
+					oldSlug,
+					body.slug,
+					resolvedId,
+					existing?.publishedAt ?? null,
+					updated.publishedAt ?? null,
+				);
 			}
 
 			// Sync non-translatable fields to sibling locales in the same
 			// translation group. Only runs when i18n is enabled, data was updated,
 			// and the item belongs to a translation group with siblings.
 			if (isI18nEnabled() && body.data && updated.translationGroup) {
-				await syncNonTranslatableFields(
-					trx,
+				await trxRepo.syncNonTranslatableFields(
 					collection,
 					updated.id,
 					updated.translationGroup,
@@ -1283,10 +1350,11 @@ export async function handleContentDelete(
 		const result = await withTransaction(db, async (trx) => {
 			const repo = new ContentRepository(trx);
 			const resolvedId = (await resolveId(repo, collection, id)) ?? id;
-			return {
-				id: resolvedId,
-				deleted: await repo.delete(collection, resolvedId),
-			};
+			const deleted = await repo.delete(collection, resolvedId);
+			if (deleted) {
+				await new EntryLockRepository(trx).releaseEntry(collection, resolvedId);
+			}
+			return { id: resolvedId, deleted };
 		});
 
 		if (!result.deleted) {
@@ -1322,12 +1390,14 @@ export async function handleContentRestore(
 	db: Kysely<Database>,
 	collection: string,
 	id: string,
-): Promise<ApiResult<{ restored: true; item: ContentItem }>> {
+	options: { _rev?: string } = {},
+): Promise<ApiResult<{ restored: true; item: ContentItem; _rev: string }>> {
 	try {
+		const expectedRevision = decodeRevisionPrecondition(options._rev);
 		const item = await withTransaction(db, async (trx) => {
 			const repo = new ContentRepository(trx);
 			const resolvedId = (await resolveIdIncludingTrashed(repo, collection, id)) ?? id;
-			return repo.restore(collection, resolvedId);
+			return repo.restore(collection, resolvedId, expectedRevision);
 		});
 
 		if (!item) {
@@ -1342,9 +1412,24 @@ export async function handleContentRestore(
 
 		return {
 			success: true,
-			data: { restored: true, item },
+			data: { restored: true, item, _rev: encodeRev(item) },
 		};
 	} catch (error) {
+		if (error instanceof ContentMutationConflictError) {
+			return {
+				success: false,
+				error: { code: "CONFLICT", message: error.message },
+			};
+		}
+		if (isTranslationLocaleConflict(error, collection)) {
+			return {
+				success: false,
+				error: {
+					code: "CONFLICT",
+					message: "An active translation already exists in this locale",
+				},
+			};
+		}
 		console.error("Content restore error:", error);
 		return {
 			success: false,
@@ -1372,6 +1457,7 @@ export async function handleContentPermanentDelete(
 		// Wrap content delete + SEO/comment cleanup in a transaction
 		const deleted = await withTransaction(db, async (trx) => {
 			const trxRepo = new ContentRepository(trx);
+			const item = await trxRepo.findByIdIncludingTrashed(collection, resolvedId);
 			const wasDeleted = await trxRepo.permanentDelete(collection, resolvedId);
 
 			if (wasDeleted) {
@@ -1384,6 +1470,23 @@ export async function handleContentPermanentDelete(
 				// Clean up revisions for permanently deleted content
 				const revisionRepo = new RevisionRepository(trx);
 				await revisionRepo.deleteByEntry(collection, resolvedId);
+				await new EntryLockRepository(trx).releaseEntry(collection, resolvedId);
+				await new BylineRepository(trx).deleteContentBylines(collection, resolvedId);
+				// Term assignments are keyed by translation_group, so they belong to the
+				// group rather than to this row. They go only once no row of the group is
+				// left, trashed ones included, since a trashed row can still be restored.
+				if (item?.translationGroup) {
+					const groupSurvives = await trxRepo.hasTranslationsIncludingTrashed(
+						collection,
+						item.translationGroup,
+					);
+					if (!groupSurvives) {
+						await new TaxonomyRepository(trx).clearEntryGroupTerms(
+							collection,
+							item.translationGroup,
+						);
+					}
+				}
 			}
 
 			return wasDeleted;
@@ -1505,8 +1608,11 @@ export async function handleContentSchedule(
 	collection: string,
 	id: string,
 	scheduledAt: string,
+	currentTime: Date = new Date(),
+	_rev?: string,
 ): Promise<ApiResult<ContentResponse>> {
 	try {
+		const expectedRevision = decodeRevisionPrecondition(_rev);
 		const item = await withTransaction(db, async (trx) => {
 			const repo = new ContentRepository(trx);
 			const existing = await repo.findByIdOrSlug(collection, id);
@@ -1515,7 +1621,7 @@ export async function handleContentSchedule(
 				const publishConfig = await getCollectionPublishConfig(trx, collection);
 				requireRoutablePublishSlug(publishConfig.routable, existing.slug);
 			}
-			return repo.schedule(collection, resolvedId, scheduledAt);
+			return repo.schedule(collection, resolvedId, scheduledAt, currentTime, expectedRevision);
 		});
 
 		const hasSeo = await collectionHasSeo(db, collection);
@@ -1526,6 +1632,12 @@ export async function handleContentSchedule(
 			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,
@@ -1553,12 +1665,14 @@ export async function handleContentUnschedule(
 	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.unschedule(collection, resolvedId);
+			return repo.unschedule(collection, resolvedId, expectedRevision);
 		});
 
 		const hasSeo = await collectionHasSeo(db, collection);
@@ -1569,6 +1683,12 @@ export async function handleContentUnschedule(
 			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,
@@ -1589,11 +1709,76 @@ export async function handleContentUnschedule(
 	}
 }
 
+/**
+ * Persist a permanent policy rejection and unschedule the publication.
+ * Databases with transactions commit both writes together. D1 persists the
+ * reason first so a failed option write cannot silently remove the entry from
+ * future sweeps; if unscheduling then fails, the due entry and its dashboard
+ * notice remain available for retry and operator action.
+ */
+export async function handleScheduledPolicyRejection(
+	db: Kysely<Database>,
+	collection: string,
+	id: string,
+	options: { _rev: string; rejection: ScheduledPolicyRejection },
+): 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;
+			const optionsRepo = new OptionsRepository(trx);
+			const rejectionKey = scheduledPolicyRejectionKey(collection, resolvedId);
+			const rejectionRevision = await optionsRepo.setVersioned(rejectionKey, {
+				...options.rejection,
+				id: resolvedId,
+			});
+			try {
+				return await repo.unschedule(collection, resolvedId, expectedRevision);
+			} catch (error) {
+				if (error instanceof ContentMutationConflictError) {
+					try {
+						await optionsRepo.compareAndDelete(rejectionKey, rejectionRevision);
+					} catch (cleanupError) {
+						console.error("Failed to clear stale scheduled policy rejection:", cleanupError);
+					}
+				}
+				throw error;
+			}
+		});
+
+		const hasSeo = await collectionHasSeo(db, collection);
+		await hydrateSeo(db, collection, item, hasSeo);
+		return { success: true, 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,
+				error: { code: "VALIDATION_ERROR", message: error.message },
+			};
+		}
+		console.error("Scheduled policy rejection error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_UNSCHEDULE_ERROR",
+				message: "Failed to record scheduled publication rejection",
+			},
+		};
+	}
+}
+
 /**
  * Publish content immediately.
  *
  * Publication is one atomic content-row statement. On databases that support
- * transactions, the existing slug-redirect side write remains grouped with it.
+ * transactions, the slug redirect and the locale sync stay grouped with it.
  */
 export async function handleContentPublish(
 	db: Kysely<Database>,
@@ -1604,6 +1789,7 @@ export async function handleContentPublish(
 		requireScheduledDue?: boolean;
 		expectedScheduledAt?: string;
 		_rev?: string;
+		currentTime?: Date;
 	} = {},
 ): Promise<ApiResult<ContentResponse>> {
 	try {
@@ -1629,8 +1815,24 @@ export async function handleContentPublish(
 				publishConfig.supportsRevisions,
 				publishConfig.routable,
 				expectedRevision,
+				options.currentTime,
 			);
 
+			if (
+				existing &&
+				isI18nEnabled() &&
+				publishConfig.supportsRevisions &&
+				published.translationGroup
+			) {
+				await repo.syncNonTranslatableFields(
+					collection,
+					published.id,
+					published.translationGroup,
+					published.data,
+					{ previous: existing.data },
+				);
+			}
+
 			// Leave a 301 behind when publishing changed the slug of an entry that
 			// was already published — its old URL was live and may be indexed or
 			// linked. A first publish is excluded: a draft's URL was never public.
@@ -1640,7 +1842,15 @@ export async function handleContentPublish(
 				published.slug &&
 				existing.slug !== published.slug
 			) {
-				await createSlugChangeRedirect(trx, collection, existing.slug, published.slug, resolvedId);
+				await createSlugChangeRedirect(
+					trx,
+					collection,
+					existing.slug,
+					published.slug,
+					resolvedId,
+					existing.publishedAt ?? null,
+					published.publishedAt ?? null,
+				);
 			}
 
 			return published;
@@ -1986,75 +2196,6 @@ export async function handleContentTranslations(
 	}
 }
 
-// ---------------------------------------------------------------------------
-// Non-translatable field sync
-// ---------------------------------------------------------------------------
-
-/**
- * Sync non-translatable fields to sibling locales.
- *
- * When a content item is updated and it belongs to a translation group,
- * any non-translatable fields in the update data are written to all other
- * rows in the same translation group within the same transaction.
- *
- * Non-translatable fields are **copied, not linked** — each row owns its
- * own data. This keeps queries simple and avoids cross-row joins.
- */
-async function syncNonTranslatableFields(
-	trx: Kysely<Database>,
-	collectionSlug: string,
-	updatedItemId: string,
-	translationGroup: string,
-	data: Record<string, unknown>,
-): Promise<void> {
-	// Get the collection to find its fields
-	const collection = await trx
-		.selectFrom("_emdash_collections")
-		.select("id")
-		.where("slug", "=", collectionSlug)
-		.executeTakeFirst();
-
-	if (!collection) return;
-
-	// Find non-translatable fields that are present in the update data
-	const fields = await trx
-		.selectFrom("_emdash_fields")
-		.select("slug")
-		.where("collection_id", "=", collection.id)
-		.where("translatable", "=", 0)
-		.execute();
-
-	const nonTranslatableSlugs = fields.map((f) => f.slug);
-	if (nonTranslatableSlugs.length === 0) return;
-
-	// Filter to only the non-translatable fields present in this update
-	const syncData: Record<string, unknown> = {};
-	for (const slug of nonTranslatableSlugs) {
-		if (slug in data) {
-			syncData[slug] = data[slug];
-		}
-	}
-	if (Object.keys(syncData).length === 0) return;
-
-	// Build the SET clause for sibling rows
-	validateIdentifier(collectionSlug, "collection slug");
-	const tableName = `ec_${collectionSlug}`;
-
-	// Update all sibling rows (same translation_group, different id)
-	const setClauses = Object.entries(syncData).map(([key, value]) => {
-		validateIdentifier(key, "field slug");
-		const serialized = typeof value === "object" && value !== null ? JSON.stringify(value) : value;
-		return sql`${sql.ref(key)} = ${serialized}`;
-	});
-
-	await sql`
-		UPDATE ${sql.ref(tableName)}
-		SET ${sql.join(setClauses, sql`, `)}
-		WHERE translation_group = ${translationGroup}
-		AND id != ${updatedItemId}
-	`.execute(trx);
-}
-
 /**
  * Resolve a `{ taxonomyName: [slug, ...] }` map to term IDs and replace the
  * entry's assignments for each named taxonomy.

package/src/api/handlers/dashboard.ts

@@ -10,9 +10,16 @@ import { sql, type Kysely } from "kysely";
 
 import { ContentRepository } from "../../database/repositories/content.js";
 import { MediaRepository } from "../../database/repositories/media.js";
+import { OptionsRepository } from "../../database/repositories/options.js";
 import { UserRepository } from "../../database/repositories/user.js";
 import type { Database } from "../../database/types.js";
 import { validateIdentifier } from "../../database/validate.js";
+import {
+	SCHEDULED_POLICY_REJECTION_PREFIX,
+	isScheduledPolicyRejection,
+	type ScheduledPolicyRejection,
+	type VersionedScheduledPolicyRejection,
+} from "../../plugins/content-policy.js";
 import { getSchedulerHealth, type SchedulerHealth } from "../../scheduler-health.js";
 import type { ApiResult } from "../types.js";
 
@@ -43,8 +50,12 @@ export interface DashboardStats {
 	userCount: number;
 	recentItems: RecentItem[];
 	schedulerHealth: SchedulerHealth;
+	policyRejectedScheduled: number;
+	policyRejections: VersionedScheduledPolicyRejection[];
 }
 
+const POLICY_REJECTION_PREVIEW_LIMIT = 20;
+
 /**
  * Fetch dashboard statistics.
  *
@@ -83,11 +94,28 @@ export async function handleDashboardStats(
 		// Media and user counts
 		const mediaRepo = new MediaRepository(db);
 		const userRepo = new UserRepository(db);
-		const [mediaCount, userCount, schedulerHealth] = await Promise.all([
+		const optionsRepo = new OptionsRepository(db);
+		const [
+			mediaCount,
+			userCount,
+			schedulerHealth,
+			policyRejectedScheduled,
+			versionedPolicyRejectionOptions,
+		] = await Promise.all([
 			mediaRepo.count(),
 			userRepo.count(),
 			getSchedulerHealth(db, now),
+			optionsRepo.countByPrefix(SCHEDULED_POLICY_REJECTION_PREFIX),
+			optionsRepo.getVersionedByPrefix<ScheduledPolicyRejection>(
+				SCHEDULED_POLICY_REJECTION_PREFIX,
+				{
+					limit: POLICY_REJECTION_PREVIEW_LIMIT,
+				},
+			),
 		]);
+		const policyRejections = [...versionedPolicyRejectionOptions.values()]
+			.filter(({ value }) => isScheduledPolicyRejection(value))
+			.map(({ value, revision }) => ({ ...value, _rev: revision }));
 
 		// Recent items across all collections (last 10 updated, any status)
 		const recentItems = await fetchRecentItems(db, collections);
@@ -100,6 +128,8 @@ export async function handleDashboardStats(
 				userCount,
 				recentItems,
 				schedulerHealth,
+				policyRejectedScheduled,
+				policyRejections,
 			},
 		};
 	} catch (error) {