// Kleine preview-server voor dist/client, voor Lighthouse en de browsertests. // // Waarom een eigen server (D10): `vite preview` kent geen echte 404 en geen // afbeelding van /over-mij naar over-mij.html, en productie draait geen // Node-server. Hier krijgt een onbekend pad 404.html met status 404, en een // pad zonder punt het bijbehorende paginabestand, zoals de host dat straks // ook moet doen (BR-SRV-01 tot 08). Varianten van een bekende pagina en een // slash aan het eind krijgen één 301 (BR-HST-03, 04). /404.html is een echte // 404; Lighthouse auditeert de 404-pagina via de opt-in route /__audit/404 // (--audit-route, BR-HST-22). import { createReadStream, readFileSync, statSync } from 'node:fs'; import { createServer, type IncomingMessage, type Server, type ServerResponse, } from 'node:http'; import { extname, join, resolve, sep, win32 } from 'node:path'; import { fileURLToPath } from 'node:url'; import { createGzip } from 'node:zlib'; import { injectCms, type InjectOptions } from './hostInjector.ts'; import { canonicalRedirect, stripTrailingSlashes } from './canonicalUrls.ts'; import { compressibleExtensions, compressibleTypes, plainTypes, } from './compressibleTypes.ts'; import { NOT_FOUND_FILE, pageFile } from './pageFiles.ts'; import { securityHeaders } from './securityHeaders.ts'; export interface FileResult { // Relatief aan clientDir, met voorwaartse slashes en zonder voorste slash file: string; status: 200 | 404; } export interface RedirectResult { // Pad zonder query; de server plakt de query van het verzoek erachter redirect: string; status: 301; } export type ResolvedRequest = FileResult | RedirectResult; export interface ResolveOptions { // Opt-in route /__audit/404: de 404-pagina met status 200, alleen voor // Lighthouse (BR-HST-22) auditRoute?: boolean; } const AUDIT_ROUTE = '/__audit/404'; const NOT_FOUND: FileResult = { file: NOT_FOUND_FILE, status: 404 }; // Een segment van alleen punten en spaties ('.', '..', '...', '.. ') wordt door // Windows tot een puntsegment teruggebracht, dus het mag nooit door const DOT_SEGMENT = /^[. ]+$/; // Het doel van een slash-redirect: de segmenten opnieuw gecodeerd, want het // pad is al gedecodeerd en kan spaties, '?' of niet-ASCII bevatten. Een // '%2F' in het origineel is dan al een segmentscheiding; dat is hier geen // probleem omdat het doel alleen een ander verzoek oplevert. const encodePath = (path: string) => path.split('/').map(encodeURIComponent).join('/'); // Het verzoekpad (zonder query of hash) naar het bestand dat erbij hoort, of // naar het pad waar één 301 heen gaat. Eerst één keer decoderen en dán pas // op segmenten controleren, zodat '%2e%2e' en '..%2f' niet langs de controle // komen (BR-SRV-06). Een dubbel gecodeerd pad blijft na één keer decoderen // een gewone bestandsnaam. export function resolveRequest( path: string, fileExists: (file: string) => boolean, options: ResolveOptions = {}, ): ResolvedRequest { let decoded: string; try { decoded = decodeURIComponent(path); } catch { return NOT_FOUND; } if ( !decoded.startsWith('/') || decoded.includes('\0') || decoded.includes('\\') ) { return NOT_FOUND; } // Puntsegmenten ('.', '..', '...') en een stationsletter horen nergens bij const segments = decoded.slice(1).split('/'); if (segments.some((segment) => DOT_SEGMENT.test(segment))) { return NOT_FOUND; } // Eén 301 voor een afwijkende vorm van een bekende pagina (BR-HST-04) en // voor een slash aan het eind van elk ander pad (BR-HST-03) const canonical = canonicalRedirect(decoded); if (canonical !== undefined) return { redirect: canonical, status: 301 }; if (decoded.length > 1 && decoded.endsWith('/')) { const stripped = stripTrailingSlashes(decoded); // Een doel dat niet veilig is (BR-HST-06) of een leeg segment heeft // (//x, BR-SRV-07, buiten de pariteit) is een onbekend pad if (stripped === undefined || stripped.includes('//')) { return NOT_FOUND; } try { return { redirect: encodePath(stripped), status: 301 }; } catch { return NOT_FOUND; } } // /404 en /404.html zijn echte 404's (BR-HST-05) if (decoded === '/404' || decoded === '/404.html') return NOT_FOUND; if (options.auditRoute && decoded === AUDIT_ROUTE) { return { file: NOT_FOUND_FILE, status: 200 }; } if (decoded === '/') return { file: pageFile('/'), status: 200 }; // Lege segmenten (dubbele slash) blijven een 404 (BR-SRV-07) if (segments.some((segment) => segment === '')) return NOT_FOUND; const isFileRequest = segments[segments.length - 1].includes('.'); const file = isFileRequest ? segments.join('/') : pageFile(decoded); // Een stationsletter ('c:/x') is op Windows een absoluut pad if (win32.isAbsolute(file)) return NOT_FOUND; return fileExists(file) ? { file, status: 200 } : NOT_FOUND; } const CONTENT_TYPES: Record = Object.fromEntries( [...compressibleTypes, ...plainTypes].map((type) => [ type.extension, type.previewContentType, ]), ); export const contentTypeOf = (file: string): string => CONTENT_TYPES[extname(file).toLowerCase()] ?? 'application/octet-stream'; // Tekst wordt gecomprimeerd, afbeeldingen en lettertypen niet (die zijn het al). // Waarom: de nulmeting draaide op `vite preview`, dat comprimeert; zonder dit // zijn de Lighthouse-metingen niet te vergelijken (scripts: 667 kB tegen // 202 kB). Productie comprimeert op de host (BR-SRV-08). export const isCompressible = (file: string): boolean => compressibleExtensions.has(extname(file).toLowerCase()); // Staat gzip in Accept-Encoding? 'gzip;q=0' weigert het, '*' staat het toe, // tenzij gzip zelf genoemd is export function acceptsGzip(header: string | undefined): boolean { if (!header) return false; let gzip: number | undefined; let star: number | undefined; for (const part of header.split(',')) { const [name, ...params] = part.trim().toLowerCase().split(';'); const q = params .map((param) => /^\s*q\s*=\s*([0-9.]+)\s*$/.exec(param)) .find(Boolean); const weight = q ? Number(q[1]) : 1; if (name === 'gzip') gzip = weight; else if (name === '*') star = weight; } return (gzip ?? star ?? 0) > 0; } // Alleen het pad: query en hash horen niet bij het bestand. Bewust niet via // `new URL`, want die haalt '..' al weg en dan ziet resolveRequest het niet. const pathOf = (target: string) => target.split(/[?#]/, 1)[0]; function send( response: ServerResponse, status: number, headers: Record, body: NodeJS.ReadableStream | string | null, ) { response.writeHead(status, { ...securityHeaders('production'), ...headers, }); if (body === null) response.end(); else if (typeof body === 'string') response.end(body); else body.pipe(response); } // De query van het verzoek, byte voor byte vanaf het eerste '?' (zonder hash) const searchOf = (target: string) => { const start = target.indexOf('?'); return start === -1 ? '' : target.slice(start).split('#', 1)[0]; }; export interface PreviewOptions { auditRoute?: boolean; // Opt-in stand-in voor de contact-API (--contact-stub): CI heeft geen // CMS-host, dus met contactForm.enabled=true kreeg de site een 404 op // de tokenroute (console-fout, run 666). Met deze optie antwoordt de // server zoals een open formulier zonder captcha: token 200, versturen // 202. Productie gebruikt dit nooit; tests kunnen het per pagina met // page.route vervangen (bijvoorbeeld 404 of een captcha). contactStub?: boolean; // Opt-in stand-in for the CMS host's injection (--cms-data=): // called for every HTML page; the answer is what the host would write into // the markers (see hostInjector.ts), null serves the page as built. inject?: () => InjectOptions | null; } const CONTACT_API = '/api/v1/contact-messages'; // Antwoord van de stub, of undefined als het verzoek er niet voor is export function contactStubResponse( method: string | undefined, path: string, ): { status: number; body: string } | undefined { const json = (status: number, value: unknown) => ({ status, body: JSON.stringify(value), }); if (method === 'GET' && path === `${CONTACT_API}/token`) { return json(200, { token: 'preview-token', minSeconds: 1, captcha: null, }); } // Live packages and banner: "no data" (204), so the page stays with the // baked list and shows no banner, without a 404 in the console (the site // asks once per page load) if ( method === 'GET' && (path === '/api/v1/offerings' || path === '/api/v1/offerings/banner' || path === '/api/v1/hero') ) { return { status: 204, body: '' }; } if (method === 'POST' && path === CONTACT_API) { return json(202, { status: 'received' }); } return undefined; } export function startPreviewServer( clientDir: string, port: number, options: PreviewOptions = {}, ): Promise { const root = resolve(clientDir); const isFile = (file: string) => { try { return statSync(join(root, file)).isFile(); } catch { return false; } }; const handle = (request: IncomingMessage, response: ServerResponse) => { if (options.contactStub) { const stub = contactStubResponse( request.method, pathOf(request.url ?? '/'), ); if (stub) { send( response, stub.status, { ...(stub.body ? { 'Content-Type': 'application/json' } : {}), 'Cache-Control': 'no-store', }, stub.body || null, ); request.resume(); return; } } if (request.method !== 'GET' && request.method !== 'HEAD') { send( response, 405, { Allow: 'GET, HEAD', 'Content-Type': 'text/plain' }, 'Method Not Allowed', ); return; } const resolved = resolveRequest( pathOf(request.url ?? '/'), isFile, options, ); if ('redirect' in resolved) { // Geen Cache-Control (BR-HST-12); de query blijft zoals ze kwam send( response, resolved.status, { Location: resolved.redirect + searchOf(request.url ?? ''), 'Content-Length': 0, }, null, ); return; } const { file, status } = resolved; const target = join(root, file); // Tweede slot naast resolveRequest: nooit buiten clientDir lezen if (!target.startsWith(root + sep) || !isFile(file)) { send( response, 404, { 'Content-Type': 'text/plain' }, request.method === 'HEAD' ? null : 'Not Found', ); return; } // Like the real host, the 404 page is not injected const injection = file.endsWith('.html') && status === 200 ? options.inject?.() : null; if (injection) { const body = injectCms(readFileSync(target, 'utf8'), injection); send( response, status, { 'Content-Type': contentTypeOf(file), 'Cache-Control': 'no-cache', 'Content-Length': Buffer.byteLength(body), }, request.method === 'HEAD' ? null : body, ); return; } const headers: Record = { 'Content-Type': contentTypeOf(file), }; if (file.endsWith('.html')) headers['Cache-Control'] = 'no-cache'; // Gzip als stroom: de lengte is vooraf niet bekend, dus dan geen // Content-Length (chunked); ook niet bij HEAD, dat geen inhoud stuurt const compressible = isCompressible(file); const gzip = compressible && acceptsGzip(request.headers['accept-encoding']); if (compressible) headers['Vary'] = 'Accept-Encoding'; if (gzip) headers['Content-Encoding'] = 'gzip'; else headers['Content-Length'] = statSync(target).size; let body: NodeJS.ReadableStream | null = null; if (request.method !== 'HEAD') { body = createReadStream(target); if (gzip) body = body.pipe(createGzip()); } send(response, status, headers, body); }; return new Promise((resolvePromise, reject) => { const server = createServer(handle); server.once('error', reject); server.listen(port, '127.0.0.1', () => { server.off('error', reject); resolvePromise(server); }); }); } // `--port 4173` en `--port=4173`; onbekende argumenten (die `vite preview` // wel kent) worden genegeerd function parseArguments(args: string[]) { const options = { port: 4173, strictPort: false, dir: 'dist/client', auditRoute: false, contactStub: false, cmsData: '', }; for (let i = 0; i < args.length; i++) { const [name, inline] = args[i].split('=', 2); const value = () => inline ?? args[++i]; if (name === '--port') options.port = Number(value()); else if (name === '--dir') options.dir = value(); else if (name === '--strictPort') options.strictPort = true; else if (name === '--audit-route') options.auditRoute = true; else if (name === '--contact-stub') options.contactStub = true; else if (name === '--cms-data') options.cmsData = value(); } return options; } const MAX_PORT_TRIES = 10; async function main(args: string[]) { const { port, strictPort, dir, auditRoute, contactStub, cmsData } = parseArguments(args); if (!Number.isInteger(port) || port < 0 || port > 65535) { console.error(`Ongeldige poort: ${port}`); process.exitCode = 1; return; } // Zonder --strictPort schuift de poort op als hij bezet is, zoals vite // preview; poort 0 (laat het systeem kiezen) schuift niet const tries = strictPort || port === 0 ? 1 : MAX_PORT_TRIES; for (let attempt = 0; attempt < tries; attempt++) { try { const server = await startPreviewServer(dir, port + attempt, { auditRoute, contactStub, // Read again for every page, so the file can change while the // server runs: { offerings, banners, publicBaseUrl? } ...(cmsData ? { inject: () => { const file = JSON.parse( readFileSync(cmsData, 'utf8'), ) as InjectOptions['data'] & { publicBaseUrl?: string; }; return { data: file, authoredBaseUrl: 'https://andreaslop.nl', publicBaseUrl: file.publicBaseUrl, }; }, } : {}), }); const address = server.address(); const actual = typeof address === 'object' && address ? address.port : port; // 'Local' moet erin staan: startServerReadyPattern van lighthouserc.cjs console.log(` Local: http://127.0.0.1:${actual}/`); return; } catch (error) { const inUse = (error as NodeJS.ErrnoException).code === 'EADDRINUSE'; if (!inUse || attempt === tries - 1) { console.error( inUse ? `Poort ${port + attempt} is al in gebruik` : String(error), ); process.exitCode = 1; return; } } } } // Draait alleen als het bestand zelf wordt gestart (pnpm preview), niet als // een test het importeert. if ( process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url) ) { await main(process.argv.slice(2)); }