Files
AndreaSlopFotografie/web/config/previewServer.ts
SluijsensandClaude Sonnet 5.5 ad0b114828 Hero from the CMS: markers HERO-HTML and HERO-PRELOAD, hero key in the data block, picture per ratio, baked fallback
The prerendered hero is plain HTML between the markers (first photo, h1, buttons), the slider takes over after hydration with the hero of the host block, the API or the build. The head preload is added to the finished HTML. Hero texts move into nl.json. The stand-in host and the e2e tests cover the hero.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-16 16:48:00 +01:00

457 lines
17 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). 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<string, string> = 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<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);
}
// 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=<json file>):
// 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<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 (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<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',
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));
}