emdash 0.0.0-b → 0.0.1

package/src/astro/middleware/redirect.ts

@@ -0,0 +1,89 @@
+/**
+ * Redirect middleware
+ *
+ * Intercepts incoming requests and checks for matching redirect rules.
+ * Runs after runtime init (needs db) but before setup/auth (should handle
+ * ALL routes, including public ones, and should be fast).
+ *
+ * Skip paths:
+ * - /_emdash/* (admin UI, API routes, auth endpoints)
+ * - /_image (Astro image optimization)
+ * - Static assets (files with extensions)
+ *
+ * 404 logging happens post-response: if next() returns 404 and the path
+ * wasn't already matched by a redirect, log it.
+ */
+
+import { defineMiddleware } from "astro:middleware";
+
+import { RedirectRepository } from "../../database/repositories/redirect.js";
+
+/** Paths that should never be intercepted by redirects */
+const SKIP_PREFIXES = ["/_emdash", "/_image"];
+
+/** Static asset extensions -- don't redirect file requests */
+const ASSET_EXTENSION = /\.\w{1,10}$/;
+
+type RedirectCode = 301 | 302 | 303 | 307 | 308;
+
+function isRedirectCode(code: number): code is RedirectCode {
+	return code === 301 || code === 302 || code === 303 || code === 307 || code === 308;
+}
+
+export const onRequest = defineMiddleware(async (context, next) => {
+	const { pathname } = context.url;
+
+	// Skip internal paths and static assets
+	if (SKIP_PREFIXES.some((prefix) => pathname.startsWith(prefix))) {
+		return next();
+	}
+	if (ASSET_EXTENSION.test(pathname)) {
+		return next();
+	}
+
+	const { emdash } = context.locals;
+	if (!emdash?.db) {
+		return next();
+	}
+
+	try {
+		const repo = new RedirectRepository(emdash.db);
+		const match = await repo.matchPath(pathname);
+
+		if (match) {
+			// Reject protocol-relative URLs (e.g. //evil.com or /\evil.com) from interpolation.
+			// Browsers normalize backslashes to forward slashes, so /\ is equivalent to //.
+			if (
+				match.resolvedDestination.startsWith("//") ||
+				match.resolvedDestination.startsWith("/\\")
+			) {
+				return next();
+			}
+			// Fire-and-forget hit recording (don't block the redirect)
+			repo.recordHit(match.redirect.id).catch(() => {});
+			const code = isRedirectCode(match.redirect.type) ? match.redirect.type : 301;
+			return context.redirect(match.resolvedDestination, code);
+		}
+
+		// No redirect matched -- proceed and check for 404
+		const response = await next();
+
+		// Log 404s for unmatched paths (fire-and-forget)
+		if (response.status === 404) {
+			const referrer = context.request.headers.get("referer") ?? null;
+			const userAgent = context.request.headers.get("user-agent") ?? null;
+			repo
+				.log404({
+					path: pathname,
+					referrer,
+					userAgent,
+				})
+				.catch(() => {});
+		}
+
+		return response;
+	} catch {
+		// If the redirects table doesn't exist yet (pre-migration), skip silently
+		return next();
+	}
+});

package/src/astro/middleware/request-context.ts

@@ -0,0 +1,129 @@
+/**
+ * EmDash Request Context Middleware
+ *
+ * Sets up AsyncLocalStorage-based request context for query functions.
+ * Skips ALS entirely for logged-out users with no CMS signals (fast path).
+ *
+ * Handles:
+ * - Preview tokens: _preview query param with signed HMAC token
+ * - Edit mode: emdash-edit-mode cookie (for visual editing)
+ * - Toolbar injection: floating pill for authenticated editors
+ */
+
+import { defineMiddleware } from "astro:middleware";
+
+import { verifyPreviewToken, parseContentId } from "../../preview/tokens.js";
+import { runWithContext } from "../../request-context.js";
+import { renderToolbar } from "../../visual-editing/toolbar.js";
+
+/**
+ * Inject toolbar HTML into a response if it's an HTML page.
+ * Returns the original response if not HTML.
+ */
+async function injectToolbar(response: Response, toolbarHtml: string): Promise<Response> {
+	const contentType = response.headers.get("content-type");
+	if (!contentType?.includes("text/html")) return response;
+
+	const html = await response.text();
+	if (!html.includes("</body>")) return new Response(html, response);
+
+	const injected = html.replace("</body>", `${toolbarHtml}</body>`);
+	return new Response(injected, {
+		status: response.status,
+		headers: response.headers,
+	});
+}
+
+export const onRequest = defineMiddleware(async (context, next) => {
+	const { cookies, url } = context;
+
+	// Skip /_emdash routes (admin has its own UI, no rendering context needed)
+	if (url.pathname.startsWith("/_emdash")) {
+		return next();
+	}
+
+	// Check for authenticated editor (role >= 30)
+	const { user } = context.locals;
+	const isEditor = !!user && user.role >= 30;
+
+	// Playground mode: the playground middleware (from @emdash-cms/cloudflare) stashes
+	// the per-session DO database on locals.__playgroundDb. We set it via ALS here
+	// (same module instance as the loader) so getDb() picks it up correctly.
+	const playgroundDb = context.locals.__playgroundDb;
+	if (playgroundDb) {
+		// Check if playground user has toggled edit mode on
+		const hasEditCookie = cookies.get("emdash-edit-mode")?.value === "true";
+		return runWithContext({ editMode: hasEditCookie, db: playgroundDb }, () => next());
+	}
+
+	// Fast path: check for CMS signals before doing any work
+	const hasEditCookie = cookies.get("emdash-edit-mode")?.value === "true";
+	const hasPreviewToken = url.searchParams.has("_preview");
+
+	// No CMS signals and not an editor → skip everything (zero overhead)
+	if (!hasEditCookie && !hasPreviewToken && !isEditor) {
+		return next();
+	}
+
+	// Determine edit mode: cookie AND authenticated editor
+	const editMode = hasEditCookie && isEditor;
+
+	// Read locale from Astro's i18n routing
+	// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- Astro context includes currentLocale when i18n is configured
+	const locale = (context as { currentLocale?: string }).currentLocale;
+
+	// Verify preview token if present
+	let preview: { collection: string; id: string } | undefined;
+	if (hasPreviewToken) {
+		const secret = import.meta.env.EMDASH_PREVIEW_SECRET || import.meta.env.PREVIEW_SECRET || "";
+
+		if (secret) {
+			const result = await verifyPreviewToken({ url, secret });
+			if (result.valid) {
+				const { collection, id } = parseContentId(result.payload.cid);
+				preview = { collection, id };
+			}
+		}
+	}
+
+	// If we have CMS signals, wrap in ALS context
+	const needsContext = hasEditCookie || hasPreviewToken;
+
+	if (needsContext) {
+		return runWithContext({ editMode, preview, locale }, async () => {
+			let response = await next();
+
+			// Preview responses must not be cached -- draft content could leak past token expiry.
+			// Clone the response before modifying headers — the original may be immutable.
+			if (preview) {
+				response = new Response(response.body, response);
+				response.headers.set("Cache-Control", "private, no-store");
+			}
+
+			// Inject toolbar for authenticated editors
+			if (isEditor) {
+				const toolbarHtml = renderToolbar({
+					editMode,
+					isPreview: !!preview,
+				});
+				return injectToolbar(response, toolbarHtml);
+			}
+
+			return response;
+		});
+	}
+
+	// Editor without CMS signals — no ALS needed, but inject toolbar
+	if (isEditor) {
+		const response = await next();
+		const toolbarHtml = renderToolbar({
+			editMode: false,
+			isPreview: false,
+		});
+		return injectToolbar(response, toolbarHtml);
+	}
+
+	return next();
+});
+
+export default onRequest;

package/src/astro/middleware/setup.ts

@@ -0,0 +1,89 @@
+/**
+ * Setup detection middleware
+ *
+ * Redirects to setup wizard if the site hasn't been set up yet.
+ * Checks both "emdash:setup_complete" option AND user existence.
+ *
+ * Detection logic (in order):
+ * 1. Does options table exist? No → setup needed
+ * 2. Is setup_complete true? No → setup needed
+ * 3. In passkey mode: Are there any users? No → setup needed
+ *    In Access mode: Skip user check (first user created on first login)
+ * 4. Proceed to admin
+ */
+
+import { defineMiddleware } from "astro:middleware";
+
+import { getAuthMode } from "../../auth/mode.js";
+
+export const onRequest = defineMiddleware(async (context, next) => {
+	// Only check setup on admin routes (but not the setup page itself)
+	const isAdminRoute = context.url.pathname.startsWith("/_emdash/admin");
+	const isSetupRoute = context.url.pathname.startsWith("/_emdash/admin/setup");
+
+	if (isAdminRoute && !isSetupRoute) {
+		// Check if setup is complete
+		const { emdash } = context.locals;
+
+		if (!emdash?.db) {
+			// No database configured - let the admin handle this error
+			return next();
+		}
+
+		try {
+			// Check setup_complete flag
+			const setupComplete = await emdash.db
+				.selectFrom("options")
+				.select("value")
+				.where("name", "=", "emdash:setup_complete")
+				.executeTakeFirst();
+
+			// Value is JSON-encoded, parse it. Accepts both boolean true and string "true"
+			const isComplete =
+				setupComplete &&
+				(() => {
+					try {
+						const parsed = JSON.parse(setupComplete.value);
+						return parsed === true || parsed === "true";
+					} catch {
+						return false;
+					}
+				})();
+
+			if (!isComplete) {
+				// Redirect to setup wizard
+				return context.redirect("/_emdash/admin/setup");
+			}
+
+			// Check auth mode - user verification differs by mode
+			const authMode = getAuthMode(emdash.config);
+
+			// In passkey mode, verify users exist
+			// In Access mode, skip this check - first user is created on first Access login
+			if (authMode.type === "passkey") {
+				// Setup is marked complete, but verify users exist
+				// This catches edge case where setup_complete is true but no users
+				const userCount = await emdash.db
+					.selectFrom("users")
+					.select((eb) => eb.fn.countAll<number>().as("count"))
+					.executeTakeFirstOrThrow();
+
+				if (userCount.count === 0) {
+					// No users - need to complete admin creation
+					return context.redirect("/_emdash/admin/setup");
+				}
+			}
+		} catch (error) {
+			// If the options table doesn't exist yet, redirect to setup
+			// This handles fresh installations where migrations haven't run
+			if (error instanceof Error && error.message.includes("no such table")) {
+				return context.redirect("/_emdash/admin/setup");
+			}
+
+			// Other errors - let the admin handle them
+			console.error("Setup middleware error:", error);
+		}
+	}
+
+	return next();
+});