emdash 0.35.0 → 0.36.0

package/src/database/migrations/071_restore_content_bylines_table.ts

@@ -0,0 +1,43 @@
+import type { Kysely } from "kysely";
+import { sql } from "kysely";
+
+import { isSqlite, tableExists } from "../dialect-helpers.js";
+
+/**
+ * Restore `_emdash_content_bylines` where migration 040's SQLite rebuild
+ * stopped between dropping the old table and renaming the staged copy.
+ *
+ * 040 guards its rebuild on `PRAGMA foreign_key_list`, which returns no rows
+ * for a missing table, so a retry after that partial run skips the rename and
+ * leaves `_emdash_content_bylines_new` behind with the credits inside. The
+ * indexes went with the dropped table.
+ *
+ * The Postgres path of 040 alters the table in place, so this is a no-op there.
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	if (!isSqlite(db)) return;
+
+	if (!(await tableExists(db, "_emdash_content_bylines"))) {
+		if (!(await tableExists(db, "_emdash_content_bylines_new"))) return;
+		await sql`ALTER TABLE _emdash_content_bylines_new RENAME TO _emdash_content_bylines`.execute(
+			db,
+		);
+	}
+
+	await db.schema
+		.createIndex("idx_content_bylines_content")
+		.ifNotExists()
+		.on("_emdash_content_bylines")
+		.columns(["collection_slug", "content_id", "sort_order"])
+		.execute();
+	await db.schema
+		.createIndex("idx_content_bylines_byline")
+		.ifNotExists()
+		.on("_emdash_content_bylines")
+		.column("byline_id")
+		.execute();
+}
+
+export async function down(_db: Kysely<unknown>): Promise<void> {
+	// no-op
+}

package/src/database/migrations/072_media_folders.ts

@@ -0,0 +1,72 @@
+import type { Kysely } from "kysely";
+
+import { columnExists } from "../dialect-helpers.js";
+
+const DUPLICATE_COLUMN_RE = /(?:duplicate column|column .* already exists|already exists.*column)/i;
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+	await db.schema
+		.createTable("media_folders")
+		.ifNotExists()
+		.addColumn("id", "text", (col) => col.primaryKey())
+		.addColumn("name", "text", (col) => col.notNull())
+		.addColumn("name_key", "text", (col) => col.notNull().unique())
+		.execute();
+
+	await addFolderColumnIfMissing(db, () =>
+		db.schema
+			.alterTable("media")
+			.addColumn("folder_id", "text", (col) =>
+				col.references("media_folders.id").onDelete("set null"),
+			)
+			.execute(),
+	);
+
+	await db.schema
+		.createIndex("idx_media_folder_id")
+		.ifNotExists()
+		.on("media")
+		.column("folder_id")
+		.execute();
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await db.schema.dropIndex("idx_media_folder_id").ifExists().execute();
+	if (await columnExists(db, "media", "folder_id")) {
+		await db.schema.alterTable("media").dropColumn("folder_id").execute();
+	}
+	await db.schema.dropTable("media_folders").ifExists().execute();
+}
+
+async function addFolderColumnIfMissing(
+	db: Kysely<unknown>,
+	addColumn: () => Promise<void>,
+): Promise<void> {
+	if (await columnExists(db, "media", "folder_id")) return;
+
+	try {
+		await addColumn();
+	} catch (error) {
+		if (DUPLICATE_COLUMN_RE.test(deepErrorMessage(error))) {
+			if (await columnExists(db, "media", "folder_id")) return;
+		}
+		throw error;
+	}
+}
+
+function deepErrorMessage(error: unknown): string {
+	if (error instanceof Error) {
+		const own = error.message ?? "";
+		if (error.cause) {
+			const causeMessage = deepErrorMessage(error.cause);
+			return own ? `${own}: ${causeMessage}` : causeMessage;
+		}
+		return own;
+	}
+	if (typeof error === "string") return error;
+	try {
+		return JSON.stringify(error);
+	} catch {
+		return String(error);
+	}
+}

package/src/database/migrations/073_media_focal_point.ts

@@ -0,0 +1,57 @@
+import type { Kysely } from "kysely";
+
+import { columnExists } from "../dialect-helpers.js";
+
+const DUPLICATE_COLUMN_RE = /(?:duplicate column|column .* already exists|already exists.*column)/i;
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+	await addFocalColumnIfMissing(db, "focal_x", () =>
+		db.schema.alterTable("media").addColumn("focal_x", "real").execute(),
+	);
+	await addFocalColumnIfMissing(db, "focal_y", () =>
+		db.schema.alterTable("media").addColumn("focal_y", "real").execute(),
+	);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	if (await columnExists(db, "media", "focal_y")) {
+		await db.schema.alterTable("media").dropColumn("focal_y").execute();
+	}
+	if (await columnExists(db, "media", "focal_x")) {
+		await db.schema.alterTable("media").dropColumn("focal_x").execute();
+	}
+}
+
+export async function addFocalColumnIfMissing(
+	db: Kysely<unknown>,
+	column: "focal_x" | "focal_y",
+	addColumn: () => Promise<void>,
+): Promise<void> {
+	if (await columnExists(db, "media", column)) return;
+
+	try {
+		await addColumn();
+	} catch (error) {
+		if (DUPLICATE_COLUMN_RE.test(deepErrorMessage(error))) {
+			if (await columnExists(db, "media", column)) return;
+		}
+		throw error;
+	}
+}
+
+function deepErrorMessage(error: unknown): string {
+	if (error instanceof Error) {
+		const own = error.message ?? "";
+		if (error.cause) {
+			const causeMessage = deepErrorMessage(error.cause);
+			return own ? `${own}: ${causeMessage}` : causeMessage;
+		}
+		return own;
+	}
+	if (typeof error === "string") return error;
+	try {
+		return JSON.stringify(error);
+	} catch {
+		return String(error);
+	}
+}

package/src/database/migrations/runner.ts

@@ -73,6 +73,9 @@ 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";
 
 const MIGRATIONS: Readonly<Record<string, Migration>> = Object.freeze({
 	"001_initial": m001,
@@ -144,6 +147,9 @@ 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,
 });
 
 /** Ordered names from the statically registered migration set. */
@@ -258,7 +264,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 +288,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/content.ts

@@ -125,10 +125,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 {
@@ -1383,8 +1386,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`);
 		}
 

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;
+	}
+}