emdash 0.32.0 → 0.34.0

package/src/content/portable-text-lists.ts

@@ -0,0 +1,205 @@
+import {
+	deriveLegacyListId,
+	normalizeListId,
+	normalizeListStart,
+} from "./converters/numbered-list.js";
+
+type ListNestingMode = "html" | "direct";
+type PortableTextNode = Record<string, unknown>;
+
+interface PortableTextListBlock extends PortableTextNode {
+	_type: "block";
+	children: unknown[];
+	level?: number;
+	listId?: unknown;
+	listItem: string;
+	listStart?: unknown;
+}
+
+export interface PortableTextListNode extends PortableTextNode {
+	_type: "@list";
+	_key: string;
+	children: PortableTextNode[];
+	level: number;
+	listItem: string;
+	mode: ListNestingMode;
+	start?: number;
+}
+
+interface ListDescriptor {
+	node: PortableTextListNode;
+	directItems: Array<{
+		original: PortableTextListBlock;
+		rendered: PortableTextListBlock;
+	}>;
+	level: number;
+	parentContext: string;
+	sourceId: string | undefined;
+	segment: number;
+}
+
+interface ParentItem {
+	context: string;
+	list: ListDescriptor;
+	rendered: PortableTextListBlock;
+}
+
+function isListBlock(node: PortableTextNode): node is PortableTextListBlock {
+	return (
+		node._type === "block" && typeof node.listItem === "string" && Array.isArray(node.children)
+	);
+}
+
+function readLevel(value: unknown): number {
+	return typeof value === "number" && Number.isInteger(value) && value >= 1 ? value : 1;
+}
+
+function findParentItem(items: Map<number, ParentItem>, level: number): ParentItem | undefined {
+	let nearestLevel = 0;
+	let nearest: ParentItem | undefined;
+	for (const [candidate, item] of items) {
+		if (candidate < level && candidate > nearestLevel) {
+			nearestLevel = candidate;
+			nearest = item;
+		}
+	}
+	return nearest;
+}
+
+function matchesList(
+	descriptor: ListDescriptor | undefined,
+	listItem: string,
+	sourceId: string | undefined,
+	parentContext: string,
+): descriptor is ListDescriptor {
+	return (
+		descriptor !== undefined &&
+		descriptor.node.listItem === listItem &&
+		descriptor.parentContext === parentContext &&
+		(listItem !== "number" || descriptor.sourceId === sourceId)
+	);
+}
+
+function buildListTree(
+	blocks: PortableTextNode[],
+	mode: ListNestingMode,
+): { tree: PortableTextNode[]; descriptors: ListDescriptor[] } {
+	const tree: PortableTextNode[] = [];
+	const descriptors: ListDescriptor[] = [];
+	const activeLists = new Map<number, ListDescriptor>();
+	const lastItems = new Map<number, ParentItem>();
+	let segment = 0;
+
+	for (let index = 0; index < blocks.length; index++) {
+		const block = blocks[index];
+		if (!isListBlock(block)) {
+			tree.push(block);
+			activeLists.clear();
+			lastItems.clear();
+			continue;
+		}
+
+		const level = readLevel(block.level);
+		for (const activeLevel of activeLists.keys()) {
+			if (activeLevel > level) activeLists.delete(activeLevel);
+		}
+		for (const itemLevel of lastItems.keys()) {
+			if (itemLevel > level) lastItems.delete(itemLevel);
+		}
+
+		const parent = findParentItem(lastItems, level);
+		const parentContext = parent?.context ?? "root";
+		const sourceId = block.listItem === "number" ? normalizeListId(block.listId) : undefined;
+		let descriptor = activeLists.get(level);
+		if (!matchesList(descriptor, block.listItem, sourceId, parentContext)) {
+			const node: PortableTextListNode = {
+				_type: "@list",
+				_key: `${typeof block._key === "string" ? block._key : index}-parent`,
+				children: [],
+				level,
+				listItem: block.listItem,
+				mode,
+			};
+			descriptor = {
+				node,
+				directItems: [],
+				level,
+				parentContext,
+				sourceId,
+				segment: segment++,
+			};
+			descriptors.push(descriptor);
+			activeLists.set(level, descriptor);
+			if (!parent) {
+				tree.push(node);
+			} else if (mode === "direct") {
+				parent.list.node.children.push(node);
+			} else {
+				parent.rendered.children.push(node);
+			}
+		}
+
+		const rendered = { ...block, children: [...block.children] };
+		descriptor.node.children.push(rendered);
+		descriptor.directItems.push({ original: block, rendered });
+		lastItems.set(level, {
+			context: `${parentContext}/item:${index}`,
+			list: descriptor,
+			rendered,
+		});
+	}
+
+	return { tree, descriptors };
+}
+
+function applyNumbering(descriptors: ListDescriptor[]): void {
+	const bases = new Map<string, number>();
+	const scopeKeys = new Map<ListDescriptor, string>();
+	for (const descriptor of descriptors) {
+		if (descriptor.node.listItem !== "number") continue;
+		const identity =
+			descriptor.sourceId ??
+			deriveLegacyListId(
+				`render:${descriptor.segment}:${descriptor.level}:${descriptor.parentContext}`,
+			);
+		const scope = JSON.stringify([identity, descriptor.level, descriptor.parentContext]);
+		scopeKeys.set(descriptor, scope);
+		if (!descriptor.sourceId || bases.has(scope)) continue;
+		for (const { original } of descriptor.directItems) {
+			const base = normalizeListStart(original.listStart);
+			if (base === undefined) continue;
+			bases.set(scope, base);
+			break;
+		}
+	}
+
+	const counts = new Map<string, number>();
+	for (const descriptor of descriptors) {
+		if (descriptor.node.listItem !== "number") continue;
+		const scope = scopeKeys.get(descriptor)!;
+		const base = bases.get(scope) ?? 1;
+		const count = counts.get(scope) ?? 0;
+		descriptor.node.start = normalizeListStart(base + count) ?? 1;
+		counts.set(scope, count + descriptor.directItems.length);
+	}
+}
+
+function preprocessLists(
+	blocks: PortableTextNode[],
+	mode: ListNestingMode,
+): { tree: PortableTextNode[]; descriptors: ListDescriptor[] } {
+	const result = buildListTree(blocks, mode);
+	applyNumbering(result.descriptors);
+	return result;
+}
+
+export function clonePortableTextValue<T>(value: T): T {
+	return structuredClone(value);
+}
+
+export function buildPortableTextListTree(
+	blocks: PortableTextNode[],
+	mode: ListNestingMode = "html",
+): PortableTextNode[] {
+	return preprocessLists(blocks, mode).tree;
+}

package/src/content-list-query.ts

@@ -0,0 +1,29 @@
+/** Scalar values accepted by indexed content-field filters. */
+export type ContentFieldFilterScalar = string | number | boolean | null;
+
+/** Inclusive or exclusive bounds for an indexed scalar field. */
+export interface ContentFieldRangeFilter {
+	gt?: string | number;
+	gte?: string | number;
+	lt?: string | number;
+	lte?: string | number;
+}
+
+/** Match any one of the supplied values. */
+export interface ContentFieldInFilter {
+	in: Array<string | number | boolean>;
+}
+
+/** A single indexed content-field condition. */
+export type ContentFieldFilterValue =
+	| ContentFieldFilterScalar
+	| ContentFieldRangeFilter
+	| ContentFieldInFilter;
+
+/**
+ * Indexed custom-field filters, combined with AND semantics.
+ *
+ * A scalar performs an exact match, `null` matches missing values, `{ in: [...] }`
+ * performs membership matching, and range bounds can be combined.
+ */
+export type ContentFieldFilters = Record<string, ContentFieldFilterValue>;

package/src/database/dialect-helpers.ts

@@ -107,35 +107,16 @@ export function currentTimestampValue(db: Kysely<any>): RawBuilder<string> {
 
 /**
  * Build WHERE clause for status filtering on a content table.
- * When filtering for 'published' status, also include scheduled content
- * whose scheduled_at time has passed (treating it as effectively published).
- *
- * Visibility is computed, not flipped by cron, so a literal
- * `status = 'published'` comparison undercounts scheduled-and-due entries —
- * every "publicly visible" filter must go through this helper.
+ * Scheduled content becomes public only after the publication sweep commits
+ * the row with a literal `published` status.
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any -- accepts any Kysely instance
 export function buildStatusCondition(
-	db: Kysely<any>,
+	_db: Kysely<any>,
 	status: string,
 	tablePrefix?: string,
 ): ReturnType<typeof sql> {
 	const statusField = tablePrefix ? `${tablePrefix}.status` : "status";
-	const scheduledAtField = tablePrefix ? `${tablePrefix}.scheduled_at` : "scheduled_at";
-
-	if (status === "published") {
-		// Include both published content AND scheduled content past its publish time.
-		// scheduled_at is stored as text (ISO 8601). On Postgres, we must cast it
-		// to timestamptz for the comparison with CURRENT_TIMESTAMP to work.
-		const scheduledAtExpr = isPostgres(db)
-			? sql`${sql.ref(scheduledAtField)}::timestamptz`
-			: sql.ref(scheduledAtField);
-		const nowExpr = isPostgres(db)
-			? currentTimestampValue(db)
-			: sql`strftime('%Y-%m-%dT%H:%M:%fZ', 'now')`;
-		return sql`(${sql.ref(statusField)} = 'published' OR (${sql.ref(statusField)} = 'scheduled' AND ${scheduledAtExpr} <= ${nowExpr}))`;
-	}
-
 	return sql`${sql.ref(statusField)} = ${status}`;
 }
 

package/src/database/migrations/055_content_translation_group_locale_index.ts

@@ -0,0 +1,67 @@
+import type { Kysely } from "kysely";
+import { sql } from "kysely";
+
+import { listTablesLike } from "../dialect-helpers.js";
+
+/**
+ * Migration: replace the single-column content `translation_group` index with
+ * one index per translation-group read shape.
+ *
+ * There are two shapes. Translation-group reads filter `deleted_at IS NULL`
+ * with `translation_group = ?` / `IN (...)` and order by locale; menu and
+ * reference resolution looks a group up by `translation_group` (+ `locale`)
+ * alone, with no `deleted_at` term.
+ *
+ * Neither shape can borrow the other's index. Seeking migration 041's
+ * `(deleted_at, locale, ...)` composites on `deleted_at` alone already returns
+ * rows in locale order, so a stats-blind planner prefers them over a
+ * single-column `translation_group` index and reads every non-deleted row in
+ * the table; the batched variant is worse still, because the `IN (...)` list
+ * multiplies the planner's row estimate for a `translation_group`-leading index
+ * and it falls back to a `deleted_at` composite from a handful of groups
+ * onward. Going the other way, an index leading with `deleted_at` cannot seek a
+ * lookup that never constrains that column. D1 never has `sqlite_stat1`, so the
+ * index shape is the only lever and each shape needs a prefix matching it term
+ * for term.
+ *
+ * Forward-only and idempotent (`IF NOT EXISTS`).
+ *
+ * Index names use short `tg_locale` / `del_tg_locale` suffixes rather than
+ * spelling out `translation_group`: Postgres truncates identifiers to 63 bytes,
+ * and the longer forms truncate to the same value for long collection slugs.
+ * Keep these identical to the names in `schema/registry.ts`.
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	const tableNames = await listTablesLike(db, "ec_%");
+
+	for (const tableName of tableNames) {
+		// D1 DDL is non-transactional: create the replacements before dropping the
+		// old index so an interrupted migration always leaves a
+		// translation_group-leading index in place.
+		await sql`
+			CREATE INDEX IF NOT EXISTS ${sql.ref(`idx_${tableName}_tg_locale`)}
+			ON ${sql.ref(tableName)} (translation_group, locale)
+		`.execute(db);
+
+		await sql`
+			CREATE INDEX IF NOT EXISTS ${sql.ref(`idx_${tableName}_del_tg_locale`)}
+			ON ${sql.ref(tableName)} (deleted_at, translation_group, locale)
+		`.execute(db);
+
+		await sql`DROP INDEX IF EXISTS ${sql.ref(`idx_${tableName}_translation_group`)}`.execute(db);
+	}
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	const tableNames = await listTablesLike(db, "ec_%");
+
+	for (const tableName of tableNames) {
+		await sql`
+			CREATE INDEX IF NOT EXISTS ${sql.ref(`idx_${tableName}_translation_group`)}
+			ON ${sql.ref(tableName)} (translation_group)
+		`.execute(db);
+
+		await sql`DROP INDEX IF EXISTS ${sql.ref(`idx_${tableName}_del_tg_locale`)}`.execute(db);
+		await sql`DROP INDEX IF EXISTS ${sql.ref(`idx_${tableName}_tg_locale`)}`.execute(db);
+	}
+}

package/src/database/migrations/056_taxonomy_term_sort_order.ts

@@ -0,0 +1,189 @@
+import { sql, type Kysely } from "kysely";
+
+import { columnExists } from "../dialect-helpers.js";
+
+/**
+ * Add `taxonomies.sort_order` and mint a position for every existing term.
+ *
+ * A position belongs to a `translation_group`, not a row: every row of a group
+ * carries the same value. Groups are numbered by `(label, id)` — the order term
+ * listings used before this migration — taking the label from the group's lowest
+ * row id. That locale's rendered order is unchanged; every other locale is
+ * re-sorted to match it, since only one locale's collation can win.
+ *
+ * Sibling groups are keyed on the raw `parent_id` column, which holds the
+ * parent's translation_group, so a group whose rows disagree about their parent
+ * is reconciled before numbering — otherwise it lands in whichever sibling group
+ * one arbitrary row happens to name.
+ *
+ * Only the `ALTER` is guarded; the passes below run unconditionally so a run that
+ * dies partway can be retried. Guarding the whole migration strands a partial
+ * numbering, because the retry early-returns on the column it added.
+ */
+
+/**
+ * Translation groups per `UPDATE`. Each costs three bound parameters — a CASE
+ * `WHEN`/`THEN` pair plus one slot in the `IN` list — which keeps a statement
+ * inside D1's 100-parameter ceiling. Writing one group per statement instead
+ * spends a subrequest per term, and a large taxonomy exhausts the 1,000 a
+ * Worker gets on the free plan before the migration finishes.
+ */
+const GROUPS_PER_UPDATE = 32;
+
+interface TermRow {
+	id: string;
+	name: string;
+	label: string | null;
+	parent_id: string | null;
+	translation_group: string;
+}
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+	const fresh = !(await columnExists(db, "taxonomies", "sort_order"));
+	if (fresh) {
+		await db.schema
+			.alterTable("taxonomies")
+			.addColumn("sort_order", "integer", (col) => col.notNull().defaultTo(0))
+			.execute();
+	}
+
+	// Migration 036 seeded `translation_group = id` on every row it rebuilt, and
+	// the repository has set it on every insert since, so this normally matches
+	// nothing. It runs anyway because everything below keys sibling groups on the
+	// column directly: a row that slipped through with a null would be numbered
+	// into no group at all, and would already be invisible to translation lookups
+	// and to `content_taxonomies`, which joins on the same value.
+	await sql`UPDATE taxonomies SET translation_group = id WHERE translation_group IS NULL`.execute(
+		db,
+	);
+
+	const { rows } = await sql<TermRow>`
+		SELECT id, name, label, parent_id, translation_group FROM taxonomies
+	`.execute(db);
+
+	await repairParents(db, rows);
+	await mintPositions(db, rows, fresh);
+}
+
+/**
+ * Give every row of a translation_group the same `parent_id`, mutating `rows` so
+ * the numbering below sees the reconciled tree.
+ *
+ * `parent_id` holds the parent's translation_group, so it is locale-agnostic and
+ * a group's rows should all agree. Reparenting used to write a single row, which
+ * left a term nested in the locale it was moved in and a root everywhere else.
+ * A non-null parent wins: it is the move somebody made, and the null is the row
+ * that missed it.
+ *
+ * The winner is copied from a sibling row, so it already satisfies the self-FK
+ * on `parent_id` and can't be rewritten into a dangling reference.
+ */
+async function repairParents(db: Kysely<unknown>, rows: TermRow[]): Promise<void> {
+	const byGroup = new Map<string, TermRow[]>();
+	for (const row of rows) {
+		const group = row.translation_group;
+		let members = byGroup.get(group);
+		if (!members) byGroup.set(group, (members = []));
+		members.push(row);
+	}
+
+	const winners = new Map<string, string>();
+	for (const [group, members] of byGroup) {
+		if (new Set(members.map((member) => member.parent_id)).size < 2) continue;
+
+		const parented = members.filter((member) => member.parent_id !== null);
+		// The anchor row decides when it names a parent, else the lowest row id
+		// that does, so the choice is the same however the rows come back.
+		const anchor = parented.find((member) => member.id === group);
+		const decider = anchor ?? parented.toSorted((a, b) => a.id.localeCompare(b.id))[0];
+		const winner = decider?.parent_id;
+		if (winner === undefined || winner === null) continue;
+
+		winners.set(group, winner);
+		for (const member of members) member.parent_id = winner;
+	}
+
+	await applyByGroup(db, "parent_id", winners);
+}
+
+/**
+ * Number each sibling group by `(label, id)`.
+ *
+ * When the column was just added every row already reads 0, so those positions
+ * are left to the default. On a retry the column is already there and may hold
+ * numbers from the run that failed, so every position is written explicitly.
+ */
+async function mintPositions(
+	db: Kysely<unknown>,
+	rows: readonly TermRow[],
+	fresh: boolean,
+): Promise<void> {
+	// One entry per translation_group: a group holds a single position, and its
+	// rows can disagree on label across locales, so the lowest row id decides for
+	// the whole group. Taxonomy names are `[a-z][a-z0-9_]*` and parents are
+	// ULIDs, so "/" can't appear in either half of the sibling key.
+	const groups = new Map<string, { sibling: string; label: string; id: string }>();
+	for (const row of rows) {
+		const group = row.translation_group;
+		const chosen = groups.get(group);
+		if (chosen && chosen.id <= row.id) continue;
+		groups.set(group, {
+			sibling: row.name + "/" + (row.parent_id ?? ""),
+			label: row.label ?? "",
+			id: row.id,
+		});
+	}
+
+	const siblings = new Map<string, { group: string; label: string; id: string }[]>();
+	for (const [group, { sibling, label, id }] of groups) {
+		let members = siblings.get(sibling);
+		if (!members) siblings.set(sibling, (members = []));
+		members.push({ group, label, id });
+	}
+
+	const positions = new Map<string, number>();
+	for (const members of siblings.values()) {
+		members.sort((a, b) => a.label.localeCompare(b.label) || a.id.localeCompare(b.id));
+		for (const [position, member] of members.entries()) {
+			if (position === 0 && fresh) continue;
+			positions.set(member.group, position);
+		}
+	}
+
+	await applyByGroup(db, "sort_order", positions);
+}
+
+/**
+ * Set one column per translation_group, chunked to stay inside the parameter
+ * ceiling.
+ */
+async function applyByGroup(
+	db: Kysely<unknown>,
+	column: "parent_id" | "sort_order",
+	values: ReadonlyMap<string, string | number>,
+): Promise<void> {
+	const entries = [...values];
+	// The CAST types the bound value. Postgres resolves a CASE whose THEN arms are
+	// all untyped parameters to text, then refuses to assign text to an integer
+	// column.
+	const valueType = column === "sort_order" ? sql`INTEGER` : sql`TEXT`;
+	for (let index = 0; index < entries.length; index += GROUPS_PER_UPDATE) {
+		const chunk = entries.slice(index, index + GROUPS_PER_UPDATE);
+		const arms = sql.join(
+			chunk.map(([group, value]) => sql`WHEN ${group} THEN CAST(${value} AS ${valueType})`),
+			sql` `,
+		);
+		const keys = sql.join(chunk.map(([group]) => sql`${group}`));
+		await sql`
+			UPDATE taxonomies
+			SET ${sql.ref(column)} = CASE translation_group ${arms} END
+			WHERE translation_group IN (${keys})
+		`.execute(db);
+	}
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	if (await columnExists(db, "taxonomies", "sort_order")) {
+		await db.schema.alterTable("taxonomies").dropColumn("sort_order").execute();
+	}
+}

package/src/database/migrations/057_collection_hidden.ts

@@ -0,0 +1,24 @@
+import type { Kysely } from "kysely";
+
+import { columnExists } from "../dialect-helpers.js";
+
+/**
+ * Migration: hide a collection from the admin sidebar.
+ *
+ * Adds `hidden` to `_emdash_collections`. A hidden collection stays fully
+ * functional (REST API, MCP, plugin hooks, direct `/content/:collection`
+ * URLs) — only its auto-generated sidebar entry is omitted, so plugins that
+ * own a collection end to end can steer editors to their own admin UI.
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	if (!(await columnExists(db, "_emdash_collections", "hidden"))) {
+		await db.schema
+			.alterTable("_emdash_collections")
+			.addColumn("hidden", "integer", (col) => col.notNull().defaultTo(0))
+			.execute();
+	}
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await db.schema.alterTable("_emdash_collections").dropColumn("hidden").execute();
+}

package/src/database/migrations/058_collection_sort_order.ts

@@ -0,0 +1,20 @@
+import type { Kysely } from "kysely";
+
+import { columnExists } from "../dialect-helpers.js";
+
+/**
+ * Migration: explicit collection order in the admin sidebar.
+ *
+ * Adds `sort_order` to `_emdash_collections`. A NULL `sort_order` means no
+ * explicit position: those collections sort after the ordered ones, keeping
+ * the alphabetical-by-slug order.
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	if (!(await columnExists(db, "_emdash_collections", "sort_order"))) {
+		await db.schema.alterTable("_emdash_collections").addColumn("sort_order", "integer").execute();
+	}
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await db.schema.alterTable("_emdash_collections").dropColumn("sort_order").execute();
+}

package/src/database/migrations/059_revision_prune_queue.ts

@@ -0,0 +1,36 @@
+import { sql, type Kysely } from "kysely";
+
+const REVISION_KEEP_COUNT = 50;
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+	await db.schema
+		.createTable("_emdash_revision_prune_queue")
+		.ifNotExists()
+		.addColumn("collection", "text", (column) => column.notNull())
+		.addColumn("entry_id", "text", (column) => column.notNull())
+		.addColumn("revision_id", "text", (column) => column.notNull())
+		.addPrimaryKeyConstraint("revision_prune_queue_pk", ["collection", "entry_id"])
+		.execute();
+
+	await db.schema
+		.createIndex("idx_revision_prune_queue_revision_id")
+		.ifNotExists()
+		.on("_emdash_revision_prune_queue")
+		.column("revision_id")
+		.execute();
+
+	await sql`
+		INSERT INTO _emdash_revision_prune_queue (collection, entry_id, revision_id)
+		SELECT collection, entry_id, MAX(id)
+		FROM revisions
+		WHERE true
+		GROUP BY collection, entry_id
+		HAVING COUNT(*) > ${REVISION_KEEP_COUNT}
+		ON CONFLICT (collection, entry_id)
+		DO UPDATE SET revision_id = excluded.revision_id
+	`.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await db.schema.dropTable("_emdash_revision_prune_queue").ifExists().execute();
+}

package/src/database/migrations/060_collection_admin_config.ts

@@ -0,0 +1,16 @@
+import type { Kysely } from "kysely";
+
+import { columnExists } from "../dialect-helpers.js";
+
+/** Persist collection-level admin presentation options. */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	if (!(await columnExists(db, "_emdash_collections", "admin_config"))) {
+		await db.schema.alterTable("_emdash_collections").addColumn("admin_config", "text").execute();
+	}
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	if (await columnExists(db, "_emdash_collections", "admin_config")) {
+		await db.schema.alterTable("_emdash_collections").dropColumn("admin_config").execute();
+	}
+}