emdash 0.28.0 → 0.29.0

package/src/components/EmDashHead.astro

@@ -33,6 +33,8 @@ import { renderSiteIdentity } from "../page/site-identity.js";
 import { getPageRuntime } from "../page/index.js";
 import { getSiteSettings } from "../settings/index.js";
 import { absolutizeMediaUrl } from "../page/absolute-url.js";
+import { getHreflangAlternates } from "../seo/hreflang.js";
+import { isI18nEnabled } from "../i18n/config.js";
 
 interface Props {
 	page: PublicPageContext;
@@ -83,8 +85,32 @@ if (runtime) {
 		defaultOgImage,
 	);
 
+	// hreflang alternates for translated content entries (#1690). Only
+	// queried when i18n is enabled and this page renders a content entry;
+	// non-i18n sites skip this entirely. Contributions sit with the base
+	// layer, so plugins can override individual hreflang entries (dedup
+	// key is the hreflang value).
+	let hreflangContributions: PageMetadataContribution[] = [];
+	if (page.content && isI18nEnabled()) {
+		const siteUrl = page.siteUrl || siteSettings.url || new URL(page.url).origin;
+		const alternates = await getHreflangAlternates(page.content.collection, page.content.id, {
+			siteUrl,
+		});
+		hreflangContributions = alternates.map((a) => ({
+			kind: "link",
+			rel: "alternate",
+			href: a.href,
+			hreflang: a.hreflang,
+		}));
+	}
+
 	const siteContributions = generateSiteSeoContributions(siteSettings.seo);
-	const allContributions = [...pluginContributions, ...siteContributions, ...baseContributions];
+	const allContributions = [
+		...pluginContributions,
+		...siteContributions,
+		...baseContributions,
+		...hreflangContributions,
+	];
 	const resolved = resolvePageMetadata(allContributions);
 	jsonLdScripts = resolved.jsonld;
 	metadataHtml = renderPageMetadata(resolved, { includeJsonLd: false });

package/src/components/InlinePortableTextEditor.tsx

@@ -365,6 +365,40 @@ function portableTextToPM(blocks: PTBlock[]): JSONContent {
 				} else break;
 			}
 			content.push(convertPTList(listBlocks, listType));
+		} else if (
+			isPTTextBlock(block) &&
+			block.style === "blockquote" &&
+			block.listItem === undefined
+		) {
+			// Group consecutive blockquote blocks into ONE blockquote node —
+			// PT is flat, so a multi-paragraph quote is stored as a run of
+			// blockquote-styled blocks. Mirrors the grouping in
+			// content/converters/portable-text-to-prosemirror.ts; without it
+			// merges revert on reload in the inline editor too (#1884).
+			const quoteBlocks: PTTextBlock[] = [];
+			while (i < blocks.length) {
+				const cur = blocks[i];
+				if (
+					!cur ||
+					!isPTTextBlock(cur) ||
+					cur.style !== "blockquote" ||
+					cur.listItem !== undefined
+				) {
+					break;
+				}
+				quoteBlocks.push(cur);
+				i++;
+			}
+			content.push({
+				type: "blockquote",
+				content: quoteBlocks.map((quoteBlock) => {
+					const pmContent = convertPTSpans(quoteBlock.children, quoteBlock.markDefs || []);
+					return {
+						type: "paragraph",
+						content: pmContent.length > 0 ? pmContent : undefined,
+					};
+				}),
+			});
 		} else {
 			const c = convertPTBlock(block);
 			if (c) content.push(c);

package/src/components/PortableText.astro

@@ -22,6 +22,7 @@ import { getEditMeta } from "../query.js";
 import { pluginBlockComponents } from "virtual:emdash/block-components";
 import { emdashComponents } from "./index.js";
 import InlineEditor from "./InlineEditor.astro";
+import { groupBlockquoteRuns } from "./portable-text-blockquote-group.js";
 
 export interface Props extends Omit<PortableTextProps, "value"> {
 	value: PortableTextProps["value"];
@@ -37,6 +38,11 @@ const withPlugins = mergeComponents(emdashComponents, { type: pluginBlockCompone
 const mergedComponents = userComponents
 	? mergeComponents(withPlugins, userComponents)
 	: withPlugins;
+
+// A multi-paragraph quote is stored as consecutive blockquote-styled blocks
+// (Portable Text is flat); merge each run into one blockquoteGroup node so
+// it renders as a single <blockquote> instead of several (#1884).
+const renderValue = Array.isArray(value) ? groupBlockquoteRuns(value) : value;
 ---
 
 {editMeta ? (
@@ -47,5 +53,5 @@ const mergedComponents = userComponents
 		field={editMeta.field}
 	/>
 ) : (
-	<BasePortableText value={value} components={mergedComponents} {...rest} />
+	<BasePortableText value={renderValue} components={mergedComponents} {...rest} />
 )}

package/src/components/index.ts

@@ -59,6 +59,7 @@ export { default as StrikeThrough } from "./marks/StrikeThrough.astro";
 export { default as Link } from "./marks/Link.astro";
 
 import BlockComponent from "./Block.astro";
+import BlockquoteGroupComponent from "./BlockquoteGroup.astro";
 import BreakComponent from "./Break.astro";
 import ButtonComponent from "./Button.astro";
 import ButtonsComponent from "./Buttons.astro";
@@ -88,6 +89,7 @@ import TableComponent from "./Table.astro";
 export const emdashComponents = {
 	block: BlockComponent,
 	type: {
+		blockquoteGroup: BlockquoteGroupComponent,
 		image: ImageComponent,
 		code: CodeComponent,
 		embed: EmbedComponent,

package/src/components/portable-text-blockquote-group.ts

@@ -0,0 +1,68 @@
+/**
+ * Groups consecutive Portable Text blocks with style "blockquote" into a
+ * single synthetic `blockquoteGroup` node so they render as ONE
+ * `<blockquote>` with a paragraph per block.
+ *
+ * Portable Text is flat: a multi-paragraph quote (e.g. from a WordPress
+ * `core/quote` import) is stored as consecutive blocks with
+ * `style: "blockquote"`. Rendering each of those as its own `<blockquote>`
+ * visually splits the quote (#1884).
+ *
+ * Runs of a single block are left untouched, so existing single-paragraph
+ * quotes render byte-for-byte as before.
+ */
+
+interface TextBlockLike {
+	_type: string;
+	_key?: string;
+	style?: string;
+	listItem?: string;
+}
+
+export interface BlockquoteGroupNode {
+	_type: "blockquoteGroup";
+	_key: string;
+	blocks: TextBlockLike[];
+}
+
+function isBlockquoteBlock(block: unknown): block is TextBlockLike {
+	if (typeof block !== "object" || block === null) return false;
+	const b: Partial<TextBlockLike> = block;
+	// Quote-styled list items belong to their list, not to a quote run.
+	return b._type === "block" && b.style === "blockquote" && b.listItem === undefined;
+}
+
+export function groupBlockquoteRuns(blocks: unknown[]): unknown[] {
+	const result: unknown[] = [];
+	let i = 0;
+
+	while (i < blocks.length) {
+		const current = blocks[i];
+		if (!isBlockquoteBlock(current)) {
+			result.push(current);
+			i++;
+			continue;
+		}
+
+		const run: TextBlockLike[] = [];
+		let next: unknown = current;
+		while (i < blocks.length && isBlockquoteBlock(next)) {
+			run.push(next);
+			i++;
+			next = blocks[i];
+		}
+
+		if (run.length === 1) {
+			result.push(run[0]);
+		} else {
+			const group: BlockquoteGroupNode = {
+				_type: "blockquoteGroup",
+				_key: `${run[0]?._key ?? "quote"}-group`,
+				blocks: run,
+			};
+			result.push(group);
+		}
+	}
+
+	return result;
+}

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

@@ -60,6 +60,37 @@ export function portableTextToProsemirror(blocks: PortableTextBlock[]): ProseMir
 			}
 
 			content.push(convertList(listBlocks, listType));
+		} else if (isTextBlock(block) && block.style === "blockquote") {
+			// Collect a blockquote "run": Portable Text is flat, so a
+			// multi-paragraph quote is stored as consecutive blocks with
+			// style "blockquote" (that's what the Gutenberg importer emits
+			// and what prosemirrorToPortableText serializes back to).
+			// Without this grouping each paragraph became its own quote
+			// node, and editor merges reverted on reload (#1884).
+			const quoteBlocks: PortableTextTextBlock[] = [];
+			while (i < blocks.length) {
+				const current = blocks[i];
+				if (
+					!isTextBlock(current) ||
+					current.style !== "blockquote" ||
+					current.listItem !== undefined
+				) {
+					break;
+				}
+				quoteBlocks.push(current);
+				i++;
+			}
+
+			content.push({
+				type: "blockquote",
+				content: quoteBlocks.map((quoteBlock) => {
+					const paragraph = convertSpans(quoteBlock.children, quoteBlock.markDefs || []);
+					return {
+						type: "paragraph",
+						content: paragraph.length > 0 ? paragraph : undefined,
+					};
+				}),
+			});
 		} else {
 			const converted = convertBlock(block);
 			if (converted) {
@@ -386,7 +417,7 @@ function convertMarks(
 						// Unknown mark def type - preserve attrs
 						pmMarks.push({
 							type: markDef._type,
-							attrs: markDef as Record<string, unknown>,
+							attrs: markDef,
 						});
 					}
 				}

package/src/database/dialect-helpers.ts

@@ -68,6 +68,40 @@ export function currentTimestampValue(db: Kysely<any>): RawBuilder<string> {
 	return sql`datetime('now')`;
 }
 
+/**
+ * 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.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- accepts any Kysely instance
+export function buildStatusCondition(
+	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}`;
+}
+
 /**
  * Check if a table exists in the database.
  */

package/src/database/migrations/039_fix_fts5_triggers.ts

@@ -135,7 +135,7 @@ function isSearchEnabled(searchConfig: string | null): boolean {
 			typeof parsed === "object" &&
 			parsed !== null &&
 			"enabled" in parsed &&
-			(parsed as { enabled: unknown }).enabled === true
+			parsed.enabled === true
 		);
 	} catch {
 		return false;

package/src/database/migrations/runner.ts

@@ -1,6 +1,7 @@
 import { type Kysely, sql } from "kysely";
 import { type Migration, type MigrationProvider, Migrator } from "kysely/migration";
 
+import { MIGRATION_LOCK_BUSY_MESSAGE } from "../pg-migration-lock.js";
 import type { Database } from "../types.js";
 // Import migrations statically for bundling
 import * as m001 from "./001_initial.js";
@@ -123,12 +124,36 @@ export interface MigrationStatus {
 	pending: string[];
 }
 
+/**
+ * Thrown when another instance held the migration lock for the whole wait
+ * window. This is NOT a migration failure — the holder may simply be slow
+ * (e.g. many pending migrations over a remote Postgres connection) — so
+ * callers with failure-backoff logic (`getDatabase` in emdash-runtime.ts)
+ * exempt it: the next request waits again instead of backing off, and init
+ * recovers as soon as the holder finishes.
+ */
+export class ConcurrentMigrationTimeoutError extends Error {
+	constructor(waitMs: number) {
+		super(
+			`Timed out waiting for another instance's migrations: the migration lock was still held after ${waitMs}ms. ` +
+				"It may still be applying migrations, or its migration may be failing repeatedly.",
+		);
+		this.name = "ConcurrentMigrationTimeoutError";
+	}
+}
+
 /** Custom migration table name */
 const MIGRATION_TABLE = "_emdash_migrations";
 const MIGRATION_LOCK_TABLE = "_emdash_migrations_lock";
 
 export interface MigrationOptions {
 	migrationTableSchema?: string;
+	/**
+	 * Override how long to wait for a concurrent migrator to finish before
+	 * giving up. Defaults to MIGRATION_RACE_WAIT_MS; tests shorten it so the
+	 * give-up path doesn't take 10 seconds per case.
+	 */
+	raceWaitMs?: number;
 }
 
 function createMigrator(db: Kysely<Database>, options?: MigrationOptions): Migrator {
@@ -260,8 +285,11 @@ async function getAppliedMigrationCount(db: Kysely<Database>): Promise<number |
  * been migrated by a newer build still treats the wait as settled instead
  * of timing out.
  */
-async function waitForConcurrentMigrator(db: Kysely<Database>): Promise<boolean> {
-	const deadline = Date.now() + MIGRATION_RACE_WAIT_MS;
+async function waitForConcurrentMigrator(
+	db: Kysely<Database>,
+	waitMs: number = MIGRATION_RACE_WAIT_MS,
+): Promise<boolean> {
+	const deadline = Date.now() + waitMs;
 	while (Date.now() < deadline) {
 		const count = await getAppliedMigrationCount(db);
 		if (count !== null && count >= MIGRATION_COUNT) {
@@ -341,13 +369,25 @@ export async function runMigrations(
 		const failedMigration = results?.find((r) => r.status === "Error");
 
 		// Concurrent-migration race: another caller is applying (or just
-		// applied) the same migration. Wait for it to finish, then verify
-		// the schema is fully migrated and treat as success.
-		if (MIGRATION_RACE_PATTERN.test(msg)) {
-			const settled = await waitForConcurrentMigrator(db);
+		// applied) the same migration. SQLite/D1 surface it as the
+		// bookkeeping UNIQUE violation (their migration lock is a no-op);
+		// Postgres surfaces it as the fail-fast advisory try-lock reporting
+		// busy (see pg-migration-lock.ts). Either way: wait for the
+		// concurrent migrator to finish, then verify the schema is fully
+		// migrated and treat as success.
+		const lockBusy = msg.includes(MIGRATION_LOCK_BUSY_MESSAGE);
+		if (MIGRATION_RACE_PATTERN.test(msg) || lockBusy) {
+			const settled = await waitForConcurrentMigrator(db, options?.raceWaitMs);
 			if (settled) {
 				return { applied };
 			}
+			if (lockBusy) {
+				// The lock holder didn't finish within the wait window —
+				// either it's slow or its migration is failing. Surface a
+				// distinct error type instead of the raw sentinel message so
+				// callers can tell "still in progress" from "failed".
+				throw new ConcurrentMigrationTimeoutError(options?.raceWaitMs ?? MIGRATION_RACE_WAIT_MS);
+			}
 		}
 
 		const failedSuffix = failedMigration ? ` (migration: ${failedMigration.migrationName})` : "";

package/src/database/pg-migration-lock.ts

@@ -0,0 +1,72 @@
+/**
+ * Fail-fast Postgres migration locking.
+ *
+ * Kysely's stock `PostgresAdapter.acquireMigrationLock` runs
+ * `select pg_advisory_xact_lock(...)` — an unbounded blocking wait on a
+ * database-wide advisory lock, held for the whole migration transaction.
+ * On Cloudflare Workers that is a stampede amplifier (#1744): every isolate
+ * that cold-starts while migrations are pending parks a connection inside
+ * Postgres waiting for the lock, and when the holder's migration fails and
+ * rolls back, the next waiter acquires the lock and re-runs the same
+ * failing migration.
+ *
+ * `FailFastPostgresDialect` swaps the blocking wait for
+ * `pg_try_advisory_xact_lock`: when another migrator holds the lock, the
+ * adapter throws `MIGRATION_LOCK_BUSY_MESSAGE` immediately instead of
+ * queueing inside the database. `runMigrations` treats that error like the
+ * SQLite/D1 concurrent-migration race — it polls the migration table with
+ * cheap bounded SELECTs until the concurrent migrator finishes (or the
+ * wait deadline passes), without holding a transaction open.
+ */
+
+import type { DialectAdapter, Kysely, MigrationLockOptions } from "kysely";
+import { PostgresAdapter as KyselyPostgresAdapter, PostgresDialect, sql } from "kysely";
+
+/**
+ * Sentinel message thrown when another migrator holds the advisory lock.
+ * `runMigrations` matches on it to route into the concurrent-migrator wait.
+ */
+export const MIGRATION_LOCK_BUSY_MESSAGE = "EMDASH_MIGRATION_LOCK_BUSY";
+
+/**
+ * Kysely's advisory lock id (LOCK_ID in kysely's postgres-adapter). Reused
+ * deliberately: during a rolling deploy, old isolates still run the stock
+ * blocking adapter, and using the same id keeps old and new builds mutually
+ * exclusive on the same lock.
+ */
+const KYSELY_PG_MIGRATION_LOCK_ID = BigInt("3853314791062309107");
+
+/**
+ * Extends the stock adapter so every capability flag and `instanceof` check
+ * is inherited, and keeps the class NAME `PostgresAdapter` because
+ * `detectDialect()` (dialect-helpers.ts) identifies the dialect via
+ * `adapter.constructor.name` — a differently-named adapter would make every
+ * dialect helper fall back to SQLite SQL against a Postgres database.
+ */
+class PostgresAdapter extends KyselyPostgresAdapter {
+	// eslint-disable-next-line typescript/no-explicit-any -- matches the DialectAdapter signature
+	override async acquireMigrationLock(db: Kysely<any>, _opt: MigrationLockOptions): Promise<void> {
+		// Transaction-level lock, like the stock adapter: Postgres supports
+		// transactional DDL, so `db` here is the migration transaction and
+		// the lock is released automatically on commit/rollback.
+		const result = await sql<{ acquired: boolean }>`
+			select pg_try_advisory_xact_lock(${sql.lit(KYSELY_PG_MIGRATION_LOCK_ID)}) as acquired
+		`.execute(db);
+		if (!result.rows[0]?.acquired) {
+			throw new Error(MIGRATION_LOCK_BUSY_MESSAGE);
+		}
+	}
+}
+
+/**
+ * Drop-in replacement for Kysely's `PostgresDialect` whose migration lock
+ * fails fast instead of blocking inside the database. Everything except
+ * `createAdapter` is inherited unchanged, and because it subclasses
+ * `PostgresDialect`, the public dialect type of `emdash/db/postgres` stays
+ * `PostgresDialect` and `instanceof` checks keep working.
+ */
+export class FailFastPostgresDialect extends PostgresDialect {
+	override createAdapter(): DialectAdapter {
+		return new PostgresAdapter();
+	}
+}

package/src/database/repositories/comment.ts

@@ -419,7 +419,7 @@ export class CommentRepository {
 		return roots.map((root) => ({
 			...root,
 			_replies: childrenMap.get(root.id) ?? [],
-		})) as Comment[];
+		}));
 	}
 
 	/**