emdash 0.37.0 → 0.38.0

package/src/database/migrations/077_plugin_storage_revisions.ts

@@ -0,0 +1,89 @@
+import { type Kysely, sql } from "kysely";
+
+import { columnExists, isPostgres } from "../dialect-helpers.js";
+
+const TABLES = [
+	{ name: "options", keys: ["name"] },
+	{ name: "_plugin_storage", keys: ["plugin_id", "collection", "id"] },
+] as const;
+
+const DUPLICATE_COLUMN_REGEX =
+	/(?:duplicate column|column .* already exists|already exists.*column)/i;
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+	for (const table of TABLES) {
+		if (await columnExists(db, table.name, "revision")) continue;
+		try {
+			await db.schema
+				.alterTable(table.name)
+				.addColumn("revision", "text", (column) => column.notNull().defaultTo("0"))
+				.execute();
+		} catch (error) {
+			if (isDuplicateColumnError(error) && (await columnExists(db, table.name, "revision"))) {
+				continue;
+			}
+			throw error;
+		}
+	}
+
+	if (isPostgres(db)) {
+		await sql`
+			CREATE OR REPLACE FUNCTION emdash_plugin_storage_assign_revision()
+			RETURNS trigger
+			LANGUAGE plpgsql
+			AS $$
+			BEGIN
+				IF TG_OP = 'INSERT' THEN
+					IF NEW.revision = '0' THEN
+						NEW.revision := gen_random_uuid()::text;
+					END IF;
+				ELSIF NEW.revision = '0' OR NEW.revision = OLD.revision THEN
+					NEW.revision := gen_random_uuid()::text;
+				END IF;
+				RETURN NEW;
+			END;
+			$$
+		`.execute(db);
+		for (const table of TABLES) {
+			await sql`
+				CREATE OR REPLACE TRIGGER ${sql.ref(`emdash_${table.name}_revision`)}
+				BEFORE INSERT OR UPDATE ON ${sql.ref(table.name)}
+				FOR EACH ROW EXECUTE FUNCTION emdash_plugin_storage_assign_revision()
+			`.execute(db);
+		}
+	} else {
+		for (const table of TABLES) {
+			const rowKey = sql.join(
+				table.keys.map((key) => sql`${sql.ref(key)} = ${sql.ref(`NEW.${key}`)}`),
+				sql` AND `,
+			);
+			await sql`
+				CREATE TRIGGER IF NOT EXISTS ${sql.ref(`emdash_${table.name}_revision_insert`)}
+				AFTER INSERT ON ${sql.ref(table.name)}
+				WHEN NEW.revision = '0'
+				BEGIN
+					UPDATE ${sql.ref(table.name)} SET revision = lower(hex(randomblob(16)))
+					WHERE ${rowKey} AND revision = NEW.revision;
+				END
+			`.execute(db);
+			await sql`
+				CREATE TRIGGER IF NOT EXISTS ${sql.ref(`emdash_${table.name}_revision_update`)}
+				AFTER UPDATE ON ${sql.ref(table.name)}
+				WHEN NEW.revision = '0' OR NEW.revision = OLD.revision
+				BEGIN
+					UPDATE ${sql.ref(table.name)} SET revision = lower(hex(randomblob(16)))
+					WHERE ${rowKey} AND revision = NEW.revision;
+				END
+			`.execute(db);
+		}
+	}
+}
+
+function isDuplicateColumnError(error: unknown): boolean {
+	if (!(error instanceof Error)) return false;
+	return DUPLICATE_COLUMN_REGEX.test(error.message) || isDuplicateColumnError(error.cause);
+}
+
+export async function down(_db: Kysely<unknown>): Promise<void> {
+	// Revisions must survive a host rollback while other writers still use them.
+}

package/src/database/migrations/runner.ts

@@ -77,6 +77,9 @@ 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";
+import * as m075 from "./075_entry_edit_locks.js";
+import * as m076 from "./076_collection_nav_group.js";
+import * as m077 from "./077_plugin_storage_revisions.js";
 
 const MIGRATIONS: Readonly<Record<string, Migration>> = Object.freeze({
 	"001_initial": m001,
@@ -152,6 +155,9 @@ const MIGRATIONS: Readonly<Record<string, Migration>> = Object.freeze({
 	"072_media_folders": m072,
 	"073_media_focal_point": m073,
 	"074_content_deleted_scheduled_index": m074,
+	"075_entry_edit_locks": m075,
+	"076_collection_nav_group": m076,
+	"077_plugin_storage_revisions": m077,
 });
 
 /** Ordered names from the statically registered migration set. */

package/src/database/repositories/content.ts

@@ -973,7 +973,7 @@ export class ContentRepository {
 				collection: type,
 				entryId: id,
 				data: mergedData,
-				...(input.authorId ? { authorId: input.authorId } : {}),
+				...(input.revisionAuthorId ? { authorId: input.revisionAuthorId } : {}),
 			});
 
 			let staged: boolean;
@@ -1074,6 +1074,162 @@ export class ContentRepository {
 		return changed;
 	}
 
+	/**
+	 * Copy non-translatable field values to every other entry in the
+	 * translation group, trashed entries included.
+	 *
+	 * Only the fields present in `data` are copied. With `previous`, `data` is
+	 * the entry's complete new state and only the fields whose value differs
+	 * from `previous` are copied, an absent field as null. An entry that already
+	 * holds every copied value is left untouched, so its `updated_at` does not
+	 * move.
+	 *
+	 * On collections with revisions a changed entry also gets a new live
+	 * revision, because republishing and unpublishing read that revision rather
+	 * than the columns. A pending draft takes a value only where it still holds
+	 * the entry's previous value, so an unpublished edit to the field survives.
+	 */
+	async syncNonTranslatableFields(
+		type: string,
+		sourceId: string,
+		translationGroup: string,
+		data: Record<string, unknown>,
+		options: { previous?: Record<string, unknown> } = {},
+	): Promise<void> {
+		const tableName = getTableName(type);
+		const collectionRows = await this.db
+			.selectFrom("_emdash_collections as collection")
+			.leftJoin("_emdash_fields as field", (join) =>
+				join.onRef("field.collection_id", "=", "collection.id").on("field.translatable", "=", 0),
+			)
+			.select(["collection.supports", "field.slug as fieldSlug"])
+			.where("collection.slug", "=", type)
+			.execute();
+
+		const { previous } = options;
+		const values: Record<string, unknown> = {};
+		for (const { fieldSlug } of collectionRows) {
+			if (!fieldSlug) continue;
+			if (previous) {
+				if (!sameStoredValue(previous[fieldSlug], data[fieldSlug])) {
+					values[fieldSlug] = data[fieldSlug] ?? null;
+				}
+			} else if (fieldSlug in data) {
+				values[fieldSlug] = data[fieldSlug];
+			}
+		}
+		if (Object.keys(values).length === 0) return;
+
+		const supportsRaw = collectionRows[0]?.supports;
+		const supports: unknown = supportsRaw ? JSON.parse(supportsRaw) : [];
+		const usesRevisions = Array.isArray(supports) && supports.includes("revisions");
+
+		const siblings = await sql<Record<string, unknown>>`
+			SELECT * FROM ${sql.ref(tableName)}
+			WHERE translation_group = ${translationGroup}
+			AND id != ${sourceId}
+		`.execute(this.db);
+
+		let changed = false;
+		for (const row of siblings.rows) {
+			if (await this.syncSiblingValues(type, this.mapRow(type, row), values, usesRevisions)) {
+				changed = true;
+			}
+		}
+		if (changed) invalidateCollectionCache(type);
+	}
+
+	private async syncSiblingValues(
+		type: string,
+		initial: ContentItem,
+		values: Record<string, unknown>,
+		usesRevisions: boolean,
+	): Promise<boolean> {
+		const tableName = getTableName(type);
+		const revisionRepo = new RevisionRepository(this.db);
+		let sibling: ContentItem | null = initial;
+
+		for (let attempt = 0; sibling && attempt < MAX_DRAFT_STAGE_ATTEMPTS; attempt++) {
+			const current: ContentItem = sibling;
+			const changed: Record<string, unknown> = {};
+			for (const [field, value] of Object.entries(values)) {
+				if (!sameStoredValue(current.data[field], value)) changed[field] = value;
+			}
+			if (Object.keys(changed).length === 0) return false;
+
+			const assignments: ReturnType<typeof sql>[] = [];
+			for (const [field, value] of Object.entries(changed)) {
+				validateIdentifier(field, "content field name");
+				assignments.push(sql`${sql.ref(field)} = ${serializeValue(value)}`);
+			}
+
+			const createdRevisionIds: string[] = [];
+			const cleanUp = async () => {
+				for (const revisionId of createdRevisionIds) {
+					await this.deleteUnstagedRevision(revisionRepo, type, current.id, revisionId);
+				}
+			};
+
+			let synced: boolean;
+			try {
+				const live =
+					usesRevisions && current.liveRevisionId
+						? await revisionRepo.findById(current.liveRevisionId)
+						: null;
+				if (live) {
+					const revision = await revisionRepo.create({
+						collection: type,
+						entryId: current.id,
+						data: { ...live.data, ...changed },
+					});
+					createdRevisionIds.push(revision.id);
+					assignments.push(sql`live_revision_id = ${revision.id}`);
+				}
+
+				const draft =
+					usesRevisions && current.draftRevisionId
+						? await revisionRepo.findById(current.draftRevisionId)
+						: null;
+				const carried: Record<string, unknown> = {};
+				for (const [field, value] of Object.entries(changed)) {
+					if (draft && sameStoredValue(draft.data[field], current.data[field])) {
+						carried[field] = value;
+					}
+				}
+				if (draft && Object.keys(carried).length > 0) {
+					const revision = await revisionRepo.create({
+						collection: type,
+						entryId: current.id,
+						data: { ...draft.data, ...carried },
+					});
+					createdRevisionIds.push(revision.id);
+					assignments.push(sql`draft_revision_id = ${revision.id}`);
+				}
+
+				assignments.push(sql`updated_at = ${new Date().toISOString()}`, sql`version = version + 1`);
+				const result = await sql`
+					UPDATE ${sql.ref(tableName)}
+					SET ${sql.join(assignments, sql`, `)}
+					WHERE id = ${current.id}
+					AND version = ${current.version}
+					AND ${nullableColumnMatch("live_revision_id", current.liveRevisionId)}
+					AND ${nullableColumnMatch("draft_revision_id", current.draftRevisionId)}
+				`.execute(this.db);
+				synced = (result.numAffectedRows ?? 0n) > 0n;
+			} catch (error) {
+				await cleanUp();
+				throw error;
+			}
+
+			if (synced) return true;
+			await cleanUp();
+			sibling = await this.findByIdIncludingTrashed(type, current.id);
+		}
+
+		if (!sibling) return false;
+		throw new ContentMutationConflictError();
+	}
+
 	/**
 	 * Delete content (soft delete - moves to trash)
 	 */
@@ -1665,6 +1821,19 @@ export class ContentRepository {
 		return result.rows.map((row) => this.mapRow(type, row));
 	}
 
+	/** Whether any row of `translationGroup` exists, trashed rows included. */
+	async hasTranslationsIncludingTrashed(type: string, translationGroup: string): Promise<boolean> {
+		const tableName = getTableName(type);
+
+		const result = await sql<Record<string, unknown>>`
+			SELECT id FROM ${sql.ref(tableName)}
+			WHERE translation_group = ${translationGroup}
+			LIMIT 1
+		`.execute(this.db);
+
+		return result.rows.length > 0;
+	}
+
 	/**
 	 * Batch variant of {@link findTranslations}: every (non-deleted) locale
 	 * variant for any of `translationGroups`, in one `WHERE translation_group IN

package/src/database/repositories/entry-locks.ts

@@ -0,0 +1,257 @@
+import type { Kysely, RawBuilder } from "kysely";
+import { sql } from "kysely";
+
+import { isPostgres } from "../dialect-helpers.js";
+import type { Database } from "../types.js";
+
+export interface EntryLock {
+	collection: string;
+	entryId: string;
+	userId: string;
+	/** Display name of the holder, `null` when the account has none set. */
+	userName: string | null;
+	acquiredAt: string;
+	expiresAt: string;
+}
+
+export type EntryLockClaim =
+	| { outcome: "acquired"; lock: EntryLock }
+	| { outcome: "held"; lock: EntryLock };
+
+interface LockKey {
+	collection: string;
+	entryId: string;
+	userId: string;
+}
+
+interface LeaseInput extends LockKey {
+	leaseSeconds: number;
+}
+
+interface LockRow {
+	collection: string;
+	entry_id: string;
+	user_id: string;
+	token: string;
+	acquired_at: string;
+	expires_at: string;
+}
+
+/**
+ * A refused claim proves a live lease existed at statement time, so a second
+ * pass only runs when that lease lapsed or was released in between.
+ */
+const CLAIM_ATTEMPTS = 2;
+
+function toEntryLock(row: LockRow & { user_name: string | null }): EntryLock {
+	return {
+		collection: row.collection,
+		entryId: row.entry_id,
+		userId: row.user_id,
+		userName: row.user_name ?? null,
+		acquiredAt: row.acquired_at,
+		expiresAt: row.expires_at,
+	};
+}
+
+/**
+ * One lease per entry, keyed by `(collection, entry_id)`.
+ *
+ * Every timestamp comes from the database clock, so leases stay comparable
+ * across isolates whose wall clocks drift.
+ */
+export class EntryLockRepository {
+	constructor(private db: Kysely<Database>) {}
+
+	/**
+	 * Claims the entry for `userId`, or reports who holds it. An expired lease
+	 * and the caller's own lease are both claimable; anyone else's live lease
+	 * needs `takeover`.
+	 *
+	 * `token` identifies the caller's editing session. The row keeps the latest
+	 * one and `release` matches on it, so two tabs of one account can share an
+	 * entry without the first tab to close dropping the lease the other still
+	 * relies on.
+	 */
+	async acquire(
+		input: LeaseInput & { token: string; takeover?: boolean },
+	): Promise<EntryLockClaim> {
+		for (let attempt = 0; attempt < CLAIM_ATTEMPTS; attempt++) {
+			const claimed = await this.claim(input);
+			if (claimed) return { outcome: "acquired", lock: await this.withHolderName(claimed) };
+
+			const holder = await this.findLive(input.collection, input.entryId);
+			if (holder) return { outcome: "held", lock: holder };
+		}
+		throw new Error(`Entry lock claim did not settle for ${input.collection}/${input.entryId}`);
+	}
+
+	/**
+	 * Extends the caller's own live lease, and reports whether they had one.
+	 * `false` lets a write path tell "mine, extended" from "someone else's, or
+	 * none" without taking a lease it was never given.
+	 */
+	async refreshHeld(input: LeaseInput): Promise<boolean> {
+		const result = await this.db
+			.updateTable("_emdash_entry_locks")
+			.set({ expires_at: this.timestampOffset(input.leaseSeconds) })
+			.where("collection", "=", input.collection)
+			.where("entry_id", "=", input.entryId)
+			.where("user_id", "=", input.userId)
+			.where(this.leaseIsLive("expires_at"))
+			.executeTakeFirst();
+		return Number(result.numUpdatedRows ?? 0) > 0;
+	}
+
+	async findLive(collection: string, entryId: string): Promise<EntryLock | null> {
+		const row = await this.liveQuery(collection, entryId).executeTakeFirst();
+		return row ? toEntryLock(row) : null;
+	}
+
+	/** The live lease, but only while the collection still has locking switched on. */
+	async findEnforceable(collection: string, entryId: string): Promise<EntryLock | null> {
+		const row = await this.liveQuery(collection, entryId)
+			.innerJoin(
+				"_emdash_collections",
+				"_emdash_collections.slug",
+				"_emdash_entry_locks.collection",
+			)
+			.where("_emdash_collections.edit_locking", "!=", 0)
+			.executeTakeFirst();
+		return row ? toEntryLock(row) : null;
+	}
+
+	/**
+	 * Drops the caller's lease. With `token`, only the session that last
+	 * claimed the row can drop it; without, any session of the account can.
+	 */
+	async release(key: LockKey & { token?: string }): Promise<boolean> {
+		let query = this.db
+			.deleteFrom("_emdash_entry_locks")
+			.where("collection", "=", key.collection)
+			.where("entry_id", "=", key.entryId)
+			.where("user_id", "=", key.userId);
+		if (key.token !== undefined) query = query.where("token", "=", key.token);
+		const result = await query.executeTakeFirst();
+		return Number(result.numDeletedRows ?? 0) > 0;
+	}
+
+	/** Drops every lease on an entry, whoever holds it. */
+	async releaseEntry(collection: string, entryId: string): Promise<void> {
+		await this.db
+			.deleteFrom("_emdash_entry_locks")
+			.where("collection", "=", collection)
+			.where("entry_id", "=", entryId)
+			.execute();
+	}
+
+	/**
+	 * Insert-or-steal in one statement. The conflict branch keeps the original
+	 * acquisition time when the holder is unchanged, so the admin can show how
+	 * long the entry has been open rather than how long ago it was last typed
+	 * into.
+	 *
+	 * Column references in the conflict branch are table-qualified: Postgres
+	 * sees both the stored row and `excluded` there and rejects a bare name as
+	 * ambiguous.
+	 */
+	private async claim(
+		input: LeaseInput & { token: string; takeover?: boolean },
+	): Promise<LockRow | undefined> {
+		const now = this.timestampOffset(0);
+		const expiresAt = this.timestampOffset(input.leaseSeconds);
+		return this.db
+			.insertInto("_emdash_entry_locks")
+			.values({
+				collection: input.collection,
+				entry_id: input.entryId,
+				user_id: input.userId,
+				token: input.token,
+				acquired_at: now,
+				expires_at: expiresAt,
+			})
+			.onConflict((oc) => {
+				const update = oc.columns(["collection", "entry_id"]).doUpdateSet({
+					user_id: input.userId,
+					token: input.token,
+					acquired_at: sql<string>`CASE
+						WHEN ${sql.ref("_emdash_entry_locks.user_id")} = ${input.userId}
+						THEN ${sql.ref("_emdash_entry_locks.acquired_at")}
+						ELSE ${now}
+					END`,
+					expires_at: expiresAt,
+				});
+				if (input.takeover === true) return update;
+				return update.where((eb) =>
+					eb.or([
+						eb("_emdash_entry_locks.user_id", "=", input.userId),
+						this.leaseHasExpired("_emdash_entry_locks.expires_at"),
+					]),
+				);
+			})
+			.returningAll()
+			.executeTakeFirst();
+	}
+
+	private liveQuery(collection: string, entryId: string) {
+		return this.db
+			.selectFrom("_emdash_entry_locks")
+			.leftJoin("users", "users.id", "_emdash_entry_locks.user_id")
+			.select([
+				"_emdash_entry_locks.collection",
+				"_emdash_entry_locks.entry_id",
+				"_emdash_entry_locks.user_id",
+				"_emdash_entry_locks.token",
+				"_emdash_entry_locks.acquired_at",
+				"_emdash_entry_locks.expires_at",
+				"users.name as user_name",
+			])
+			.where("_emdash_entry_locks.collection", "=", collection)
+			.where("_emdash_entry_locks.entry_id", "=", entryId)
+			.where(this.leaseIsLive("_emdash_entry_locks.expires_at"));
+	}
+
+	private async withHolderName(row: LockRow): Promise<EntryLock> {
+		const user = await this.db
+			.selectFrom("users")
+			.select("name")
+			.where("id", "=", row.user_id)
+			.executeTakeFirst();
+		return {
+			collection: row.collection,
+			entryId: row.entry_id,
+			userId: row.user_id,
+			userName: user?.name ?? null,
+			acquiredAt: row.acquired_at,
+			expiresAt: row.expires_at,
+		};
+	}
+
+	private leaseIsLive(column: string) {
+		const expiresAt = sql.ref(column);
+		return isPostgres(this.db)
+			? sql<boolean>`${expiresAt}::timestamptz > clock_timestamp()`
+			: sql<boolean>`${expiresAt} > strftime('%Y-%m-%dT%H:%M:%fZ', 'now')`;
+	}
+
+	private leaseHasExpired(column: string) {
+		const expiresAt = sql.ref(column);
+		return isPostgres(this.db)
+			? sql<boolean>`${expiresAt}::timestamptz <= clock_timestamp()`
+			: sql<boolean>`${expiresAt} <= strftime('%Y-%m-%dT%H:%M:%fZ', 'now')`;
+	}
+
+	private timestampOffset(offsetSeconds: number): RawBuilder<string> {
+		if (isPostgres(this.db)) {
+			return sql<string>`to_char(
+				(clock_timestamp() AT TIME ZONE 'UTC') + (${offsetSeconds} * INTERVAL '1 second'),
+				'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"'
+			)`;
+		}
+		return sql<string>`strftime(
+			'%Y-%m-%dT%H:%M:%fZ',
+			'now',
+			${`${offsetSeconds >= 0 ? "+" : ""}${offsetSeconds} seconds`}
+		)`;
+	}
+}

package/src/database/repositories/options.ts

@@ -1,5 +1,15 @@
-import { sql, type Kysely, type SqlBool } from "kysely";
-
+import { sql, type Insertable, type Kysely, type SqlBool } from "kysely";
+
+import {
+	assertStorageKey,
+	assertStorageRevision,
+	serializeConditionalValue,
+} from "../../plugins/conditional-storage.js";
+import type {
+	VersionedValue,
+	ConditionalWriteResult,
+	ConditionalDeleteResult,
+} from "../../plugins/types.js";
 import type { Database, OptionTable } from "../types.js";
 
 function escapeLike(value: string): string {
@@ -42,16 +52,19 @@ export class OptionsRepository {
 	 * Set an option value (creates or updates)
 	 */
 	async set<T = unknown>(name: string, value: T): Promise<void> {
-		const row: OptionTable = {
+		const row: Insertable<OptionTable> = {
 			name,
 			value: JSON.stringify(value),
+			revision: crypto.randomUUID(),
 		};
 
 		// Upsert: insert or replace
 		await this.db
 			.insertInto("options")
 			.values(row)
-			.onConflict((oc) => oc.column("name").doUpdateSet({ value: row.value }))
+			.onConflict((oc) =>
+				oc.column("name").doUpdateSet({ value: row.value, revision: row.revision }),
+			)
 			.execute();
 	}
 
@@ -64,9 +77,10 @@ export class OptionsRepository {
 	 * existed (regardless of its value — even an empty string or null).
 	 */
 	async setIfAbsent<T = unknown>(name: string, value: T): Promise<boolean> {
-		const row: OptionTable = {
+		const row: Insertable<OptionTable> = {
 			name,
 			value: JSON.stringify(value),
+			revision: crypto.randomUUID(),
 		};
 
 		const result = await this.db
@@ -80,6 +94,56 @@ export class OptionsRepository {
 		return (result.numInsertedOrUpdatedRows ?? 0n) > 0n;
 	}
 
+	async getVersioned<T = unknown>(name: string): Promise<VersionedValue<T> | null> {
+		assertStorageKey(name, 2048);
+		const row = await this.db
+			.selectFrom("options")
+			.select(["value", "revision"])
+			.where("name", "=", name)
+			.executeTakeFirst();
+		if (!row) return null;
+		return { value: JSON.parse(row.value), revision: row.revision };
+	}
+
+	async compareAndSet(
+		name: string,
+		expectedRevision: string | null,
+		value: unknown,
+	): Promise<ConditionalWriteResult> {
+		assertStorageKey(name, 2048);
+		if (expectedRevision !== null) assertStorageRevision(expectedRevision);
+		const serialized = serializeConditionalValue(value);
+		const revision = crypto.randomUUID();
+		const row =
+			expectedRevision === null
+				? await this.db
+						.insertInto("options")
+						.values({ name, value: serialized, revision })
+						.onConflict((oc) => oc.column("name").doNothing())
+						.returning("revision")
+						.executeTakeFirst()
+				: await this.db
+						.updateTable("options")
+						.set({ value: serialized, revision })
+						.where("name", "=", name)
+						.where("revision", "=", expectedRevision)
+						.returning("revision")
+						.executeTakeFirst();
+		return row ? { applied: true, revision: row.revision } : { applied: false };
+	}
+
+	async compareAndDelete(name: string, expectedRevision: string): Promise<ConditionalDeleteResult> {
+		assertStorageKey(name, 2048);
+		assertStorageRevision(expectedRevision);
+		const row = await this.db
+			.deleteFrom("options")
+			.where("name", "=", name)
+			.where("revision", "=", expectedRevision)
+			.returning("name")
+			.executeTakeFirst();
+		return { applied: row !== undefined };
+	}
+
 	/**
 	 * Delete an option
 	 */