emdash 1.0.0 → 1.0.1-rc.1

package/src/database/repositories/revision.ts

@@ -1,10 +1,16 @@
-import type { Kysely } from "kysely";
+import { sql, type Kysely, type Selectable } from "kysely";
 import { monotonicFactory } from "ulidx";
 
+import { ContentDatetimeNormalizer, type DatetimeContextCache } from "../content-datetime.js";
 import type { Database, RevisionTable } from "../types.js";
+import { validateIdentifier } from "../validate.js";
 
 const monotonic = monotonicFactory();
 
+export function createRevisionId(): string {
+	return monotonic();
+}
+
 export interface Revision {
 	id: string;
 	collection: string;
@@ -21,6 +27,12 @@ export interface CreateRevisionInput {
 	authorId?: string;
 }
 
+export function normalizeRevisionLimit(value: unknown): number {
+	const numeric = Number(value);
+	if (!Number.isFinite(numeric)) return 50;
+	return Math.max(1, Math.min(Math.trunc(numeric), 100));
+}
+
 /**
  * Revision repository for version history
  *
@@ -28,19 +40,27 @@ export interface CreateRevisionInput {
  * Used when collection has `supports: ["revisions"]` enabled.
  */
 export class RevisionRepository {
-	constructor(private db: Kysely<Database>) {}
+	private readonly datetimes: ContentDatetimeNormalizer;
+
+	constructor(
+		private db: Kysely<Database>,
+		datetimeContexts?: DatetimeContextCache,
+	) {
+		this.datetimes = new ContentDatetimeNormalizer(db, datetimeContexts);
+	}
 
 	/**
 	 * Create a new revision
 	 */
 	async create(input: CreateRevisionInput): Promise<Revision> {
-		const id = monotonic();
+		const id = createRevisionId();
+		const data = await this.datetimes.normalizeData(input.collection, input.data);
 
 		const row: Omit<RevisionTable, "created_at"> = {
 			id,
 			collection: input.collection,
 			entry_id: input.entryId,
-			data: JSON.stringify(input.data),
+			data: JSON.stringify(data),
 			author_id: input.authorId ?? null,
 		};
 
@@ -50,9 +70,33 @@ export class RevisionRepository {
 		if (!revision) {
 			throw new Error("Failed to create revision");
 		}
+
+		await this.queuePruning(input.collection, input.entryId, id);
+
 		return revision;
 	}
 
+	async queuePruning(collection: string, entryId: string, revisionId: string): Promise<void> {
+		try {
+			await this.db
+				.insertInto("_emdash_revision_prune_queue")
+				.values({
+					collection,
+					entry_id: entryId,
+					revision_id: revisionId,
+				})
+				.onConflict((conflict) =>
+					conflict.columns(["collection", "entry_id"]).doUpdateSet({ revision_id: revisionId }),
+				)
+				.execute();
+		} catch (error) {
+			console.error(
+				`[revisions] Failed to queue revision pruning for ${collection}/${entryId}:`,
+				error,
+			);
+		}
+	}
+
 	/**
 	 * Find revision by ID
 	 */
@@ -63,7 +107,23 @@ export class RevisionRepository {
 			.where("id", "=", id)
 			.executeTakeFirst();
 
-		return row ? this.rowToRevision(row) : null;
+		return row ? this.normalizeRow(row) : null;
+	}
+
+	/** Shallow-merge `patch` into a stored revision's data. */
+	async mergeData(id: string, patch: Record<string, unknown>): Promise<void> {
+		const row = await this.db
+			.selectFrom("revisions")
+			.select("data")
+			.where("id", "=", id)
+			.executeTakeFirst();
+		if (!row) return;
+		const data: Record<string, unknown> = { ...JSON.parse(row.data), ...patch };
+		await this.db
+			.updateTable("revisions")
+			.set({ data: JSON.stringify(data) })
+			.where("id", "=", id)
+			.execute();
 	}
 
 	/**
@@ -89,7 +149,71 @@ export class RevisionRepository {
 		}
 
 		const rows = await query.execute();
-		return rows.map((row) => this.rowToRevision(row));
+		const data = await this.datetimes.normalizeDataMany(
+			collection,
+			rows.map((row) => JSON.parse(row.data)),
+		);
+		return rows.map((row, index) => {
+			const normalized = data[index];
+			if (!normalized) throw new Error("Failed to normalize revision data");
+			return this.rowToRevision(row, normalized);
+		});
+	}
+
+	/** Read revisions only when the owning content row is visible in the same statement snapshot. */
+	async findVisibleByEntry(
+		collection: string,
+		entryId: string,
+		options: { limit?: number } = {},
+	): Promise<Revision[]> {
+		validateIdentifier(collection, "collection");
+		const tableName = `ec_${collection}`;
+		const limit = normalizeRevisionLimit(options.limit);
+		const result = await sql<Selectable<RevisionTable>>`
+			SELECT revisions.* FROM revisions
+			WHERE revisions.collection = ${collection}
+			AND revisions.entry_id = ${entryId}
+			AND EXISTS (
+				SELECT 1 FROM ${sql.ref(tableName)} AS content
+				WHERE content.id = ${entryId}
+				AND content.deleted_at IS NULL
+			)
+			ORDER BY revisions.id DESC
+			LIMIT ${limit}
+		`.execute(this.db);
+		const data = await this.datetimes.normalizeDataMany(
+			collection,
+			result.rows.map((row) => JSON.parse(row.data)),
+		);
+		return result.rows.map((row, index) => {
+			const normalized = data[index];
+			if (!normalized) throw new Error("Failed to normalize revision data");
+			return this.rowToRevision(row, normalized);
+		});
+	}
+
+	/** Read one revision only when its owning content row is visible in the same statement snapshot. */
+	async findVisibleById(
+		collection: string,
+		entryId: string,
+		revisionId: string,
+	): Promise<Revision | null> {
+		validateIdentifier(collection, "collection");
+		const tableName = `ec_${collection}`;
+		const result = await sql<Selectable<RevisionTable>>`
+			SELECT revisions.* FROM revisions
+			WHERE revisions.id = ${revisionId}
+			AND revisions.collection = ${collection}
+			AND revisions.entry_id = ${entryId}
+			AND EXISTS (
+				SELECT 1 FROM ${sql.ref(tableName)} AS content
+				WHERE content.id = ${entryId}
+				AND content.deleted_at IS NULL
+			)
+			LIMIT 1
+		`.execute(this.db);
+		const row = result.rows[0];
+		return row ? this.normalizeRow(row) : null;
 	}
 
 	/**
@@ -105,7 +229,7 @@ export class RevisionRepository {
 			.limit(1)
 			.executeTakeFirst();
 
-		return row ? this.rowToRevision(row) : null;
+		return row ? this.normalizeRow(row) : null;
 	}
 
 	/**
@@ -132,67 +256,137 @@ export class RevisionRepository {
 			.where("entry_id", "=", entryId)
 			.executeTakeFirst();
 
+		try {
+			await this.db
+				.deleteFrom("_emdash_revision_prune_queue")
+				.where("collection", "=", collection)
+				.where("entry_id", "=", entryId)
+				.execute();
+		} catch (error) {
+			console.error(
+				`[revisions] Failed to clear queued revision pruning for ${collection}/${entryId}:`,
+				error,
+			);
+		}
+
 		return Number(result.numDeletedRows ?? 0);
 	}
 
 	/**
 	 * Delete old revisions, keeping the most recent N
 	 */
-	async pruneOldRevisions(collection: string, entryId: string, keepCount: number): Promise<number> {
-		// Get IDs of revisions to keep
-		const keep = await this.db
+	async pruneOldRevisions(
+		collection: string,
+		entryId: string,
+		keepCount: number,
+		throughRevisionId?: string,
+	): Promise<number> {
+		validateIdentifier(collection, "collection");
+		const tableName = `ec_${collection}`;
+		let keepQuery = this.db
 			.selectFrom("revisions")
 			.select("id")
 			.where("collection", "=", collection)
 			.where("entry_id", "=", entryId)
 			.orderBy("created_at", "desc")
 			.orderBy("id", "desc") // ULID tiebreaker
-			.limit(keepCount)
-			.execute();
+			.limit(keepCount);
+
+		if (throughRevisionId) {
+			keepQuery = keepQuery.where("id", "<=", throughRevisionId);
+		}
+
+		const keep = await keepQuery.execute();
 
 		const keepIds = keep.map((r) => r.id);
 
 		if (keepIds.length === 0) return 0;
+		const revisionBoundary = throughRevisionId ? sql`AND id <= ${throughRevisionId}` : sql``;
 
-		// Delete everything else for this entry
-		const result = await this.db
-			.deleteFrom("revisions")
-			.where("collection", "=", collection)
-			.where("entry_id", "=", entryId)
-			.where("id", "not in", keepIds)
-			.executeTakeFirst();
+		const result = await sql`
+			DELETE FROM revisions
+			WHERE collection = ${collection}
+			AND entry_id = ${entryId}
+			${revisionBoundary}
+			AND id NOT IN (${sql.join(keepIds.map((id) => sql`${id}`))})
+			AND NOT EXISTS (
+				SELECT 1 FROM ${sql.ref(tableName)} AS content
+				WHERE content.live_revision_id = revisions.id
+				OR content.draft_revision_id = revisions.id
+			)
+		`.execute(this.db);
 
-		return Number(result.numDeletedRows ?? 0);
+		return Number(result.numAffectedRows ?? 0);
 	}
 
-	/**
-	 * Update revision data in place
-	 * Used for autosave to avoid creating many small revisions.
-	 */
-	async updateData(id: string, data: Record<string, unknown>): Promise<void> {
+	async pruneQueuedEntry(
+		collection: string,
+		entryId: string,
+		queuedRevisionId: string,
+		keepCount: number,
+	): Promise<number> {
+		const pruned = await this.pruneOldRevisions(collection, entryId, keepCount, queuedRevisionId);
 		await this.db
-			.updateTable("revisions")
-			.set({ data: JSON.stringify(data) })
-			.where("id", "=", id)
+			.deleteFrom("_emdash_revision_prune_queue")
+			.where("collection", "=", collection)
+			.where("entry_id", "=", entryId)
+			.where("revision_id", "=", queuedRevisionId)
 			.execute();
+		return pruned;
+	}
+
+	async deleteIfUnreferenced(
+		collection: string,
+		entryId: string,
+		revisionId: string,
+	): Promise<boolean> {
+		validateIdentifier(collection, "collection");
+		const tableName = `ec_${collection}`;
+		const result = await sql`
+			DELETE FROM revisions
+			WHERE id = ${revisionId}
+			AND collection = ${collection}
+			AND entry_id = ${entryId}
+			AND NOT EXISTS (
+				SELECT 1 FROM ${sql.ref(tableName)} AS content
+				WHERE content.live_revision_id = revisions.id
+				OR content.draft_revision_id = revisions.id
+			)
+		`.execute(this.db);
+		return (result.numAffectedRows ?? 0n) > 0n;
 	}
 
 	/**
 	 * Convert database row to Revision object
 	 */
-	private rowToRevision(row: {
+	private async normalizeRow(row: {
 		id: string;
 		collection: string;
 		entry_id: string;
 		data: string;
 		author_id: string | null;
 		created_at: string;
-	}): Revision {
+	}): Promise<Revision> {
+		const data = await this.datetimes.normalizeData(row.collection, JSON.parse(row.data));
+		return this.rowToRevision(row, data);
+	}
+
+	private rowToRevision(
+		row: {
+			id: string;
+			collection: string;
+			entry_id: string;
+			data: string;
+			author_id: string | null;
+			created_at: string;
+		},
+		data: Record<string, unknown>,
+	): Revision {
 		return {
 			id: row.id,
 			collection: row.collection,
 			entryId: row.entry_id,
-			data: JSON.parse(row.data),
+			data,
 			authorId: row.author_id,
 			createdAt: row.created_at,
 		};

package/src/database/repositories/seo.ts

@@ -1,5 +1,6 @@
 import { sql, type Kysely } from "kysely";
 
+import { invalidateCollectionCache } from "../../object-cache/index.js";
 import { chunks, SQL_BATCH_SIZE } from "../../utils/chunks.js";
 import type { Database } from "../types.js";
 import type { ContentSeo, ContentSeoInput } from "./types.js";
@@ -153,6 +154,7 @@ export class SeoRepository {
 				updated_at = ${now}
 		`.execute(this.db);
 
+		invalidateCollectionCache(collection);
 		return this.get(collection, contentId);
 	}
 
@@ -165,6 +167,7 @@ export class SeoRepository {
 			.where("collection", "=", collection)
 			.where("content_id", "=", contentId)
 			.execute();
+		invalidateCollectionCache(collection);
 	}
 
 	/**

package/src/database/repositories/taxonomy-def.ts

@@ -0,0 +1,126 @@
+import { sql, type Kysely } from "kysely";
+
+import type { Database } from "../types.js";
+
+/**
+ * A taxonomy's structure: the same in every locale. Stored once in
+ * `_emdash_taxonomy_def_groups`, keyed by name, and copied onto each locale's
+ * `_emdash_taxonomy_defs` row for code that reads it directly, such as the plugin
+ * sandbox bridges.
+ */
+export interface TaxonomyStructure {
+	hierarchical: boolean;
+	collections: string[];
+}
+
+/**
+ * Select definition rows (aliased `d`) with their taxonomy's structure.
+ * Qualify columns in `where` and `orderBy`: `id` and `name` exist on both tables.
+ *
+ * A row that has no group yet, because code without the group table wrote it
+ * during a rolling deploy, reads its own copy.
+ */
+export function selectTaxonomyDefs(db: Kysely<Database>) {
+	return db
+		.selectFrom("_emdash_taxonomy_defs as d")
+		.leftJoin("_emdash_taxonomy_def_groups as g", "g.name", "d.name")
+		.select([
+			"d.id",
+			"d.name",
+			"d.label",
+			"d.label_singular",
+			"d.created_at",
+			"d.locale",
+			"d.translation_group",
+			sql<number>`coalesce(g.hierarchical, d.hierarchical)`.as("hierarchical"),
+			sql<string | null>`coalesce(g.collections, d.collections)`.as("collections"),
+		]);
+}
+
+/**
+ * The taxonomy's group id and structure, or null when no locale defines `name`.
+ * A group whose definitions are all gone counts as deleted.
+ */
+export async function findTaxonomyStructure(
+	db: Kysely<Database>,
+	name: string,
+): Promise<(TaxonomyStructure & { id: string }) | null> {
+	const row = await selectTaxonomyDefs(db)
+		.where("d.name", "=", name)
+		.orderBy("d.id", "asc")
+		.executeTakeFirst();
+	if (!row) return null;
+	return {
+		id: row.translation_group ?? row.id,
+		hierarchical: row.hierarchical === 1,
+		collections: parseTaxonomyCollections(row.collections),
+	};
+}
+
+/**
+ * Write a taxonomy's structure for every locale and return its group id.
+ *
+ * Creates the group with `groupId` and `structure` when the name has none. An
+ * existing group changes only the fields in `overwrite`, so a caller holding an
+ * older read of the other field does not write it back. Every definition row of
+ * the name is then linked to the group and copies its values, including rows
+ * written without it.
+ */
+export async function saveTaxonomyStructure(
+	db: Kysely<Database>,
+	name: string,
+	groupId: string,
+	structure: TaxonomyStructure,
+	overwrite: Partial<TaxonomyStructure> = structure,
+): Promise<string> {
+	const changes: { hierarchical?: number; collections?: string } = {};
+	if (overwrite.hierarchical !== undefined) changes.hierarchical = overwrite.hierarchical ? 1 : 0;
+	if (overwrite.collections !== undefined) {
+		changes.collections = JSON.stringify([...new Set(overwrite.collections)]);
+	}
+	const saved = await db
+		.insertInto("_emdash_taxonomy_def_groups")
+		.values({
+			id: groupId,
+			name,
+			hierarchical: structure.hierarchical ? 1 : 0,
+			collections: JSON.stringify([...new Set(structure.collections)]),
+		})
+		.onConflict((oc) =>
+			Object.keys(changes).length > 0
+				? oc.column("name").doUpdateSet(changes)
+				: oc.column("name").doNothing(),
+		)
+		.returning(["id", "hierarchical", "collections"])
+		.executeTakeFirst();
+	const group =
+		saved ??
+		(await db
+			.selectFrom("_emdash_taxonomy_def_groups")
+			.select(["id", "hierarchical", "collections"])
+			.where("name", "=", name)
+			.executeTakeFirstOrThrow());
+	await db
+		.updateTable("_emdash_taxonomy_defs")
+		.set({
+			hierarchical: group.hierarchical,
+			collections: group.collections,
+			translation_group: group.id,
+		})
+		.where("name", "=", name)
+		.execute();
+	return group.id;
+}
+
+/** Parse a stored `collections` value, skipping anything that isn't a string list. */
+export function parseTaxonomyCollections(value: string | null): string[] {
+	if (!value) return [];
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(value);
+	} catch {
+		return [];
+	}
+	if (!Array.isArray(parsed)) return [];
+	return [...new Set(parsed.filter((entry): entry is string => typeof entry === "string"))];
+}