@coywolf/emdash 0.0.0-stage → 0.35.14

package/src/redirects/slug-changes.ts

@@ -0,0 +1,207 @@
+/**
+ * "Slug changes" (feature "redirects.slugChanges"): when a published entry's
+ * public URL changes (a new slug, or a new category or parent page), add a 301
+ * from the old URL to the new one.
+ *
+ * EmDash makes its own slug-change redirect from the collection's URL pattern,
+ * which can't express category or parent paths (posts here have no pattern, so
+ * it writes /posts/<old> → /posts/<new>, which aren't real URLs). This uses the
+ * pack's URL resolver (src/core/content-url.ts), the same one the sitemaps and
+ * breadcrumbs use, so the rule matches the URL readers and search engines saw.
+ *
+ * The old URL is remembered per entry in plugin storage: recorded before a save
+ * (from the live row) and after every save or publish. Rules are made with a
+ * "Slug change:" note; only those are ever edited or deleted.
+ */
+import type { PluginContext } from "emdash";
+
+import { COLLECTION_SLUG, entryUrl, hostDefaultLocale, readCollections } from "../core/content-url.js";
+import { REDIRECTS_TAG, purgePageCache } from "../pageCache/lib.js";
+import { workerEnv } from "../shared.js";
+import { invalidateRedirectCache } from "./middleware.js";
+import { type EntrySnapshot, snapshotFromContent, snapshotFromRow } from "./removed-core.js";
+import { deleteRule, ensureTable, normalizePath, saveRule } from "./rules.js";
+import { type PlanRule, SLUG_NOTE_PREFIX, planSlugChange } from "./slug-core.js";
+
+export const SLUG_CHANGES_FEATURE = "redirects.slugChanges";
+const STORE = "redirects_urls";
+
+export const slugStorage = { [STORE]: { indexes: ["at"] } };
+
+interface KnownUrl {
+	url: string;
+	at: string;
+}
+
+// biome-ignore lint/suspicious/noExplicitAny: plugin storage collections are untyped here.
+const urls = (ctx: PluginContext) => (ctx.storage as Record<string, any>)[STORE] as {
+	get(id: string): Promise<KnownUrl | null>;
+	put(id: string, data: KnownUrl): Promise<void>;
+};
+
+const key = (collection: string, id: string) => `${collection}:${id}`;
+const live = (entry: EntrySnapshot) => entry.status === "published" && Boolean(entry.slug);
+/**
+ * Only default-locale entries: translations can share a slug with the default-locale
+ * entry, and the resolver's database path doesn't add a locale prefix, so a translation's
+ * rename would write a rule over the live default-locale page.
+ */
+const handled = async (entry: EntrySnapshot) => !entry.locale || entry.locale === (await hostDefaultLocale());
+/** How long beforeSave may spend recording a URL: EmDash fails the save if a beforeSave hook times out (5 s). */
+const BEFORE_SAVE_BUDGET_MS = 1500;
+
+export function slugChangesModule(options: { database?: string }) {
+	async function db(): Promise<D1Database | undefined> {
+		try {
+			return (await workerEnv())[options.database ?? "DB"] as D1Database | undefined;
+		} catch {
+			return undefined;
+		}
+	}
+
+	const urlOf = (d1: D1Database, collection: string, entry: EntrySnapshot) =>
+		entry.slug ? entryUrl(d1, collection, { id: entry.id, slug: entry.slug, publishedAt: entry.publishedAt, locale: entry.locale }).catch(() => null) : Promise.resolve(null);
+
+	/** Every exact rule whose source or target is either URL. */
+	async function related(d1: D1Database, a: string, b: string): Promise<PlanRule[]> {
+		await ensureTable(d1);
+		const paths = [normalizePath(a), normalizePath(b)];
+		const { results } = await d1
+			.prepare("SELECT id, source, target, note FROM coywolf_redirects WHERE is_regex = 0 AND (source IN (?, ?) OR target IN (?, ?, ?, ?))")
+			.bind(...paths, ...paths, `${paths[0]}/`, `${paths[1]}/`)
+			.all<PlanRule>();
+		return results;
+	}
+
+	async function moved(ctx: PluginContext, d1: D1Database, collection: string, entry: EntrySnapshot, from: string, to: string) {
+		const rules = await related(d1, from, to);
+		const plan = planSlugChange(from, to, rules);
+		if (plan.kind === "none") return;
+		for (const id of plan.deleteIds) await deleteRule(d1, id);
+		for (const id of plan.retargetIds) {
+			await d1.prepare("UPDATE coywolf_redirects SET target = ?, updated_at = ? WHERE id = ?").bind(to, new Date().toISOString(), id).run();
+		}
+		if (plan.keptManual) {
+			ctx.log.info("Slug change: a redirect for the old URL already exists; left as is", { from, to, rule: plan.keptManual.id });
+		} else {
+			await saveRule(d1, {
+				...(plan.upsert.id ? { id: plan.upsert.id } : {}),
+				source: from,
+				target: to,
+				type: 301,
+				note: `${SLUG_NOTE_PREFIX} ${entry.title ?? entry.slug ?? entry.id}`.slice(0, 500),
+			});
+		}
+		// EmDash collapses its own chains too, so its rows from those earlier URLs now point at the new one.
+		const retargetedSources = rules.filter((r) => plan.retargetIds.includes(r.id)).map((r) => r.source);
+		const replaced = await dropEmDashAuto(d1, collection, from, entry.slug, retargetedSources);
+		invalidateRedirectCache();
+		await purgePageCache({ tags: [REDIRECTS_TAG] });
+		ctx.log.info("Slug change redirect", { collection, from, to, deleted: plan.deleteIds.length, retargeted: plan.retargetIds.length, emdashAutoRemoved: replaced });
+	}
+
+	/**
+	 * Delete the redirect EmDash made for the same change (its "Auto: slug change" rows).
+	 * EmDash builds them from the collection's URL pattern: without one it writes
+	 * /<collection>/<slug> paths that don't exist, and for a nested page it writes a
+	 * top-level /<old> that can hijack a real page there. Its middleware runs before
+	 * the pack's, so its rule would also answer first (without the trailing slash).
+	 * Only auto rows from the old URL (or URLs whose rules were just pointed at the new one,
+	 * since EmDash collapses its chains the same way) whose destination ends in the new
+	 * slug; EmDash's own table and API keep working for everything else.
+	 */
+	async function dropEmDashAuto(d1: D1Database, collection: string, from: string, newSlug: string | null, earlier: string[] = []): Promise<number> {
+		const oldSlug = normalizePath(from).split("/").pop();
+		if (!oldSlug || !newSlug) return 0;
+		try {
+			const slugs = [oldSlug, ...earlier.map((path) => normalizePath(path).split("/").pop() ?? "")].filter(Boolean);
+			const sources = [...new Set([normalizePath(from), ...earlier.map(normalizePath), ...slugs.flatMap((slug) => [`/${collection}/${slug}`, `/${slug}`])])];
+			const result = await d1
+				.prepare(
+					`DELETE FROM _emdash_redirects WHERE auto = 1 AND group_name = 'Auto: slug change' AND rtrim(source, '/') IN (${sources.map(() => "?").join(", ")}) AND rtrim(destination, '/') LIKE ?`,
+				)
+				.bind(...sources, `%/${newSlug}`)
+				.run();
+			return result.meta.changes ?? 0;
+		} catch {
+			return 0; // EmDash's table changed shape: leave it.
+		}
+	}
+
+	/**
+	 * An entry is live at `url`: delete our rules from that URL (left by another entry
+	 * that used to be there, or by this one before it moved back). Exact rules are read
+	 * before pages render, so one left behind would send readers away from the live page.
+	 */
+	async function freeUrl(ctx: PluginContext, d1: D1Database, url: string) {
+		await ensureTable(d1);
+		const { results } = await d1
+			.prepare("SELECT id FROM coywolf_redirects WHERE is_regex = 0 AND source = ? AND note LIKE ?")
+			.bind(normalizePath(url), `${SLUG_NOTE_PREFIX}%`)
+			.all<{ id: string }>();
+		if (!results.length) return;
+		for (const row of results) await deleteRule(d1, row.id);
+		invalidateRedirectCache();
+		await purgePageCache({ tags: [REDIRECTS_TAG] });
+		ctx.log.info("Slug change redirect removed: the URL is live again", { url, rules: results.length });
+	}
+
+	/** Remember a live entry's URL, from its row as stored now (before a save changes it). */
+	async function rememberStored(ctx: PluginContext, collection: string, id: string) {
+		if (!COLLECTION_SLUG.test(collection) || (await urls(ctx).get(key(collection, id)))) return;
+		const d1 = await db();
+		if (!d1) return;
+		const info = (await readCollections(d1, [collection])).get(collection);
+		const row = await d1.prepare(`SELECT * FROM "ec_${collection}" WHERE id = ? AND deleted_at IS NULL`).bind(id).first<Record<string, unknown>>();
+		if (!row) return;
+		const entry = snapshotFromRow(row, info?.titleField ?? null);
+		if (!live(entry) || !(await handled(entry))) return;
+		const url = await urlOf(d1, collection, entry);
+		if (url) await urls(ctx).put(key(collection, id), { url, at: new Date().toISOString() });
+	}
+
+	/** After a save or publish: compare the live URL with the remembered one, redirect if it moved, remember the new one. */
+	async function settle(ctx: PluginContext, collection: string, content: Record<string, unknown>) {
+		if (!COLLECTION_SLUG.test(collection) || content.id == null) return;
+		const d1 = await db();
+		if (!d1) return;
+		const info = (await readCollections(d1, [collection])).get(collection);
+		const entry = snapshotFromContent(content, info?.titleField ?? null);
+		if (!live(entry) || !(await handled(entry))) return;
+		const url = await urlOf(d1, collection, entry);
+		if (!url) return;
+		const id = key(collection, entry.id);
+		const known = await urls(ctx).get(id);
+		if (known?.url === url) return;
+		if (known) await moved(ctx, d1, collection, entry, known.url, url);
+		else await freeUrl(ctx, d1, url);
+		await urls(ctx).put(id, { url, at: new Date().toISOString() });
+	}
+
+	const hooks = {
+		"content:beforeSave": async (event: { collection: string; id?: string; isNew: boolean }, ctx: PluginContext) => {
+			if (event.isNew || !event.id) return undefined;
+			let timer: ReturnType<typeof setTimeout> | undefined;
+			const deadline = new Promise<"late">((resolve) => {
+				timer = setTimeout(() => resolve("late"), BEFORE_SAVE_BUDGET_MS);
+			});
+			try {
+				const outcome = await Promise.race([rememberStored(ctx, event.collection, event.id).then(() => "done" as const), deadline]);
+				if (outcome === "late") ctx.log.warn("Slug changes: recording the current URL took too long; skipped", { collection: event.collection, id: event.id });
+			} catch (error) {
+				ctx.log.warn("Slug changes: could not record the current URL", { error: String(error) });
+			} finally {
+				clearTimeout(timer);
+			}
+			return undefined; // Never changes or blocks the save.
+		},
+		"content:afterSave": async (event: { content: Record<string, unknown>; collection: string }, ctx: PluginContext) => {
+			await settle(ctx, event.collection, event.content).catch((error: unknown) => ctx.log.warn("Slug changes: could not check the URL", { error: String(error) }));
+		},
+		"content:afterPublish": async (event: { content: Record<string, unknown>; collection: string }, ctx: PluginContext) => {
+			await settle(ctx, event.collection, event.content).catch((error: unknown) => ctx.log.warn("Slug changes: could not check the URL", { error: String(error) }));
+		},
+	};
+
+	return { hooks, storage: slugStorage };
+}

package/src/redirects/slug-core.ts

@@ -0,0 +1,49 @@
+/**
+ * Pure planning for "Slug changes" (feature "redirects.slugChanges"): what to do
+ * with the redirect rules when a published entry's public URL changes. No
+ * imports, so `node --test` can load this file.
+ */
+
+/** Rules this feature made carry a note starting with this, so it only ever edits its own. */
+export const SLUG_NOTE_PREFIX = "Slug change:";
+
+export interface PlanRule {
+	id: string;
+	source: string;
+	target: string;
+	note: string | null;
+}
+
+export type SlugPlan =
+	| { kind: "none"; reason: string }
+	| {
+			kind: "apply";
+			/** Our rules to delete: their source is the entry's URL again (renamed back), which they would shadow or loop. */
+			deleteIds: string[];
+			/** Our rules that pointed at the old URL: point them at the new one, so there's no chain. */
+			retargetIds: string[];
+			/** Create the old → new rule, or update our existing rule for the old URL. */
+			upsert: { id?: string };
+			/** A rule someone else made already answers the old URL: left alone. */
+			keptManual?: PlanRule;
+	  };
+
+const trim = (path: string) => (path.length > 1 ? path.replace(/\/+$/, "") : path);
+export const isOurs = (rule: Pick<PlanRule, "note">) => (rule.note ?? "").startsWith(SLUG_NOTE_PREFIX);
+
+/**
+ * The plan for an entry whose URL went from `oldUrl` to `newUrl`.
+ * `related` is every exact rule whose source or target is either URL (any note).
+ */
+export function planSlugChange(oldUrl: string | null, newUrl: string | null, related: PlanRule[]): SlugPlan {
+	if (!oldUrl || !newUrl) return { kind: "none", reason: "no URL" };
+	const from = trim(oldUrl);
+	const to = trim(newUrl);
+	if (from === to) return { kind: "none", reason: "unchanged" };
+	const ours = related.filter(isOurs);
+	const deleteIds = ours.filter((r) => trim(r.source) === to).map((r) => r.id);
+	const retargetIds = ours.filter((r) => trim(r.target) === from && trim(r.source) !== to && trim(r.source) !== from).map((r) => r.id);
+	const forOld = related.find((r) => trim(r.source) === from);
+	if (forOld && !isOurs(forOld)) return { kind: "apply", deleteIds, retargetIds, upsert: {}, keptManual: forOld };
+	return { kind: "apply", deleteIds, retargetIds, upsert: forOld ? { id: forOld.id } : {} };
+}

package/src/redirects/transfer.ts

@@ -0,0 +1,92 @@
+/**
+ * Redirect export and import formats, shared by the Redirects page and the
+ * tests. An export imports back as is (Import updates rules with the same
+ * source), so a site's redirects can move between sites or into a
+ * spreadsheet and back.
+ *
+ *   CSV:  source, target, type, is_regex, enabled, note, then hits, last_hit,
+ *         created_at, updated_at (for reference; Import ignores them)
+ *   JSON: an array of rules, as the list route returns them
+ *
+ * Import also takes header-less rows of source, target, type, is_regex
+ * separated by commas or tabs, e.g. a Coywolf SEO export from WordPress.
+ */
+import { type CsvCell, parseCsv, toCsv, unguardCell } from "../core/csv.js";
+import type { RedirectInput, RedirectRule } from "./rules.js";
+
+export const REDIRECT_CSV_COLUMNS = ["source", "target", "type", "is_regex", "enabled", "note", "hits", "last_hit", "created_at", "updated_at"] as const;
+
+/**
+ * All rules as CSV. Cells are guarded against spreadsheet formulas; Import
+ * removes the guard again (see src/core/csv.ts), so the round trip is exact.
+ */
+export function redirectsToCsv(rules: RedirectRule[]): string {
+	const rows: CsvCell[][] = [[...REDIRECT_CSV_COLUMNS]];
+	for (const r of rules) rows.push([r.source, r.target, r.type, r.isRegex, r.enabled, r.note ?? "", r.hits, r.lastHit ?? "", r.createdAt, r.updatedAt]);
+	return toCsv(rows, { guard: true });
+}
+
+export function redirectsToJson(rules: RedirectRule[]): string {
+	return `${JSON.stringify(rules, null, "\t")}\n`;
+}
+
+const truthy = (value: string | undefined) => /^(1|true|yes|y)$/i.test((value ?? "").trim());
+const falsy = (value: string | undefined) => /^(0|false|no|n|off)$/i.test((value ?? "").trim());
+
+/** One import row to a rule; enabled and note are left out when the file doesn't have them. */
+function fromCells(cells: { source?: string; target?: string; type?: string; regex?: string; enabled?: string; note?: string }): RedirectInput {
+	const type = (cells.type ?? "").trim();
+	const rule: RedirectInput = {
+		source: (cells.source ?? "").trim(),
+		target: (cells.target ?? "").trim(),
+		type: type ? Number(type) : 301,
+		isRegex: truthy(cells.regex),
+	};
+	if (cells.enabled !== undefined && cells.enabled.trim() !== "") rule.enabled = !falsy(cells.enabled);
+	if (cells.note !== undefined) rule.note = cells.note.trim() || null;
+	return rule;
+}
+
+function fromJson(value: unknown): RedirectInput[] {
+	const list = Array.isArray(value) ? value : value && typeof value === "object" && Array.isArray((value as { redirects?: unknown }).redirects) ? (value as { redirects: unknown[] }).redirects : null;
+	if (!list) throw new Error("The JSON must be a list of redirects.");
+	return list.map((item, i) => {
+		if (!item || typeof item !== "object") throw new Error(`Item ${i + 1} isn't a redirect.`);
+		const r = item as Record<string, unknown>;
+		const rule: RedirectInput = {
+			source: typeof r.source === "string" ? r.source : "",
+			target: typeof r.target === "string" ? r.target : "",
+			type: r.type === undefined ? 301 : Number(r.type),
+			isRegex: r.isRegex === true,
+		};
+		if (typeof r.enabled === "boolean") rule.enabled = r.enabled;
+		if (typeof r.note === "string" || r.note === null) rule.note = r.note;
+		return rule;
+	});
+}
+
+/** Parse pasted or uploaded rules: a JSON array, or CSV/tab-separated rows with or without a header. */
+export function parseRedirectsImport(text: string): RedirectInput[] {
+	const trimmed = text.replace(/^/, "").trim();
+	if (!trimmed) return [];
+	if (trimmed.startsWith("[") || trimmed.startsWith("{")) {
+		let parsed: unknown;
+		try {
+			parsed = JSON.parse(trimmed);
+		} catch (error) {
+			throw new Error(`That isn't valid JSON: ${(error as Error).message}`);
+		}
+		return fromJson(parsed);
+	}
+	const rows = parseCsv(trimmed).map((row) => row.map(unguardCell));
+	const header = rows[0].map((c) => c.trim().toLowerCase());
+	if (!header.includes("source")) {
+		return rows.map((r) => fromCells({ source: r[0], target: r[1], type: r[2], regex: r[3] }));
+	}
+	const at = (...names: string[]) => header.findIndex((h) => names.includes(h));
+	const [s, t, ty, rx, en, no] = [at("source"), at("target", "destination"), at("type", "code", "status"), at("is_regex", "regex", "isregex"), at("enabled"), at("note")];
+	const cell = (row: string[], i: number) => (i >= 0 ? (row[i] ?? "") : undefined);
+	return rows.slice(1).map((r) =>
+		fromCells({ source: cell(r, s), target: cell(r, t), type: cell(r, ty), regex: cell(r, rx), enabled: cell(r, en), note: cell(r, no) }),
+	);
+}