Files
AndreaSlopFotografie/web/config/previewServer.ts
T
SluijsensandClaude Opus 5.5 0c5d8b8f40 Compresses responses in the preview server
The baseline ran on vite preview, which compresses, so measurements could not
be compared without this. Also records that the real servers need compression.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-31 18:30:30 +01:00

277 lines
10 KiB
TypeScript

// 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).
import { createReadStream, 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 { NOT_FOUND_FILE, pageFile } from './pageFiles.ts';
import { securityHeaders } from './securityHeaders.ts';
export interface ResolvedRequest {
// Relatief aan clientDir, met voorwaartse slashes en zonder voorste slash
file: string;
status: 200 | 404;
}
const NOT_FOUND: ResolvedRequest = { 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 verzoekpad (zonder query of hash) naar het bestand dat erbij hoort.
// 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,
): ResolvedRequest {
let decoded: string;
try {
decoded = decodeURIComponent(path);
} catch {
return NOT_FOUND;
}
if (
!decoded.startsWith('/') ||
decoded.includes('\0') ||
decoded.includes('\\')
) {
return NOT_FOUND;
}
if (decoded === '/') return { file: pageFile('/'), status: 200 };
// Lege segmenten (dubbele slash, slash aan het eind) en puntsegmenten:
// geen redirect in unit 1, die regel is definitief in unit 3
// Infrastructure Design (BR-SRV-07)
const segments = decoded.slice(1).split('/');
if (
segments.some((segment) => segment === '' || DOT_SEGMENT.test(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;
// Tussenregel, definitief in unit 3 Infrastructure Design: het pagina-pad
// /404 antwoordt met 404, niet met 200. Het bestandsverzoek /404.html is
// gewoon een bestand (BR-SRV-04) en geeft 200: Lighthouse weigert een
// pagina met een 404-status te auditen en gebruikt dit pad als terugval.
if (!isFileRequest && file === NOT_FOUND_FILE) return NOT_FOUND;
return fileExists(file) ? { file, status: 200 } : NOT_FOUND;
}
const CONTENT_TYPES: Record<string, string> = {
'.html': 'text/html; charset=utf-8',
'.js': 'text/javascript; charset=utf-8',
'.css': 'text/css; charset=utf-8',
'.svg': 'image/svg+xml',
'.png': 'image/png',
'.jpg': 'image/jpeg',
'.webp': 'image/webp',
'.woff2': 'font/woff2',
'.ico': 'image/x-icon',
'.xml': 'application/xml; charset=utf-8',
'.txt': 'text/plain; charset=utf-8',
'.json': 'application/json; charset=utf-8',
};
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, gevonden in stap 24). Productie comprimeert op de host (BR-SRV-08).
const COMPRESSIBLE = new Set([
'.html',
'.js',
'.css',
'.svg',
'.json',
'.xml',
'.txt',
]);
export const isCompressible = (file: string): boolean =>
COMPRESSIBLE.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<string, string | number>,
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);
}
export function startPreviewServer(
clientDir: string,
port: number,
): Promise<Server> {
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 (request.method !== 'GET' && request.method !== 'HEAD') {
send(
response,
405,
{ Allow: 'GET, HEAD', 'Content-Type': 'text/plain' },
'Method Not Allowed',
);
return;
}
const { file, status } = resolveRequest(
pathOf(request.url ?? '/'),
isFile,
);
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;
}
const headers: Record<string, string | number> = {
'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' };
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;
}
return options;
}
const MAX_PORT_TRIES = 10;
async function main(args: string[]) {
const { port, strictPort, dir } = 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);
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));
}