Files
AndreaSlopFotografie/web/config/previewServer.ts
T
SluijsensandClaude Sonnet 5.5 bf21b6f690 Builds the markers, data block and stand-in host for the CMS host injection
The pages carry the CMS markers (data block, list regions, JSON-LD price,
inline price); PackagesProvider reads the host's data block after hydration
and asks the API only when there is none; the site address comes from the
block. A stand-in for the host (config/hostInjector.ts, --cms-data in the
preview server) and browser tests check the behaviour with different data.

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

451 lines
16 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')
) {
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;
}
const injection = file.endsWith('.html') ? 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));
}