@coywolf/emdash 0.0.0-stage → 0.35.14

package/src/redirects/middleware.ts

@@ -0,0 +1,169 @@
+/**
+ * Serves Coywolf redirects (through the pack middleware in src/middleware.ts).
+ * Each request reads its exact rule, if any, from D1: one row through the
+ * (source, is_regex) index. Pattern rules (few) are kept in memory per
+ * Worker isolate, compiled in source order, and read again after a redirect
+ * edit (in this isolate at once; in others when they see the new settings
+ * generation, see src/core/generation.ts), or after `cacheSeconds`. Reading
+ * never writes: the table is created by the first admin write. Hits are
+ * counted after the response is sent.
+ *
+ * With Astro's cacheCloudflare() provider, GET and HEAD redirects are kept in
+ * the edge cache (Workers Cache) for 30 days, tagged REDIRECTS_TAG; any
+ * redirect edit purges that tag (src/pageCache/lib.ts purgeScope). Repeats
+ * served from the cache don't reach the Worker, so they aren't counted as hits.
+ */
+import type { MiddlewareHandler } from "astro";
+
+import { isCurrent, settingsEpoch } from "../core/features.js";
+import { noteReadFailure } from "../core/read-failures.js";
+import { REDIRECTS_TAG } from "../pageCache/lib.js";
+import { type CompiledRules, compile, findExactRule, loadPatternRules, match, recordHit } from "./rules.js";
+
+export interface CoywolfRedirectsOptions {
+	/** D1 binding of the site database. Default "DB". */
+	database?: string;
+	/** Longest time to keep pattern rules per isolate, in seconds. Default 600 (edits reload them sooner). */
+	cacheSeconds?: number;
+}
+
+type Patterns = CompiledRules["patterns"];
+
+let cache: { patterns: Patterns; at: number; epoch: number } | null = null;
+/** A load in progress: concurrent requests of a cold isolate share it. */
+let loading: Promise<Patterns> | null = null;
+
+/** Drop the in-memory pattern rules so the next request reloads them (called after admin edits). */
+export function invalidateRedirectCache(): void {
+	cache = null;
+	loading = null;
+}
+
+function patterns(db: D1Database, ttl: number): Promise<Patterns> {
+	if (cache && isCurrent(cache, ttl)) return Promise.resolve(cache.patterns);
+	if (!loading) {
+		const epoch = settingsEpoch();
+		const load = loadPatternRules(db)
+			.then((list) => {
+				const compiled = compile(list).patterns;
+				if (loading === load && epoch === settingsEpoch()) cache = { patterns: compiled, at: Date.now(), epoch };
+				return compiled;
+			})
+			.finally(() => {
+				if (loading === load) loading = null;
+			});
+		loading = load;
+	}
+	return loading;
+}
+
+/** The rules that can match a request (its exact rule and the patterns), read once per request URL. */
+const lookups = new WeakMap<URL, Promise<CompiledRules>>();
+
+function rulesFor(url: URL, db: D1Database, ttl: number): Promise<CompiledRules> {
+	let found = lookups.get(url);
+	if (!found) {
+		// Issued in the same tick, so both reads go to D1 in one batch.
+		found = Promise.all([findExactRule(db, url.pathname), patterns(db, ttl)]).then(([exact, list]) => ({
+			exact: new Map(exact ? [[exact.source, exact]] : []),
+			patterns: list,
+		}));
+		lookups.set(url, found);
+	}
+	return found;
+}
+
+const SKIP = /^\/(_emdash|_astro|_image)\//;
+const ttlOf = (options: CoywolfRedirectsOptions) => (options.cacheSeconds ?? 600) * 1000;
+
+/**
+ * Start this request's lookup without waiting: the pack middleware calls it
+ * before reading the feature switches, so when those aren't cached all the
+ * reads go to D1 in one batch. Errors surface (logged) in serveRedirect.
+ */
+export function prefetchRedirects(url: URL, env: Record<string, unknown>, options: CoywolfRedirectsOptions = {}): void {
+	const db = env[options.database ?? "DB"] as D1Database | undefined;
+	if (!db || SKIP.test(url.pathname)) return;
+	rulesFor(url, db, ttlOf(options)).catch(() => undefined);
+}
+
+/**
+ * Answer a request from the redirect rules, or return undefined to pass it on.
+ * `edge`: the response will be kept in the edge cache (see serveCachedRedirect).
+ */
+export async function serveRedirect(
+	url: URL,
+	env: Record<string, unknown>,
+	waitUntil: (p: Promise<unknown>) => void,
+	options: CoywolfRedirectsOptions = {},
+	edge = false,
+): Promise<Response | undefined> {
+	const { pathname, search } = url;
+	if (SKIP.test(pathname)) return undefined;
+	const db = env[options.database ?? "DB"] as D1Database | undefined;
+	if (!db) return undefined;
+
+	let compiled: CompiledRules;
+	try {
+		compiled = await rulesFor(url, db, ttlOf(options));
+	} catch (error) {
+		console.error("coywolf redirects: could not load rules", error);
+		// The page this URL renders instead of its redirect mustn't be edge-cached.
+		noteReadFailure("redirect rules");
+		return undefined;
+	}
+
+	const found = match(compiled, pathname, search);
+	if (!found) return undefined;
+
+	waitUntil(recordHit(db, found.rule.id).catch(() => undefined));
+
+	// Browsers may keep a redirect for an hour. Unless it goes in the edge cache
+	// (whose lifetime Astro sets in Cloudflare-CDN-Cache-Control), "private" keeps
+	// Workers Cache from storing it untagged, where an edit couldn't clear it.
+	const caching = { "Cache-Control": edge ? "max-age=3600" : "private, max-age=3600" };
+	if (found.rule.type === 410) return new Response("Gone", { status: 410, headers: caching });
+	let location = found.location;
+	if (location.startsWith("/")) {
+		// match() already collapses leading slashes from capture groups; this is a
+		// second check that a site-relative destination never resolves off-site.
+		const resolved = new URL(location, url);
+		if (resolved.origin !== url.origin) return undefined;
+		// The edge cache is shared by every hostname the Worker answers (it's keyed by
+		// path and query), so a cached redirect stays on whichever host was asked.
+		location = edge ? resolved.pathname + resolved.search + resolved.hash : resolved.href;
+	}
+	return new Response(null, { status: found.rule.type, headers: { Location: location, ...caching } });
+}
+
+/** Astro's per-request cache controls (route caching), as far as redirects use them. */
+interface RouteCache {
+	enabled?: boolean;
+	set(options: { maxAge?: number; tags?: string[] } | false): void;
+}
+
+/** How long the edge cache keeps a redirect: until an edit purges it, or 30 days. */
+export const REDIRECT_EDGE_MAX_AGE = 30 * 86400;
+
+/**
+ * The pack middleware's redirect handler: serveRedirect, and for GET and HEAD
+ * with Astro route caching on, the edge lifetime and tag (replacing any the
+ * site's route rules gave the request). Astro sends them as
+ * Cloudflare-CDN-Cache-Control and Cache-Tag, which Cloudflare strips before
+ * the response reaches the browser.
+ */
+export async function serveCachedRedirect(
+	context: Parameters<MiddlewareHandler>[0],
+	env: Record<string, unknown>,
+	waitUntil: (p: Promise<unknown>) => void,
+): Promise<Response | undefined> {
+	const cache = (context as unknown as { cache?: RouteCache }).cache;
+	const method = context.request.method;
+	const edge = Boolean(cache?.enabled) && (method === "GET" || method === "HEAD");
+	const response = await serveRedirect(context.url, env, waitUntil, {}, edge);
+	if (response && edge) {
+		cache!.set(false);
+		cache!.set({ maxAge: REDIRECT_EDGE_MAX_AGE, tags: [REDIRECTS_TAG] });
+	}
+	return response;
+}

package/src/redirects/module.ts

@@ -0,0 +1,124 @@
+/**
+ * Redirects module: the admin side of Coywolf redirects (rules are served by
+ * the middleware in ./middleware.ts).
+ */
+import { PluginRouteError, definePluginRoute } from "emdash";
+import { z } from "zod";
+
+import { parseInput, workerEnv } from "../shared.js";
+import { invalidateRedirectCache } from "./middleware.js";
+import {
+	REDIRECT_TYPES,
+	RedirectValidationError,
+	compile,
+	deleteRule,
+	listRules,
+	match,
+	saveRule,
+	validate,
+} from "./rules.js";
+
+export interface RedirectsOptions {
+	/** D1 binding of the site database. Default "DB". */
+	database?: string;
+}
+
+const ruleInput = z.object({
+	id: z.string().optional(),
+	source: z.string().max(2000),
+	target: z.string().max(2000).optional(),
+	type: z.number().int().optional(),
+	isRegex: z.boolean().optional(),
+	enabled: z.boolean().optional(),
+	note: z.string().max(500).nullish(),
+});
+
+export function redirectsModule(options: RedirectsOptions) {
+	async function db() {
+		const env = await workerEnv();
+		const database = env[options.database ?? "DB"] as D1Database | undefined;
+		if (!database) throw PluginRouteError.badRequest("Redirects: missing database binding.");
+		return database;
+	}
+
+	/** Turn rule validation errors into readable 400s. */
+	async function guarded<T>(fn: () => Promise<T>): Promise<T> {
+		try {
+			return await fn();
+		} catch (error) {
+			if (error instanceof RedirectValidationError) throw PluginRouteError.badRequest(error.message);
+			throw error;
+		}
+	}
+
+	const routes = {
+		"redirects/list": {
+			permission: "plugins:manage" as const,
+			handler: async () => ({ items: await listRules(await db()), types: REDIRECT_TYPES }),
+		},
+
+		"redirects/save": definePluginRoute({
+			permission: "plugins:manage",
+			methods: ["POST"],
+			request: { body: "json" },
+			handler: async (ctx) => {
+				const input = parseInput(ruleInput, ctx.input);
+				const rule = await guarded(() => db().then((d) => saveRule(d, input)));
+				invalidateRedirectCache();
+				ctx.log.info("Redirect saved", { source: rule.source, target: rule.target });
+				return rule;
+			},
+		}),
+
+		"redirects/delete": definePluginRoute({
+			permission: "plugins:manage",
+			methods: ["POST"],
+			request: { body: "json" },
+			handler: async (ctx) => {
+				const { id } = parseInput(z.object({ id: z.string() }), ctx.input);
+				const deleted = await deleteRule(await db(), id);
+				invalidateRedirectCache();
+				return { deleted };
+			},
+		}),
+
+		/** Add or update many rules (matched by source). Every rule is validated before any is saved. */
+		"redirects/import": definePluginRoute({
+			permission: "plugins:manage",
+			methods: ["POST"],
+			request: { body: "json", maxBytes: 2 * 1024 * 1024 },
+			handler: async (ctx) => {
+				const { rules } = parseInput(z.object({ rules: z.array(ruleInput.omit({ id: true })).max(5000) }), ctx.input);
+				const errors: string[] = [];
+				rules.forEach((rule, i) => {
+					try {
+						validate(rule);
+					} catch (error) {
+						errors.push(`Row ${i + 1} (${rule.source}): ${(error as Error).message}`);
+					}
+				});
+				if (errors.length) throw PluginRouteError.badRequest(errors.slice(0, 10).join("\n"));
+				const database = await db();
+				for (const rule of rules) await saveRule(database, rule);
+				invalidateRedirectCache();
+				ctx.log.info("Redirects imported", { count: rules.length });
+				return { imported: rules.length };
+			},
+		}),
+
+		/** Which rule (if any) a URL would hit. */
+		"redirects/test": definePluginRoute({
+			permission: "plugins:manage",
+			methods: ["POST"],
+			request: { body: "json" },
+			handler: async (ctx) => {
+				const { url } = parseInput(z.object({ url: z.string().min(1).max(2000) }), ctx.input);
+				const parsed = new URL(url, "https://example.invalid");
+				const found = match(compile(await listRules(await db())), parsed.pathname, parsed.search);
+				return found ? { matched: true, rule: found.rule, location: found.location } : { matched: false };
+			},
+		}),
+	};
+
+	return { routes };
+}

package/src/redirects/pack.ts

@@ -0,0 +1,89 @@
+import type { PluginContext } from "emdash";
+
+import { cachedCtxFeatures, isOn, registerFeatures } from "../core/features.js";
+import type { PackMiddleware, PackModule } from "../core/module.js";
+import { serveCachedRedirect } from "./middleware.js";
+import { type RedirectsOptions, redirectsModule } from "./module.js";
+import { TRASH_PROMPT_FEATURE, removedModule } from "./removed.js";
+import { SLUG_CHANGES_FEATURE, slugChangesModule } from "./slug-changes.js";
+
+const FEATURES = [
+	{
+		id: "redirects",
+		label: "Redirects",
+		description: "External and file-path redirects, regular expressions, hit counts, and import.",
+		default: true,
+	},
+	{
+		id: TRASH_PROMPT_FEATURE,
+		label: "Removed content",
+		description:
+			"When a published entry is trashed or unpublished, ask what its old URL should do: redirect it or return 410 Gone. Undecided URLs stay listed on the Redirects page.",
+		default: false,
+	},
+	{
+		id: SLUG_CHANGES_FEATURE,
+		label: "Slug changes",
+		description:
+			"When a published entry's URL changes (a new slug, category or parent page), add a 301 from the old URL to the new one. EmDash's own slug-change redirect uses the collection's URL pattern, which can't express category or parent paths.",
+		default: true,
+	},
+];
+registerFeatures(FEATURES);
+
+// biome-ignore lint/suspicious/noExplicitAny: hook events differ per hook.
+type Hook = (event: any, ctx: PluginContext) => Promise<unknown>;
+
+/**
+ * One handler per hook from the features that share it, each run only while its
+ * feature is on (the module's own gate is the main Redirects switch).
+ */
+function mergeHooks(parts: Array<{ feature: string; hooks: Record<string, Hook> }>): Record<string, Hook> {
+	const names = new Set(parts.flatMap((p) => Object.keys(p.hooks)));
+	return Object.fromEntries(
+		[...names].map((name) => [
+			name,
+			async (event: unknown, ctx: PluginContext) => {
+				const features = await cachedCtxFeatures(ctx);
+				let result: unknown;
+				for (const part of parts) {
+					const run = part.hooks[name];
+					if (!run || !isOn(features, part.feature)) continue;
+					// Each feature on its own, as compose.ts isolates modules: one failing doesn't skip the other.
+					try {
+						const value = await run(event, ctx);
+						if (value !== undefined) result = value;
+					} catch (error) {
+						ctx.log.warn(`Redirects: ${part.feature} ${name} failed`, { error: String(error) });
+					}
+				}
+				return result;
+			},
+		]),
+	);
+}
+
+export function redirectsPack(options: RedirectsOptions): PackModule {
+	const removed = removedModule(options);
+	const slugs = slugChangesModule(options);
+	return {
+		id: "redirects",
+		label: "Redirects",
+		features: FEATURES,
+		routes: { ...redirectsModule(options).routes, ...removed.routes },
+		adminPages: [{ path: "/redirects", label: "Redirects", icon: "arrow-bend-up-right" }],
+		hooks: mergeHooks([
+			{ feature: TRASH_PROMPT_FEATURE, hooks: removed.hooks },
+			{ feature: SLUG_CHANGES_FEATURE, hooks: slugs.hooks },
+		]),
+		storage: { ...removed.storage, ...slugs.storage },
+		capabilities: ["content:read"],
+	};
+}
+
+export const redirectsMiddleware: PackMiddleware = {
+	module: "redirects",
+	feature: "redirects",
+	ownsCache: true,
+	handle: serveCachedRedirect,
+};

package/src/redirects/removed-core.ts

@@ -0,0 +1,151 @@
+/**
+ * "Removed content" decisions (feature "redirects.trashPrompt"): the pure
+ * parts, unit tested in Node. When a published entry is deleted or
+ * unpublished, its former URL is recorded so an editor can redirect it,
+ * mark it 410 Gone, or dismiss it.
+ */
+import { type CollectionInfo, interpolateUrlPattern } from "../core/content-url.js";
+
+export type RemovalReason = "deleted" | "unpublished";
+
+export interface PendingDecision {
+	/** Storage id: "<collection>:<entry id>". */
+	id: string;
+	collection: string;
+	entryId: string;
+	/** Former public path (the site's `urls` override, or the collection's URL pattern). */
+	url: string;
+	title: string;
+	reason: RemovalReason;
+	locale: string | null;
+	/** ISO time of the removal. */
+	at: string;
+}
+
+/** The entry fields a decision needs, from a D1 row or a hook's content record. */
+export interface EntrySnapshot {
+	id: string;
+	slug: string | null;
+	status: string | null;
+	publishedAt: string | null;
+	locale: string | null;
+	title: string | null;
+}
+
+export const pendingId = (collection: string, entryId: string) => `${collection}:${entryId}`;
+
+const str = (v: unknown): string | null => (typeof v === "string" && v ? v : null);
+
+/** Read a snapshot from an ec_* row (snake_case columns, title in the collection's title field). */
+export function snapshotFromRow(row: Record<string, unknown>, titleField: string | null): EntrySnapshot {
+	return {
+		id: String(row.id),
+		slug: str(row.slug),
+		status: str(row.status),
+		publishedAt: str(row.published_at),
+		locale: str(row.locale),
+		title: str(titleField ? row[titleField] : null) ?? str(row.title),
+	};
+}
+
+/** Read a snapshot from a content hook's record (EmDash ContentItem: camelCase, fields under data). */
+export function snapshotFromContent(content: Record<string, unknown>, titleField: string | null): EntrySnapshot {
+	const data = (content.data ?? {}) as Record<string, unknown>;
+	return {
+		id: String(content.id),
+		slug: str(content.slug),
+		status: str(content.status),
+		publishedAt: str(content.publishedAt),
+		locale: str(content.locale),
+		title: str(titleField ? data[titleField] : null) ?? str(data.title) ?? str(content.title),
+	};
+}
+
+/**
+ * Build the decision for a removed entry, or null when there's nothing to
+ * decide: the entry never had a public URL (no slug, never published), or,
+ * for deletes, it wasn't live when it was deleted.
+ */
+export function buildPending(
+	collection: string,
+	entry: EntrySnapshot,
+	/** The former path when already resolved (core/content-url.ts entryUrl), else the collection's URL pattern. */
+	info: { url?: string | null; urlPattern?: CollectionInfo["urlPattern"] } | undefined,
+	reason: RemovalReason,
+	now: Date = new Date(),
+): PendingDecision | null {
+	if (!entry.slug) return null;
+	if (reason === "deleted" && entry.status !== "published") return null;
+	if (reason === "unpublished" && !entry.publishedAt) return null;
+	const url =
+		info?.url ||
+		interpolateUrlPattern({
+			pattern: info?.urlPattern ?? null,
+			collection,
+			slug: entry.slug,
+			id: entry.id,
+			date: entry.publishedAt,
+		});
+	return {
+		id: pendingId(collection, entry.id),
+		collection,
+		entryId: entry.id,
+		url,
+		title: entry.title ?? entry.slug,
+		reason,
+		locale: entry.locale,
+		at: now.toISOString(),
+	};
+}
+
+/**
+ * A redirect or 410 rule created from a removal decision, remembered so that
+ * restoring or republishing the entry can take the rule away again.
+ */
+export interface AppliedRule {
+	/** Same id as the decision: "<collection>:<entry id>". */
+	id: string;
+	collection: string;
+	entryId: string;
+	/** The former path the rule was created for. */
+	url: string;
+	ruleId: string;
+	action: "redirect" | "gone";
+	/** ISO time the rule was created. */
+	at: string;
+}
+
+const samePath = (a: string, b: string) => (a.length > 1 ? a.replace(/\/+$/, "") : a) === (b.length > 1 ? b.replace(/\/+$/, "") : b);
+
+/** Whether the rule is still the one a removal decision made: same source, our "Removed:" note. Edited, replaced, or deleted since: false. */
+export function appliedStillOurs(applied: Pick<AppliedRule, "url">, rule: { source: string; note: string | null } | null): boolean {
+	return rule !== null && samePath(rule.source, applied.url) && (rule.note?.startsWith("Removed:") ?? false);
+}
+
+/**
+ * Whether restoring or republishing an entry should delete the rule its
+ * removal created: only while the rule is still the one we made
+ * (appliedStillOurs), and, on publish, only when the entry is back at the
+ * same URL (a new slug means the old URL still needs the rule).
+ */
+export function shouldDropApplied(
+	applied: Pick<AppliedRule, "url">,
+	rule: { source: string; note: string | null } | null,
+	currentUrl: string | null,
+	reason: "restore" | "publish",
+): boolean {
+	if (!appliedStillOurs(applied, rule)) return false;
+	if (reason === "publish") return currentUrl !== null && samePath(currentUrl, applied.url);
+	return true;
+}
+
+/** Group pending decisions' entry ids by collection, for one "is it live?" query per collection. */
+export function idsByCollection(items: Array<Pick<PendingDecision, "collection" | "entryId">>): Map<string, string[]> {
+	const out = new Map<string, string[]>();
+	for (const item of items) {
+		const ids = out.get(item.collection) ?? [];
+		if (!ids.includes(item.entryId)) ids.push(item.entryId);
+		out.set(item.collection, ids);
+	}
+	return out;
+}