emdash 0.35.0 → 0.37.0

package/src/database/migrations/runner.ts

@@ -73,6 +73,10 @@ import * as m067 from "./067_indexed_content_fields.js";
 import * as m068 from "./068_content_taxonomy_entry_groups.js";
 import * as m069 from "./069_collection_title_date_fields.js";
 import * as m070 from "./070_collection_routable.js";
+import * as m071 from "./071_restore_content_bylines_table.js";
+import * as m072 from "./072_media_folders.js";
+import * as m073 from "./073_media_focal_point.js";
+import * as m074 from "./074_content_deleted_scheduled_index.js";
 
 const MIGRATIONS: Readonly<Record<string, Migration>> = Object.freeze({
 	"001_initial": m001,
@@ -144,6 +148,10 @@ const MIGRATIONS: Readonly<Record<string, Migration>> = Object.freeze({
 	"068_content_taxonomy_entry_groups": m068,
 	"069_collection_title_date_fields": m069,
 	"070_collection_routable": m070,
+	"071_restore_content_bylines_table": m071,
+	"072_media_folders": m072,
+	"073_media_focal_point": m073,
+	"074_content_deleted_scheduled_index": m074,
 });
 
 /** Ordered names from the statically registered migration set. */
@@ -205,7 +213,7 @@ export interface MigrationOptions {
 	raceWaitMs?: number;
 }
 
-function createMigrator(db: Kysely<Database>, options?: MigrationOptions): Migrator {
+export function createMigrator(db: Kysely<Database>, options?: MigrationOptions): Migrator {
 	return new Migrator({
 		db,
 		provider: new StaticMigrationProvider(),
@@ -258,7 +266,7 @@ function escapeRegExp(value: string): string {
  *
  * We match on the table name (not the full error text) because different
  * SQLite drivers phrase the message differently
- * (`UNIQUE constraint failed: _emdash_migrations.name` for better-sqlite3,
+ * (`UNIQUE constraint failed: _emdash_migrations.name` for file-backed SQLite,
  * `D1_ERROR: UNIQUE constraint failed: _emdash_migrations.name: SQLITE_CONSTRAINT`
  * for D1, etc.). The pattern is built from `MIGRATION_TABLE` so a rename
  * cannot silently disable race detection.
@@ -282,7 +290,7 @@ const MIGRATION_RACE_POLL_MS = 100;
  * Pattern used to detect "table does not exist" errors across the dialects
  * EmDash supports. The phrasing differs by driver:
  *
- *   - better-sqlite3: `no such table: _emdash_migrations`
+ *   - SQLite:         `no such table: _emdash_migrations`
  *   - D1:             `D1_ERROR: no such table: _emdash_migrations: SQLITE_ERROR`
  *   - PostgreSQL:     `relation "_emdash_migrations" does not exist`
  *                     (also occasionally `table "_emdash_migrations" does not exist`)

package/src/database/repositories/byline.ts

@@ -30,9 +30,9 @@ type BylineRow = Selectable<BylineTable>;
 
 /**
  * A byline row optionally augmented with the avatar's media columns, folded in
- * by the `LEFT JOIN media` in the content-credit hydration queries. The plain
- * `selectAll()` finders produce rows without these keys, so they're optional
- * and `rowToByline` defaults them to null.
+ * by the `LEFT JOIN media` in the credit-hydration and single-row finder
+ * queries. `findMany` selects without the join, so the keys are optional and
+ * `rowToByline` defaults them to null.
  */
 type BylineRowWithAvatar = BylineRow & {
 	avatar_storage_key?: string | null;
@@ -298,7 +298,7 @@ export class BylineRepository {
 	 * same way `BylineRepository` doesn't resolve locale fallback for
 	 * the base byline lookup.
 	 */
-	private async withCustomFields(rows: BylineRow[]): Promise<BylineSummary[]> {
+	private async withCustomFields(rows: BylineRowWithAvatar[]): Promise<BylineSummary[]> {
 		const summaries = rows.map(rowToByline);
 		// Always populate `customFields = {}` (PR plan AC #6) — even when
 		// no fields are registered, every BylineSummary carries the empty
@@ -311,7 +311,9 @@ export class BylineRepository {
 		return summaries;
 	}
 
-	private async withCustomFieldsOne(row: BylineRow | undefined): Promise<BylineSummary | null> {
+	private async withCustomFieldsOne(
+		row: BylineRowWithAvatar | undefined,
+	): Promise<BylineSummary | null> {
 		if (!row) return null;
 		const [result] = await this.withCustomFields([row]);
 		return result ?? null;
@@ -501,12 +503,26 @@ export class BylineRepository {
 	// Reads
 	// ============================================
 
+	/**
+	 * Every byline column plus the avatar's media columns, folded in by the
+	 * same `LEFT JOIN media` the credit-hydration queries use. Only the
+	 * single-row finders select this; `findMany` stays a single-table scan.
+	 */
+	private selectBylineWithAvatar() {
+		return this.db
+			.selectFrom("_emdash_bylines as b")
+			.leftJoin("media as m", "m.id", "b.avatar_media_id")
+			.selectAll("b")
+			.select([
+				"m.storage_key as avatar_storage_key",
+				"m.alt as avatar_alt",
+				"m.blurhash as avatar_blurhash",
+				"m.dominant_color as avatar_dominant_color",
+			]);
+	}
+
 	async findById(id: string): Promise<BylineSummary | null> {
-		const row = await this.db
-			.selectFrom("_emdash_bylines")
-			.selectAll()
-			.where("id", "=", id)
-			.executeTakeFirst();
+		const row = await this.selectBylineWithAvatar().where("b.id", "=", id).executeTakeFirst();
 		return this.withCustomFieldsOne(row);
 	}
 
@@ -516,9 +532,9 @@ export class BylineRepository {
 	 * calls). Mirrors `TaxonomyRepository.findBySlug`.
 	 */
 	async findBySlug(slug: string, options?: { locale?: string }): Promise<BylineSummary | null> {
-		let query = this.db.selectFrom("_emdash_bylines").selectAll().where("slug", "=", slug);
-		if (options?.locale !== undefined) query = query.where("locale", "=", options.locale);
-		const row = await query.orderBy("locale", "asc").executeTakeFirst();
+		let query = this.selectBylineWithAvatar().where("b.slug", "=", slug);
+		if (options?.locale !== undefined) query = query.where("b.locale", "=", options.locale);
+		const row = await query.orderBy("b.locale", "asc").executeTakeFirst();
 		return this.withCustomFieldsOne(row);
 	}
 
@@ -529,9 +545,9 @@ export class BylineRepository {
 	 * the lowest-locale-code match.
 	 */
 	async findByUserId(userId: string, options?: { locale?: string }): Promise<BylineSummary | null> {
-		let query = this.db.selectFrom("_emdash_bylines").selectAll().where("user_id", "=", userId);
-		if (options?.locale !== undefined) query = query.where("locale", "=", options.locale);
-		const row = await query.orderBy("locale", "asc").executeTakeFirst();
+		let query = this.selectBylineWithAvatar().where("b.user_id", "=", userId);
+		if (options?.locale !== undefined) query = query.where("b.locale", "=", options.locale);
+		const row = await query.orderBy("b.locale", "asc").executeTakeFirst();
 		return this.withCustomFieldsOne(row);
 	}
 

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" }
@@ -125,10 +135,13 @@ function matchesPublicationFence(observed: ContentItem, existing: ContentItem):
 	);
 }
 
-function isConfirmedStatementFailure(error: unknown): boolean {
+export function isConfirmedStatementFailure(error: unknown): boolean {
 	if (typeof error !== "object" || error === null || !("code" in error)) return false;
 	const code = (error as { code?: unknown }).code;
-	return typeof code === "string" && (code.startsWith("SQLITE_") || SQLSTATE_PATTERN.test(code));
+	return (
+		typeof code === "string" &&
+		(code === "ERR_SQLITE_ERROR" || code.startsWith("SQLITE_") || SQLSTATE_PATTERN.test(code))
+	);
 }
 
 interface ResolvedOrderField {
@@ -834,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
 	 */
@@ -858,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) {
@@ -1017,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) {
@@ -1126,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);
@@ -1143,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);
@@ -1199,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);
 	}
@@ -1383,8 +1414,6 @@ export class ContentRepository {
 		if (bylineIds.length === 0) {
 			// A filter that resolved to no ids must match nothing rather than
 			// silently degrade to "no filter" and return the whole collection.
-			// `1 = 0` rather than a bound `false`: better-sqlite3 refuses to
-			// bind JS booleans.
 			return query.where(() => sql<boolean>`1 = 0`);
 		}
 
@@ -1526,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
@@ -1776,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();
@@ -1784,6 +1815,7 @@ export class ContentRepository {
 		if (!existing) {
 			throw new EmDashValidationError("Content item not found");
 		}
+		assertRevisionPrecondition(existing, expectedRevision);
 		if (
 			requireDue &&
 			expectedScheduledAt !== undefined &&
@@ -1828,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)}
@@ -1953,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)}
@@ -2027,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();
 
@@ -2038,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;
 	}
 
 	/**
@@ -2142,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
@@ -2158,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-folders.ts

@@ -0,0 +1,115 @@
+import { sql, type Kysely } from "kysely";
+import { ulid } from "ulidx";
+
+import type { Database } from "../types.js";
+import { decodeCursor, EmDashValidationError, encodeCursor, type FindManyResult } from "./types.js";
+
+export interface MediaFolder {
+	id: string;
+	name: string;
+}
+
+export interface FindManyMediaFoldersOptions {
+	limit?: number;
+	cursor?: string;
+	q?: string;
+}
+
+function escapeLike(value: string): string {
+	return value.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_");
+}
+
+function normalizeFolderSearch(value: string): string {
+	return value.trim().normalize("NFKC").toLowerCase();
+}
+
+function normalizeFolderName(name: string): { name: string; nameKey: string } {
+	if (typeof name !== "string") {
+		throw new EmDashValidationError("Folder name must be a string");
+	}
+	const trimmed = name.trim();
+	if (trimmed.length < 1 || trimmed.length > 200) {
+		throw new EmDashValidationError("Folder name must be between 1 and 200 characters");
+	}
+	return { name: trimmed, nameKey: trimmed.normalize("NFKC").toLowerCase() };
+}
+
+export class MediaFolderRepository {
+	constructor(private db: Kysely<Database>) {}
+
+	async findMany(options: FindManyMediaFoldersOptions = {}): Promise<FindManyResult<MediaFolder>> {
+		const limit = Math.max(1, Math.min(options.limit ?? 50, 100));
+		let query = this.db
+			.selectFrom("media_folders")
+			.select(["id", "name", "name_key"])
+			.orderBy("name_key", "asc")
+			.orderBy("id", "asc")
+			.limit(limit + 1);
+
+		const term = normalizeFolderSearch(options.q ?? "");
+		if (term) {
+			const pattern = `%${escapeLike(term)}%`;
+			query = query.where("name_key", "like", sql<string>`${pattern} escape '\\'`);
+		}
+
+		if (options.cursor !== undefined) {
+			const { orderValue: nameKey, id } = decodeCursor(options.cursor);
+			query = query.where((eb) =>
+				eb.or([
+					eb("name_key", ">", nameKey),
+					eb.and([eb("name_key", "=", nameKey), eb("id", ">", id)]),
+				]),
+			);
+		}
+
+		const rows = await query.execute();
+		const hasMore = rows.length > limit;
+		const visible = rows.slice(0, limit);
+		return {
+			items: visible.map(({ id, name }) => ({ id, name })),
+			nextCursor:
+				hasMore && visible.length > 0
+					? encodeCursor(visible.at(-1)!.name_key, visible.at(-1)!.id)
+					: undefined,
+		};
+	}
+
+	async findById(id: string): Promise<MediaFolder | null> {
+		const row = await this.db
+			.selectFrom("media_folders")
+			.select(["id", "name"])
+			.where("id", "=", id)
+			.executeTakeFirst();
+		return row ?? null;
+	}
+
+	async create(inputName: string): Promise<MediaFolder> {
+		const { name, nameKey } = normalizeFolderName(inputName);
+		const row = await this.db
+			.insertInto("media_folders")
+			.values({ id: ulid(), name, name_key: nameKey })
+			.returning(["id", "name"])
+			.executeTakeFirstOrThrow();
+		return row;
+	}
+
+	async update(id: string, inputName: string): Promise<MediaFolder | null> {
+		const { name, nameKey } = normalizeFolderName(inputName);
+		const row = await this.db
+			.updateTable("media_folders")
+			.set({ name, name_key: nameKey })
+			.where("id", "=", id)
+			.returning(["id", "name"])
+			.executeTakeFirst();
+		return row ?? null;
+	}
+
+	async delete(id: string): Promise<boolean> {
+		const row = await this.db
+			.deleteFrom("media_folders")
+			.where("id", "=", id)
+			.returning("id")
+			.executeTakeFirst();
+		return row !== undefined;
+	}
+}