emdash 0.16.0 → 0.17.0

package/src/client/index.ts

@@ -521,6 +521,7 @@ export class EmDashClient {
 			slug?: string;
 			status?: string;
 			_rev?: string;
+			locale?: string;
 		},
 	): Promise<ContentItem> {
 		// Convert markdown strings to PT
@@ -536,9 +537,11 @@ export class EmDashClient {
 			status: input.status,
 			...(input._rev ? { _rev: input._rev } : {}),
 		};
+		const params = new URLSearchParams();
+		if (input.locale) params.set("locale", input.locale);
 		const result = await this.request<{ item: ContentItem; _rev?: string }>(
 			"PUT",
-			`/content/${encodeURIComponent(collection)}/${encodeURIComponent(id)}`,
+			`/content/${encodeURIComponent(collection)}/${encodeURIComponent(id)}${params.toString() ? `?${params}` : ""}`,
 			body,
 		);
 

package/src/components/InlinePortableTextEditor.tsx

@@ -183,6 +183,14 @@ function convertPMNode(node: PMNode): PTBlock | PTBlock[] | null {
 				language: attrStrOpt(node.attrs, "language"),
 			};
 		}
+		case "htmlBlock": {
+			const rawHtml = node.attrs?.html;
+			return {
+				_type: "htmlBlock",
+				_key: k(),
+				html: typeof rawHtml === "string" ? rawHtml : "",
+			};
+		}
 		case "image": {
 			const provider = attrStrOpt(node.attrs, "provider");
 			return {
@@ -391,6 +399,13 @@ function convertPTBlock(block: PTBlock): JSONContent | null {
 	if (block._type === "break") {
 		return { type: "horizontalRule" };
 	}
+	if (block._type === "htmlBlock") {
+		const hb = block as PTBlock & { html?: string };
+		return {
+			type: "htmlBlock",
+			attrs: { html: hb.html || "" },
+		};
+	}
 	if (block._type === "image") {
 		const ib = block as PTBlock & {
 			asset?: { _ref?: string; url?: string; provider?: string };
@@ -731,6 +746,21 @@ const slashCommands: SlashCommandItem[] = [
 			editor.chain().focus().deleteRange(range).toggleCodeBlock().run();
 		},
 	},
+	{
+		id: "htmlBlock",
+		title: "HTML",
+		description: "Insert raw HTML",
+		icon: "< >",
+		aliases: ["html", "raw", "markup"],
+		command: ({ editor, range }) => {
+			editor
+				.chain()
+				.focus()
+				.deleteRange(range)
+				.insertContent({ type: "htmlBlock", attrs: { html: "" } })
+				.run();
+		},
+	},
 	{
 		id: "divider",
 		title: "Divider",
@@ -771,6 +801,44 @@ const initialSlashMenuState: SlashMenuState = {
 	range: null,
 };
 
+/**
+ * Minimal `htmlBlock` TipTap node for the inline (visual-editing) editor.
+ *
+ * Like PluginBlockNode below, this renders as a read-only placeholder so the
+ * block's data is preserved across edits in the visual editor. Full editing
+ * (textarea + preview) is only available in the admin editor.
+ */
+const HtmlBlockNode = Node.create({
+	name: "htmlBlock",
+	group: "block",
+	atom: true,
+	selectable: true,
+	draggable: true,
+
+	addAttributes() {
+		const noDom = { rendered: false, parseHTML: () => null };
+		return {
+			html: { default: "", ...noDom },
+		};
+	},
+
+	parseHTML() {
+		return [{ tag: 'div[data-emdash-html-block="true"]' }];
+	},
+
+	renderHTML({ HTMLAttributes }) {
+		return [
+			"div",
+			mergeAttributes(HTMLAttributes, {
+				"data-emdash-html-block": "true",
+				class: "emdash-plugin-block-placeholder",
+				contenteditable: "false",
+			}),
+			"HTML block (edit in admin)",
+		];
+	},
+});
+
 /**
  * Minimal `pluginBlock` TipTap node for the inline (visual-editing) editor.
  *
@@ -1801,6 +1869,7 @@ export function InlinePortableTextEditor({
 				mode: "all",
 			}),
 			Typography,
+			HtmlBlockNode,
 			PluginBlockNode,
 			slashCommandsExtension,
 		],

package/src/content/converters/portable-text-to-prosemirror.ts

@@ -121,6 +121,13 @@ function convertBlock(block: PortableTextBlock): ProseMirrorNode | null {
 	if (isCodeBlock(block)) {
 		return convertCodeBlock(block);
 	}
+	if (block._type === "htmlBlock") {
+		const hb = block as PortableTextBlock & { html?: string };
+		return {
+			type: "htmlBlock",
+			attrs: { html: hb.html || "" },
+		};
+	}
 	if (block._type === "break") {
 		return { type: "horizontalRule" };
 	}

package/src/content/converters/prosemirror-to-portable-text.ts

@@ -14,6 +14,7 @@ import type {
 	PortableTextMarkDef,
 	PortableTextImageBlock,
 	PortableTextCodeBlock,
+	PortableTextHtmlBlock,
 } from "./types.js";
 
 /**
@@ -70,6 +71,9 @@ function convertNode(node: ProseMirrorNode): PortableTextBlock | PortableTextBlo
 		case "codeBlock":
 			return convertCodeBlock(node);
 
+		case "htmlBlock":
+			return convertHtmlBlock(node);
+
 		case "image":
 			return convertImage(node);
 
@@ -268,6 +272,18 @@ function convertCodeBlock(node: ProseMirrorNode): PortableTextCodeBlock {
 	};
 }
 
+/**
+ * Convert HTML block to Portable Text
+ */
+function convertHtmlBlock(node: ProseMirrorNode): PortableTextHtmlBlock {
+	const rawHtml = node.attrs?.html;
+	return {
+		_type: "htmlBlock",
+		_key: generateKey(),
+		html: typeof rawHtml === "string" ? rawHtml : "",
+	};
+}
+
 /**
  * Convert image to Portable Text
  */

package/src/content/converters/types.ts

@@ -80,6 +80,15 @@ export interface PortableTextCodeBlock {
 	filename?: string;
 }
 
+/**
+ * HTML block (raw HTML content)
+ */
+export interface PortableTextHtmlBlock {
+	_type: "htmlBlock";
+	_key: string;
+	html: string;
+}
+
 /**
  * Unknown/custom block (preserved for plugin compatibility)
  */
@@ -96,6 +105,7 @@ export type PortableTextBlock =
 	| PortableTextTextBlock
 	| PortableTextImageBlock
 	| PortableTextCodeBlock
+	| PortableTextHtmlBlock
 	| PortableTextUnknownBlock;
 
 /**

package/src/database/migrations/041_content_locale_list_index.ts

@@ -0,0 +1,47 @@
+import type { Kysely } from "kysely";
+import { sql } from "kysely";
+
+import { listTablesLike } from "../dialect-helpers.js";
+
+/**
+ * Migration: locale-aware composite indexes for content list queries.
+ *
+ * Addresses GitHub issue #1219. When i18n is enabled the admin content list
+ * filters by `locale` and orders by `updated_at`/`created_at`. The existing
+ * composite indexes (033/034) cover `(deleted_at, updated_at DESC, id DESC)`
+ * etc. but omit `locale`, so a locale-filtered ordered list can't be served
+ * by a single index on large tables. These indexes restore index-only paging
+ * for the locale-scoped case.
+ *
+ * Forward-only and idempotent (`IF NOT EXISTS`).
+ *
+ * Index names use a short `loc_upd`/`loc_crt` suffix rather than spelling out
+ * `deleted_locale_updated_id`: Postgres truncates identifiers to 63 bytes, and
+ * the longer form pushes the `updated`/`created` discriminator past byte 63 for
+ * slugs as short as 40 chars, making both names truncate to the same string.
+ * 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) {
+		await sql`
+			CREATE INDEX IF NOT EXISTS ${sql.ref(`idx_${tableName}_loc_upd`)}
+			ON ${sql.ref(tableName)} (deleted_at, locale, updated_at DESC, id DESC)
+		`.execute(db);
+
+		await sql`
+			CREATE INDEX IF NOT EXISTS ${sql.ref(`idx_${tableName}_loc_crt`)}
+			ON ${sql.ref(tableName)} (deleted_at, locale, created_at DESC, id DESC)
+		`.execute(db);
+	}
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	const tableNames = await listTablesLike(db, "ec_%");
+
+	for (const tableName of tableNames) {
+		await sql`DROP INDEX IF EXISTS ${sql.ref(`idx_${tableName}_loc_upd`)}`.execute(db);
+		await sql`DROP INDEX IF EXISTS ${sql.ref(`idx_${tableName}_loc_crt`)}`.execute(db);
+	}
+}

package/src/database/migrations/042_byline_fields.ts

@@ -0,0 +1,157 @@
+import type { Kysely } from "kysely";
+import { sql } from "kysely";
+
+import { currentTimestamp } from "../dialect-helpers.js";
+
+/**
+ * Byline custom fields (Discussion #1174). Adds three tables and a
+ * version-counter row in `options`. Purely additive: no change to
+ * `_emdash_bylines` columns landed by migration 040, no change to
+ * `_emdash_content_bylines`.
+ *
+ * Storage model (D11 in the design spec):
+ *
+ * - `_emdash_byline_fields` — definitions. One row per registered field.
+ * - `_emdash_byline_field_values` — translatable values, keyed by
+ *   `(byline_id, field_id)`. One value per locale variant of a byline.
+ * - `_emdash_byline_field_group_values` — non-translatable values, keyed
+ *   by `(translation_group, field_id)`. One value shared across every
+ *   locale variant of the byline's translation group.
+ *
+ * The per-field `translatable` flag (column on `_emdash_byline_fields`)
+ * decides which value table a field writes to. The split is at the
+ * storage level rather than per-row so a single SELECT … IN per locale
+ * bucket suffices for batched hydration (see Phase 3 of the PR plan).
+ *
+ * `options('byline_fields_version', '0')` is the version counter the
+ * field-definitions cache reads (Phase 3). Every mutation on
+ * `_emdash_byline_fields` bumps this row; cached defs invalidate on a
+ * mismatch. Storing it in `options` (the same table `settings/index.ts`
+ * uses) means we get the request-cache + persisted-version pattern for
+ * free — no new infrastructure.
+ *
+ * Idempotency: every `CREATE TABLE` and `CREATE INDEX` uses
+ * `.ifNotExists()`, so a partial prior run (a crash mid-migration, retried
+ * after the runner's race-recovery path or after a manual fix) re-applies
+ * cleanly — including any indexes that landed in the failed pass after the
+ * table itself. A coarse table-level guard would skip the index step if the
+ * table existed but indexes didn't (the realistic crash window between
+ * `CREATE TABLE` and the next `CREATE INDEX`). The runner records applied
+ * migrations only after a successful pass, so a crashed-then-retried `up()`
+ * is the normal recovery path here.
+ *
+ * D1 has no transactions — the schema builder and `INSERT` for the
+ * version row execute one statement at a time. Order matters: parent
+ * tables first (`_emdash_byline_fields`), then the value tables that
+ * reference it. If `down()` runs after a partial `up()`, missing tables
+ * are tolerated (`DROP TABLE IF EXISTS`).
+ */
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+	await db.schema
+		.createTable("_emdash_byline_fields")
+		.ifNotExists()
+		.addColumn("id", "text", (col) => col.primaryKey())
+		.addColumn("slug", "text", (col) => col.notNull().unique())
+		.addColumn("label", "text", (col) => col.notNull())
+		.addColumn("type", "text", (col) => col.notNull())
+		.addColumn("required", "integer", (col) => col.notNull().defaultTo(0))
+		.addColumn("translatable", "integer", (col) => col.notNull().defaultTo(1))
+		.addColumn("validation", "text") // JSON: { options?: string[] }
+		.addColumn("sort_order", "integer", (col) => col.notNull().defaultTo(0))
+		.addColumn("created_at", "text", (col) => col.defaultTo(currentTimestamp(db)))
+		.addColumn("updated_at", "text", (col) => col.defaultTo(currentTimestamp(db)))
+		.execute();
+
+	await db.schema
+		.createIndex("idx__emdash_byline_fields_sort_order")
+		.ifNotExists()
+		.on("_emdash_byline_fields")
+		.column("sort_order")
+		.execute();
+
+	await db.schema
+		.createTable("_emdash_byline_field_values")
+		.ifNotExists()
+		.addColumn("byline_id", "text", (col) =>
+			col.notNull().references("_emdash_bylines.id").onDelete("cascade"),
+		)
+		.addColumn("field_id", "text", (col) =>
+			col.notNull().references("_emdash_byline_fields.id").onDelete("cascade"),
+		)
+		.addColumn("value", "text") // JSON-encoded CustomFieldValue
+		.addColumn("created_at", "text", (col) => col.defaultTo(currentTimestamp(db)))
+		.addColumn("updated_at", "text", (col) => col.defaultTo(currentTimestamp(db)))
+		.addPrimaryKeyConstraint("_emdash_byline_field_values_pk", ["byline_id", "field_id"])
+		.execute();
+
+	await db.schema
+		.createIndex("idx__emdash_byline_field_values_byline")
+		.ifNotExists()
+		.on("_emdash_byline_field_values")
+		.column("byline_id")
+		.execute();
+	await db.schema
+		.createIndex("idx__emdash_byline_field_values_field")
+		.ifNotExists()
+		.on("_emdash_byline_field_values")
+		.column("field_id")
+		.execute();
+
+	await db.schema
+		.createTable("_emdash_byline_field_group_values")
+		.ifNotExists()
+		.addColumn("translation_group", "text", (col) => col.notNull())
+		.addColumn("field_id", "text", (col) =>
+			col.notNull().references("_emdash_byline_fields.id").onDelete("cascade"),
+		)
+		.addColumn("value", "text") // JSON-encoded CustomFieldValue
+		.addColumn("created_at", "text", (col) => col.defaultTo(currentTimestamp(db)))
+		.addColumn("updated_at", "text", (col) => col.defaultTo(currentTimestamp(db)))
+		.addPrimaryKeyConstraint("_emdash_byline_field_group_values_pk", [
+			"translation_group",
+			"field_id",
+		])
+		.execute();
+
+	await db.schema
+		.createIndex("idx__emdash_byline_field_group_values_group")
+		.ifNotExists()
+		.on("_emdash_byline_field_group_values")
+		.column("translation_group")
+		.execute();
+	await db.schema
+		.createIndex("idx__emdash_byline_field_group_values_field")
+		.ifNotExists()
+		.on("_emdash_byline_field_group_values")
+		.column("field_id")
+		.execute();
+
+	// Version-counter row read by the field-definitions cache (Phase 3).
+	// `options.value` stores JSON, so the initial counter is the JSON literal
+	// `0`. `INSERT … ON CONFLICT DO NOTHING` so a retry after a crash that
+	// landed the row but failed later in the migration does not double-insert.
+	await sql`
+		INSERT INTO options (name, value) VALUES ('byline_fields_version', '0')
+		ON CONFLICT (name) DO NOTHING
+	`.execute(db);
+}
+
+/**
+ * Reverses the schema additions and removes the version-counter row.
+ * Used by the test suite and by `rollbackMigration`; the runner itself
+ * never invokes `down()` automatically.
+ *
+ * The drops are unconditional `IF EXISTS` so a `down()` after a partial
+ * `up()` (only one or two tables landed) still settles the database back
+ * to its pre-042 state.
+ */
+export async function down(db: Kysely<unknown>): Promise<void> {
+	// Child tables first to avoid FK reference issues on Postgres. SQLite +
+	// D1 accept either order with `IF EXISTS`, but explicit ordering keeps
+	// the dialects parity-safe.
+	await db.schema.dropTable("_emdash_byline_field_group_values").ifExists().execute();
+	await db.schema.dropTable("_emdash_byline_field_values").ifExists().execute();
+	await db.schema.dropTable("_emdash_byline_fields").ifExists().execute();
+	await sql`DELETE FROM options WHERE name = 'byline_fields_version'`.execute(db);
+}

package/src/database/migrations/runner.ts

@@ -42,6 +42,8 @@ import * as m037 from "./037_credential_algorithm.js";
 import * as m038 from "./038_registry_plugin_state.js";
 import * as m039 from "./039_fix_fts5_triggers.js";
 import * as m040 from "./040_byline_i18n.js";
+import * as m041 from "./041_content_locale_list_index.js";
+import * as m042 from "./042_byline_fields.js";
 
 const MIGRATIONS: Readonly<Record<string, Migration>> = Object.freeze({
 	"001_initial": m001,
@@ -83,6 +85,8 @@ const MIGRATIONS: Readonly<Record<string, Migration>> = Object.freeze({
 	"038_registry_plugin_state": m038,
 	"039_fix_fts5_triggers": m039,
 	"040_byline_i18n": m040,
+	"041_content_locale_list_index": m041,
+	"042_byline_fields": m042,
 });
 
 /** Total number of registered migrations. Exported for use in tests. */