emdash 0.36.0 → 0.37.0

package/src/database/repositories/content.ts

@@ -42,6 +42,16 @@ const MAX_IN_FILTER_VALUES = SQL_BATCH_SIZE;
 const MAX_FILTER_STRING_LENGTH = 2048;
 
 type NormalizedFilterScalar = string | number;
+export type ContentRevisionPrecondition = Pick<ContentItem, "version" | "updatedAt">;
+
+function assertRevisionPrecondition(
+	item: ContentItem,
+	expected: ContentRevisionPrecondition | undefined,
+): void {
+	if (expected && (item.version !== expected.version || item.updatedAt !== expected.updatedAt)) {
+		throw new ContentMutationConflictError();
+	}
+}
 
 type ResolvedFieldFilter =
 	| { column: string; kind: "null" }
@@ -837,6 +847,15 @@ export class ContentRepository {
 		return mappedResult;
 	}
 
+	private normalizeScheduledAt(value: string | null): string | null {
+		if (value === null) return null;
+		const scheduledDate = new Date(value);
+		if (isNaN(scheduledDate.getTime())) {
+			throw new EmDashValidationError("Invalid scheduled date");
+		}
+		return scheduledDate.toISOString();
+	}
+
 	/**
 	 * Update content
 	 */
@@ -861,7 +880,7 @@ export class ContentRepository {
 		}
 
 		if (input.scheduledAt !== undefined) {
-			updates.scheduled_at = input.scheduledAt;
+			updates.scheduled_at = this.normalizeScheduledAt(input.scheduledAt);
 		}
 
 		if (input.authorId !== undefined) {
@@ -1020,7 +1039,7 @@ export class ContentRepository {
 			liveMetadataChanged = true;
 		}
 		if (input.scheduledAt !== undefined) {
-			assignments.push(sql`scheduled_at = ${input.scheduledAt}`);
+			assignments.push(sql`scheduled_at = ${this.normalizeScheduledAt(input.scheduledAt)}`);
 			liveMetadataChanged = true;
 		}
 		if (input.authorId !== undefined) {
@@ -1129,7 +1148,7 @@ export class ContentRepository {
 	 */
 	async findTrashed(
 		type: string,
-		options: Omit<FindManyOptions, "where"> = {},
+		options: Omit<FindManyOptions, "where"> & { where?: { locale?: string } } = {},
 	): Promise<FindManyResult<ContentItem & { deletedAt: string }>> {
 		const tableName = getTableName(type);
 		const limit = Math.min(options.limit || 50, 100);
@@ -1146,6 +1165,10 @@ export class ContentRepository {
 			.selectAll()
 			.where("deleted_at" as never, "is not", null);
 
+		if (options.where?.locale) {
+			query = query.where("locale" as any, "=", options.where.locale);
+		}
+
 		// Handle cursor pagination — decodeCursor throws on invalid input.
 		if (options.cursor) {
 			const { orderValue, id: cursorId } = decodeCursor(options.cursor);
@@ -1202,14 +1225,19 @@ export class ContentRepository {
 	/**
 	 * Count trashed content items
 	 */
-	async countTrashed(type: string): Promise<number> {
+	async countTrashed(type: string, options: { locale?: string } = {}): Promise<number> {
 		const tableName = getTableName(type);
 
-		const result = await this.db
+		let query = this.db
 			.selectFrom(tableName as keyof Database)
 			.select((eb) => eb.fn.count("id").as("count"))
-			.where("deleted_at" as never, "is not", null)
-			.executeTakeFirst();
+			.where("deleted_at" as never, "is not", null);
+
+		if (options.locale) {
+			query = query.where("locale" as any, "=", options.locale);
+		}
+
+		const result = await query.executeTakeFirst();
 
 		return Number(result?.count || 0);
 	}
@@ -1527,10 +1555,11 @@ export class ContentRepository {
 		// transition to 'scheduled' so they aren't visible before the time.
 		const newStatus = existing.status === "published" ? "published" : "scheduled";
 
+		// The due query compares ISO strings, so every stored schedule uses the same UTC form.
 		await sql`
 			UPDATE ${sql.ref(tableName)}
 			SET status = ${newStatus},
-				scheduled_at = ${scheduledAt},
+				scheduled_at = ${scheduledDate.toISOString()},
 				updated_at = ${now}
 			WHERE id = ${id}
 			AND deleted_at IS NULL
@@ -1777,6 +1806,7 @@ export class ContentRepository {
 		expectedScheduledAt?: string,
 		promoteRevision = true,
 		requireSlug = true,
+		expectedRevision?: ContentRevisionPrecondition,
 	): Promise<ContentItem> {
 		const tableName = getTableName(type);
 		const now = new Date().toISOString();
@@ -1785,6 +1815,7 @@ export class ContentRepository {
 		if (!existing) {
 			throw new EmDashValidationError("Content item not found");
 		}
+		assertRevisionPrecondition(existing, expectedRevision);
 		if (
 			requireDue &&
 			expectedScheduledAt !== undefined &&
@@ -1829,6 +1860,7 @@ export class ContentRepository {
 						WHERE id = ${id}
 						AND deleted_at IS NULL
 						AND version = ${existing.version}
+						AND updated_at = ${existing.updatedAt}
 						AND status = ${existing.status}
 						AND ${nullableColumnMatch("live_revision_id", existing.liveRevisionId)}
 						AND ${nullableColumnMatch("draft_revision_id", existing.draftRevisionId)}
@@ -1954,6 +1986,7 @@ export class ContentRepository {
 					WHERE id = ${id}
 					AND deleted_at IS NULL
 					AND version = ${existing.version}
+					AND updated_at = ${existing.updatedAt}
 					AND status = ${existing.status}
 					AND ${nullableColumnMatch("live_revision_id", existing.liveRevisionId)}
 					AND ${nullableColumnMatch("draft_revision_id", existing.draftRevisionId)}
@@ -2028,10 +2061,14 @@ export class ContentRepository {
 	/**
 	 * Unpublish content
 	 *
-	 * Removes live pointer but preserves draft. If no draft exists,
-	 * creates one from the live version so the content isn't lost.
+	 * Removes live pointer but preserves the draft and publication date. If no
+	 * draft exists, creates one from the live version so the content isn't lost.
 	 */
-	async unpublish(type: string, id: string): Promise<ContentItem> {
+	async unpublish(
+		type: string,
+		id: string,
+		expectedRevision?: ContentRevisionPrecondition,
+	): Promise<ContentItem> {
 		const tableName = getTableName(type);
 		const now = new Date().toISOString();
 
@@ -2039,44 +2076,61 @@ export class ContentRepository {
 		if (!existing) {
 			throw new EmDashValidationError("Content item not found");
 		}
+		assertRevisionPrecondition(existing, expectedRevision);
+		if (existing.status === "draft" && !existing.liveRevisionId) return existing;
 
-		// If no draft exists, create one from the live version
-		if (!existing.draftRevisionId && existing.liveRevisionId) {
-			const revisionRepo = new RevisionRepository(this.db);
-			const liveRevision = await revisionRepo.findById(existing.liveRevisionId);
-			if (liveRevision) {
-				const draft = await revisionRepo.create({
-					collection: type,
-					entryId: id,
-					data: liveRevision.data,
-				});
-
-				await sql`
-					UPDATE ${sql.ref(tableName)}
-					SET draft_revision_id = ${draft.id}
-					WHERE id = ${id}
-				`.execute(this.db);
+		const revisionRepo = new RevisionRepository(this.db);
+		let provisionalRevisionId: string | null = null;
+		try {
+			let draftRevisionId = existing.draftRevisionId;
+			if (!draftRevisionId && existing.liveRevisionId) {
+				const liveRevision = await revisionRepo.findById(existing.liveRevisionId);
+				if (liveRevision) {
+					const draft = await revisionRepo.create({
+						collection: type,
+						entryId: id,
+						data: liveRevision.data,
+					});
+					draftRevisionId = draft.id;
+					provisionalRevisionId = draft.id;
+				}
 			}
-		}
 
-		await sql`
-			UPDATE ${sql.ref(tableName)}
-			SET live_revision_id = NULL,
-				status = 'draft',
-				published_at = NULL,
-				updated_at = ${now}
-			WHERE id = ${id}
-			AND deleted_at IS NULL
-		`.execute(this.db);
+			const result = await sql`
+				UPDATE ${sql.ref(tableName)}
+				SET live_revision_id = NULL,
+					draft_revision_id = ${draftRevisionId},
+					status = 'draft',
+					updated_at = ${now},
+					version = version + 1
+				WHERE id = ${id}
+				AND deleted_at IS NULL
+				AND version = ${existing.version}
+				AND updated_at = ${existing.updatedAt}
+				AND status = ${existing.status}
+				AND ${nullableColumnMatch("live_revision_id", existing.liveRevisionId)}
+				AND ${nullableColumnMatch("draft_revision_id", existing.draftRevisionId)}
+				AND ${nullableColumnMatch("scheduled_at", existing.scheduledAt)}
+			`.execute(this.db);
+			if ((result.numAffectedRows ?? 0n) === 0n) throw new ContentMutationConflictError();
 
-		invalidateCollectionCache(type);
-
-		const updated = await this.findById(type, id);
-		if (!updated) {
-			throw new Error("Content not found");
+			invalidateCollectionCache(type);
+			const updated = await this.findById(type, id);
+			if (!updated) throw new Error("Content not found");
+			return updated;
+		} catch (error) {
+			if (provisionalRevisionId) {
+				try {
+					await revisionRepo.deleteIfUnreferenced(type, id, provisionalRevisionId);
+				} catch (cleanupError) {
+					console.error(
+						`[content] Failed to clean up provisional revision ${provisionalRevisionId}:`,
+						cleanupError,
+					);
+				}
+			}
+			throw error;
 		}
-
-		return updated;
 	}
 
 	/**
@@ -2143,13 +2197,18 @@ export class ContentRepository {
 	 * Clears draft_revision_id. The content table columns already hold the
 	 * published version, so no data sync is needed.
 	 */
-	async discardDraft(type: string, id: string): Promise<ContentItem> {
+	async discardDraft(
+		type: string,
+		id: string,
+		expectedRevision?: ContentRevisionPrecondition,
+	): Promise<ContentItem> {
 		const tableName = getTableName(type);
 
 		const existing = await this.findById(type, id);
 		if (!existing) {
 			throw new EmDashValidationError("Content item not found");
 		}
+		assertRevisionPrecondition(existing, expectedRevision);
 
 		if (!existing.draftRevisionId) {
 			// No draft to discard
@@ -2159,12 +2218,20 @@ export class ContentRepository {
 		// Discarding a draft restores the state from before the draft was
 		// staged — nothing about the live entry changed in between, so
 		// updated_at stays at its pre-draft value (#2143).
-		await sql`
+		const result = await sql`
 			UPDATE ${sql.ref(tableName)}
-			SET draft_revision_id = NULL
+			SET draft_revision_id = NULL,
+				version = version + 1
 			WHERE id = ${id}
 			AND deleted_at IS NULL
+			AND version = ${existing.version}
+			AND updated_at = ${existing.updatedAt}
+			AND status = ${existing.status}
+			AND ${nullableColumnMatch("live_revision_id", existing.liveRevisionId)}
+			AND ${nullableColumnMatch("draft_revision_id", existing.draftRevisionId)}
+			AND ${nullableColumnMatch("scheduled_at", existing.scheduledAt)}
 		`.execute(this.db);
+		if ((result.numAffectedRows ?? 0n) === 0n) throw new ContentMutationConflictError();
 
 		const updated = await this.findById(type, id);
 		if (!updated) {

package/src/database/repositories/media-usage.ts

@@ -1801,12 +1801,21 @@ export class MediaUsageRepository {
 		};
 	}
 
+	/**
+	 * Scans for reclaimable occurrences, or resolves to `null` when the sweep was
+	 * never issued because the lease is gone or the tick is out of budget. An
+	 * empty array means the scan ran and found nothing, which lets the caller
+	 * retire the sweep window; `null` must leave the cursor where it was.
+	 */
 	async findMediaUsageCleanupCandidates(input: {
 		cutoff: string;
 		cursor: MediaUsageCleanupCursor | null;
 		limit: number;
 		cleanupLease?: MediaUsageCleanupLease;
-	}): Promise<MediaUsageCleanupCandidate[]> {
+		canIssueStatement?: () => boolean;
+	}): Promise<MediaUsageCleanupCandidate[] | null> {
+		if (!(await this.admitCleanupScan(input.cleanupLease, input.canIssueStatement))) return null;
+
 		let query = this.db
 			.selectFrom("_emdash_media_usage as u")
 			.leftJoin("_emdash_media_usage_sources as s", "s.source_key", "u.source_key")
@@ -1828,19 +1837,11 @@ export class MediaUsageRepository {
 			.orderBy("u.created_at", "asc")
 			.orderBy("u.id", "asc")
 			.limit(Math.max(0, Math.floor(input.limit)));
-		if (input.cleanupLease) {
-			query = query.where(this.activeCleanupLeaseExpression(input.cleanupLease));
-		}
 
 		if (input.cursor) {
+			const cursor = input.cursor;
 			query = query.where((eb) =>
-				eb.or([
-					eb("u.created_at", ">", input.cursor!.createdAt),
-					eb.and([
-						eb("u.created_at", "=", input.cursor!.createdAt),
-						eb("u.id", ">", input.cursor!.id),
-					]),
-				]),
+				eb(eb.refTuple("u.created_at", "u.id"), ">", eb.tuple(cursor.createdAt, cursor.id)),
 			);
 		}
 
@@ -1928,9 +1929,9 @@ export class MediaUsageRepository {
 				options.canIssueStatement,
 			);
 		}
-		if (!canIssueCleanupStatement(options.canIssueStatement)) return 0;
+		if (!(await this.admitCleanupScan(options.cleanupLease, options.canIssueStatement))) return 0;
 
-		let query = this.db
+		const rows = await this.db
 			.selectFrom("_emdash_media_usage as u")
 			.leftJoin("_emdash_media_usage_sources as s", (join) =>
 				join.onRef("s.source_key", "=", "u.source_key"),
@@ -1946,11 +1947,8 @@ export class MediaUsageRepository {
 			.where(this.noActiveGenerationWriteExpression("u"))
 			.orderBy("u.created_at", "asc")
 			.orderBy("u.id", "asc")
-			.limit(batchLimit);
-		if (options.cleanupLease) {
-			query = query.where(this.activeCleanupLeaseExpression(options.cleanupLease));
-		}
-		const rows = await query.execute();
+			.limit(batchLimit)
+			.execute();
 
 		return this.deleteOrphanCandidateIds(
 			rows.map((row) => row.id),
@@ -1975,9 +1973,9 @@ export class MediaUsageRepository {
 				options.canIssueStatement,
 			);
 		}
-		if (!canIssueCleanupStatement(options.canIssueStatement)) return 0;
+		if (!(await this.admitCleanupScan(options.cleanupLease, options.canIssueStatement))) return 0;
 
-		let query = this.db
+		const rows = await this.db
 			.selectFrom("_emdash_media_usage as u")
 			.innerJoin("_emdash_media_usage_sources as s", (join) =>
 				join.onRef("s.source_key", "=", "u.source_key"),
@@ -1994,11 +1992,8 @@ export class MediaUsageRepository {
 			.where(this.noActiveGenerationWriteExpression("u"))
 			.orderBy("u.created_at", "asc")
 			.orderBy("u.id", "asc")
-			.limit(batchLimit);
-		if (options.cleanupLease) {
-			query = query.where(this.activeCleanupLeaseExpression(options.cleanupLease));
-		}
-		const rows = await query.execute();
+			.limit(batchLimit)
+			.execute();
 
 		return this.deleteStaleCandidateIds(
 			rows.map((row) => row.id),
@@ -2023,9 +2018,9 @@ export class MediaUsageRepository {
 				options.canIssueStatement,
 			);
 		}
-		if (!canIssueCleanupStatement(options.canIssueStatement)) return 0;
+		if (!(await this.admitCleanupScan(options.cleanupLease, options.canIssueStatement))) return 0;
 
-		let query = this.db
+		const rows = await this.db
 			.selectFrom("_emdash_media_usage as u")
 			.innerJoin("_emdash_media_usage_sources as s", (join) =>
 				join.onRef("s.source_key", "=", "u.source_key"),
@@ -2042,11 +2037,8 @@ export class MediaUsageRepository {
 			.where(this.noActiveGenerationWriteExpression("u"))
 			.orderBy("u.created_at", "asc")
 			.orderBy("u.id", "asc")
-			.limit(batchLimit);
-		if (options.cleanupLease) {
-			query = query.where(this.activeCleanupLeaseExpression(options.cleanupLease));
-		}
-		const rows = await query.execute();
+			.limit(batchLimit)
+			.execute();
 
 		return this.deleteAbandonedCandidateIds(
 			rows.map((row) => row.id),
@@ -2062,16 +2054,16 @@ export class MediaUsageRepository {
 		canIssueStatement?: () => boolean,
 	): Promise<number> {
 		const batchLimit = Math.floor(limit);
-		if (batchLimit <= 0 || !canIssueCleanupStatement(canIssueStatement)) return 0;
-		let query = this.db
+		if (batchLimit <= 0) return 0;
+		if (!(await this.admitCleanupScan(cleanupLease, canIssueStatement))) return 0;
+		const rows = await this.db
 			.selectFrom("_emdash_media_usage_generation_writes")
 			.select("lease_token")
 			.where(this.generationWriteLeaseHasExpired("expires_at"))
 			.orderBy("expires_at", "asc")
 			.orderBy("lease_token", "asc")
-			.limit(batchLimit);
-		if (cleanupLease) query = query.where(this.activeCleanupLeaseExpression(cleanupLease));
-		const rows = await query.execute();
+			.limit(batchLimit)
+			.execute();
 		if (rows.length === 0 || !canIssueCleanupStatement(canIssueStatement)) return 0;
 		let deleteQuery = this.db
 			.deleteFrom("_emdash_media_usage_generation_writes")
@@ -2906,6 +2898,43 @@ export class MediaUsageRepository {
 			)`;
 	}
 
+	/**
+	 * Gates a bounded cleanup scan on the lease and the tick's statement budget.
+	 *
+	 * The budget is re-read after the lease row because that read is itself a
+	 * statement: an isolate suspended across it can resume with the budget spent.
+	 */
+	private async admitCleanupScan(
+		cleanupLease: MediaUsageCleanupLease | undefined,
+		canIssueStatement: (() => boolean) | undefined,
+	): Promise<boolean> {
+		if (!canIssueCleanupStatement(canIssueStatement)) return false;
+		if (!cleanupLease) return true;
+		return (
+			(await this.holdsCleanupLease(cleanupLease)) && canIssueCleanupStatement(canIssueStatement)
+		);
+	}
+
+	/**
+	 * Reads the lease row on its own so a lost lease can short-circuit a sweep.
+	 *
+	 * As a row-level `EXISTS` inside a `LIMIT`ed scan this predicate is constant
+	 * across every candidate row: when it is false the limit is unreachable and
+	 * the scan reads the whole `created_at` range before returning nothing.
+	 * Mutating statements still carry {@link activeCleanupLeaseExpression},
+	 * which is what actually fences a displaced owner.
+	 */
+	private async holdsCleanupLease(cleanupLease: MediaUsageCleanupLease): Promise<boolean> {
+		let query = this.db
+			.selectFrom("_emdash_media_usage_cleanup")
+			.select("task_key")
+			.where("task_key", "=", "projection_gc")
+			.where("lease_token", "=", cleanupLease.leaseToken)
+			.where(this.cleanupLeaseExpiryIsInFuture("_emdash_media_usage_cleanup.lease_expires_at"));
+		if (isPostgres(this.db)) query = query.forUpdate();
+		return (await query.executeTakeFirst()) !== undefined;
+	}
+
 	private activeCleanupLeaseExpression(cleanupLease: MediaUsageCleanupLease) {
 		const rowLock = isPostgres(this.db) ? sql` FOR UPDATE` : sql``;
 		return sql<boolean>`EXISTS (

package/src/database/repositories/media.ts

@@ -83,6 +83,7 @@ export interface CreateMediaInput {
 	dominantColor?: string;
 	status?: MediaStatus;
 	authorId?: string;
+	folderId?: string | null;
 }
 
 export interface FindManyMediaOptions {
@@ -105,6 +106,13 @@ export interface UpdateMediaInput extends FocalPointUpdate {
 	folderId?: string | null;
 }
 
+export interface ReplaceReadyMediaInput {
+	size: number;
+	width: number;
+	height: number;
+	contentHash: string;
+}
+
 export interface FindMediaPageOptions extends Omit<FindManyMediaOptions, "cursor"> {
 	page: number;
 }
@@ -148,7 +156,7 @@ export class MediaRepository {
 			status: input.status ?? "ready",
 			created_at: now,
 			author_id: input.authorId ?? null,
-			folder_id: null,
+			folder_id: input.folderId ?? null,
 		};
 
 		await this.db.insertInto("media").values(row).execute();
@@ -166,6 +174,7 @@ export class MediaRepository {
 		storageKey: string;
 		contentHash?: string;
 		authorId?: string;
+		folderId?: string | null;
 	}): Promise<MediaItem> {
 		return this.create({
 			...input,
@@ -375,6 +384,30 @@ export class MediaRepository {
 		return row ? this.rowToItem(row) : null;
 	}
 
+	async findAvailableFilename(filename: string): Promise<string> {
+		const exists = async (candidate: string) =>
+			Boolean(
+				await this.db
+					.selectFrom("media")
+					.select("id")
+					.where(sql<string>`lower(filename)`, "=", candidate.toLowerCase())
+					.executeTakeFirst(),
+			);
+		if (!(await exists(filename))) return filename;
+
+		const extensionIndex = filename.lastIndexOf(".");
+		const hasExtension = extensionIndex > 0;
+		const extension = hasExtension ? filename.slice(extensionIndex) : "";
+		const stem = hasExtension ? filename.slice(0, extensionIndex) : filename;
+		let copyNumber = 2;
+		let candidate = `${stem}-${copyNumber}${extension}`;
+		while (await exists(candidate)) {
+			copyNumber += 1;
+			candidate = `${stem}-${copyNumber}${extension}`;
+		}
+		return candidate;
+	}
+
 	/**
 	 * Find media by content hash
 	 * Used for deduplication - same content = same hash
@@ -480,6 +513,32 @@ export class MediaRepository {
 		return this.findById(id);
 	}
 
+	async replaceReadyFile(
+		id: string,
+		expectedStorageKey: string,
+		input: ReplaceReadyMediaInput,
+	): Promise<MediaItem | null> {
+		const row = await this.db
+			.updateTable("media")
+			.set({
+				size: input.size,
+				width: input.width,
+				height: input.height,
+				content_hash: input.contentHash,
+				blurhash: null,
+				dominant_color: null,
+				focal_x: null,
+				focal_y: null,
+			})
+			.where("id", "=", id)
+			.where("status", "=", "ready")
+			.where("storage_key", "=", expectedStorageKey)
+			.returningAll()
+			.executeTakeFirst();
+
+		return row ? this.rowToItem(row) : null;
+	}
+
 	/**
 	 * Delete media item
 	 */