emdash 0.34.0 → 0.36.0

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/policy.ts

@@ -0,0 +1,70 @@
+import type { Kysely } from "kysely";
+
+import type { Database } from "../types.js";
+import { getExactMigrationStatus, runMigrations } from "./runner.js";
+
+export type RuntimeMigrationMode = "auto" | "check" | "manual";
+
+export interface RuntimeMigrationConfig {
+	runtime: RuntimeMigrationMode;
+	dev?: RuntimeMigrationMode;
+}
+
+function parseMigrationMode(value: unknown, source: string): RuntimeMigrationMode {
+	if (value === "auto" || value === "check" || value === "manual") {
+		return value;
+	}
+	throw new Error(
+		`Invalid ${source} value ${JSON.stringify(value)}; expected "auto", "check", or "manual"`,
+	);
+}
+
+export function normalizeMigrationConfig(value: unknown): RuntimeMigrationConfig {
+	if (value === undefined) return { runtime: "auto" };
+	if (typeof value !== "object" || value === null || Array.isArray(value)) {
+		throw new Error("Invalid migrations configuration; expected an object");
+	}
+
+	const runtimeValue = Reflect.get(value, "runtime");
+	const devValue = Reflect.get(value, "dev");
+	const runtime = parseMigrationMode(runtimeValue, "migrations.runtime");
+	const dev = devValue === undefined ? undefined : parseMigrationMode(devValue, "migrations.dev");
+	return dev === undefined ? { runtime } : { runtime, dev };
+}
+
+export function resolveRuntimeMigrationMode(
+	config: RuntimeMigrationConfig | undefined,
+	options: { dev: boolean; override?: unknown },
+): RuntimeMigrationMode {
+	if (options.override !== undefined) {
+		return parseMigrationMode(options.override, "EMDASH_MIGRATIONS_MODE");
+	}
+	if (options.dev) return config?.dev ?? "auto";
+	return config?.runtime ?? "auto";
+}
+
+export class PendingMigrationsError extends Error {
+	readonly pending: string[];
+
+	constructor(pending: readonly string[]) {
+		super(`Database has pending EmDash migrations: ${pending.join(", ")}`);
+		this.name = "PendingMigrationsError";
+		this.pending = [...pending];
+	}
+}
+
+export async function enforceRuntimeMigrationPolicy(
+	db: Kysely<Database>,
+	mode: RuntimeMigrationMode,
+): Promise<void> {
+	if (mode === "manual") return;
+	if (mode === "auto") {
+		await runMigrations(db);
+		return;
+	}
+
+	const status = await getExactMigrationStatus(db);
+	if (status.pending.length > 0) {
+		throw new PendingMigrationsError(status.pending);
+	}
+}

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,10 +147,16 @@ 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. */
+export const MIGRATION_NAMES: readonly string[] = Object.freeze(Object.keys(MIGRATIONS));
+
 /** Total number of registered migrations. Exported for use in tests. */
-export const MIGRATION_COUNT = Object.keys(MIGRATIONS).length;
+export const MIGRATION_COUNT = MIGRATION_NAMES.length;
 
 /**
  * Migration provider that uses statically imported migrations.
@@ -164,6 +173,12 @@ export interface MigrationStatus {
 	pending: string[];
 }
 
+export interface ExactMigrationStatus {
+	knownApplied: string[];
+	pending: string[];
+	unknownApplied: string[];
+}
+
 /**
  * Thrown when another instance held the migration lock for the whole wait
  * window. This is NOT a migration failure — the holder may simply be slow
@@ -249,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.
@@ -273,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`)
@@ -286,8 +301,8 @@ const MIGRATION_RACE_POLL_MS = 100;
  * built from `MIGRATION_TABLE` so a rename cannot drift.
  */
 const MIGRATION_TABLE_MISSING_PATTERN = new RegExp(
-	`(?:no such table:\\s*${escapeRegExp(MIGRATION_TABLE)}\\b` +
-		`|(?:relation|table)\\s+"?${escapeRegExp(MIGRATION_TABLE)}"?\\s+does(?:n't| not) exist\\b)`,
+	`(?:no such table:\\s*(?:[a-z][a-z0-9_]*\\.)?${escapeRegExp(MIGRATION_TABLE)}\\b` +
+		`|(?:relation|table)\\s+"?(?:[a-z][a-z0-9_]*\\.)?${escapeRegExp(MIGRATION_TABLE)}"?\\s+does(?:n't| not) exist\\b)`,
 	"i",
 );
 
@@ -359,6 +374,43 @@ function deepErrorMessage(error: unknown): string {
 	}
 }
 
+/**
+ * Read exact migration status without invoking Kysely's migration
+ * introspection. Registered names retain execution order; unknown database
+ * records are sorted so reports remain stable across dialects.
+ */
+export async function getExactMigrationStatus(
+	db: Kysely<Database>,
+	options?: MigrationOptions,
+): Promise<ExactMigrationStatus> {
+	const table = options?.migrationTableSchema
+		? sql`${sql.ref(options.migrationTableSchema)}.${sql.ref(MIGRATION_TABLE)}`
+		: sql.ref(MIGRATION_TABLE);
+
+	let rows: readonly { name: string }[];
+	try {
+		const result = await sql<{ name: string }>`SELECT name FROM ${table}`.execute(db);
+		rows = result.rows;
+	} catch (error) {
+		if (MIGRATION_TABLE_MISSING_PATTERN.test(deepErrorMessage(error))) {
+			return {
+				knownApplied: [],
+				pending: [...MIGRATION_NAMES],
+				unknownApplied: [],
+			};
+		}
+		throw error;
+	}
+
+	const appliedNames = new Set(rows.map((row) => row.name));
+	const knownApplied = MIGRATION_NAMES.filter((name) => appliedNames.has(name));
+	const pending = MIGRATION_NAMES.filter((name) => !appliedNames.has(name));
+	const knownNames = new Set(MIGRATION_NAMES);
+	const unknownApplied = [...appliedNames].filter((name) => !knownNames.has(name)).toSorted();
+
+	return { knownApplied, pending, unknownApplied };
+}
+
 /**
  * Run all pending migrations.
  *

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