emdash 0.4.0 → 0.6.0

package/src/bylines/index.ts

@@ -13,47 +13,19 @@ import type { BylineSummary, ContentBylineCredit } from "../database/repositorie
 import { validateIdentifier } from "../database/validate.js";
 import { getDb } from "../loader.js";
 import { chunks, SQL_BATCH_SIZE } from "../utils/chunks.js";
+import { isMissingTableError } from "../utils/db-errors.js";
 
 /**
- * Cached result of "does any byline exist in the database?"
- * null = not yet checked, true/false = cached result.
- * Invalidated when bylines are created or deleted.
- */
-let hasBylines: boolean | null = null;
-
-/**
- * Invalidate the cached "has any bylines" check.
- * Call this when bylines are created, updated, or deleted.
+ * No-op — kept for API compatibility.
+ *
+ * Used to invalidate a worker-lifetime "has any byline?" probe. That
+ * probe added a query on every cold isolate to save one query on sites
+ * with zero bylines (i.e. the wrong tradeoff), so we dropped it. The
+ * batch byline join below returns an empty map for empty sites at the
+ * same cost as the probe, without the pre-check.
  */
 export function invalidateBylineCache(): void {
-	hasBylines = null;
-}
-
-/**
- * Check if any bylines exist in the database. Result is cached
- * for the lifetime of the worker/process and invalidated on writes.
- */
-async function hasAnyBylines(): Promise<boolean> {
-	if (hasBylines !== null) return hasBylines;
-
-	try {
-		const db = await getDb();
-		const result = await sql<{ id: string }>`
-			SELECT id FROM _emdash_bylines LIMIT 1
-		`.execute(db);
-		hasBylines = result.rows.length > 0;
-	} catch (error: unknown) {
-		// Only treat "no such table" as a safe false -- anything else should
-		// not be cached so the next request retries.
-		const message = error instanceof Error ? error.message : "";
-		if (message.includes("no such table")) {
-			hasBylines = false;
-		} else {
-			return false;
-		}
-	}
-
-	return hasBylines;
+	// Intentionally empty.
 }
 
 /**
@@ -176,17 +148,22 @@ export async function getBylinesForEntries(
 		return result;
 	}
 
-	// Skip DB queries entirely when no bylines have been created.
-	// The cache is invalidated when bylines are created/deleted.
-	if (!(await hasAnyBylines())) {
-		return result;
-	}
-
 	const db = await getDb();
 	const repo = new BylineRepository(db);
 
-	// 1. Batch fetch all explicit byline credits
-	const bylinesMap = await repo.getContentBylinesMany(collection, entryIds);
+	// 1. Batch fetch all explicit byline credits. Sites with no bylines
+	// get an empty map back for one query — the previous "has any bylines"
+	// probe traded an extra round-trip on every request to save that one
+	// query on empty sites, which is exactly backwards for the common case.
+	// Pre-migration databases (bylines table missing) fall through to the
+	// `isMissingTableError` catch below and return empty results.
+	let bylinesMap;
+	try {
+		bylinesMap = await repo.getContentBylinesMany(collection, entryIds);
+	} catch (error) {
+		if (isMissingTableError(error)) return result;
+		throw error;
+	}
 
 	// 2. Collect entry IDs that need fallback lookup
 	const fallbackEntryIds: string[] = [];

package/src/components/EmDashHead.astro

@@ -16,8 +16,12 @@
 import type { PublicPageContext, PageMetadataContribution } from "../plugins/types.js";
 import { resolvePageMetadata, renderPageMetadata } from "../page/metadata.js";
 import { renderFragments } from "../page/fragments.js";
-import { generateBaseSeoContributions } from "../page/seo-contributions.js";
+import {
+	generateBaseSeoContributions,
+	generateSiteSeoContributions,
+} from "../page/seo-contributions.js";
 import { getPageRuntime } from "../page/index.js";
+import { getSiteSetting } from "../settings/index.js";
 
 interface Props {
 	page: PublicPageContext;
@@ -33,14 +37,26 @@ let metadataHtml = "";
 let fragmentsHtml = "";
 
 if (runtime) {
-	// Plugin contributions come BEFORE base, so resolvePageMetadata's
-	// first-wins dedup lets plugins override base SEO defaults
-	const pluginContributions = await runtime.collectPageMetadata(page);
-	const allContributions = [...pluginContributions, ...baseContributions];
+	// Run independent async loads in parallel: site SEO settings (for
+	// search engine verification meta tags) and plugin page-metadata
+	// contributions. Plugin contributions come BEFORE site/base in the
+	// array, so resolvePageMetadata's first-wins dedup lets plugins
+	// override defaults.
+	//
+	// `getSiteSetting("seo")` is request-cached and — crucially — reads
+	// from `getSiteSettings()`'s cached batch when a parent template has
+	// already called it. So this is either a single-key query or free,
+	// not a second round-trip.
+	const [seoSettings, pluginContributions, fragments] = await Promise.all([
+		getSiteSetting("seo"),
+		runtime.collectPageMetadata(page),
+		runtime.collectPageFragments(page),
+	]);
+
+	const siteContributions = generateSiteSeoContributions(seoSettings);
+	const allContributions = [...pluginContributions, ...siteContributions, ...baseContributions];
 	const resolved = resolvePageMetadata(allContributions);
 	metadataHtml = renderPageMetadata(resolved);
-
-	const fragments = await runtime.collectPageFragments(page);
 	fragmentsHtml = renderFragments(fragments, "head");
 } else {
 	// No runtime (EmDash not initialized) — still render base SEO

package/src/components/Table.astro

@@ -2,8 +2,13 @@
 /**
  * Portable Text Table block component
  *
- * Renders tables from WordPress imports.
+ * Renders tables from content imports. Cell content is rendered through the
+ * standard Portable Text pipeline so all marks (bold, italic, links, etc.) are
+ * handled by the registered mark components -- including `sanitizeHref` for links.
  */
+import { PortableText } from "astro-portabletext";
+import { emdashMarkComponents } from "./marks.js";
+
 export interface Props {
 	node: {
 		_type: "table";
@@ -32,6 +37,8 @@ export interface Props {
 	};
 }
 
+const markComponents = { mark: emdashMarkComponents };
+
 const { node } = Astro.props;
 const rows = node?.rows ?? [];
 
@@ -39,45 +46,65 @@ if (!rows.length) {
 	return null;
 }
 
-// Helper to render cell content as text (simplified - doesn't handle marks)
-function renderCellText(
-	content: Array<{ text: string; marks?: string[] }>,
-): string {
-	return content.map((span) => span.text).join("");
+/**
+ * Wrap a table cell's inline content as a Portable Text block so it can be
+ * rendered through the standard pipeline (marks, markDefs, etc.).
+ */
+function cellToBlock(cell: Props["node"]["rows"][number]["cells"][number]) {
+	return [
+		{
+			_type: "block" as const,
+			_key: cell._key,
+			children: cell.content,
+			markDefs: cell.markDefs ?? [],
+		},
+	];
 }
----
 
-{() => {
-	const hasHeader = node?.hasHeaderRow;
-	const headerRow = hasHeader ? rows[0] : null;
-	const bodyRows = hasHeader ? rows.slice(1) : rows;
+const hasHeader = node?.hasHeaderRow;
+const headerRow = hasHeader ? rows[0] : null;
+const bodyRows = hasHeader ? rows.slice(1) : rows;
+---
 
-	return (
-		<div class="emdash-table-wrapper">
-			<table class="emdash-table">
-				{headerRow && (
-					<thead>
-						<tr>
-							{headerRow.cells.map((cell) => (
-								<th>{renderCellText(cell.content)}</th>
-							))}
-						</tr>
-					</thead>
-				)}
-				<tbody>
-					{bodyRows.map((row) => (
-						<tr>
-							{row.cells.map((cell) => {
-								const CellTag = cell.isHeader ? "th" : "td";
-								return <CellTag>{renderCellText(cell.content)}</CellTag>;
-							})}
-						</tr>
-					))}
-				</tbody>
-			</table>
-		</div>
-	);
-}}
+<div class="emdash-table-wrapper">
+	<table class="emdash-table">
+		{
+			headerRow && (
+				<thead>
+					<tr>
+						{headerRow.cells.map((cell) => (
+							<th>
+								<PortableText
+									value={cellToBlock(cell)}
+									components={markComponents}
+								/>
+							</th>
+						))}
+					</tr>
+				</thead>
+			)
+		}
+		<tbody>
+			{
+				bodyRows.map((row) => (
+					<tr>
+						{row.cells.map((cell) => {
+							const CellTag = cell.isHeader ? "th" : "td";
+							return (
+								<CellTag>
+									<PortableText
+										value={cellToBlock(cell)}
+										components={markComponents}
+									/>
+								</CellTag>
+							);
+						})}
+					</tr>
+				))
+			}
+		</tbody>
+	</table>
+</div>
 
 <style>
 	.emdash-table-wrapper {
@@ -91,18 +118,23 @@ function renderCellText(
 	}
 	.emdash-table th,
 	.emdash-table td {
-		border: 1px solid #ddd;
+		border: 1px solid var(--color-border, #ddd);
 		padding: 0.75rem;
 		text-align: left;
 	}
+	/* Remove default block margins inside cells */
+	.emdash-table th :global(p),
+	.emdash-table td :global(p) {
+		margin: 0;
+	}
 	.emdash-table th {
-		background: #f5f5f5;
+		background: var(--color-surface, #f5f5f5);
 		font-weight: 600;
 	}
 	.emdash-table tbody tr:nth-child(even) {
-		background: #fafafa;
+		background: var(--color-bg-subtle, #fafafa);
 	}
 	.emdash-table tbody tr:hover {
-		background: #f0f0f0;
+		background: var(--color-surface, #f0f0f0);
 	}
 </style>

package/src/components/index.ts

@@ -69,11 +69,7 @@ import GalleryComponent from "./Gallery.astro";
 import HtmlBlockComponent from "./HtmlBlock.astro";
 // Pre-configured components object for PortableText
 import ImageComponent from "./Image.astro";
-import LinkMark from "./marks/Link.astro";
-import StrikeThroughMark from "./marks/StrikeThrough.astro";
-import SubscriptMark from "./marks/Subscript.astro";
-import SuperscriptMark from "./marks/Superscript.astro";
-import UnderlineMark from "./marks/Underline.astro";
+import { emdashMarkComponents } from "./marks.js";
 import PullquoteComponent from "./Pullquote.astro";
 import TableComponent from "./Table.astro";
 
@@ -101,13 +97,7 @@ export const emdashComponents = {
 		file: FileComponent,
 		pullquote: PullquoteComponent,
 	},
-	mark: {
-		superscript: SuperscriptMark,
-		subscript: SubscriptMark,
-		underline: UnderlineMark,
-		"strike-through": StrikeThroughMark,
-		link: LinkMark,
-	},
+	mark: emdashMarkComponents,
 };
 
 // Public page contribution components

package/src/components/marks.ts

@@ -0,0 +1,20 @@
+/**
+ * Shared mark component map for Portable Text rendering.
+ *
+ * Used by both the top-level `emdashComponents` config and individual block
+ * components (e.g. Table) that render nested inline content through the PT
+ * pipeline.
+ */
+import LinkMark from "./marks/Link.astro";
+import StrikeThroughMark from "./marks/StrikeThrough.astro";
+import SubscriptMark from "./marks/Subscript.astro";
+import SuperscriptMark from "./marks/Superscript.astro";
+import UnderlineMark from "./marks/Underline.astro";
+
+export const emdashMarkComponents = {
+	superscript: SuperscriptMark,
+	subscript: SubscriptMark,
+	underline: UnderlineMark,
+	"strike-through": StrikeThroughMark,
+	link: LinkMark,
+};

package/src/database/connection.ts

@@ -1,6 +1,7 @@
 import BetterSqlite3 from "better-sqlite3";
 import { Kysely, SqliteDialect } from "kysely";
 
+import { kyselyLogOption } from "./instrumentation.js";
 import type { Database } from "./types.js";
 
 export interface DatabaseConfig {
@@ -18,6 +19,23 @@ export class EmDashDatabaseError extends Error {
 	}
 }
 
+/**
+ * Returns a helpful, actionable message when better-sqlite3's native binary
+ * was compiled against a different Node.js version than the one running. This
+ * happens after upgrading Node without rebuilding native deps.
+ *
+ * Returns null if the error is not a NODE_MODULE_VERSION mismatch.
+ */
+export function formatNativeModuleVersionError(error: unknown): string | null {
+	const message = error instanceof Error ? error.message : String(error);
+	if (!message.includes("NODE_MODULE_VERSION")) return null;
+	return (
+		"better-sqlite3's native binary was compiled against a different Node.js version. " +
+		"Rebuild it with `pnpm rebuild better-sqlite3` (or `npm rebuild better-sqlite3`), " +
+		"or reinstall dependencies with your current Node.js version."
+	);
+}
+
 /**
  * Creates a Kysely database instance
  * Supports:
@@ -45,7 +63,7 @@ export function createDatabase(config: DatabaseConfig): Kysely<Database> {
 				database: sqlite,
 			});
 
-			return new Kysely<Database>({ dialect });
+			return new Kysely<Database>({ dialect, log: kyselyLogOption() });
 		}
 
 		// Handle libSQL (Turso)
@@ -62,6 +80,10 @@ export function createDatabase(config: DatabaseConfig): Kysely<Database> {
 		if (error instanceof EmDashDatabaseError) {
 			throw error;
 		}
+		const nativeVersionHint = formatNativeModuleVersionError(error);
+		if (nativeVersionHint) {
+			throw new EmDashDatabaseError(nativeVersionHint, error);
+		}
 		throw new EmDashDatabaseError("Failed to create database", error);
 	}
 }

package/src/database/instrumentation.ts

@@ -0,0 +1,98 @@
+/**
+ * Query instrumentation
+ *
+ * Dev/test-only: captures every Kysely query executed inside a request,
+ * tagged with the route, method, and a caller-supplied phase (e.g. "cold"
+ * or "warm"). Events are emitted as prefixed NDJSON on stdout so the
+ * harness can capture them from both Node and workerd — workerd has no
+ * filesystem access, but `console.log` is portable.
+ *
+ * The recorder lives on the request context (AsyncLocalStorage). The
+ * Kysely `log` hook reads the recorder at query time and appends an
+ * event. When no recorder is attached, the hook is a null check.
+ */
+
+import type { LogEvent, Logger } from "kysely";
+
+import { getRequestContext } from "../request-context.js";
+
+export const QUERY_LOG_ENV = "EMDASH_QUERY_LOG";
+export const QUERY_LOG_PREFIX = "[emdash-query-log]";
+
+export interface QueryEvent {
+	sql: string;
+	params: readonly unknown[];
+	durationMs: number;
+	route: string;
+	method: string;
+	phase: string;
+}
+
+export interface QueryRecorder {
+	events: QueryEvent[];
+	route: string;
+	method: string;
+	phase: string;
+}
+
+export function createRecorder(route: string, method: string, phase: string): QueryRecorder {
+	return { events: [], route, method, phase };
+}
+
+export function recordEvent(
+	rec: QueryRecorder,
+	sql: string,
+	params: readonly unknown[],
+	durationMs: number,
+): void {
+	rec.events.push({
+		sql,
+		params,
+		durationMs,
+		route: rec.route,
+		method: rec.method,
+		phase: rec.phase,
+	});
+}
+
+/**
+ * Emit all events from a recorder as prefixed NDJSON on stdout. The
+ * harness pipes the child's stdout, filters lines beginning with
+ * QUERY_LOG_PREFIX, and writes them to its own file. Using stdout means
+ * the sink works uniformly in Node and in workerd (which has no fs).
+ */
+export function flushRecorder(rec: QueryRecorder): void {
+	if (rec.events.length === 0) return;
+	for (const e of rec.events) {
+		console.log(`${QUERY_LOG_PREFIX} ${JSON.stringify(e)}`);
+	}
+}
+
+/**
+ * Whether query instrumentation is enabled. Read at Kysely construction
+ * time and middleware entry — the env var is a process-lifetime flag, not
+ * per-request. Gated via `process.env` so adapters that ship env through
+ * to the worker (e.g. Miniflare via wrangler.jsonc `vars` or host env
+ * pass-through) can enable it at runtime.
+ */
+export function isInstrumentationEnabled(): boolean {
+	return Boolean(
+		typeof process !== "undefined" && process.env && process.env[QUERY_LOG_ENV] === "1",
+	);
+}
+
+function kyselyLog(event: LogEvent): void {
+	if (event.level !== "query") return;
+	const rec = getRequestContext()?.queryRecorder;
+	if (!rec) return;
+	recordEvent(rec, event.query.sql, event.query.parameters, event.queryDurationMillis);
+}
+
+/**
+ * Returns a Kysely `log` option when instrumentation is enabled, or undefined.
+ * Pass as `new Kysely({ dialect, log: kyselyLogOption() })` so disabled mode
+ * has zero overhead — Kysely skips query timing entirely when `log` is absent.
+ */
+export function kyselyLogOption(): Logger | undefined {
+	return isInstrumentationEnabled() ? kyselyLog : undefined;
+}

package/src/db/adapters.ts

@@ -33,6 +33,21 @@ export interface DatabaseDescriptor {
 	entrypoint: string;
 	config: unknown;
 	type: DatabaseDialectType;
+	/**
+	 * When true, the adapter's runtime entrypoint MUST export a named
+	 * `createRequestScopedDb` function matching the signature declared in
+	 * `virtual:emdash/dialect`. The virtual-module generator re-exports it
+	 * by name, so a missing export becomes a build-time bundler error.
+	 *
+	 * The function is called once per request and decides — based on its own
+	 * runtime config (e.g. whether the user opted into D1 sessions) — whether
+	 * to return a per-request Kysely or null. Use this for features like D1
+	 * read-replica sessions, bookmark cookies, or any per-request DB handle.
+	 *
+	 * When false or absent, the generator emits a stub that returns null and
+	 * the middleware takes its default (singleton) path.
+	 */
+	supportsRequestScope?: boolean;
 }
 
 export interface SqliteConfig {