emdash 0.1.1 → 0.2.0

package/src/plugins/context.ts

@@ -12,7 +12,9 @@ import { ContentRepository } from "../database/repositories/content.js";
 import { MediaRepository } from "../database/repositories/media.js";
 import { OptionsRepository } from "../database/repositories/options.js";
 import { PluginStorageRepository } from "../database/repositories/plugin-storage.js";
+import { SeoRepository } from "../database/repositories/seo.js";
 import { UserRepository } from "../database/repositories/user.js";
+import { withTransaction } from "../database/transaction.js";
 import type { Database } from "../database/types.js";
 import { validateExternalUrl, SsrfError, stripCredentialHeaders } from "../import/ssrf.js";
 import type { Storage } from "../storage/types.js";
@@ -36,6 +38,8 @@ import type {
 	UserAccess,
 	UserInfo,
 	ContentItem,
+	ContentItemSeoInput,
+	ContentWriteInput,
 	MediaItem,
 	PaginatedResult,
 	QueryOptions,
@@ -148,24 +152,66 @@ export function createStorageAccess<T extends PluginStorageConfig>(
 // Content Access
 // =============================================================================
 
+/**
+ * Extract `seo` from a plugin-supplied content write input and return both
+ * parts. Mutates nothing — returns a new field map without the `seo` key.
+ */
+function splitSeoFromInput(input: ContentWriteInput): {
+	fields: Record<string, unknown>;
+	seo: ContentItemSeoInput | undefined;
+} {
+	const { seo, ...fields } = input;
+	// Reject non-object seo values rather than silently dropping them.
+	if (seo !== undefined && (seo === null || typeof seo !== "object" || Array.isArray(seo))) {
+		throw new Error("content.seo must be an object");
+	}
+	return { fields, seo };
+}
+
+/**
+ * Reject writing SEO to a collection that does not have it enabled.
+ * Matches the REST API behavior (VALIDATION_ERROR).
+ */
+async function assertSeoEnabled(
+	seoRepo: SeoRepository,
+	collection: string,
+	seo: ContentItemSeoInput | undefined,
+): Promise<boolean> {
+	const hasSeo = await seoRepo.isEnabled(collection);
+	if (seo !== undefined && !hasSeo) {
+		throw new Error(
+			`Collection "${collection}" does not have SEO enabled. ` +
+				`Remove the seo field or enable SEO on this collection.`,
+		);
+	}
+	return hasSeo;
+}
+
 /**
  * Create read-only content access
  */
 export function createContentAccess(db: Kysely<Database>): ContentAccess {
 	const contentRepo = new ContentRepository(db);
+	const seoRepo = new SeoRepository(db);
 
 	return {
 		async get(collection: string, id: string): Promise<ContentItem | null> {
 			const item = await contentRepo.findById(collection, id);
 			if (!item) return null;
 
-			return {
+			const result: ContentItem = {
 				id: item.id,
 				type: item.type,
 				data: item.data,
 				createdAt: item.createdAt,
 				updatedAt: item.updatedAt,
 			};
+
+			if (await seoRepo.isEnabled(collection)) {
+				result.seo = await seoRepo.get(collection, item.id);
+			}
+
+			return result;
 		},
 
 		async list(
@@ -188,14 +234,27 @@ export function createContentAccess(db: Kysely<Database>): ContentAccess {
 				orderBy,
 			});
 
+			const items: ContentItem[] = result.items.map((item) => ({
+				id: item.id,
+				type: item.type,
+				data: item.data,
+				createdAt: item.createdAt,
+				updatedAt: item.updatedAt,
+			}));
+
+			if (items.length > 0 && (await seoRepo.isEnabled(collection))) {
+				const seoMap = await seoRepo.getMany(
+					collection,
+					items.map((i) => i.id),
+				);
+				for (const item of items) {
+					const seo = seoMap.get(item.id);
+					if (seo) item.seo = seo;
+				}
+			}
+
 			return {
-				items: result.items.map((item) => ({
-					id: item.id,
-					type: item.type,
-					data: item.data,
-					createdAt: item.createdAt,
-					updatedAt: item.updatedAt,
-				})),
+				items,
 				cursor: result.nextCursor,
 				hasMore: !!result.nextCursor,
 			};
@@ -204,47 +263,97 @@ export function createContentAccess(db: Kysely<Database>): ContentAccess {
 }
 
 /**
- * Create full content access with write operations
+ * Create full content access with write operations.
+ *
+ * `create` and `update` accept a reserved `seo` key in their `data`
+ * argument. When present, it is routed to the core SEO panel
+ * (`_emdash_seo`) via `SeoRepository.upsert`, in the same transaction as
+ * the content write. The returned `ContentItem.seo` reflects the resulting
+ * SEO state for SEO-enabled collections.
  */
 export function createContentAccessWithWrite(db: Kysely<Database>): ContentAccessWithWrite {
-	const contentRepo = new ContentRepository(db);
 	const readAccess = createContentAccess(db);
 
 	return {
 		...readAccess,
 
-		async create(collection: string, data: Record<string, unknown>): Promise<ContentItem> {
-			const item = await contentRepo.create({
-				type: collection,
-				data,
-			});
+		async create(collection: string, data: ContentWriteInput): Promise<ContentItem> {
+			const { fields, seo } = splitSeoFromInput(data);
 
-			return {
-				id: item.id,
-				type: item.type,
-				data: item.data,
-				createdAt: item.createdAt,
-				updatedAt: item.updatedAt,
-			};
+			return withTransaction(db, async (trx) => {
+				const trxContentRepo = new ContentRepository(trx);
+				const trxSeoRepo = new SeoRepository(trx);
+
+				const hasSeo = await assertSeoEnabled(trxSeoRepo, collection, seo);
+
+				const item = await trxContentRepo.create({
+					type: collection,
+					data: fields,
+				});
+
+				const result: ContentItem = {
+					id: item.id,
+					type: item.type,
+					data: item.data,
+					createdAt: item.createdAt,
+					updatedAt: item.updatedAt,
+				};
+
+				if (hasSeo) {
+					result.seo =
+						seo !== undefined
+							? await trxSeoRepo.upsert(collection, item.id, seo)
+							: await trxSeoRepo.get(collection, item.id);
+				}
+
+				return result;
+			});
 		},
 
-		async update(
-			collection: string,
-			id: string,
-			data: Record<string, unknown>,
-		): Promise<ContentItem> {
-			const item = await contentRepo.update(collection, id, { data });
+		async update(collection: string, id: string, data: ContentWriteInput): Promise<ContentItem> {
+			const { fields, seo } = splitSeoFromInput(data);
+
+			return withTransaction(db, async (trx) => {
+				const trxContentRepo = new ContentRepository(trx);
+				const trxSeoRepo = new SeoRepository(trx);
+
+				const hasSeo = await assertSeoEnabled(trxSeoRepo, collection, seo);
+
+				// Pass the `data` payload to ContentRepository.update only when
+				// there are field updates — passing an empty object would still
+				// bump updated_at/version, but we want a seo-only call to touch
+				// only the SEO table. ContentRepository.update handles the no-op
+				// path by returning the current row.
+				const hasFieldUpdates = Object.keys(fields).length > 0;
+				const item = hasFieldUpdates
+					? await trxContentRepo.update(collection, id, { data: fields })
+					: await (async () => {
+							const existing = await trxContentRepo.findById(collection, id);
+							if (!existing) throw new Error("Content not found");
+							return existing;
+						})();
+
+				const result: ContentItem = {
+					id: item.id,
+					type: item.type,
+					data: item.data,
+					createdAt: item.createdAt,
+					updatedAt: item.updatedAt,
+				};
 
-			return {
-				id: item.id,
-				type: item.type,
-				data: item.data,
-				createdAt: item.createdAt,
-				updatedAt: item.updatedAt,
-			};
+				if (hasSeo) {
+					result.seo =
+						seo !== undefined
+							? await trxSeoRepo.upsert(collection, item.id, seo)
+							: await trxSeoRepo.get(collection, item.id);
+				}
+
+				return result;
+			});
 		},
 
 		async delete(collection: string, id: string): Promise<boolean> {
+			const contentRepo = new ContentRepository(db);
 			return contentRepo.delete(collection, id);
 		},
 	};
@@ -384,6 +493,7 @@ const MAX_PLUGIN_REDIRECTS = 5;
 
 function isHostAllowed(host: string, allowedHosts: string[]): boolean {
 	return allowedHosts.some((pattern) => {
+		if (pattern === "*") return true;
 		if (pattern.startsWith("*.")) {
 			const suffix = pattern.slice(1); // ".example.com"
 			return host.endsWith(suffix) || host === pattern.slice(2);

package/src/plugins/manager.ts

@@ -18,6 +18,7 @@ import type { Storage } from "../storage/types.js";
 import type { PluginContextFactoryOptions } from "./context.js";
 import { setCronTasksEnabled } from "./cron.js";
 import { definePlugin } from "./define-plugin.js";
+import type { EmailPipeline } from "./email.js";
 import {
 	HookPipeline,
 	type HookResult,
@@ -83,6 +84,17 @@ export class PluginManager {
 		};
 	}
 
+	/**
+	 * Set the email pipeline used when creating plugin contexts.
+	 * Reinitializes routes/hooks if already initialized so ctx.email is available immediately.
+	 */
+	setEmailPipeline(pipeline: EmailPipeline): void {
+		this.factoryOptions.emailPipeline = pipeline;
+		if (this.initialized) {
+			this.reinitialize();
+		}
+	}
+
 	// =========================================================================
 	// Plugin Registration
 	// =========================================================================

package/src/plugins/types.ts

@@ -161,6 +161,34 @@ export interface KVAccess {
 	list(prefix?: string): Promise<Array<{ key: string; value: unknown }>>;
 }
 
+/**
+ * SEO metadata for a content item, as stored in the core SEO panel.
+ *
+ * Only present on items in collections with `has_seo = 1`. For collections
+ * without SEO enabled, `ContentItem.seo` is `undefined`.
+ */
+export interface ContentItemSeo {
+	title: string | null;
+	description: string | null;
+	image: string | null;
+	canonical: string | null;
+	noIndex: boolean;
+}
+
+/**
+ * SEO input accepted by content write operations.
+ *
+ * All fields are optional — only fields that are present overwrite existing
+ * values. An empty object is treated as a no-op.
+ */
+export interface ContentItemSeoInput {
+	title?: string | null;
+	description?: string | null;
+	image?: string | null;
+	canonical?: string | null;
+	noIndex?: boolean;
+}
+
 /**
  * Content item returned from content API
  */
@@ -168,6 +196,11 @@ export interface ContentItem {
 	id: string;
 	type: string;
 	data: Record<string, unknown>;
+	/**
+	 * SEO metadata, populated when the collection has SEO enabled
+	 * (`has_seo = 1`). `undefined` for non-SEO collections.
+	 */
+	seo?: ContentItemSeo;
 	createdAt: string;
 	updatedAt: string;
 }
@@ -181,6 +214,18 @@ export interface ContentListOptions {
 	orderBy?: Record<string, "asc" | "desc">;
 }
 
+/**
+ * Input accepted by `content.create` / `content.update`.
+ *
+ * Most entries are field slugs mapped to their values. The reserved `seo`
+ * key is extracted and routed to the core SEO panel (the `_emdash_seo`
+ * table), matching the shape accepted by the REST API. Passing `seo` for a
+ * collection that does not have SEO enabled throws a validation error.
+ */
+export type ContentWriteInput = Record<string, unknown> & {
+	seo?: ContentItemSeoInput;
+};
+
 /**
  * Content access interface - capability-gated
  */
@@ -190,8 +235,8 @@ export interface ContentAccess {
 	list(collection: string, options?: ContentListOptions): Promise<PaginatedResult<ContentItem>>;
 
 	// Write operations (requires write:content) - optional on interface
-	create?(collection: string, data: Record<string, unknown>): Promise<ContentItem>;
-	update?(collection: string, id: string, data: Record<string, unknown>): Promise<ContentItem>;
+	create?(collection: string, data: ContentWriteInput): Promise<ContentItem>;
+	update?(collection: string, id: string, data: ContentWriteInput): Promise<ContentItem>;
 	delete?(collection: string, id: string): Promise<boolean>;
 }
 
@@ -199,8 +244,8 @@ export interface ContentAccess {
  * Full content access with write operations
  */
 export interface ContentAccessWithWrite extends ContentAccess {
-	create(collection: string, data: Record<string, unknown>): Promise<ContentItem>;
-	update(collection: string, id: string, data: Record<string, unknown>): Promise<ContentItem>;
+	create(collection: string, data: ContentWriteInput): Promise<ContentItem>;
+	update(collection: string, id: string, data: ContentWriteInput): Promise<ContentItem>;
 	delete(collection: string, id: string): Promise<boolean>;
 }
 
@@ -747,6 +792,17 @@ export type UninstallHandler = (event: UninstallEvent, ctx: PluginContext) => Pr
 /** Placement targets for page fragment contributions */
 export type PagePlacement = "head" | "body:start" | "body:end";
 
+/**
+ * A single breadcrumb trail item. Used by `PublicPageContext.breadcrumbs`
+ * so themes can publish breadcrumb trails that SEO plugins consume.
+ */
+export interface BreadcrumbItem {
+	/** Display name for this crumb (e.g. "Home", "Blog", "My Post"). */
+	name: string;
+	/** Absolute or root-relative URL for this crumb. */
+	url: string;
+}
+
 /**
  * Describes the page being rendered. Passed to page hooks so plugins
  * can decide what to contribute without fetching content themselves.
@@ -757,7 +813,10 @@ export interface PublicPageContext {
 	locale: string | null;
 	kind: "content" | "custom";
 	pageType: string;
+	/** Full document title for the rendered page */
 	title: string | null;
+	/** Page-only title for OG/Twitter/JSON-LD headline output */
+	pageTitle?: string | null;
 	description: string | null;
 	canonical: string | null;
 	image: string | null;
@@ -781,6 +840,23 @@ export interface PublicPageContext {
 	};
 	/** Site name for structured data and og:site_name */
 	siteName?: string;
+	/**
+	 * Optional breadcrumb trail for this page, root first. When set,
+	 * SEO plugins should use this verbatim rather than deriving a trail
+	 * from `path`. Themes typically populate this at the point they
+	 * build the context (e.g. from a content hierarchy walk, taxonomy
+	 * lookup, or per-`pageType` routing logic).
+	 *
+	 * Semantics for consumers:
+	 *   - `undefined` — theme has no opinion; consumer falls back to
+	 *     its own derivation.
+	 *   - `[]` — this page has no breadcrumbs (e.g. homepage); consumer
+	 *     should skip `BreadcrumbList` emission entirely.
+	 *   - Non-empty array — used verbatim for `BreadcrumbList` output.
+	 */
+	breadcrumbs?: BreadcrumbItem[];
+	/** Public-facing site URL (origin) for structured data */
+	siteUrl?: string;
 }
 
 // ── page:metadata ───────────────────────────────────────────────

package/src/query.ts

@@ -422,6 +422,24 @@ export async function getEmDashEntry<T extends string, D = InferCollectionData<T
 
 			if (!baseEntry) continue; // Try next locale in chain
 
+			// Preview tokens are item-scoped: verify the resolved entry matches.
+			// Edit mode (authenticated editors) has collection-wide draft access.
+			if (isPreviewMode && !isEditMode) {
+				const dbId = entryDatabaseId(baseEntry);
+				if (preview!.id !== dbId && preview!.id !== id) {
+					// Token doesn't match — serve only if publicly visible, without draft access
+					if (isVisible(baseEntry)) {
+						return successResult(wrapEntry(baseEntry), {
+							isPreview: false,
+							fallbackLocale,
+							cacheHint: cacheHint ?? {},
+						});
+					}
+					// Not visible — try next locale in fallback chain
+					continue;
+				}
+			}
+
 			// Check if entry has a draft revision — if so, re-fetch with revision data
 			const baseData = entryData(baseEntry);
 			const draftRevisionId = dataStr(baseData, "draftRevisionId") || undefined;

package/src/schema/registry.ts

@@ -595,6 +595,11 @@ export class SchemaRegistry {
 			CREATE INDEX ${sql.ref(`idx_${tableName}_deleted_created_id`)}
 			ON ${sql.ref(tableName)} (deleted_at, created_at DESC, id DESC)
 		`.execute(conn);
+
+		await sql`
+			CREATE INDEX ${sql.ref(`idx_${tableName}_deleted_published_id`)}
+			ON ${sql.ref(tableName)} (deleted_at, published_at DESC, id DESC)
+		`.execute(conn);
 	}
 
 	/**

package/src/settings/index.ts

@@ -201,3 +201,67 @@ export async function setSiteSettings(
 
 	await options.setMany(updates);
 }
+
+/**
+ * Get a single plugin setting by key.
+ *
+ * Plugin settings are stored in the options table under
+ * `plugin:<pluginId>:settings:<key>`.
+ */
+export async function getPluginSetting<T = unknown>(
+	pluginId: string,
+	key: string,
+): Promise<T | undefined> {
+	const db = await getDb();
+	return getPluginSettingWithDb<T>(pluginId, key, db);
+}
+
+/**
+ * Get a single plugin setting by key (with explicit db).
+ *
+ * @internal Use `getPluginSetting()` in templates and plugin rendering code.
+ */
+export async function getPluginSettingWithDb<T = unknown>(
+	pluginId: string,
+	key: string,
+	db: Kysely<Database>,
+): Promise<T | undefined> {
+	const options = new OptionsRepository(db);
+	const value = await options.get<T>(`plugin:${pluginId}:settings:${key}`);
+	return value ?? undefined;
+}
+
+/**
+ * Get all persisted plugin settings for a plugin.
+ *
+ * Defaults declared in `admin.settingsSchema` are not materialized
+ * automatically; callers should apply their own fallback defaults.
+ */
+export async function getPluginSettings(pluginId: string): Promise<Record<string, unknown>> {
+	const db = await getDb();
+	return getPluginSettingsWithDb(pluginId, db);
+}
+
+/**
+ * Get all persisted plugin settings for a plugin (with explicit db).
+ *
+ * @internal Use `getPluginSettings()` in templates and plugin rendering code.
+ */
+export async function getPluginSettingsWithDb(
+	pluginId: string,
+	db: Kysely<Database>,
+): Promise<Record<string, unknown>> {
+	const prefix = `plugin:${pluginId}:settings:`;
+	const options = new OptionsRepository(db);
+	const allOptions = await options.getByPrefix(prefix);
+
+	const settings: Record<string, unknown> = {};
+	for (const [key, value] of allOptions) {
+		if (!key.startsWith(prefix)) {
+			continue;
+		}
+		settings[key.slice(prefix.length)] = value;
+	}
+
+	return settings;
+}

package/src/utils/chunks.ts

@@ -0,0 +1,17 @@
+/**
+ * Split an array into chunks of at most `size` elements.
+ *
+ * Used to keep SQL `IN (?, ?, …)` clauses within Cloudflare D1's
+ * bound-parameter limit (~100 per statement).
+ */
+export function chunks<T>(arr: T[], size: number): T[][] {
+	if (arr.length === 0) return [];
+	const result: T[][] = [];
+	for (let i = 0; i < arr.length; i += size) {
+		result.push(arr.slice(i, i + size));
+	}
+	return result;
+}
+
+/** Conservative default chunk size for SQL IN clauses (well within D1's limit). */
+export const SQL_BATCH_SIZE = 50;