emdash 0.2.0 → 0.4.0

package/src/mcp/server.ts

@@ -1257,26 +1257,8 @@ export function createMcpServer(): McpServer {
 			requireScope(extra, "content:read");
 			const ec = getEmDash(extra);
 			try {
-				const rows = (await ec.db
-					.selectFrom("_emdash_taxonomy_defs" as never)
-					.selectAll()
-					.execute()) as Array<{
-					id: string;
-					name: string;
-					label: string;
-					label_singular: string | null;
-					hierarchical: number;
-					collections: string | null;
-				}>;
-				const taxonomies = rows.map((row) => ({
-					id: row.id,
-					name: row.name,
-					label: row.label,
-					labelSingular: row.label_singular ?? undefined,
-					hierarchical: row.hierarchical === 1,
-					collections: row.collections ? JSON.parse(row.collections) : [],
-				}));
-				return jsonResult(taxonomies);
+				const { handleTaxonomyList } = await import("../api/handlers/taxonomies.js");
+				return unwrap(await handleTaxonomyList(ec.db));
 			} catch (error) {
 				return errorResult(error);
 			}
@@ -1302,32 +1284,44 @@ export function createMcpServer(): McpServer {
 			requireScope(extra, "content:read");
 			const ec = getEmDash(extra);
 			try {
-				const taxonomy = (await ec.db
-					.selectFrom("_emdash_taxonomy_defs" as never)
-					.select("id" as never)
-					.where("name" as never, "=", args.taxonomy as never)
-					.executeTakeFirst()) as { id: string } | undefined;
-
+				// Verify taxonomy exists via handler layer
+				const { handleTaxonomyList } = await import("../api/handlers/taxonomies.js");
+				const listResult = await handleTaxonomyList(ec.db);
+				if (!listResult.success) return unwrap(listResult);
+
+				const taxonomies = (listResult.data as { taxonomies: Array<{ name: string; id?: string }> })
+					.taxonomies;
+				const taxonomy = taxonomies.find((t: { name: string }) => t.name === args.taxonomy);
 				if (!taxonomy) return errorResult(`Taxonomy '${args.taxonomy}' not found`);
 
+				// Paginated term query via repository (avoids N+1 of handleTermList)
+				const { TaxonomyRepository } = await import("../database/repositories/taxonomy.js");
+				const repo = new TaxonomyRepository(ec.db);
 				const limit = Math.min(args.limit ?? 50, 100);
-				let query = ec.db
-					.selectFrom("_emdash_taxonomy_terms" as never)
-					.selectAll()
-					.where("taxonomy_id" as never, "=", taxonomy.id as never)
-					.orderBy("label" as never, "asc")
-					.limit(limit + 1);
+				const terms = await repo.findByName(args.taxonomy);
 
+				// Manual cursor pagination over the sorted results
+				let startIdx = 0;
 				if (args.cursor) {
-					query = query.where("id" as never, ">" as never, args.cursor as never);
+					const cursorIdx = terms.findIndex((t) => t.id === args.cursor);
+					if (cursorIdx >= 0) startIdx = cursorIdx + 1;
 				}
 
-				const rows = (await query.execute()) as Array<{ id: string }>;
-				const hasMore = rows.length > limit;
-				const items = hasMore ? rows.slice(0, limit) : rows;
-				const nextCursor = hasMore ? items.at(-1)?.id : undefined;
-
-				return jsonResult({ items, nextCursor });
+				const page = terms.slice(startIdx, startIdx + limit);
+				const hasMore = startIdx + limit < terms.length;
+				const nextCursor = hasMore ? page.at(-1)?.id : undefined;
+
+				return jsonResult({
+					items: page.map((t) => ({
+						id: t.id,
+						name: t.name,
+						slug: t.slug,
+						label: t.label,
+						parentId: t.parentId,
+						description: typeof t.data?.description === "string" ? t.data.description : undefined,
+					})),
+					nextCursor,
+				});
 			} catch (error) {
 				return errorResult(error);
 			}
@@ -1354,36 +1348,15 @@ export function createMcpServer(): McpServer {
 			requireRole(extra, Role.EDITOR);
 			const ec = getEmDash(extra);
 			try {
-				const { ulid } = await import("ulidx");
-
-				const taxonomy = (await ec.db
-					.selectFrom("_emdash_taxonomy_defs" as never)
-					.select("id" as never)
-					.where("name" as never, "=", args.taxonomy as never)
-					.executeTakeFirst()) as { id: string } | undefined;
-
-				if (!taxonomy) return errorResult(`Taxonomy '${args.taxonomy}' not found`);
-
-				const id = ulid();
-				await ec.db
-					.insertInto("_emdash_taxonomy_terms" as never)
-					.values({
-						id,
-						taxonomy_id: taxonomy.id,
+				const { handleTermCreate } = await import("../api/handlers/taxonomies.js");
+				return unwrap(
+					await handleTermCreate(ec.db, args.taxonomy, {
 						slug: args.slug,
 						label: args.label,
-						parent_id: args.parentId ?? null,
-						description: args.description ?? null,
-					} as never)
-					.execute();
-
-				const term = await ec.db
-					.selectFrom("_emdash_taxonomy_terms" as never)
-					.selectAll()
-					.where("id" as never, "=", id as never)
-					.executeTakeFirstOrThrow();
-
-				return jsonResult(term);
+						parentId: args.parentId,
+						description: args.description,
+					}),
+				);
 			} catch (error) {
 				return errorResult(error);
 			}

package/src/menus/index.ts

@@ -8,6 +8,7 @@ import type { Kysely } from "kysely";
 import { sql } from "kysely";
 
 import type { Database } from "../database/types.js";
+import { validateIdentifier } from "../database/validate.js";
 import { getDb } from "../loader.js";
 import { sanitizeHref } from "../utils/url.js";
 import type { Menu, MenuItem, MenuItemRow } from "./types.js";
@@ -273,6 +274,9 @@ async function resolveContentUrl(
 	}
 
 	try {
+		// Validate collection name before interpolating into table reference
+		validateIdentifier(collection, "menu item collection");
+
 		// Dynamic content tables (ec_*) aren't in the Database type, so use sql
 		const result = await sql<{ slug: string }>`
 			SELECT slug FROM ${sql.ref(`ec_${collection}`)} WHERE id = ${entryId} LIMIT 1

package/src/plugins/context.ts

@@ -202,9 +202,13 @@ export function createContentAccess(db: Kysely<Database>): ContentAccess {
 			const result: ContentItem = {
 				id: item.id,
 				type: item.type,
+				slug: item.slug,
+				status: item.status,
 				data: item.data,
 				createdAt: item.createdAt,
 				updatedAt: item.updatedAt,
+				locale: item.locale,
+				publishedAt: item.publishedAt,
 			};
 
 			if (await seoRepo.isEnabled(collection)) {
@@ -237,9 +241,13 @@ export function createContentAccess(db: Kysely<Database>): ContentAccess {
 			const items: ContentItem[] = result.items.map((item) => ({
 				id: item.id,
 				type: item.type,
+				slug: item.slug,
+				status: item.status,
 				data: item.data,
 				createdAt: item.createdAt,
 				updatedAt: item.updatedAt,
+				locale: item.locale,
+				publishedAt: item.publishedAt,
 			}));
 
 			if (items.length > 0 && (await seoRepo.isEnabled(collection))) {
@@ -294,9 +302,13 @@ export function createContentAccessWithWrite(db: Kysely<Database>): ContentAcces
 				const result: ContentItem = {
 					id: item.id,
 					type: item.type,
+					slug: item.slug,
+					status: item.status,
 					data: item.data,
 					createdAt: item.createdAt,
 					updatedAt: item.updatedAt,
+					locale: item.locale,
+					publishedAt: item.publishedAt,
 				};
 
 				if (hasSeo) {
@@ -336,9 +348,13 @@ export function createContentAccessWithWrite(db: Kysely<Database>): ContentAcces
 				const result: ContentItem = {
 					id: item.id,
 					type: item.type,
+					slug: item.slug,
+					status: item.status,
 					data: item.data,
 					createdAt: item.createdAt,
 					updatedAt: item.updatedAt,
+					locale: item.locale,
+					publishedAt: item.publishedAt,
 				};
 
 				if (hasSeo) {
@@ -439,12 +455,13 @@ export function createMediaAccessWithWrite(
 				);
 			}
 
-			const mediaId = ulid();
+			// Generate a storage key with a unique prefix
+			const keyPrefix = ulid();
 			// Extract extension from basename (ignore path separators)
 			const basename = filename.split("/").pop() ?? filename;
 			const dotIdx = basename.lastIndexOf(".");
 			const ext = dotIdx > 0 ? basename.slice(dotIdx).toLowerCase() : "";
-			const storageKey = `${mediaId}${ext}`;
+			const storageKey = `${keyPrefix}${ext}`;
 
 			// Upload to storage first
 			await storage.upload({
@@ -454,8 +471,9 @@ export function createMediaAccessWithWrite(
 			});
 
 			// Create DB record — clean up storage on failure
+			let media;
 			try {
-				await mediaRepo.create({
+				media = await mediaRepo.create({
 					filename: basename,
 					mimeType: contentType,
 					size: bytes.byteLength,
@@ -472,7 +490,7 @@ export function createMediaAccessWithWrite(
 			}
 
 			return {
-				mediaId,
+				mediaId: media.id,
 				storageKey,
 				url: `/_emdash/api/media/file/${storageKey}`,
 			};
@@ -491,11 +509,17 @@ export function createMediaAccessWithWrite(
 /** Maximum number of redirects to follow in plugin HTTP access */
 const MAX_PLUGIN_REDIRECTS = 5;
 
+/**
+ * Check if a hostname matches any pattern in the allowed list.
+ * Patterns: "*" matches all, "*.example.com" matches subdomains AND bare "example.com",
+ * "api.example.com" matches exactly.
+ */
 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"
+			// Match subdomains (foo.example.com) and bare domain (example.com)
 			return host.endsWith(suffix) || host === pattern.slice(2);
 		}
 		return host === pattern;

package/src/plugins/cron.ts

@@ -113,13 +113,38 @@ export class CronExecutor {
 
 			if (task.is_oneshot) {
 				if (hookFailed) {
-					// Keep the task for retry — reset to idle with a 1-minute backoff
-					const retryAt = new Date(Date.now() + 60_000).toISOString();
-					await sql`
+					// Retry metadata is namespaced under __emdash to avoid collisions
+					// with plugin-controlled data fields.
+					const meta =
+						parsedData?.__emdash != null && typeof parsedData.__emdash === "object"
+							? (parsedData.__emdash as Record<string, unknown>)
+							: undefined;
+					const raw = meta?.retryCount;
+					const retryCount =
+						typeof raw === "number" && Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : 0;
+					const MAX_ONESHOT_RETRIES = 5;
+
+					if (retryCount >= MAX_ONESHOT_RETRIES) {
+						console.error(
+							`[cron] One-shot task ${task.plugin_id}:${task.task_name} exceeded ${MAX_ONESHOT_RETRIES} retries, removing`,
+						);
+						await sql`
+						DELETE FROM _emdash_cron_tasks WHERE id = ${task.id}
+					`.execute(this.db);
+					} else {
+						// Retry with exponential backoff: 1m, 2m, 4m, 8m, 16m
+						const backoffMs = 60_000 * Math.pow(2, retryCount);
+						const retryAt = new Date(Date.now() + backoffMs).toISOString();
+						const updatedData = JSON.stringify({
+							...parsedData,
+							__emdash: { ...meta, retryCount: retryCount + 1 },
+						});
+						await sql`
 						UPDATE _emdash_cron_tasks
-						SET status = 'idle', locked_at = NULL, next_run_at = ${retryAt}
+						SET status = 'idle', locked_at = NULL, next_run_at = ${retryAt}, data = ${updatedData}
 						WHERE id = ${task.id}
 					`.execute(this.db);
+					}
 				} else {
 					// Success: delete the one-shot task
 					await sql`

package/src/plugins/hooks.ts

@@ -324,7 +324,11 @@ export class HookPipeline {
 			);
 
 			if (ready.length === 0) {
-				// Circular dependency or missing dependency - just add by priority
+				// Circular dependency or missing dependency - log warning and fall back to priority
+				const pluginIds = remaining.map((h) => h.pluginId).join(", ");
+				console.warn(
+					`[hooks] Hook dependency cycle or missing dependency detected among plugins: ${pluginIds}. Falling back to priority order.`,
+				);
 				remaining.sort((a, b) => a.priority - b.priority);
 				sorted.push(...remaining);
 				break;
@@ -344,12 +348,16 @@ export class HookPipeline {
 	 * Execute a hook with timeout
 	 */
 	private async executeWithTimeout<T>(fn: () => Promise<T>, timeout: number): Promise<T> {
-		return Promise.race([
-			fn(),
-			new Promise<T>((_, reject) =>
-				setTimeout(() => reject(new Error(`Hook timeout after ${timeout}ms`)), timeout),
-			),
-		]);
+		let timer: ReturnType<typeof setTimeout>;
+		const timeoutPromise = new Promise<T>(
+			(_, reject) =>
+				(timer = setTimeout(() => reject(new Error(`Hook timeout after ${timeout}ms`)), timeout)),
+		);
+		try {
+			return await Promise.race([fn(), timeoutPromise]);
+		} finally {
+			clearTimeout(timer!);
+		}
 	}
 
 	// =========================================================================
@@ -561,7 +569,7 @@ export class HookPipeline {
 
 		for (const hook of hooks) {
 			const { handler } = hook;
-			const event: ContentDeleteEvent = { id, collection };
+			const event: ContentDeleteEvent = { id, collection, permanent: false };
 			const ctx = this.getContext(hook.pluginId);
 			const start = Date.now();
 
@@ -597,13 +605,17 @@ export class HookPipeline {
 	/**
 	 * Run content:afterDelete hooks
 	 */
-	async runContentAfterDelete(id: string, collection: string): Promise<HookResult<void>[]> {
+	async runContentAfterDelete(
+		id: string,
+		collection: string,
+		permanent: boolean,
+	): Promise<HookResult<void>[]> {
 		const hooks = this.getTypedHooks("content:afterDelete");
 		const results: HookResult<void>[] = [];
 
 		for (const hook of hooks) {
 			const { handler } = hook;
-			const event: ContentDeleteEvent = { id, collection };
+			const event: ContentDeleteEvent = { id, collection, permanent };
 			const ctx = this.getContext(hook.pluginId);
 			const start = Date.now();
 

package/src/plugins/index.ts

@@ -121,6 +121,7 @@ export type {
 	ResolvedPluginHooks,
 	ContentHookEvent,
 	ContentDeleteEvent,
+	ContentPublishStateChangeEvent,
 	MediaUploadEvent,
 	MediaAfterUploadEvent,
 	LifecycleEvent,

package/src/plugins/manager.ts

@@ -333,9 +333,13 @@ export class PluginManager {
 	/**
 	 * Run content:afterDelete hooks across all active plugins
 	 */
-	async runContentAfterDelete(id: string, collection: string): Promise<HookResult<void>[]> {
+	async runContentAfterDelete(
+		id: string,
+		collection: string,
+		permanent: boolean,
+	): Promise<HookResult<void>[]> {
 		this.ensureInitialized();
-		return this.hookPipeline!.runContentAfterDelete(id, collection);
+		return this.hookPipeline!.runContentAfterDelete(id, collection, permanent);
 	}
 
 	/**

package/src/plugins/marketplace.ts

@@ -241,12 +241,42 @@ class MarketplaceClientImpl implements MarketplaceClient {
 	async downloadBundle(id: string, version: string): Promise<PluginBundle> {
 		const bundleUrl = `${this.baseUrl}/api/v1/plugins/${encodeURIComponent(id)}/versions/${encodeURIComponent(version)}/bundle`;
 
+		const marketplaceOrigin = new URL(this.baseUrl).origin;
+		const MAX_REDIRECTS = 5;
 		let response: Response;
 		try {
-			response = await fetch(bundleUrl, {
-				redirect: "follow",
-			});
+			let currentUrl = bundleUrl;
+			response = await fetch(currentUrl, { redirect: "manual" });
+
+			// Follow redirects manually, validating each target stays on the marketplace host
+			for (let i = 0; i < MAX_REDIRECTS; i++) {
+				if (response.status < 300 || response.status >= 400) break;
+
+				const location = response.headers.get("location");
+				if (!location) break;
+
+				const target = new URL(location, currentUrl);
+				if (target.origin !== marketplaceOrigin) {
+					throw new MarketplaceError(
+						`Bundle download redirected to untrusted host: ${target.origin}`,
+						response.status,
+						"BUNDLE_REDIRECT_UNTRUSTED",
+					);
+				}
+				currentUrl = target.href;
+				response = await fetch(currentUrl, { redirect: "manual" });
+			}
+
+			// If still a redirect after MAX_REDIRECTS, fail explicitly
+			if (response.status >= 300 && response.status < 400) {
+				throw new MarketplaceError(
+					`Bundle download exceeded maximum redirects (${MAX_REDIRECTS})`,
+					response.status,
+					"BUNDLE_TOO_MANY_REDIRECTS",
+				);
+			}
 		} catch (err) {
+			if (err instanceof MarketplaceError) throw err;
 			throw new MarketplaceUnavailableError(err);
 		}
 

package/src/plugins/routes.ts

@@ -124,13 +124,13 @@ export class PluginRouteHandler {
 				};
 			}
 
-			// Unknown error
-			const message = error instanceof Error ? error.message : String(error);
+			// Unknown error -- log internally, return generic message
+			console.error(`[plugin:${this.plugin.id}] Route handler failed:`, error);
 			return {
 				success: false,
 				error: {
 					code: "INTERNAL_ERROR",
-					message: `Route handler failed: ${message}`,
+					message: "An internal error occurred",
 				},
 				status: 500,
 			};

package/src/plugins/types.ts

@@ -195,6 +195,9 @@ export interface ContentItemSeoInput {
 export interface ContentItem {
 	id: string;
 	type: string;
+	slug: string | null;
+	status: string;
+	locale: string | null;
 	data: Record<string, unknown>;
 	/**
 	 * SEO metadata, populated when the collection has SEO enabled
@@ -203,6 +206,7 @@ export interface ContentItem {
 	seo?: ContentItemSeo;
 	createdAt: string;
 	updatedAt: string;
+	publishedAt: string | null;
 }
 
 /**
@@ -702,6 +706,8 @@ export interface ContentHookEvent {
 export interface ContentDeleteEvent {
 	id: string;
 	collection: string;
+	/** `true` when the content is permanently deleted (not just trashed). */
+	permanent: boolean;
 }
 
 /**
@@ -876,6 +882,7 @@ export type PageMetadataLinkRel =
 	| "alternate"
 	| "author"
 	| "license"
+	| "nlweb"
 	| "site.standard.document";
 
 export type PageMetadataContribution =

package/src/query.ts

@@ -637,6 +637,22 @@ function patternToRegex(pattern: string): { regex: RegExp; paramNames: string[]
 	return { regex: new RegExp(`^${regexStr}$`), paramNames };
 }
 
+/** Cached compiled URL patterns for resolveEmDashPath */
+interface CachedPattern {
+	slug: string;
+	regex: RegExp;
+	paramNames: string[];
+}
+let cachedUrlPatterns: CachedPattern[] | null = null;
+
+/**
+ * Invalidate the cached URL patterns used by resolveEmDashPath.
+ * Call when collection URL patterns change (schema updates).
+ */
+export function invalidateUrlPatternCache(): void {
+	cachedUrlPatterns = null;
+}
+
 /**
  * Resolve a URL path to a content entry by matching against collection URL patterns.
  *
@@ -659,32 +675,39 @@ function patternToRegex(pattern: string): { regex: RegExp; paramNames: string[]
 export async function resolveEmDashPath<T = Record<string, unknown>>(
 	path: string,
 ): Promise<ResolvePathResult<T> | null> {
-	const { getDb } = await import("./loader.js");
-	const { SchemaRegistry } = await import("./schema/registry.js");
-	const db = await getDb();
-	const registry = new SchemaRegistry(db);
-	const collections = await registry.listCollections();
-
-	for (const collection of collections) {
-		if (!collection.urlPattern) continue;
+	// Build and cache compiled patterns on first call
+	if (!cachedUrlPatterns) {
+		const { getDb } = await import("./loader.js");
+		const { SchemaRegistry } = await import("./schema/registry.js");
+		const db = await getDb();
+		const registry = new SchemaRegistry(db);
+		const collections = await registry.listCollections();
+
+		cachedUrlPatterns = [];
+		for (const collection of collections) {
+			if (!collection.urlPattern) continue;
+			const { regex, paramNames } = patternToRegex(collection.urlPattern);
+			cachedUrlPatterns.push({ slug: collection.slug, regex, paramNames });
+		}
+	}
 
-		const { regex, paramNames } = patternToRegex(collection.urlPattern);
-		const match = path.match(regex);
+	for (const pattern of cachedUrlPatterns) {
+		const match = path.match(pattern.regex);
 		if (!match) continue;
 
 		// Extract params
 		const params: Record<string, string> = {};
-		for (let i = 0; i < paramNames.length; i++) {
-			params[paramNames[i]] = match[i + 1];
+		for (let i = 0; i < pattern.paramNames.length; i++) {
+			params[pattern.paramNames[i]] = match[i + 1];
 		}
 
 		// Look up entry by slug (most common pattern)
 		const slug = params.slug;
 		if (!slug) continue;
 
-		const { entry } = await getEmDashEntry<string, T>(collection.slug, slug);
+		const { entry } = await getEmDashEntry<string, T>(pattern.slug, slug);
 		if (entry) {
-			return { entry, collection: collection.slug, params };
+			return { entry, collection: pattern.slug, params };
 		}
 	}
 

package/src/redirects/cache.ts

@@ -0,0 +1,68 @@
+/**
+ * Redirect pattern cache.
+ *
+ * Module-level cache for compiled redirect pattern rules. The middleware
+ * populates this on first request; route handlers invalidate it on writes.
+ *
+ * This module deliberately has NO Astro imports so it can be safely imported
+ * from handlers, seed, CLI, and tests without dragging in `astro:middleware`.
+ */
+
+import type { Redirect } from "../database/repositories/redirect.js";
+import type { CompiledPattern } from "./patterns.js";
+import { compilePattern, interpolateDestination, matchPattern } from "./patterns.js";
+
+export interface CachedRedirectRule {
+	redirect: Redirect;
+	compiled: CompiledPattern;
+}
+
+/**
+ * Cached pattern rules with compiled regexes.
+ * null = not yet populated, array = cached.
+ */
+let cachedPatternRules: CachedRedirectRule[] | null = null;
+
+/**
+ * Invalidate the cached redirect pattern rules.
+ * Call when redirects are created, updated, or deleted.
+ */
+export function invalidateRedirectCache(): void {
+	cachedPatternRules = null;
+}
+
+/**
+ * Get the cached compiled pattern rules, or null if the cache is cold.
+ */
+export function getCachedPatternRules(): CachedRedirectRule[] | null {
+	return cachedPatternRules;
+}
+
+/**
+ * Populate the pattern rules cache from a list of enabled pattern redirects.
+ */
+export function setCachedPatternRules(redirects: Redirect[]): CachedRedirectRule[] {
+	cachedPatternRules = redirects.map((r) => ({
+		redirect: r,
+		compiled: compilePattern(r.source),
+	}));
+	return cachedPatternRules;
+}
+
+/**
+ * Match a path against the cached pattern rules.
+ * Returns the resolved destination and matching redirect, or null.
+ */
+export function matchCachedPatterns(
+	rules: CachedRedirectRule[],
+	pathname: string,
+): { redirect: Redirect; destination: string } | null {
+	for (const { redirect, compiled } of rules) {
+		const params = matchPattern(compiled, pathname);
+		if (params) {
+			const dest = interpolateDestination(redirect.destination, params);
+			return { redirect, destination: dest };
+		}
+	}
+	return null;
+}