From 4311944a249bf86e0d90d64f29d1ee8fd2d43dcc Mon Sep 17 00:00:00 2001 From: Lilleman auf Larv Date: Mon, 9 Nov 2026 00:51:27 +0100 Subject: [PATCH] =?UTF-8?q?Answer=20stability=20round=201:=200=20?= =?UTF-8?q?=F0=9F=94=B4,=204=20=F0=9F=9F=A1=20(0=20misread);=20drop=20the?= =?UTF-8?q?=20null=20built-in=20result,=20pin=20the=20owner's=20views=20an?= =?UTF-8?q?d=20locale=20on=20the=20landing=20slots?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/function-limits.test.ts | 2 +- src/http/app-i18n.test.ts | 18 ++++++++++++++++-- src/http/app.ts | 11 ++++------- src/http/builtin-route.test.ts | 2 +- src/http/builtin-route.ts | 11 ++++------- 5 files changed, 26 insertions(+), 18 deletions(-) diff --git a/src/function-limits.test.ts b/src/function-limits.test.ts index 4b5f423..87287be 100644 --- a/src/function-limits.test.ts +++ b/src/function-limits.test.ts @@ -13,7 +13,7 @@ const LIMITS = { lines: 50, complexity: 20 }; // Each function over a limit, at its measurement. A ceiling follows its function down, and a metric // leaves the entry once it fits, so a function that shrank can't grow back. const grandfathered: Record = { - "src/http/app.ts createApp": { lines: 135, complexity: 26 }, + "src/http/app.ts createApp": { lines: 133, complexity: 26 }, "src/auth/flow-view.ts buildFlowView": { complexity: 24 }, "src/auth/hydra-admin.ts createHydraAdmin": { lines: 87 }, "src/auth/kratos-admin.ts createKratosAdmin": { lines: 68 }, diff --git a/src/http/app-i18n.test.ts b/src/http/app-i18n.test.ts index 6ed8e0b..24e57b6 100644 --- a/src/http/app-i18n.test.ts +++ b/src/http/app-i18n.test.ts @@ -78,12 +78,15 @@ test("a plugin that owns a landing page, or short-circuits a hook, translates fr mkdirSync(join(dir, "demo", "i18n"), { recursive: true }); t.after(() => rmSync(dir, { force: true, recursive: true })); writeFileSync(join(dir, "demo", "i18n", "en-US.ts"), 'const m = { "demo.hello": "Hello from the plugin" };\nexport default m;\n'); + mkdirSync(join(dir, "demo", "views"), { recursive: true }); + writeFileSync(join(dir, "demo", "views", "landing.ejs"), '<%= t("demo.hello") %>'); // Every plugin-owned render path: the public landing, the gated dashboard, and a hook short-circuit. + // The landings return a view, so the host's choice of views and context shows in the output. const demo: Plugin = { apiVersion: "1.0.0", - dashboard: (ctx) => ({ html: ctx.t("demo.hello") }), - home: (ctx) => ({ html: ctx.t("demo.hello") }), + dashboard: () => ({ view: "landing" }), + home: () => ({ view: "landing" }), hooks: { onRequest: (ctx) => (ctx.url.pathname === "/hooked" ? { html: ctx.t("demo.hello") } : undefined) }, id: "demo", }; @@ -100,6 +103,17 @@ test("a plugin that owns a landing page, or short-circuits a hook, translates fr assert.equal(await (await fetch(`${url}/dashboard`, { headers: { cookie } })).text(), "Hello from the plugin"); }); +test("a redirect from a plugin-owned landing keeps the visitor's chosen locale", async (t) => { + const demo: Plugin = { apiVersion: "1.0.0", home: () => ({ redirect: "/demo/next" }), id: "demo" }; + const app = createApp({ i18n: createI18n(await loadI18n()), plugins: [demo] }); + await new Promise((r) => app.listen(0, r)); + t.after(() => app.close()); + const url = `http://localhost:${(app.address() as AddressInfo).port}`; + const res = await fetch(`${url}/?locale=sv-SE`, { redirect: "manual" }); + assert.equal(res.status, 303); + assert.equal(res.headers.get("location"), "/demo/next?locale=sv-SE"); +}); + test("an error page renders without composing the menu — it exists for when the shell's data is what failed", async (t) => { // The chrome getter is lazy on purpose; a render that reads no chrome must not trigger it, or a // broken menu takes the error pages down with it. diff --git a/src/http/app.ts b/src/http/app.ts index 685e851..e7ba7d7 100644 --- a/src/http/app.ts +++ b/src/http/app.ts @@ -143,7 +143,6 @@ export function createApp(options: AppOptions = {}): Server { const serveHome = async (ctx: RequestContext, csrf: RequestCsrf, contextFor: PluginContextFactory): Promise => { csrf.setCookie(); if (!homePlugin) return { data: { chrome: ctx.chrome, user: ctx.user }, view: "home" }; - // The plugin owns this page, so it runs on its own context — its catalog first, then core. const pluginCtx = contextFor(homePlugin.id); return { ctx: pluginCtx, pluginId: homePlugin.id, result: (await homePlugin.home(pluginCtx)) ?? null }; }; @@ -154,7 +153,7 @@ export function createApp(options: AppOptions = {}): Server { // The page carries the Sign-out form, so Set-Cookie a fresh CSRF token here when absent. csrf.setCookie(); if (!dashboardPlugin) return { data: { chrome: ctx.chrome }, view: "dashboard" }; - const pluginCtx = contextFor(dashboardPlugin.id); // as serveHome: the owner's own translator + const pluginCtx = contextFor(dashboardPlugin.id); return { ctx: pluginCtx, pluginId: dashboardPlugin.id, result: (await dashboardPlugin.dashboard(pluginCtx)) ?? null }; }; @@ -168,9 +167,8 @@ export function createApp(options: AppOptions = {}): Server { const host: Host = { anyRequestHooks, anyResponseHooks, assets, authOptions, builtinRoutes, csrfSecret, i18n, jwks, keto, kratos, kratosAdmin, menu, permissionCatalog, pluginViewsFor, plugins, secureCookies, settingsCatalog, system, viewsFor }; - // Static files, the canonical-host redirect and prepareRequest come first; then the answering - // stages in order — onRequest hook, plugin route, built-in route, else 404/405. A stage that - // returns a boolean returns true once it has answered the request, and false to pass it on. + // A stage that returns a boolean returns true once it has answered the request, and false to + // pass the request to the next stage. const handleRequest = async (req: IncomingMessage, res: ServerResponse, reqLog: Log): Promise => { // Error pages can render before this request has a context at all (a throw on the way to one), // so they start on the built-in English and switch to the visitor's locale once it is resolved. @@ -358,8 +356,7 @@ async function answerBuiltinRoute(host: Host, state: RequestState): Promise ({ handler: () => null, method, path }); +const entry = (method: "GET" | "POST", path: string): BuiltinRoute => ({ handler: () => ({ html: "" }), method, path }); test("matches exact path + method; GET also answers HEAD", () => { const get = entry("GET", "/error"); diff --git a/src/http/builtin-route.ts b/src/http/builtin-route.ts index 1abfbd8..7515a15 100644 --- a/src/http/builtin-route.ts +++ b/src/http/builtin-route.ts @@ -1,8 +1,6 @@ // The host's internal route table: each built-in endpoint (the auth/OAuth2 group, the landing // slots, /error) is a named handler with the plugin RouteHandler shape, plus the request's CSRF -// mint (host-only — a plugin reads the token via ctx.chrome instead). app.ts matches this table -// after plugin routes — exact path, a GET route also answering HEAD like the plugin router — and -// sends the result against the core views, or against the owning plugin's where it is a PluginOwned. +// mint (host-only — a plugin reads the token via ctx.chrome instead). import type { Gate } from "../auth/gate.ts"; import type { RequestContext } from "./context.ts"; import type { RouteResult } from "../plugin-host/plugin.ts"; @@ -20,8 +18,8 @@ export interface RequestCsrf { // own context — otherwise the plugin's keys render as bare keys on the pages it owns. export type PluginContextFactory = (pluginId: string) => RequestContext; -// A landing slot's result when a plugin owns it: the host renders it against that plugin's views -// on `ctx`, and shows it to the response hooks like a plugin route's result. +// What a landing slot returns when a plugin owns it. The host renders `result` with that plugin's +// views and `ctx`, and passes it to every plugin's onResponse hook, as it does for a plugin route. export interface PluginOwned { ctx: RequestContext; // the owner's own context, from PluginContextFactory pluginId: string; @@ -29,8 +27,7 @@ export interface PluginOwned { } export interface BuiltinRoute extends Gate { - // Returns a RouteResult, or null when the handler wrote to ctx.res itself. - handler: (ctx: RequestContext, csrf: RequestCsrf, contextFor: PluginContextFactory) => Promise | RouteResult | PluginOwned | null; + handler: (ctx: RequestContext, csrf: RequestCsrf, contextFor: PluginContextFactory) => Promise | RouteResult | PluginOwned; method: "GET" | "POST"; // a GET route also answers HEAD, like plugin routes path: string; // exact pathname }