emdash 0.37.0 → 0.38.0

package/src/database/repositories/plugin-storage.ts

@@ -10,6 +10,11 @@
 import type { Kysely, RawBuilder } from "kysely";
 import { sql } from "kysely";
 
+import {
+	assertStorageKey,
+	assertStorageRevision,
+	serializeConditionalValue,
+} from "../../plugins/conditional-storage.js";
 import {
 	buildWhereClause,
 	validateWhereClause,
@@ -17,17 +22,59 @@ import {
 	getIndexedFields,
 	jsonOrderExtract,
 	StorageQueryError,
+	isInFilter,
+	StorageSerializationError,
 } from "../../plugins/storage-query.js";
+import { parseStorageUpdate } from "../../plugins/storage-update.js";
 import type {
 	StorageCollection,
 	QueryOptions,
 	PaginatedResult,
 	WhereClause,
+	UpdateIfResult,
+	VersionedValue,
+	ConditionalWriteResult,
+	ConditionalDeleteResult,
 } from "../../plugins/types.js";
+import { pluginDataWriteExpr, pluginDataUpdateGuard } from "../dialect-helpers.js";
 import { withTransaction } from "../transaction.js";
 import type { Database } from "../types.js";
 import { encodeCursor, decodeCursor } from "./types.js";
 
+/**
+ * SQLSTATEs a losing concurrent `updateIf` writer can abort with.
+ *
+ * `40001` (serialization_failure) is raised only above READ COMMITTED, where
+ * the loser cannot re-evaluate its guard against a newer snapshot. `40P01`
+ * (deadlock_detected) is not tied to isolation level: it needs only two
+ * transactions taking row locks in opposite order, which a caller reaches at
+ * READ COMMITTED by wrapping several `updateIf` calls in one transaction.
+ */
+const SERIALIZATION_SQLSTATES = new Set(["40001", "40P01"]);
+
+function errSqlState(err: unknown): string | undefined {
+	if (typeof err !== "object" || err === null) return undefined;
+	const code = (err as { code?: unknown }).code;
+	if (typeof code === "string") return code;
+	const cause = (err as { cause?: unknown }).cause;
+	if (typeof cause === "object" && cause !== null) {
+		const causeCode = (cause as { code?: unknown }).code;
+		if (typeof causeCode === "string") return causeCode;
+	}
+	return undefined;
+}
+
+export function mapSerializationFailure(err: unknown): unknown {
+	const sqlState = errSqlState(err);
+	if (sqlState !== undefined && SERIALIZATION_SQLSTATES.has(sqlState)) {
+		return new StorageSerializationError(
+			"Storage write must be retried. Restart the transaction before retrying when using an explicit transaction.",
+			{ cause: err, sqlState },
+		);
+	}
+	return err;
+}
+
 /**
  * Interleave a `?`-placeholder SQL string with its params into a single
  * boolean raw expression. Used as a WHERE predicate directly — wrapping it
@@ -101,6 +148,7 @@ export class PluginStorageRepository<T = unknown> implements StorageCollection<T
 	async put(id: string, data: T): Promise<void> {
 		const now = new Date().toISOString();
 		const jsonData = JSON.stringify(data);
+		const revision = crypto.randomUUID();
 
 		await this.db
 			.insertInto("_plugin_storage")
@@ -109,18 +157,85 @@ export class PluginStorageRepository<T = unknown> implements StorageCollection<T
 				collection: this.collection,
 				id,
 				data: jsonData,
+				revision,
 				created_at: now,
 				updated_at: now,
 			})
 			.onConflict((oc) =>
 				oc.columns(["plugin_id", "collection", "id"]).doUpdateSet({
 					data: jsonData,
+					revision,
 					updated_at: now,
 				}),
 			)
 			.execute();
 	}
 
+	async getVersioned(id: string): Promise<VersionedValue<T> | null> {
+		assertStorageKey(id);
+		const row = await this.db
+			.selectFrom("_plugin_storage")
+			.select(["data", "revision"])
+			.where("plugin_id", "=", this.pluginId)
+			.where("collection", "=", this.collection)
+			.where("id", "=", id)
+			.executeTakeFirst();
+		if (!row) return null;
+		return { value: JSON.parse(row.data), revision: row.revision };
+	}
+
+	async compareAndSet(
+		id: string,
+		expectedRevision: string | null,
+		data: T,
+	): Promise<ConditionalWriteResult> {
+		assertStorageKey(id);
+		if (expectedRevision !== null) assertStorageRevision(expectedRevision);
+		const jsonData = serializeConditionalValue(data);
+		const revision = crypto.randomUUID();
+		const now = new Date().toISOString();
+		const row =
+			expectedRevision === null
+				? await this.db
+						.insertInto("_plugin_storage")
+						.values({
+							plugin_id: this.pluginId,
+							collection: this.collection,
+							id,
+							data: jsonData,
+							revision,
+							created_at: now,
+							updated_at: now,
+						})
+						.onConflict((oc) => oc.columns(["plugin_id", "collection", "id"]).doNothing())
+						.returning("revision")
+						.executeTakeFirst()
+				: await this.db
+						.updateTable("_plugin_storage")
+						.set({ data: jsonData, revision, updated_at: now })
+						.where("plugin_id", "=", this.pluginId)
+						.where("collection", "=", this.collection)
+						.where("id", "=", id)
+						.where("revision", "=", expectedRevision)
+						.returning("revision")
+						.executeTakeFirst();
+		return row ? { applied: true, revision: row.revision } : { applied: false };
+	}
+
+	async compareAndDelete(id: string, expectedRevision: string): Promise<ConditionalDeleteResult> {
+		assertStorageKey(id);
+		assertStorageRevision(expectedRevision);
+		const row = await this.db
+			.deleteFrom("_plugin_storage")
+			.where("plugin_id", "=", this.pluginId)
+			.where("collection", "=", this.collection)
+			.where("id", "=", id)
+			.where("revision", "=", expectedRevision)
+			.returning("id")
+			.executeTakeFirst();
+		return { applied: row !== undefined };
+	}
+
 	/**
 	 * Delete a document
 	 */
@@ -185,6 +300,7 @@ export class PluginStorageRepository<T = unknown> implements StorageCollection<T
 		await withTransaction(this.db, async (trx) => {
 			for (const item of items) {
 				const jsonData = JSON.stringify(item.data);
+				const revision = crypto.randomUUID();
 				await trx
 					.insertInto("_plugin_storage")
 					.values({
@@ -192,12 +308,14 @@ export class PluginStorageRepository<T = unknown> implements StorageCollection<T
 						collection: this.collection,
 						id: item.id,
 						data: jsonData,
+						revision,
 						created_at: now,
 						updated_at: now,
 					})
 					.onConflict((oc) =>
 						oc.columns(["plugin_id", "collection", "id"]).doUpdateSet({
 							data: jsonData,
+							revision,
 							updated_at: now,
 						}),
 					)
@@ -372,6 +490,47 @@ export class PluginStorageRepository<T = unknown> implements StorageCollection<T
 		// Number() because the pg driver returns COUNT(*) (bigint) as a string.
 		return Number(result?.count ?? 0);
 	}
+
+	async updateIf(id: string, args: unknown): Promise<UpdateIfResult<T>> {
+		if (typeof id !== "string") throw new TypeError("Storage ID must be a string");
+		const { where, setEntries, deltaEntries } = parseStorageUpdate(args);
+
+		// Defensive empty-`in` guard: an empty `in: []` matches nothing. The shared
+		// where-translation would emit invalid `IN ()`; short-circuit to a no-op
+		// (matches nothing → applied:false) BEFORE building any SQL.
+		for (const value of Object.values(where)) {
+			if (isInFilter(value) && value.in.length === 0) {
+				return { applied: false };
+			}
+		}
+
+		const now = new Date().toISOString();
+		const dataExpr = pluginDataWriteExpr(this.db, setEntries, deltaEntries);
+
+		let query = this.db
+			.updateTable("_plugin_storage")
+			.set({ data: dataExpr, updated_at: now })
+			.where("plugin_id", "=", this.pluginId)
+			.where("collection", "=", this.collection)
+			.where("id", "=", id)
+			.where(pluginDataUpdateGuard(this.db, deltaEntries));
+
+		const whereResult = buildWhereClause(this.db, where);
+		if (whereResult.sql) {
+			query = query.where(rawWhereExpr(whereResult.sql, whereResult.params));
+		}
+
+		let row: { data: string } | undefined;
+		try {
+			row = await query.returning("data").executeTakeFirst();
+		} catch (err) {
+			throw mapSerializationFailure(err);
+		}
+		if (!row) return { applied: false };
+		// eslint-disable-next-line typescript/no-unsafe-type-assertion -- JSON.parse returns any; generic callers provide T
+		const data = JSON.parse(row.data) as T;
+		return { applied: true, data };
+	}
 }
 
 /**

package/src/database/repositories/redirect.ts

@@ -1,6 +1,7 @@
 import { sql, type Kysely } from "kysely";
 import { ulid } from "ulidx";
 
+import { interpolateUrlPattern } from "../../i18n/resolve.js";
 import {
 	compilePattern,
 	matchPattern,
@@ -359,13 +360,23 @@ export class RedirectRepository {
 		newSlug: string,
 		contentId: string,
 		urlPattern: string | null,
+		oldPublishedAt?: string | null,
+		newPublishedAt?: string | null,
 	): Promise<Redirect | null> {
-		const oldUrl = urlPattern
-			? urlPattern.replace("{slug}", oldSlug).replace("{id}", contentId)
-			: `/${collection}/${oldSlug}`;
-		const newUrl = urlPattern
-			? urlPattern.replace("{slug}", newSlug).replace("{id}", contentId)
-			: `/${collection}/${newSlug}`;
+		const oldUrl = interpolateUrlPattern({
+			pattern: urlPattern,
+			collection,
+			slug: oldSlug,
+			id: contentId,
+			date: oldPublishedAt,
+		});
+		const newUrl = interpolateUrlPattern({
+			pattern: urlPattern,
+			collection,
+			slug: newSlug,
+			id: contentId,
+			date: newPublishedAt,
+		});
 
 		// A redirect from a URL to itself would make the page unreachable
 		if (oldUrl === newUrl) return null;

package/src/database/repositories/taxonomy.ts

@@ -749,7 +749,15 @@ export class TaxonomyRepository {
 	async clearEntryTerms(collection: string, entryId: string): Promise<number> {
 		const entryGroup = await this.resolveEntryTranslationGroup(collection, entryId);
 		if (!entryGroup) return 0;
+		return this.clearEntryGroupTerms(collection, entryGroup);
+	}
 
+	/**
+	 * Remove every term assignment held by an entry translation group. Takes the
+	 * group rather than an entry id, so it still works after the group's last
+	 * row has been deleted.
+	 */
+	async clearEntryGroupTerms(collection: string, entryGroup: string): Promise<number> {
 		const result = await this.db
 			.deleteFrom("content_taxonomies")
 			.where("collection", "=", collection)

package/src/database/repositories/types.ts

@@ -34,7 +34,10 @@ export interface UpdateContentInput {
 	slug?: string | null;
 	publishedAt?: string | null;
 	scheduledAt?: string | null;
+	/** Entry owner (`ec_{collection}.author_id`). */
 	authorId?: string | null;
+	/** Revision author, separate from entry ownership. */
+	revisionAuthorId?: string | null;
 	primaryBylineId?: string | null;
 }
 

package/src/database/types.ts

@@ -396,6 +396,7 @@ export interface DeviceCodeTable {
 export interface OptionTable {
 	name: string;
 	value: string; // JSON
+	revision: Generated<string>;
 }
 
 export interface AuditLogTable {
@@ -433,12 +434,14 @@ export interface CollectionTable {
 	date_field: string | null; // field slug (datetime) for the admin list Date column (NULL = default)
 	url_pattern: string | null; // URL pattern with {slug} placeholder (e.g. "/blog/{slug}")
 	routable: Generated<number>; // 0 or 1 — published entries require a slug when enabled
-	hidden: Generated<number>; // 0 or 1 — omit the auto-generated admin sidebar entry
+	hidden: Generated<number>; // 0 or 1 — omit the auto-generated sidebar entry and dashboard quick action
 	sort_order: number | null; // explicit admin sidebar position; NULL = alphabetical fallback
+	nav_group: string | null; // admin sidebar folder label; NULL = inline
 	comments_enabled: Generated<number>; // 0 or 1
 	comments_moderation: Generated<string>; // 'all' | 'first_time' | 'none'
 	comments_closed_after_days: Generated<number>; // 0 = never close
 	comments_auto_approve_users: Generated<number>; // 0 or 1
+	edit_locking: Generated<number>; // 0 or 1; take an edit lock when an entry is opened
 	created_at: Generated<string>;
 	updated_at: Generated<string>;
 }
@@ -482,6 +485,7 @@ export interface PluginStorageTable {
 	collection: string;
 	id: string;
 	data: string; // JSON
+	revision: Generated<string>;
 	created_at: Generated<string>;
 	updated_at: Generated<string>;
 }
@@ -686,6 +690,7 @@ export interface Database {
 	_emdash_relations: RelationTable;
 	_emdash_content_references: ContentReferenceTable;
 	_emdash_rate_limits: RateLimitTable;
+	_emdash_entry_locks: EntryLockTable;
 }
 
 export type MediaRow = {
@@ -860,3 +865,12 @@ export interface RateLimitTable {
 	window: string; // ISO timestamp truncated to window size
 	count: number;
 }
+
+export interface EntryLockTable {
+	collection: string;
+	entry_id: string; // ID in the ec_* table
+	user_id: string;
+	token: string; // identifies the holder's editing session, one per tab
+	acquired_at: string; // ISO 8601 with milliseconds
+	expires_at: string; // ISO 8601 with milliseconds
+}